diff --git a/sdk/.clang-format b/.clang-format
similarity index 100%
rename from sdk/.clang-format
rename to .clang-format
diff --git a/sdk/.clang-tidy b/.clang-tidy
similarity index 100%
rename from sdk/.clang-tidy
rename to .clang-tidy
diff --git a/.github/actions/detectChanges/action.yml b/.github/actions/detectChanges/action.yml
deleted file mode 100644
index 6b579406..00000000
--- a/.github/actions/detectChanges/action.yml
+++ /dev/null
@@ -1,53 +0,0 @@
-name: Detect code changes
-description: |
-  Determines whether a push/PR contains code changes that require building
-  and testing, or only documentation changes (sdk/docs/) that can be skipped.
-
-  Sets output 'code' to 'true' if build/test should run, 'false' if not.
-
-  Safe defaults — always sets code=true when:
-  - Triggered by schedule or workflow_dispatch (no base SHA available).
-  - git diff fails for any reason (e.g. fetch error, missing commit).
-
-outputs:
-  code:
-    description: "'true' if code changes detected, 'false' if docs-only"
-    value: ${{ steps.check.outputs.code }}
-
-runs:
-  using: composite
-  steps:
-    - name: Detect code vs docs-only changes
-      id: check
-      shell: bash
-      run: |
-        # In Docker containers the workspace may be owned by a different user.
-        git config --global --add safe.directory "$GITHUB_WORKSPACE"
-
-        BASE=${{ github.event.pull_request.base.sha || github.event.before }}
-
-        # schedule/workflow_dispatch have no base SHA — always run tests.
-        if [ -z "$BASE" ]; then
-          echo "code=true" >> $GITHUB_OUTPUT
-          echo "Scheduled/manual run — build and test will run."
-          exit 0
-        fi
-
-        # Ensure the base commit is available locally regardless of PR depth.
-        git fetch --depth=1 origin "$BASE"
-
-        CHANGED=$(git diff --name-only "$BASE" ${{ github.sha }})
-        if [ $? -ne 0 ]; then
-          # git diff failed — safer to run tests than silently skip.
-          echo "code=true" >> $GITHUB_OUTPUT
-          echo "git diff failed — assuming code changes, build and test will run."
-          exit 0
-        fi
-
-        if echo "$CHANGED" | grep -qvE '^sdk/docs/'; then
-          echo "code=true" >> $GITHUB_OUTPUT
-          echo "Code changes detected — build and test will run."
-        else
-          echo "code=false" >> $GITHUB_OUTPUT
-          echo "Documentation-only changes detected — skipping build and test."
-        fi
diff --git a/.github/actions/linuxTest/action.yml b/.github/actions/linuxTest/action.yml
deleted file mode 100644
index 284443cb..00000000
--- a/.github/actions/linuxTest/action.yml
+++ /dev/null
@@ -1,47 +0,0 @@
-name: 'Linux tests for PTI'
-description: |
-  Run the tests with a partition that is expected to ALWAYS succeed and
-  another partition that MAY fail. The latter is designated as Quarantine.
-inputs:
-  wdir:
-    description: Working directory
-    required: true
-  preset:
-    description: Preset used in the build to be tested.
-    required: true
-  skip_hw_metrics:
-    description: Skip hw-metrics tests
-    required: false
-    default: 'false'
-
-runs:
-  using: "composite"
-  steps:
-
-    - name: Tests that MUST succeed.
-      working-directory: ${{ inputs.wdir }}
-      shell: bash
-      run: |
-        source /opt/intel/oneapi/setvars.sh
-
-        EXCLUDE_PATTERN='performance|quarantine'
-        if [[ "${{ inputs.skip_hw_metrics }}" == "true" ]]; then
-          EXCLUDE_PATTERN="${EXCLUDE_PATTERN}|hw-metrics"
-        fi
-
-        ctest --output-on-failure --preset ${{ inputs.preset }} -LE "$EXCLUDE_PATTERN"
-
-    - name: Quarantined tests # performance and flaky tests
-      continue-on-error: true
-      working-directory: ${{ inputs.wdir }}
-      shell: bash
-      run: |
-        source /opt/intel/oneapi/setvars.sh
-
-        if ctest --output-on-failure --preset ${{ inputs.preset }} -L 'performance|quarantine'; then
-          echo "Test status: 0"
-          echo "Quarantined tests pass"
-        else
-          echo "Test status: 1"
-          echo "::warning::Quarantined tests failed"
-        fi
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8f65d90b..0a203010 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,9 +1,8 @@
 ---
 
-# This is an experimental workflow exercising unification of the PTI
-# and Unitrace build.
-#
-# Avoid running on every PR until the tests are ported over.
+# Build-only check of the aggregate top-level CMake project on a GitHub-hosted
+# runner (no GPU, no oneAPI). Components that need oneAPI (icpx), MDAPI,
+# GTPin or IGA are skipped.
 
 name: ci
 
@@ -13,182 +12,42 @@ concurrency:
 
 on:
   workflow_dispatch:
-  schedule:
-    - cron: '0 5 * * *' # Daily 5:00 AM UTC
   push:
     branches: [ "master" ]
-    paths:
-      - .github/workflows/ci.yml
-      - VERSION
-      - '**/CMakeLists.txt'
-      - '**/*.cmake'
   pull_request:
     branches: [ "master" ]
-    paths:
-      - .github/workflows/ci.yml
-      - VERSION
-      - '**/CMakeLists.txt'
-      - '**/*.cmake'
 
 permissions:
   contents: read
 
 jobs:
   build-lin:
-    if: vars.PTI_RUN_TESTS == 1
-    name: Build PTI ${{ matrix.os_id }} ${{ matrix.tags }}
-    runs-on: ${{ fromJSON(matrix.tags) }}
-    timeout-minutes: 20
+    name: Build tools and samples (ubuntu-24.04)
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
     defaults:
       run:
         shell: bash
-    strategy:
-      matrix:
-        include:
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
-            tags: '["self-hosted", "Linux", "pti", "PVC"]'
-            os_id: "ubuntu-24.04.server.2026.1"
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            tags: '["self-hosted", "Linux", "pti", "BMG"]'
-            os_id: "ubuntu-24.04.client.2026.1"
-    container:
-      image: ${{ matrix.container }}
-      options: --device=/dev/dri --cap-add CAP_PERFMON --shm-size=24G --volume=/dev/dri/by-path:/dev/dri/by-path
     steps:
-      - name: Clean
-        run: |
-          shopt -s dotglob
-          rm -rf ./*
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      - name: Configure Environment
-        run: |
-          echo "CMAKE_BUILD_PARALLEL_LEVEL=$(($(nproc)/2))" >> "$GITHUB_ENV"
-
-      - name: Build
-        run: |
-          source /opt/intel/oneapi/setvars.sh --include-intel-llvm
-          cmake -S . -B build \
-            -DCMAKE_CXX_COMPILER=icpx \
-            -DCMAKE_C_COMPILER=icx \
-            -GNinja -DCMAKE_BUILD_TYPE=Release \
-            -DBUILD_TESTING=ON
-          cmake --build build
-
-      - name: Test
-        run: |
-          source /opt/intel/oneapi/setvars.sh --include-intel-llvm
-          ctest --test-dir build --no-tests=error --output-on-failure \
-                -LE "performance|quarantine" \
-                -E "test_unitrace"
-
-      - name: Package
-        run: |
-          source /opt/intel/oneapi/setvars.sh --include-intel-llvm
-          cpack -G TGZ --config build/CPackConfig.cmake
-
-      - name: Upload
-        uses: actions/upload-artifact@v4
-        with:
-          name: pti-gpu-${{ matrix.os_id }}
-          path: |
-            pti*.tar.gz*
-
-  build-win:
-    if: vars.PTI_RUN_TESTS == 1
-    name: Build PTI for Windows
-    runs-on: [self-hosted, Windows, pti, ARC]
-    timeout-minutes: 20
-    env:
-      LEVEL_ZERO_LOADER_VERSION: 1.32.0
-    defaults:
-      run:
-        shell: cmd
-    steps:
-      - name: Clean
-        shell: bash
-        run: |
-          shopt -s dotglob
-          rm -rf ./*
-
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Configure Environment
+      - name: Install dependencies
         run: |
-          set /A JOBS=%NUMBER_OF_PROCESSORS%/2
-          >>%GITHUB_ENV% echo CMAKE_BUILD_PARALLEL_LEVEL=%JOBS%
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build libze-dev opencl-headers \
+            ocl-icd-opencl-dev libdrm-dev python3
 
-      # Can't dynamically acquire yet - needs to be an agreement between
-      # `tools/unitrace` and `sdk`
-      - name: Get Level Zero Loader Version
-        id: loader-ver
+      - name: Configure
         run: |
-          @echo off
-          >>%GITHUB_OUTPUT% echo ze_loader_ver=%LEVEL_ZERO_LOADER_VERSION%
-
-      - uses: actions/cache@v4
-        id: cache
-        with:
-          path: sdk/level-zero-sdk
-          key: ${{ runner.os }}-ci-Ze-Loader-${{ steps.loader-ver.outputs.ze_loader_ver }}
-
-      - name: Download Dependencies
-        if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          rmdir /S /Q sdk\level-zero-sdk
-          del /s level-zero-win-sdk-%LEVEL_ZERO_LOADER_VERSION%.zip
-          echo https://github.com/oneapi-src/level-zero/releases/download/v%LEVEL_ZERO_LOADER_VERSION%/level-zero-win-sdk-%LEVEL_ZERO_LOADER_VERSION%.zip
-          curl.exe -L -O https://github.com/oneapi-src/level-zero/releases/download/v%LEVEL_ZERO_LOADER_VERSION%/level-zero-win-sdk-%LEVEL_ZERO_LOADER_VERSION%.zip
-          7z x level-zero-win-sdk-%LEVEL_ZERO_LOADER_VERSION%.zip -osdk\level-zero-sdk
-          >>%GITHUB_STEP_SUMMARY% echo **Successfully Downloaded Level Zero Loader Version:** %LEVEL_ZERO_LOADER_VERSION%
+          # instcount and memaccess need GTPin. MDAPI is only needed at run
+          # time (its headers are downloaded). icpx and IGA samples are
+          # skipped automatically when the compiler or library is not found.
+          cmake -S . -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
+            "-DPTI_GPU_SKIP=instcount;memaccess"
 
       - name: Build
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          cmake -S . -B build ^
-            -DCMAKE_CXX_COMPILER=icx ^
-            -DCMAKE_C_COMPILER=icx ^
-            -GNinja -DCMAKE_BUILD_TYPE=Release ^
-            -DBUILD_TESTING=ON ^
-            -DLevelZero_ROOT=${{ github.workspace }}/sdk/level-zero-sdk ^
-            -DFETCHCONTENT_BASE_DIR=${{ runner.temp }}/_deps ^
-            -DCMAKE_OBJECT_PATH_MAX=300
-          cmake --build build
-
-      - name: Test
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          REM TODO(PTI-88): OverheadRecordsCountsAllOnesViewRecords fails on Windows. Investigation needed. Bug filed.
-          ctest --test-dir build --no-tests=error --output-on-failure ^
-            -LE "performance|quarantine" ^
-            -E "MainFixtureTest.OverheadRecordsCountsAllOnesViewRecords|test_unitrace"
-
-      - name: Package
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          cpack -G ZIP --config build/CPackConfig.cmake
+        run: cmake --build build
 
-      - name: Upload
-        uses: actions/upload-artifact@v4
-        with:
-          name: pti-gpu-windows
-          path: |
-            pti*.zip*
+      - name: Install
+        run: cmake --install build --prefix "${{ runner.temp }}/pti-install"
diff --git a/.github/workflows/deploy_docs.yml b/.github/workflows/deploy_docs.yml
deleted file mode 100644
index 6cd2721a..00000000
--- a/.github/workflows/deploy_docs.yml
+++ /dev/null
@@ -1,109 +0,0 @@
-name: Deploy Documentation to GitHub Pages
-
-on:
-  push:
-    tags:
-      - 'pti-*'                 # Build and deploy on version tags (for production)
-  pull_request:
-    branches:
-      - master
-    paths:
-      - 'sdk/docs/**'
-      - 'sdk/include/**'
-      - '.github/workflows/deploy_docs.yml'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-concurrency:
-  group: "pages-${{ github.repository }}"
-  cancel-in-progress: false
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  build:
-    name: Build Documentation
-    runs-on: ${{ contains(github.repository, 'pti-gpu') && 'ubuntu-latest' || vars.DIND_ARC_RUNNER_GITHUB }}
-    container: ${{ contains(github.repository, 'pti-gpu') && 'ubuntu:24.04' || vars.PTI_BARE_UBUNTU_24_04 }}
-    
-
-    steps:
-      - name: Install system dependencies
-        run: |
-          apt-get update && apt-get install -y \
-            lsb-release \
-            doxygen \
-            graphviz \
-            cmake \
-            make \
-            ninja-build \
-            g++ \
-            git
-
-      - name: Clean
-        run: |
-          shopt -s dotglob
-          rm -rf ./*
-
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Python Environment Setup
-        uses: astral-sh/setup-uv@v6
-        with:
-          python-version: '3.11'
-          activate-environment: true
-          cache-local-path: ${{ github.workspace }}/.cache/uv
-
-      - name: Install Python dependencies
-        run: |
-          uv pip install --upgrade pip
-          uv pip install -r sdk/docs/requirements.txt
-
-      - name: Build documentation with CMake
-        working-directory: sdk
-        run: |
-          cmake -B build -DCMAKE_BUILD_TYPE=Release \
-            -DBUILD_TESTING=OFF \
-            -DPTI_BUILD_TESTING=OFF \
-            -DPTI_BUILD_SAMPLES=OFF
-          cmake --build build --target docs
-
-      - name: Add .nojekyll file
-        run: |
-          # Prevent Jekyll processing on GitHub Pages
-          touch sdk/build/docs/sphinx/build/html/.nojekyll
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: sdk/build/docs/sphinx/build/html
-
-  deploy:
-    name: Deploy to GitHub Pages
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-
-    runs-on: ${{ contains(github.repository, 'pti-gpu') && 'ubuntu-latest' || vars.DIND_ARC_RUNNER_GITHUB }}
-    needs: build
-
-    if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/pti-')) || github.event_name == 'workflow_dispatch'
-
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4
-
-      - name: Deployment Summary
-        run: |
-          echo "Documentation deployed successfully"
-          echo "Repository: ${{ github.repository }}"
-          echo "Tag: ${{ github.ref_name }}"
-          echo "Deployment URL: ${{ steps.deployment.outputs.page_url }}"
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
deleted file mode 100644
index 5a897afc..00000000
--- a/.github/workflows/lint.yml
+++ /dev/null
@@ -1,65 +0,0 @@
----
-
-name: Linter Checks
-
-on:
-  push:
-    branches: [ "master" ]
-    paths:
-      - sdk/**
-  pull_request:
-    branches: [ "master" ]
-    paths:
-      - sdk/**
-
-defaults:
-  run:
-    shell: bash
-
-permissions:
-  contents: read
-
-jobs:
-  run-format-check:
-
-    container:
-      image: ${{ vars.PTI_DOCKER_IMAGE }}
-
-    if: vars.PTI_RUN_TESTS == 1
-
-    runs-on: [self-hosted, Linux, pti]
-
-    steps:
-      - name: Clean
-        run: |
-          rm -rf ./*
-          rm -rf ./.venv
-          rm -rf ./.cache
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      - name: Python Environment Setup
-        uses: astral-sh/setup-uv@v6
-        with:
-          python-version: '3.11'
-          activate-environment: true
-          cache-local-path: ${{ github.workspace }}/.cache/uv
-
-      - name: Install Dependencies
-        run: |
-          uv pip install "clang-format>=18,<19"
-          uv pip install ruff==0.15.15
-
-      - name: Check SDK Format
-        working-directory: sdk
-        run: |
-          # Expedited configure
-          cmake -S . -B build -DPTI_BUILD_TESTING=OFF -DPTI_BUILD_SAMPLES=OFF -DPTI_INSTALL=OFF
-          cmake --build build --target format-chk
diff --git a/.github/workflows/nightly_build_and_test.yml b/.github/workflows/nightly_build_and_test.yml
deleted file mode 100644
index 4862d095..00000000
--- a/.github/workflows/nightly_build_and_test.yml
+++ /dev/null
@@ -1,266 +0,0 @@
-name: nightly-build-and-test
-
-on:
-  push:
-    branches: [ "master" ]
-    paths:
-      - .github/workflows/nightly_build_and_test.yml
-      - .github/actions/linuxTest/action.yml
-  pull_request:
-    branches: [ "master" ]
-    paths:
-      - .github/workflows/nightly_build_and_test.yml
-      - .github/actions/linuxTest/action.yml
-  workflow_dispatch:
-  schedule:
-    - cron: '30 5 * * *' # Daily 5:30 AM UTC / 12:30 AM EST
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-permissions:
-  contents: read
-
-jobs:
-  sdk-build-and-test:
-    name: BldTest PTI
-
-    timeout-minutes: 30
-
-    runs-on: ${{ fromJSON(matrix.tags) }}
-
-    strategy:
-      fail-fast: false
-      max-parallel: 3
-      matrix:
-        include:
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_NMINUS1 }}
-            uploadname: ${{ vars.PTI_PKG_UBUNTU_24_4_ONEAPI_NMINUS1 }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-          - container: ${{ vars.PTI_DOCKER_ROCKY_8_ONEAPI_NMINUS1 }}
-            uploadname: ${{ vars.PTI_PKG_ROCKY_8_ONEAPI_NMINUS1 }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_26_4_CLIENT_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_UBUNTU_26_4_CLIENT_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "client", "BMG"]'
-          #
-          # This is the n-1 container for BMG
-          #
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_25_10_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_UBUNTU_25_10_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "client", "BMG"]'
-          - container: ${{ vars.PTI_DOCKER_ROCKY_8_ONEAPI_NMINUS1 }}
-            uploadname: ${{ vars.PTI_PKG_ROCKY_8_GXX_NMINUS1 }}
-            preset: linux-gxx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_UBUNTU_24_4_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "client", "BMG"]'
-          - container: ${{ vars.PTI_DOCKER_ROCKY_8_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_ROCKY_8_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-          - container: ${{ vars.PTI_DOCKER_ROCKY_8_ONEAPI_N }}
-            uploadname: ${{ vars.PTI_PKG_ROCKY_8_GXX_N }}
-            preset: linux-gxx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-
-    container:
-      image: ${{ matrix.container }}
-      options: --device=/dev/dri --cap-add CAP_PERFMON ${{ vars.PTI_DOCKER_PROXIES }} --volume=/dev/dri/by-path:/dev/dri/by-path
-
-    if: vars.PTI_RUN_TESTS == 1
-
-    steps:
-      - name: Clean-up
-        run: |
-          rm -rf *
-          echo uploadname ${{ matrix.uploadname }}
-          echo container ${{ matrix.container }}
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Configure Git to use GitHub PAT
-        run: |
-          git config --global url."https://user:${{ secrets.pat_pti_tools }}@github.com".insteadOf "https://github.com"
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      # Cache only the FetchContent sources and sub-builds, not <dep>-build: the
-      # top-level .ninja_log is not cached, so Ninja rebuilds those objects anyway.
-      - name: Cache third-party dependency sources
-        uses: actions/cache@v4
-        with:
-          path: |
-            sdk/build-*/_deps/*-src
-            sdk/build-*/_deps/*-subbuild
-          key: ${{ runner.os }}-sdk-deps-${{ matrix.uploadname }}-${{ hashFiles('sdk/cmake/dependency_pins.cmake') }}
-
-      - name: Build
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset ${{ matrix.preset }}
-          cmake --build --preset ${{ matrix.preset }} -j $(($(nproc)/2))
-
-      - name: Test action
-        uses: ./.github/actions/linuxTest
-        with:
-          wdir: sdk
-          preset: ${{ matrix.preset }}
-
-      - name: Build AddressSanitizer
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-asan
-          cmake --build --preset linux-asan --parallel $(($(nproc)/2))
-
-      - name: Build ThreadSanitizer
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-tsan
-          cmake --build --preset linux-tsan --parallel $(($(nproc)/2))
-
-      - name: Build libFuzzer
-        working-directory: sdk
-        run: |
-          # To ensure it still builds, run build for fuzz targets until we have
-          # proper fuzz testing infrastructure in place.
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-fuzz
-          cmake --build --preset linux-fuzz --parallel $(($(nproc)/2))
-
-      - name: Test AddressSanitizer
-        if: ${{ !contains(fromJSON(matrix.tags), 'BMG') }}
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          ctest --preset linux-asan --output-on-failure -L samples
-
-      - name: Test ThreadSanitizer
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          ctest --preset linux-tsan --output-on-failure -L samples
-
-      - name: Package SDK
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cpack -G TGZ --config build-${{ matrix.preset }}/CPackConfig.cmake
-
-      - name: Upload SDK
-        uses: actions/upload-artifact@v4
-        with:
-          name: "PTI-SDK-PKG-${{ matrix.preset }}-${{ matrix.uploadname }}"
-          path: |
-            sdk/pti*.tar.gz
-            sdk/pti*.tar.gz*
-
-  pti-tools-build-and-test:
-    if: vars.PTI_RUN_TESTS == 1
-    name: PTI Tools
-
-    timeout-minutes: 30
-
-    runs-on: [Linux, pti, pvc]
-
-    continue-on-error: true
-
-    strategy:
-      max-parallel: 2
-      matrix:
-        include:
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
-
-    container:
-      image: ${{ matrix.container }}
-      options: --device=/dev/dri --cap-add CAP_PERFMON ${{ vars.PTI_DOCKER_PROXIES }}
-
-    steps:
-      - name: Clean-up
-        run:  rm -rf *
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      - name: Build-unitrace
-        working-directory: tools/unitrace
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          mkdir build
-          cd build
-          cmake -DBUILD_WITH_MPI=0 -GNinja ..
-          ninja
-
-      - name: Test-unitrace
-        working-directory: tools/unitrace/test
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./test_unitrace.py
-
-      - name: Build-and-test-onetrace
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s onetrace
-
-      - name: Build-and-test-oneprof
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s oneprof
-
-      - name: Build-and-test-sysmon
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s sysmon
-
-      - name: Build-and-test-cl_gpu_metrics
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s cl_gpu_metrics
-
-      - name: Build-and-test-cl_debug_info
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s cl_debug_info
-
-      - name: Build-and-test-instcount
-        if: false
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python ./tests/run.py -s instcount
-
-      - name: Build-and-test-ze_debug_info
-        #
-        # It fails for all containers after oneAPI-2025.2
-        #
-        if: false
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          python3 ./tests/run.py -s ze_debug_info
diff --git a/.github/workflows/pti-tools_build_and_test.yml b/.github/workflows/pti-tools_build_and_test.yml
index 3d60741c..0d68f2f0 100644
--- a/.github/workflows/pti-tools_build_and_test.yml
+++ b/.github/workflows/pti-tools_build_and_test.yml
@@ -5,12 +5,10 @@ on:
   push:
     branches: [ "master" ]
     paths-ignore:
-      - sdk/**
       - .github/**
   pull_request:
     branches: [ "master" ]
     paths-ignore:
-      - sdk/**
       - .github/**
 
 concurrency:
@@ -41,9 +39,6 @@ jobs:
           - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
             tags: '["self-hosted", "Linux", "pti", "PVC"]'
             os_id: "ubuntu-24.04.2026.1"
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            tags: '["self-hosted", "Linux", "pti", "BMG"]'
-            os_id: "ubuntu-24.04.2026.1"
 
     container:
       image: ${{ matrix.container }}
@@ -62,66 +57,6 @@ jobs:
           proxy: ${{ vars.PTI_GIT_PROXY }}
           runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
 
-      - name: Build-unitrace
-        working-directory: tools/unitrace
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          mkdir build
-          cd build
-          cmake -GNinja ..
-          ninja
-
-      - name: Unitrace-install-test
-        working-directory: tools/unitrace
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --install build --prefix install_dir
-
-      - name: Build-l0-only-unitrace
-        working-directory: tools/unitrace
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          mkdir l0_only_build
-          cd l0_only_build
-          cmake -DBUILD_WITH_ITT=0 -DBUILD_WITH_MPI=0 -DBUILD_WITH_XPTI=0 -DBUILD_WITH_OPENCL=0 -GNinja ..
-          ninja
-
-      - name: Unitrace-cpp-test
-        working-directory: tools/unitrace/test
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          # The Python fuzz targets need atheris and the scripts' packages; without
-          # them they are skipped.
-          python -m venv fuzz_venv
-          source fuzz_venv/bin/activate
-          python -m pip install atheris -r ../requirements.txt
-          python ./test_unitrace.py --test-group cpp-test
-
-      - name: Unitrace-trace-format
-        working-directory: tools/unitrace/test
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          # Perfetto's traceconv launcher downloads its binary via curl.
-          command -v curl >/dev/null || (apt-get update && apt-get install -y curl)
-          python -m venv venv
-          source venv/bin/activate
-          python -m pip install -r requirements.txt
-          python ./trace_format_test.py
-
-      - name: Python Environment Setup
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-
-      - name: Unitrace-python-test
-        working-directory: tools/unitrace/test
-        run: |
-           python -m venv venv
-           source venv/bin/activate
-           python -m pip install --upgrade setuptools wheel
-           python -m pip install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/xpu
-           python ./test_unitrace.py --test-group python-test
-
       - name: Build-and-test-sysmon
         if: contains(fromJSON(matrix.tags), 'PVC')
         run: |
@@ -135,15 +70,13 @@ jobs:
           python ./tests/run.py -s cl_gpu_metrics
 
       - name: Build-and-test-instcount
-        if: false
-        #if: contains(fromJSON(matrix.tags), 'PVC')
+        if: contains(fromJSON(matrix.tags), 'PVC')
         run: |
           source /opt/intel/oneapi/setvars.sh
           python ./tests/run.py -s instcount
 
       - name: Build-and-test-ze_debug_info
-        if: false
-        #if: contains(fromJSON(matrix.tags), 'PVC')
+        if: contains(fromJSON(matrix.tags), 'PVC')
         run: |
           source /opt/intel/oneapi/setvars.sh
           python ./tests/run.py -s ze_debug_info
@@ -153,113 +86,3 @@ jobs:
         run: |
           source /opt/intel/oneapi/setvars.sh
           python ./tests/run.py -s cl_debug_info
-
-  pti-tools-build-and-test-windows:
-
-    name: Test unitrace on Windows
-
-    timeout-minutes: 20
-
-    if: vars.PTI_RUN_TESTS == 1
-
-    runs-on: [self-hosted, Windows, pti, ARC]
-
-    defaults:
-      run:
-        shell: cmd
-
-    steps:
-      - name: Clean-up
-        run: |
-          del /S /Q /F *
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Build-unitrace
-        working-directory: tools/unitrace
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          mkdir build
-          cd build
-          cmake -GNinja ..
-          ninja
-
-      - name: Unitrace-install-test
-        working-directory: tools/unitrace
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          cmake --install build --prefix install_dir
-
-      - name: Test-unitrace
-        working-directory: tools/unitrace/test
-        env:
-          SYCL_UR_USE_LEVEL_ZERO_V2: 0
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          rem The workspace path is long; keep unitrace output under MAX_PATH
-          python ./test_unitrace.py --output-dir "%RUNNER_TEMP%\ut"
-
-      - name: Unitrace-trace-format
-        working-directory: tools/unitrace/test
-        env:
-          SYCL_UR_USE_LEVEL_ZERO_V2: 0
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          python -m venv venv
-          call venv\Scripts\activate.bat
-          python -m pip install -r requirements.txt
-          python ./trace_format_test.py
-
-      - name: Print output files on failure
-        if: failure()
-        run: |
-          @echo off
-          setlocal enabledelayedexpansion
-
-          set "ROOT=%RUNNER_TEMP%\ut\cpp_test\logs"
-
-          if not exist "%ROOT%" (
-            echo [WARN] Logs folder not found: "%ROOT%"
-            goto :eof
-          )
-
-          echo.
-          echo ===== Enumerating test logs under "%ROOT%" =====
-
-          rem One log file per test scenario
-          for %%F in ("%ROOT%\*.log") do (
-            echo.
-            echo ---------- [Test: %%~nF] ----------
-            echo [INFO] Found: "%%~fF"
-            type "%%~fF"
-          )
-
-          echo.
-          echo ===== Done printing test logs =====
-
-          rem Print output files from results directory
-          set "RESULTS=%RUNNER_TEMP%\ut\cpp_test\results"
-
-          if not exist "%RESULTS%" (
-            echo [WARN] Results folder not found: "%RESULTS%"
-            goto :eof
-          )
-
-          echo.
-          echo ===== Enumerating output files under "%RESULTS%" =====
-
-          rem One results\<test> folder per test
-          for /R "%RESULTS%" %%F in (*.txt) do (
-            echo.
-            echo ---------- [Output File: %%~nxF] ----------
-            echo [INFO] Found: "%%~fF"
-            type "%%~fF"
-          )
-
-          echo.
-          echo ===== Done printing output files =====
diff --git a/.github/workflows/sdk_build_and_test.yml b/.github/workflows/sdk_build_and_test.yml
deleted file mode 100644
index ba9ed7f3..00000000
--- a/.github/workflows/sdk_build_and_test.yml
+++ /dev/null
@@ -1,251 +0,0 @@
-name: sdk-build-and-test
-
-on:
-  push:
-    paths:
-      - .github/workflows/sdk_build_and_test.yml
-      - .github/actions/linuxTest/action.yml
-      - .github/actions/detectChanges/action.yml
-      - sdk/**
-    branches:
-      - master
-      - release/**
-  pull_request:
-    branches:
-      - master
-      - release/**
-    paths:
-      - sdk/**
-      - .github/workflows/**
-      - .github/actions/**
-  workflow_dispatch:
-  schedule:
-    # Daily 4:00 AM UTC - staggered vs nightly_build_and_test (5:30 UTC) so the
-    # two heavy scheduled runs do not compete for the same runners (PTI-511)
-    - cron: '0 4 * * *'
-
-concurrency:
-  group: sdk-build-${{ github.event.pull_request.number || github.run_id }}
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-permissions:
-  contents: read
-
-jobs:
-  sdk-build-and-test:
-    name: Test PTI ${{ matrix.os_id }} ${{ matrix.tags }}
-
-    timeout-minutes: 45
-
-    runs-on: ${{ fromJSON(matrix.tags) }}
-    defaults:
-      run:
-        shell: bash
-
-    strategy:
-      matrix:
-        include:
-
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            os_id: ${{vars.PTI_PKG_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "client", "BMG"]'
-          - container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
-            os_id: ${{vars.PTI_PKG_UBUNTU_24_4_ONEAPI_N}}
-            preset: linux-icpx-release
-            tags: '["self-hosted", "Linux", "pti", "server", "PVC"]'
-
-    container:
-      image: ${{ matrix.container }}
-      options: --device=/dev/dri --cap-add CAP_PERFMON --shm-size=24G --volume=/dev/dri/by-path:/dev/dri/by-path
-      credentials:
-        username: ${{ vars.PTI_DOCKER_USER }}
-        password: ${{ secrets.PTI_DOCKER_PWD }}
-
-    if: vars.PTI_RUN_LINUX_TESTS == 1
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          clean: true
-
-      - name: Detect code changes
-        id: check
-        uses: ./.github/actions/detectChanges
-
-      - name: Configure Git to use GitHub PAT
-        run: |
-          git config --global url."https://user:${{ secrets.pat_pti_tools }}@github.com".insteadOf "https://github.com"
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      # Cache only the FetchContent sources and sub-builds, not <dep>-build: the
-      # top-level .ninja_log is not cached, so Ninja rebuilds those objects anyway.
-      - name: Cache third-party dependency sources
-        if: steps.check.outputs.code == 'true'
-        uses: actions/cache@v4
-        with:
-          path: |
-            sdk/build-*/_deps/*-src
-            sdk/build-*/_deps/*-subbuild
-          key: ${{ runner.os }}-sdk-deps-${{ join(fromJSON(matrix.tags), '-') }}-${{ hashFiles('sdk/cmake/dependency_pins.cmake') }}
-
-      - name: Build
-        if: steps.check.outputs.code == 'true'
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset ${{ matrix.preset }}
-          cmake --build --preset ${{ matrix.preset }} -j $(($(nproc)/2))
-
-      - name: Test action
-        if: steps.check.outputs.code == 'true'
-        uses: ./.github/actions/linuxTest
-        with:
-          wdir: sdk
-          preset: ${{ matrix.preset }}
-
-      - name: Build AddressSanitizer
-        if: steps.check.outputs.code == 'true' && contains(fromJSON(matrix.tags), 'server')
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-asan
-          cmake --build --preset linux-asan --parallel $(($(nproc)/2))
-
-      - name: Build ThreadSanitizer
-        if: steps.check.outputs.code == 'true' && contains(fromJSON(matrix.tags), 'server')
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-tsan
-          cmake --build --preset linux-tsan --parallel $(($(nproc)/2))
-
-      - name: Build libFuzzer
-        if: steps.check.outputs.code == 'true' && contains(fromJSON(matrix.tags), 'server')
-        working-directory: sdk
-        run: |
-          # To ensure it still builds, run build for fuzz targets until we have
-          # proper fuzz testing infrastructure in place.
-          source /opt/intel/oneapi/setvars.sh
-          cmake --preset linux-fuzz
-          cmake --build --preset linux-fuzz --parallel $(($(nproc)/2))
-
-      #
-      # Rocky8 has a problem with this test.
-      #
-      - name: Test AddressSanitizer
-        if: steps.check.outputs.code == 'true' && contains(fromJSON(matrix.tags), 'server')
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-
-          #
-          # Must skip Rocky8 with more than one GPU because of
-          # an unexpected failure as documented in PTI-74
-          #
-          if [ $(sycl-ls|grep 'ext_oneapi_level_zero:gpu:' -c) -gt 1 ] &&\
-             [[ $(cat /etc/redhat-release)  =~ Rocky.*8 ]]; then
-            exit 0
-          fi
-          ctest --preset linux-asan --output-on-failure -L samples
-
-      - name: Test ThreadSanitizer
-        if: steps.check.outputs.code == 'true' && contains(fromJSON(matrix.tags), 'server')
-        working-directory: sdk
-        run: |
-          source /opt/intel/oneapi/setvars.sh
-          ctest --preset linux-tsan --output-on-failure -L samples
-
-
-  win-lib-build-and-test:
-    name: Test pti-lib on Windows
-    runs-on: ${{ fromJSON(matrix.tags) }}
-
-    timeout-minutes: 30
-
-    defaults:
-      run:
-        shell: cmd
-        working-directory: sdk
-
-    strategy:
-      matrix:
-        include:
-          - preset: windows-ci-release
-            build-dir: wbr
-            tags: '["self-hosted", "Windows", "pti", "client", "BMG"]'
-
-    if: vars.PTI_RUN_TESTS == 1
-
-    steps:
-      - name: Clean
-        shell: bash
-        working-directory: ${{ github.workspace }}
-        run: |
-          shopt -s dotglob
-          rm -rf ./*
-
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Configure Environment
-        run: |
-          set /A JOBS=%NUMBER_OF_PROCESSORS%/2
-          >>%GITHUB_ENV% echo CMAKE_BUILD_PARALLEL_LEVEL=%JOBS%
-          >>%GITHUB_ENV% echo PTI_FETCH_DEPS_DIR=%RUNNER_TEMP%/_deps
-
-      - name: Detect code changes
-        id: check
-        uses: ./.github/actions/detectChanges
-
-      # runner.name is in the key because *-subbuild/CMakeCache.txt records the
-      # absolute RUNNER_TEMP path, which differs between runners.
-      # CMake will fail if the path changes.
-      # Whereas, Linux jobs run in containers and see the same path.
-      - name: Cache third-party dependency sources
-        if: steps.check.outputs.code == 'true'
-        uses: actions/cache@v4
-        with:
-          path: |
-            ${{ env.PTI_FETCH_DEPS_DIR }}/*-src
-            ${{ env.PTI_FETCH_DEPS_DIR }}/*-subbuild
-          key: ${{ runner.os }}-${{ runner.name }}-sdk-deps-${{ hashFiles('sdk/cmake/dependency_pins.cmake') }}
-
-      - name: Build
-        if: steps.check.outputs.code == 'true'
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          cmake --preset ${{ matrix.preset }} ^
-            -DFETCHCONTENT_BASE_DIR=%PTI_FETCH_DEPS_DIR%
-          cmake --build --preset ${{ matrix.preset }}
-
-      - name: Test
-        if: steps.check.outputs.code == 'true'
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          REM TODO(PTI-88): OverheadRecordsCountsAllOnesViewRecords fails on Windows. Investigation needed. Bug filed.
-          ctest --output-on-failure --preset ${{ matrix.preset }} -LE "performance|quarantine" ^
-            -E "MainFixtureTest.OverheadRecordsCountsAllOnesViewRecords"
-
-      - name: Quarantined tests # performance and flaky tests
-        if: steps.check.outputs.code == 'true'
-        continue-on-error: true
-        run: |
-          @echo off
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-          call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-          ctest --output-on-failure --preset ${{ matrix.preset }} -L "performance|quarantine"
-          if %ERRORLEVEL% NEQ 0 (
-            echo ::warning::Quarantined tests step failed.
-          )
-          exit /b 0 ::always exit 0 to keep the green check mark going
-
diff --git a/.github/workflows/sdk_compat_check.yml b/.github/workflows/sdk_compat_check.yml
deleted file mode 100644
index 3a9f9dfb..00000000
--- a/.github/workflows/sdk_compat_check.yml
+++ /dev/null
@@ -1,374 +0,0 @@
-name: sdk-compat-check
-
-#
-# Checks that the PTI SDK has not broken compatibility with the last released
-# version on the same major line, in two ways:
-#
-#   API  baseline-era consumer source must still compile against today's headers
-#   ABI  libabigail's abidiff on libpti_view.so, built from both revisions
-#
-# Gating follows semver, comparing sdk/VERSION against the baseline tag:
-#
-#   PATCH  x.y.Z   nothing may change, not even additions
-#   MINOR  x.Y.0   new exported symbols allowed, nothing else may change
-#
-# There is no MAJOR case: the baseline is only ever searched for on the current
-# major line, so right after a major bump no baseline exists and the whole job
-# is skipped until that major's first release is tagged. That leaves the major
-# development cycle unchecked, which is deliberate (2.x may break 1.x) but also
-# means an unintended break during it will not be caught.
-#
-
-on:
-  pull_request:
-    branches:
-      - master
-      - release/**
-    paths:
-      - sdk/include/**
-      - sdk/src/**
-      - sdk/VERSION
-      - sdk/CMakePresets.json
-      - sdk/CMakeLists.txt
-      - .github/workflows/sdk_compat_check.yml
-  push:
-    branches:
-      - master
-      - release/**
-    paths:
-      - sdk/include/**
-      - sdk/src/**
-      - sdk/VERSION
-      - .github/workflows/sdk_compat_check.yml
-  workflow_dispatch:
-    inputs:
-      baseline:
-        description: 'Tag to compare against (default: newest release below sdk/VERSION)'
-        required: false
-  schedule:
-    - cron: '0 6 * * *' # Daily 6:00 AM UTC, after the nightly build
-
-defaults:
-  run:
-    shell: bash
-
-permissions:
-  contents: read
-
-jobs:
-  compat-check:
-    name: API/ABI compatibility
-
-    timeout-minutes: 40
-
-    #TODO: may use a different machine
-    runs-on: [self-hosted, Linux, pti, server]
-
-    # No GPU is used: this job only compiles the library and inspects the ELF.
-    container:
-      image: ${{ vars.PTI_DOCKER_UBUNTU_24_4_ONEAPI_N }}
-      credentials:
-        username: ${{ vars.PTI_DOCKER_USER }}
-        password: ${{ secrets.PTI_DOCKER_PWD }}
-
-    if: vars.PTI_RUN_LINUX_TESTS == 1
-
-    env:
-      # ABI: library only, gcc, DWARF for abidiff. API: samples, so icpx.
-      PRESET: linux-abi
-      API_PRESET: linux-oneAPI-release
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          # Tags are required to resolve and build the baseline release.
-          fetch-depth: 0
-          clean: true
-
-      - name: GitHub Proxy Usage
-        uses: ./.github/actions/github-proxy-usage
-        with:
-          proxy: ${{ vars.PTI_GIT_PROXY }}
-          runner-pattern: ${{ vars.PTI_GIT_PROXY_RUNNER_PATTERN }}
-
-      - name: Resolve paths
-        run: |
-          {
-            echo "BASE_SRC=${RUNNER_TEMP}/pti-compat-baseline"
-            echo "CUR_INSTALL=${RUNNER_TEMP}/pti-install-current"
-            echo "BASE_INSTALL=${RUNNER_TEMP}/pti-install-baseline"
-          } >> "$GITHUB_ENV"
-
-      - name: Install libabigail
-        run: |
-          if command -v abidiff; then
-            abidiff --version
-            exit 0
-          fi
-          apt-get update -qq
-          if ! apt-get install -y --no-install-recommends abigail-tools; then
-            echo "::error::abigail-tools install failed"
-            exit 1
-          fi
-          abidiff --version
-
-      - name: Resolve baseline release and release type
-        id: baseline
-        run: |
-          git config --global --add safe.directory "$GITHUB_WORKSPACE"
-
-          VERSION=$(tr -d '[:space:]' < sdk/VERSION)
-          MAJOR=${VERSION%%.*}          # 1.2.0 -> 1
-          REST=${VERSION#*.}            # 1.2.0 -> 2.0
-          MINOR=${REST%%.*}             # 2.0   -> 2
-
-          # Release candidates and alphas are not the compatibility contract.
-          FINAL_RELEASE='^pti-[0-9]+\.[0-9]+\.[0-9]+$'
-
-          TAG='${{ inputs.baseline }}'
-          if [ -n "$TAG" ]; then
-            git rev-parse -q --verify "refs/tags/${TAG}" >/dev/null \
-              || { echo "::error::no such tag: ${TAG}"; exit 1; }
-          else
-            # Newest release below VERSION, so release/1.1.x compares against
-            # 1.1.0 and not a later 1.2.0. Empty TAG falls through to the skip.
-            CANDIDATES=$(git tag -l "pti-${MAJOR}.*" | grep -E "$FINAL_RELEASE" | sed 's/^pti-//')
-            BASE=$(printf '%s\n' $CANDIDATES "$VERSION" | sort -V -u \
-                   | awk -v v="$VERSION" '$0==v{exit} {last=$0} END{print last}')
-            [ -z "$BASE" ] || TAG="pti-${BASE}"
-          fi
-
-          if [ -z "$TAG" ]; then
-            echo "No pti-${MAJOR}.y.z release tagged yet; nothing to compare against."
-            echo "skip=true" >> "$GITHUB_OUTPUT"
-            # Without this the run is a bare green check, indistinguishable from
-            # a check that actually ran.
-            {
-              echo "### API/ABI compatibility"
-              echo ""
-              echo ":warning: **Skipped.** No \`pti-${MAJOR}.y.z\` release is tagged yet, so there is"
-              echo "no baseline for \`${VERSION}\`. API and ABI are unchecked until that release exists."
-            } >> "$GITHUB_STEP_SUMMARY"
-            exit 0
-          fi
-
-          BASE_VERSION=${TAG#pti-}      # pti-1.0.1 -> 1.0.1
-          BASE_MINOR=${BASE_VERSION#*.}
-          BASE_MINOR=${BASE_MINOR%%.*}  # 1.0.1     -> 0
-
-          if [ "$MINOR" != "$BASE_MINOR" ]; then
-            TYPE=MINOR
-          else
-            TYPE=PATCH
-          fi
-
-          echo "skip=false"                >> "$GITHUB_OUTPUT"
-          echo "tag=${TAG}"                >> "$GITHUB_OUTPUT"
-          echo "base_version=${BASE_VERSION}" >> "$GITHUB_OUTPUT"
-          echo "version=${VERSION}"        >> "$GITHUB_OUTPUT"
-          echo "type=${TYPE}"              >> "$GITHUB_OUTPUT"
-
-          {
-            echo "### API/ABI compatibility"
-            echo ""
-            echo "| | |"
-            echo "|---|---|"
-            echo "| current version | \`${VERSION}\` |"
-            echo "| baseline | \`${TAG}\` |"
-            echo "| release type | **${TYPE}** |"
-          } >> "$GITHUB_STEP_SUMMARY"
-
-      - name: Build and install current tree
-        if: steps.baseline.outputs.skip == 'false'
-        working-directory: sdk
-        run: |
-          cmake --preset "$PRESET"
-          cmake --build --preset "$PRESET" -j "$(($(nproc)/2))"
-          cmake --install "build-${PRESET}" --prefix "$CUR_INSTALL"
-
-      - name: Build and install baseline ${{ steps.baseline.outputs.tag }}
-        if: steps.baseline.outputs.skip == 'false'
-        run: |
-          TAG='${{ steps.baseline.outputs.tag }}'
-
-          git config --global --add safe.directory "$GITHUB_WORKSPACE"
-          git config --global --add safe.directory "$BASE_SRC"
-
-          rm -rf "$BASE_SRC"
-          git worktree prune
-          git worktree add --detach "$BASE_SRC" "$TAG"
-
-          # The preset postdates the tag. Copying it in keeps both sides on
-          # identical flags, so abidiff cannot report toolchain differences.
-          cp sdk/CMakePresets.json "${BASE_SRC}/sdk/CMakePresets.json"
-
-          cmake -S "${BASE_SRC}/sdk" --preset "$PRESET"
-          cmake --build "${BASE_SRC}/sdk/build-${PRESET}" -j "$(($(nproc)/2))"
-          cmake --install "${BASE_SRC}/sdk/build-${PRESET}" --prefix "$BASE_INSTALL"
-
-      # Source-level check: the baseline's samples are the consumer code we have,
-      # and they must still build against today's headers. abidiff cannot cover
-      # this: a deleted macro, for one, leaves the library byte-identical.
-      - name: Check API compatibility and report results
-        if: steps.baseline.outputs.skip == 'false'
-        run: |
-          # A failing build is this step's signal, not an error to abort on.
-          set +e
-
-          BASE="${BASE_SRC}/sdk"
-          BASE_VER='${{ steps.baseline.outputs.base_version }}'
-          BUILD="${GITHUB_WORKSPACE}/sdk/build-${API_PRESET}"
-          JOBS="$(($(nproc)/2))"
-
-          source /opt/intel/oneapi/setvars.sh >/dev/null
-          command -v icpx >/dev/null || { echo "::error::icpx not on PATH after setvars.sh"; exit 1; }
-
-          # Overlaid, not replaced: samples added since the baseline are named in
-          # today's CMakeLists.
-          cp -r "${BASE}/samples/." "${GITHUB_WORKSPACE}/sdk/samples/"
-
-          # Samples added after the baseline that compile sources of an overlaid
-          # sample, so the overlay pairs their current code with baseline code.
-          # pc_sampling_profiler builds ../pc_sampling/pc_sampling_client.cc, whose
-          # API changed after 1.2.0. Remove it once pti-1.3.0 is the baseline.
-          COMPAT_EXCLUDED_SAMPLES="pc_sampling_profiler"
-          for name in $COMPAT_EXCLUDED_SAMPLES; do
-            if [ -e "${BASE}/samples/${name}" ]; then
-              echo "::warning::${name} is in ${BASE_VER} and is checked; remove it from COMPAT_EXCLUDED_SAMPLES"
-              continue
-            fi
-            echo "excluded ${name}: added after ${BASE_VER}"
-            echo "return()" > "${GITHUB_WORKSPACE}/sdk/samples/${name}/CMakeLists.txt"
-            echo "- excluded \`${name}\` (added after \`${BASE_VER}\`)" >> "$GITHUB_STEP_SUMMARY"
-          done
-
-          # Current tests may depend on sample APIs added after the baseline.
-          cmake -S "${GITHUB_WORKSPACE}/sdk" --preset "$API_PRESET" -DPTI_BUILD_TESTING=OFF 2>&1 | tee configure.log
-          [ "${PIPESTATUS[0]}" -eq 0 ] || { echo "::error::configuring with the ${BASE_VER} samples failed"; exit 1; }
-
-          # A sample returns early when a compiler or dependency check fails, which
-          # would leave the build green having compiled no consumer at all.
-          if grep -A2 "CMake Warning" configure.log | grep -E "requires|only supported"; then
-            echo "::error::a sample skipped itself; the samples above were not checked"
-            exit 1
-          fi
-
-          if cmake --build "$BUILD" -j "$JOBS"; then
-            echo "PASS: the ${BASE_VER} samples build against today's headers."
-            echo "consumers built:"
-            ls "${BUILD}/bin"
-            echo ":white_check_mark: API compatible with \`${BASE_VER}\`." >> "$GITHUB_STEP_SUMMARY"
-            exit 0
-          fi
-
-          echo "::error::API break: the ${BASE_VER} samples no longer build against today's headers"
-          {
-            echo ""
-            echo ":x: **API break.** Source written against \`${BASE_VER}\` no longer builds"
-            echo "against the current headers. Renaming or removing anything in a public"
-            echo "header breaks every consumer's build. The compiler errors are in the"
-            echo "step log."
-          } >> "$GITHUB_STEP_SUMMARY"
-
-          exit 1
-
-      - name: Compare ABI and report results
-        if: steps.baseline.outputs.skip == 'false'
-        run: |
-          # abidiff's non-zero exit is this step's result, not an error to abort on.
-          set +e
-
-          TYPE='${{ steps.baseline.outputs.type }}'
-
-          # Excluded: their exported set varies by compiler, not by PTI's sources.
-          #   __itt_*  vendored ittnotify, versioned upstream by Intel
-          #   _Z*      C++ template instantiations escaping -fvisibility=hidden
-          cat > suppressions.ini <<'EOF'
-          [suppress_function]
-            symbol_name_regexp = ^(__itt_|_Z)
-          [suppress_variable]
-            symbol_name_regexp = ^(__itt_|_Z)
-          EOF
-
-          ARGS=(--suppressions suppressions.ini)
-          if [ "$TYPE" = MINOR ]; then
-            ARGS+=(--no-added-syms)
-          fi
-
-          # What PTI ships is whatever it installs, so both sides are listed rather
-          # than named here. The unversioned symlink is the stable name.
-          shipped() { # <install prefix>
-            find "$1/lib" -maxdepth 1 -name '*.so' -printf '%f\n' | sort
-          }
-
-          ADDED=$(comm -13 <(shipped "$BASE_INSTALL") <(shipped "$CUR_INSTALL"))
-          REMOVED=$(comm -23 <(shipped "$BASE_INSTALL") <(shipped "$CUR_INSTALL"))
-          KEPT=$(comm -12 <(shipped "$BASE_INSTALL") <(shipped "$CUR_INSTALL"))
-
-          [ -n "$KEPT$REMOVED" ] || { echo "::error::no installed libraries found to compare"; exit 1; }
-
-          rc=0
-
-          if [ -n "$REMOVED" ]; then
-            echo "::error::libraries no longer shipped: $(echo $REMOVED)"
-            rc=1
-          fi
-
-          if [ -n "$ADDED" ]; then
-            if [ "$TYPE" = PATCH ]; then
-              echo "::error::libraries added in a PATCH: $(echo $ADDED). Bump the minor in sdk/VERSION."
-              rc=1
-            else
-              echo "New library this ${TYPE}: $(echo $ADDED)"
-            fi
-          fi
-
-          for lib in $KEPT; do
-            echo "abidiff ${ARGS[*]} $lib"
-            abidiff "${ARGS[@]}" "${BASE_INSTALL}/lib/${lib}" "${CUR_INSTALL}/lib/${lib}" | tee "abidiff-${lib}.log"
-            RC=${PIPESTATUS[0]}
-            echo "${lib}: abidiff exit status $RC"
-
-            # Bit field: 1 ERROR, 2 USAGE, 4 ABI_CHANGE, 8 INCOMPATIBLE_CHANGE.
-            if [ $((RC & 3)) -ne 0 ]; then
-              echo "::error::abidiff could not complete on ${lib} (exit $RC)"
-              rc=1
-              continue
-            fi
-
-            if [ "$RC" -eq 0 ]; then
-              echo ":white_check_mark: \`${lib}\`: no incompatible ABI change." >> "$GITHUB_STEP_SUMMARY"
-              continue
-            fi
-
-            rc=1
-            {
-              echo ""
-              echo ":x: **\`${lib}\`: changes that are not allowed in a ${TYPE} release.**"
-              echo ""
-              echo '```'
-              head -50 "abidiff-${lib}.log"
-              echo '```'
-            } >> "$GITHUB_STEP_SUMMARY"
-          done
-
-          if [ "$rc" -eq 0 ]; then
-            echo "PASS: ABI is compatible as a ${TYPE} release."
-            exit 0
-          fi
-
-          if [ "$TYPE" = PATCH ]; then
-            echo "::error::A PATCH allows no ABI change. To add API, bump the minor in sdk/VERSION; to change existing API, bump the major."
-          else
-            echo "::error::A MINOR may add exported symbols but not change or remove them. Added symbols were already ignored, so the changes above alter the existing surface. Make it additive (see sdk/samples/view_record_versioned/main.cc) or plan a MAJOR."
-          fi
-
-          exit 1
-
-      - name: Remove baseline worktree
-        if: always()
-        run: |
-          git worktree remove --force "$BASE_SRC" 2>/dev/null || true
-          rm -rf "$BASE_SRC"
-          git worktree prune 2>/dev/null || true
diff --git a/.github/workflows/sdk_opensource_dpcpp.yml b/.github/workflows/sdk_opensource_dpcpp.yml
deleted file mode 100644
index ab3eba33..00000000
--- a/.github/workflows/sdk_opensource_dpcpp.yml
+++ /dev/null
@@ -1,176 +0,0 @@
-name: sdk-opensource-dpcpp-build-and-test
-
-#
-# Build and test the SDK with the open-source DPC++ compiler (github.com/intel/llvm,
-# branch sycl-rel-7_0) instead of oneAPI.
-#
-
-on:
-  push:
-    branches: [ "master" ]
-    paths:
-      - .github/workflows/sdk_opensource_dpcpp.yml
-  pull_request:
-    branches: [ "master" ]
-    paths:
-      - .github/workflows/sdk_opensource_dpcpp.yml
-  workflow_dispatch:
-  schedule:
-    # Daily 8:00 AM UTC / 12:00 AM PST.
-    - cron: '0 8 * * *'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-defaults:
-  run:
-    shell: bash
-
-permissions:
-  contents: read
-
-jobs:
-  # Separate job because the container used in 'build-and-test' cannot reach ghcr.
-  get-toolchain:
-    name: Extract ${{ matrix.toolchain }}
-
-    timeout-minutes: 10
-
-    runs-on: [self-hosted, Linux, pti, server]
-
-    strategy:
-      matrix:
-        include:
-          - toolchain: dpcpp-7.0
-            # TODO: move to a repo variable, like the other container images.
-            # e.g. vars.PTI_DOCKER_DPCPP_REL_7_0
-            image: ghcr.io/intel/llvm/sycl_prebuilt_tests:sycl-rel-7_0
-
-    container:
-      image: ${{ matrix.image }}
-      options: --user root ${{ vars.PTI_DOCKER_PROXIES }}
-      credentials:
-        username: ${{ secrets.PTI_GHCR_USER }}
-        password: ${{ secrets.PTI_GHCR_PWD }}
-
-    if: vars.PTI_RUN_OPENSOURCE_TESTS == 1
-
-    steps:
-      - name: Decompress toolchain
-        run: |
-          # Decompressed here, the later container has tar but no zstd.
-          zstd -d -f /sycl-prebuilt/toolchain.tar.zst -o "$GITHUB_WORKSPACE/toolchain.tar"
-          ls -lh "$GITHUB_WORKSPACE/toolchain.tar"
-
-      - name: Upload toolchain
-        uses: actions/upload-artifact@v4
-        with:
-          name: toolchain-${{ matrix.toolchain }}
-          path: toolchain.tar
-          retention-days: 1
-          # Fast deflate: the tar is ~1 GB of binaries and compresses ~3x.
-          compression-level: 1
-
-  build-and-test:
-    name: Test PTI ${{ matrix.label }}
-
-    needs: get-toolchain
-
-    timeout-minutes: 30
-
-    runs-on: ${{ fromJSON(matrix.tags) }}
-
-    strategy:
-      # One failing configuration must not cancel the others; the run still fails.
-      fail-fast: false
-      matrix:
-        include:
-          - label: ubuntu-24.04-client BMG dpcpp-7.0
-            toolchain: dpcpp-7.0
-            container: ${{ vars.PTI_DOCKER_UBUNTU_24_4_CLIENT_ONEAPI_N }}
-            preset: linux-dpclang-release
-            tags: '["self-hosted", "Linux", "pti", "client", "BMG"]'
-
-    container:
-      image: ${{ matrix.container }}
-      options: --device=/dev/dri --cap-add CAP_PERFMON --shm-size=24G ${{ vars.PTI_DOCKER_PROXIES }} --volume=/dev/dri/by-path:/dev/dri/by-path
-      credentials:
-        username: ${{ vars.PTI_DOCKER_USER }}
-        password: ${{ secrets.PTI_DOCKER_PWD }}
-
-    if: vars.PTI_RUN_OPENSOURCE_TESTS == 1
-
-    env:
-      # The tarball has bin/, include/ and lib/ at its top level.
-      TC: ${{ github.workspace }}/dpcpp-toolchain
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          clean: true
-
-      - name: Download toolchain
-        uses: actions/download-artifact@v4
-        with:
-          name: toolchain-${{ matrix.toolchain }}
-
-      - name: Unpack toolchain
-        run: |
-          mkdir -p "$TC"
-          tar -xf toolchain.tar -C "$TC"
-          rm -f toolchain.tar
-          echo "$TC/bin" >> "$GITHUB_PATH"
-          echo "LD_LIBRARY_PATH=${TC}/lib${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}" >> "$GITHUB_ENV"
-          echo "LIBRARY_PATH=${TC}/lib${LIBRARY_PATH:+:${LIBRARY_PATH}}" >> "$GITHUB_ENV"
-          echo "CPLUS_INCLUDE_PATH=${TC}/include${CPLUS_INCLUDE_PATH:+:${CPLUS_INCLUDE_PATH}}" >> "$GITHUB_ENV"
-          echo "CMAKE_PREFIX_PATH=${TC}${CMAKE_PREFIX_PATH:+:${CMAKE_PREFIX_PATH}}" >> "$GITHUB_ENV"
-
-      - name: Verify toolchain and GPU
-        run: |
-          echo "dpclang++ resolves to: $(which dpclang++)"
-          case "$(which dpclang++)" in
-            "$TC"/bin/dpclang++) ;;
-            *) echo "::error::dpclang++ is not the open-source toolchain"; exit 1 ;;
-          esac
-
-          dpclang++ --version
-
-          if ! sycl-ls | grep -q 'gpu'; then
-            echo "::error::no SYCL GPU device found"
-            SYCL_UR_TRACE=1 sycl-ls --verbose || true
-            exit 1
-          fi
-          sycl-ls
-
-      - name: Build
-        id: build
-        working-directory: sdk
-        run: |
-          # Note: "Could NOT find unified-runtime" is expected and fails soft:
-          # Findunified-runtime.cmake does not search include/unified-runtime/,
-          # so UR-specific tests are silently skipped.
-          cmake --preset ${{ matrix.preset }}
-          cmake --build --preset ${{ matrix.preset }} -j $(($(nproc)/2))
-
-      - name: Testing
-        working-directory: sdk
-        run: |
-          # onemkl_gemm_exe and omp_vec_add report Not Run: their samples skip
-          # themselves at configure time without oneMKL / icx, but the tests are
-          # still registered.
-          ctest --output-on-failure --preset ${{ matrix.preset }} \
-            -LE "performance|quarantine" \
-            -E "run-onemkl_gemm_exe|run-omp_vec_add"
-
-      - name: Quarantined tests # performance and flaky tests
-        if: ${{ !cancelled() && steps.build.outcome == 'success' }}
-        continue-on-error: true
-        working-directory: sdk
-        run: |
-          if ctest --output-on-failure --preset ${{ matrix.preset }} -L 'performance|quarantine'; then
-            echo "Quarantined tests pass"
-          else
-            echo "::warning::Quarantined tests failed"
-          fi
diff --git a/.gitignore b/.gitignore
index 1e80cc7f..99b0ae1d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,5 +12,3 @@ CMakeUserPresets.json
 error_diff.txt
 *.swp
 
-# fuzz harness build (tools/unitrace/test/fuzz/README.md)
-build-fuzz/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index be0602f0..adf16908 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,22 @@
 #
 # SPDX-License-Identifier: MIT
 # =============================================================
+#
+# Aggregate build of the PTI-GPU tools and samples.
+#
+# Every tool and sample is a standalone CMake project (see build_utils/), so
+# each one is built here as an ExternalProject in its own binary directory:
+#   ${CMAKE_BINARY_DIR}/tools/<name>
+#   ${CMAKE_BINARY_DIR}/samples/<name>
+# The per-folder builds used by tests/run.py keep working unchanged.
+#
+# Options:
+#   PTI_GPU_BUILD_TOOLS    Build the tools (default ON)
+#   PTI_GPU_BUILD_SAMPLES  Build the samples (default ON)
+#   PTI_GPU_TOOLS          List of tools to build (default: all)
+#   PTI_GPU_SAMPLES        List of samples to build (default: all)
+#   PTI_GPU_SKIP           List of tools/samples to skip, e.g. "instcount;memaccess"
+#   BUILD_TESTING          Add the "legacy" ctest that runs tests/run.py
 cmake_minimum_required(VERSION 3.22)
 
 include(cmake/helpers.cmake)
@@ -12,52 +28,174 @@ SetPtiGpuVersion()
 project(
   pti-gpu
   VERSION ${PTI_GPU_VERSION}
-  DESCRIPTION "Intel Profiling Tools"
-  HOMEPAGE_URL "https://github.com/intel/pti-gpu"
+  DESCRIPTION "Profiling and tracing tools and samples for Intel(R) GPUs"
+  HOMEPAGE_URL "https://github.com/vladimir-tsymbal/pti-gpu"
   LANGUAGES C CXX)
 
-if(PROJECT_IS_TOP_LEVEL)
-  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin CACHE STRING "")
-  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib CACHE STRING "")
-  if(NOT APPLE)
-    list(APPEND CMAKE_BUILD_RPATH $ORIGIN)
-  endif()
-  GetCurrentGitRev(PTI_GPU_COMMIT_HASH)
+if(NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  # The build_utils Windows paths are kept, but this fork develops and
+  # tests on Linux only.
+  message(WARNING "Only Linux is tested in this fork; ${CMAKE_SYSTEM_NAME} builds may not work")
 endif()
 
-option(PTI_GPU_BUILD_SDK "Build PTI" ON)
-option(PTI_GPU_BUILD_UNITRACE "Build unitrace" ON)
+include(ExternalProject)
+
+set(PTI_GPU_ALL_TOOLS
+    cl_tracer
+    ze_tracer
+    onetrace
+    oneprof
+    gpuinfo
+    instcount
+    memaccess
+    sysmon)
+
+set(PTI_GPU_ALL_SAMPLES
+    cl_debug_info
+    cl_gemm
+    cl_gemm_inst
+    cl_gemm_itt
+    cl_gpu_metrics
+    cl_gpu_query
+    cl_hot_functions
+    cl_hot_kernels
+    dpc_gemm
+    dpc_info
+    gpu_perfmon_set
+    omp_gemm
+    omp_hot_regions
+    ze_debug_info
+    ze_gemm
+    ze_hot_functions
+    ze_hot_kernels
+    ze_info
+    ze_metric_info
+    ze_metric_query
+    ze_metric_streamer
+    ze_sysman)
+
+# Samples that hard-code icpx as their compiler.
+set(PTI_GPU_ICPX_SAMPLES dpc_gemm dpc_info omp_gemm omp_hot_regions)
+# Samples that need the IGA library (FindIGALibrary is fatal without it).
+set(PTI_GPU_IGA_SAMPLES cl_debug_info ze_debug_info)
+
+option(PTI_GPU_BUILD_TOOLS "Build the PTI-GPU tools" ON)
+option(PTI_GPU_BUILD_SAMPLES "Build the PTI-GPU samples" ON)
+set(PTI_GPU_TOOLS
+    "${PTI_GPU_ALL_TOOLS}"
+    CACHE STRING "Tools to build")
+set(PTI_GPU_SAMPLES
+    "${PTI_GPU_ALL_SAMPLES}"
+    CACHE STRING "Samples to build")
+set(PTI_GPU_SKIP
+    ""
+    CACHE STRING "Tools and samples to skip")
 option(BUILD_TESTING "Build tests" OFF)
 
 include(CTest)
 
-if(PTI_GPU_BUILD_SDK)
-  if(PTI_GPU_COMMIT_HASH)
-    set(PTI_COMMIT_HASH
-        ${PTI_GPU_COMMIT_HASH}
-        CACHE INTERNAL "PTI commit hash")
-  endif()
-  set(PTI_BUILD_TESTING
-      ${BUILD_TESTING}
-      CACHE INTERNAL "Build PTI tests")
-  set(PTI_BUILD_SAMPLES
-      ${BUILD_TESTING}
-      CACHE INTERNAL "Build PTI samples")
-  add_subdirectory(sdk)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE
+      Release
+      CACHE STRING "Build type" FORCE)
 endif()
 
-if(PTI_GPU_BUILD_UNITRACE)
-  if(NOT MPI_FOUND)
-    find_package(MPI QUIET)
+# Cheap dependency probes. A missing dependency skips the affected components
+# with a message instead of failing the whole build. Linux only: on Windows
+# the samples pick other compilers and build_utils locates IGA by its DLL.
+if(WIN32)
+  set(PTI_GPU_ICPX ON)
+  set(PTI_GPU_IGA_LIB ON)
+else()
+  find_program(PTI_GPU_ICPX icpx)
+  find_library(PTI_GPU_IGA_LIB NAMES iga64)
+endif()
+
+# Settings forwarded to each sub-project when they are set here.
+set(PTI_GPU_EP_CMAKE_ARGS "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+foreach(_var CMAKE_PREFIX_PATH CMAKE_INCLUDE_PATH CMAKE_LIBRARY_PATH GTPIN_PATH)
+  if(DEFINED ${_var} AND NOT "${${_var}}" STREQUAL "")
+    string(REPLACE ";" "|" _val "${${_var}}")
+    list(APPEND PTI_GPU_EP_CMAKE_ARGS "-D${_var}=${_val}")
   endif()
-  if(NOT MPI_FOUND)
-    set(BUILD_WITH_MPI
-        OFF
-        CACHE BOOL "Build Unitrace with MPI support")
+endforeach()
+
+# Returns TRUE in OUT_VAR if component NAME should be built.
+function(pti_gpu_component_enabled NAME OUT_VAR)
+  set(_enabled TRUE)
+  if(NAME IN_LIST PTI_GPU_SKIP)
+    message(STATUS "Skipping ${NAME}: listed in PTI_GPU_SKIP")
+    set(_enabled FALSE)
+  elseif(NAME IN_LIST PTI_GPU_ICPX_SAMPLES AND NOT PTI_GPU_ICPX)
+    message(STATUS "Skipping ${NAME}: icpx not found (source oneAPI setvars.sh)")
+    set(_enabled FALSE)
+  elseif(NAME IN_LIST PTI_GPU_IGA_SAMPLES AND NOT PTI_GPU_IGA_LIB)
+    message(STATUS "Skipping ${NAME}: IGA library (libiga64) not found")
+    set(_enabled FALSE)
   endif()
-  add_subdirectory(tools/unitrace)
+  set(${OUT_VAR}
+      ${_enabled}
+      PARENT_SCOPE)
+endfunction()
+
+set(PTI_GPU_ENABLED_TOOLS "")
+set(PTI_GPU_STAGE_DIR "${CMAKE_BINARY_DIR}/stage")
+
+if(PTI_GPU_BUILD_TOOLS)
+  foreach(_tool IN LISTS PTI_GPU_TOOLS)
+    if(NOT _tool IN_LIST PTI_GPU_ALL_TOOLS)
+      message(FATAL_ERROR "Unknown tool in PTI_GPU_TOOLS: ${_tool}")
+    endif()
+    pti_gpu_component_enabled(${_tool} _enabled)
+    if(NOT _enabled)
+      continue()
+    endif()
+    # Each tool installs into its own staging prefix; the top-level install()
+    # below copies it into CMAKE_INSTALL_PREFIX as a per-tool CPack component.
+    ExternalProject_Add(
+      ${_tool}
+      SOURCE_DIR "${PROJECT_SOURCE_DIR}/tools/${_tool}"
+      BINARY_DIR "${CMAKE_BINARY_DIR}/tools/${_tool}"
+      INSTALL_DIR "${PTI_GPU_STAGE_DIR}/${_tool}"
+      LIST_SEPARATOR "|"
+      CMAKE_ARGS ${PTI_GPU_EP_CMAKE_ARGS} "-DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>"
+      BUILD_ALWAYS ON)
+    install(
+      DIRECTORY "${PTI_GPU_STAGE_DIR}/${_tool}/"
+      DESTINATION .
+      USE_SOURCE_PERMISSIONS
+      COMPONENT ${_tool})
+    list(APPEND PTI_GPU_ENABLED_TOOLS ${_tool})
+  endforeach()
+endif()
+
+if(PTI_GPU_BUILD_SAMPLES)
+  foreach(_sample IN LISTS PTI_GPU_SAMPLES)
+    if(NOT _sample IN_LIST PTI_GPU_ALL_SAMPLES)
+      message(FATAL_ERROR "Unknown sample in PTI_GPU_SAMPLES: ${_sample}")
+    endif()
+    pti_gpu_component_enabled(${_sample} _enabled)
+    if(NOT _enabled)
+      continue()
+    endif()
+    ExternalProject_Add(
+      ${_sample}
+      SOURCE_DIR "${PROJECT_SOURCE_DIR}/samples/${_sample}"
+      BINARY_DIR "${CMAKE_BINARY_DIR}/samples/${_sample}"
+      LIST_SEPARATOR "|"
+      CMAKE_ARGS ${PTI_GPU_EP_CMAKE_ARGS}
+      BUILD_ALWAYS ON
+      INSTALL_COMMAND "")
+  endforeach()
 endif()
 
-if(PROJECT_IS_TOP_LEVEL)
-  include(cmake/packaging.cmake)
+if(BUILD_TESTING)
+  find_package(Python3 REQUIRED COMPONENTS Interpreter)
+  # Builds and runs every sample and tool in-tree (<dir>/build), as before.
+  add_test(NAME legacy_run_py
+           COMMAND ${Python3_EXECUTABLE} ${PROJECT_SOURCE_DIR}/tests/run.py
+           WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/tests)
+  set_tests_properties(legacy_run_py PROPERTIES LABELS legacy)
 endif()
+
+include(cmake/packaging.cmake)
diff --git a/README.md b/README.md
index 958e8630..36b1ab73 100644
--- a/README.md
+++ b/README.md
@@ -1,23 +1,20 @@
 # Profiling Tools Interfaces for GPU (PTI for GPU)
 
-> [!WARNING]
-> The samples and auxiliary tools (other than `tools/unitrace`) are no longer
-> under active development and will be removed soon. Candidates for removal:
-> 
-> - `chapters`
-> - `samples`
-> - `loader`
-> - `tests`
-> - `tools/ze_tracer`
-> - `tools/memaccess`
-> - `tools/gpuinfo`
-> - `tools/oneprof`
-> - `tools/onetrace`
-> - `tools/instcount`
-> - `tools/sysmon`
-> 
-> Identical functionality can be found in `unitrace` for most of the tools. For
-> GTPin-related tools, one can find tools and usage samples at <https://www.intel.com/content/www/us/en/developer/articles/tool/gtpin.html>.
+## About this fork
+
+This fork is a maintained continuation of the PTI-GPU tools and samples that
+upstream marked as no longer under active development. The PTI SDK and
+`unitrace` are not part of this fork.
+
+- Targets Linux with both the i915 and xe kernel drivers. Testing is
+  currently done on i915; xe validation is in progress. The Windows build
+  paths are kept, but Windows is not tested here.
+- Tools: [onetrace](tools/onetrace/README.md), [oneprof](tools/oneprof/README.md),
+  [ze_tracer](tools/ze_tracer/README.md), [cl_tracer](tools/cl_tracer/README.md),
+  [gpuinfo](tools/gpuinfo/README.md), [instcount](tools/instcount/README.md),
+  [memaccess](tools/memaccess/README.md), [sysmon](tools/sysmon/README.md).
+- Also included: the [samples](#sample-tools--utilities), the profiling
+  [chapters](#profiling-chapters), and the `tests/run.py` test driver.
 
 ## Overview
 
@@ -33,8 +30,8 @@ You may obtain a copy of the License at <https://opensource.org/license/MIT>
 
 ## Supported OS
 
-- Linux
-- Windows
+- Linux (i915 and xe kernel drivers): developed and tested (xe validation in progress)
+- Windows: build paths kept, not tested in this fork
 
 ## Supported Platforms
 
@@ -46,11 +43,9 @@ You may obtain a copy of the License at <https://opensource.org/license/MIT>
 
 *Some samples may have higher hardware requirements.*
 
-## Regularly Tested Configurations
+## Tested Configurations
 
-- Ubuntu 24.04 with Intel® Arc™ B580 Graphics
-- Ubuntu 24.04 with Intel® Data Center GPU Max Series
-- Windows 11 with Intel® Arc™ B580 Graphics
+- Ubuntu 24.04 with Intel® Data Center GPU Max Series (i915)
 
 ## Profiling Chapters
 
@@ -79,22 +74,22 @@ You may obtain a copy of the License at <https://opensource.org/license/MIT>
 
 ## Profiling & Debug Tools
 
-- [unitrace](tools/unitrace/README.md) - unified tracing and profiling tool. In
-  addition to Level Zero and/or OpenCL, this tool is capable of profiling
-  software layers in the software stack, for example, SYCL and plugins, oneCCL,
-  MPI etc., for scale-up and scale-out applications. It also supports profiling
-  hardware metrics (including instruction-level EU stalls) and software events
-  at the same time.
+- [onetrace](tools/onetrace/README.md) - host and device tracing tool for
+  OpenCL(TM) and Level Zero backends (including DPC++ and OpenMP* GPU offload);
+- [ze_tracer](tools/ze_tracer/README.md) - host and device tracing tool for
+  Level Zero;
+- [cl_tracer](tools/cl_tracer/README.md) - host and device tracing tool for
+  OpenCL(TM);
+- [oneprof](tools/oneprof/README.md) - GPU HW metrics collection tool;
 - [gpuinfo](tools/gpuinfo/README.md) - provides basic information about the
   GPUs installed in a system, and the list of HW metrics one can collect
   for it;
 - [instcount](tools/instcount/README.md) - prints GPU kernel assembly (GEN ISA)
   annotated by instruction execution count;
+- [memaccess](tools/memaccess/README.md) - GT Pin based analysis of GPU kernel
+  memory accesses;
 - [sysmon](tools/sysmon/README.md) - Linux "top" like utility to monitor GPUs
   installed on a system;
-- [pti](sdk/README.md) - profiling library one can link against to gain the
-  capability of profiling SYCL and Level Zero; used by PyTorch Profiler for the
-  Intel® XPU Activity.
 
 ## Sample Tools & Utilities
 
@@ -196,6 +191,42 @@ sample description page.
 
 ## Build and Run
 
+### Building everything
+
+The top-level CMake project builds every tool and sample, each as a
+separate CMake sub-build in `build/tools/<name>` and `build/samples/<name>`:
+
+```sh
+source /opt/intel/oneapi/setvars.sh  # needed for the DPC++/OpenMP samples
+cmake -S . -B build -GNinja -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+cmake --install build --prefix <install_dir>  # installs the tools into <install_dir>/bin
+```
+
+Options:
+
+| Option | Default | Description |
+|---|---|---|
+| `PTI_GPU_BUILD_TOOLS` | `ON` | Build the tools |
+| `PTI_GPU_BUILD_SAMPLES` | `ON` | Build the samples |
+| `PTI_GPU_TOOLS` | all | List of tools to build, e.g. `"onetrace;sysmon"` |
+| `PTI_GPU_SAMPLES` | all | List of samples to build |
+| `PTI_GPU_SKIP` | empty | List of tools or samples to skip, e.g. `"instcount;memaccess"` |
+| `BUILD_TESTING` | `OFF` | Add a `legacy` ctest that runs `tests/run.py` |
+
+Samples that need `icpx` (DPC++ and OpenMP) are skipped automatically if the
+compiler is not found, and the `*_debug_info` samples are skipped if the IGA
+library (`libiga64.so`) is not found. `instcount` and `memaccess` download
+GT Pin at configure time.
+
+Per-tool packages can be created with CPack, e.g.:
+
+```sh
+cd build && cpack -G TGZ  # or DEB / RPM
+```
+
+### Building a single sample or tool
+
 In general, to build samples one need to perform the following steps
 (specific instructions for particular sample can be found on sample
 description page):
@@ -254,18 +285,6 @@ To remove all of these folders, use:
 python <pti_root>/tests/run.py -c
 ```
 
-## Unitrace and PTI SDK Experimental Build
-
-The two products in active development are Unitrace and PTI SDK. A new,
-top-level, CMakeLists.txt file can be used to build them together.  
-To build them, use CMake in the root of this repository.
-
-```console
-source /opt/intel/oneapi/setvars.sh
-cmake -S . -B build -GNinja -DCMAKE_BUILD_TYPE=Release
-cmake --build build
-```
-
 **Tested software versions one may find in [SOFTWARE](SOFTWARE) file.**
 
 **(*) Other names and brands may be claimed as property of others.**
diff --git a/build_utils/CMakeLists.txt b/build_utils/CMakeLists.txt
index 5617cfc7..9a93b742 100644
--- a/build_utils/CMakeLists.txt
+++ b/build_utils/CMakeLists.txt
@@ -1,7 +1,7 @@
 set(PTI_CMAKE_MACRO_DIR ${CMAKE_CURRENT_LIST_DIR} CACHE INTERNAL "")
 
 macro(SetRequiredCMakeVersion)
-  set(REQUIRED_CMAKE_VERSION 3.12)
+  set(REQUIRED_CMAKE_VERSION 3.22)
 endmacro()
 
 macro(RequirePythonInterp)
@@ -224,8 +224,9 @@ macro(FindIGALibrary TARGET)
         string(REPLACE ":" ";" SEARCH_LIB_PATH $ENV{LD_LIBRARY_PATH})
       endif()
     endif()
+    # Accept the versioned runtime soname when no dev symlink is installed.
     find_library(IGA_LIB_PATH
-      NAMES iga64
+      NAMES iga64 libiga64.so.2 libiga64.so.1
       PATHS ${SEARCH_LIB_PATH})
     if(NOT IGA_LIB_PATH)
       message(FATAL_ERROR
@@ -358,7 +359,7 @@ macro(CheckForMDLibrary TARGET)
       endif()
     endif()
     find_library(MD_LIB_PATH
-      NAMES igdmd md
+      NAMES igdmd md libigdmd.so.1
       PATHS ${SEARCH_LIB_PATH})
     if(NOT MD_LIB_PATH)
       message(WARNING
@@ -389,7 +390,7 @@ macro(CheckForMetricsLibrary)
       endif()
     endif()
     find_library(ML_LIB_PATH
-      NAMES igdml64
+      NAMES igdml64 igdml libigdml.so.1
       PATHS ${SEARCH_LIB_PATH})
   endif()
 
@@ -433,22 +434,59 @@ macro(GetGTPinPackage)
         message(FATAL_ERROR "Graphics Technology Pin (GT Pin) is not supported for the platform")
       endif()
     endif()
+    # Download the archive ourselves instead of letting FetchContent do it:
+    # ExternalProject retries a timed-out download 5 times, and its inactivity
+    # timeout does not cover a stalled TCP connect (e.g. a proxy
+    # misconfiguration), so an unreachable host used to hang configure forever.
+    set(GTPIN_DOWNLOAD_PAGE
+      "https://www.intel.com/content/www/us/en/download/730596/867025/gtpin.html")
+    if(NOT DEFINED GTPIN_DOWNLOAD_TIMEOUT)
+      set(GTPIN_DOWNLOAD_TIMEOUT 900)
+    endif()
+    if(NOT DEFINED GTPIN_DOWNLOAD_INACTIVITY_TIMEOUT)
+      set(GTPIN_DOWNLOAD_INACTIVITY_TIMEOUT 60)
+    endif()
+    if(EXISTS "${GTPIN_LINK}")
+      set(GTPIN_ARCHIVE "${GTPIN_LINK}")
+    else()
+      get_filename_component(GTPIN_ARCHIVE_NAME "${GTPIN_LINK}" NAME)
+      set(GTPIN_ARCHIVE "${CMAKE_BINARY_DIR}/_deps/${GTPIN_ARCHIVE_NAME}")
+    endif()
+    if(NOT EXISTS "${GTPIN_ARCHIVE}")
+      message(STATUS "Downloading GTPin package: ${GTPIN_LINK} "
+        "(timeout ${GTPIN_DOWNLOAD_TIMEOUT} s, inactivity timeout ${GTPIN_DOWNLOAD_INACTIVITY_TIMEOUT} s)")
+      string(RANDOM LENGTH 8 GTPIN_PART_SUFFIX)
+      set(GTPIN_ARCHIVE_PART "${GTPIN_ARCHIVE}.${GTPIN_PART_SUFFIX}.part")
+      file(DOWNLOAD "${GTPIN_LINK}" "${GTPIN_ARCHIVE_PART}"
+        TIMEOUT ${GTPIN_DOWNLOAD_TIMEOUT}
+        INACTIVITY_TIMEOUT ${GTPIN_DOWNLOAD_INACTIVITY_TIMEOUT}
+        STATUS GTPIN_DOWNLOAD_STATUS)
+      list(GET GTPIN_DOWNLOAD_STATUS 0 GTPIN_DOWNLOAD_CODE)
+      if(NOT GTPIN_DOWNLOAD_CODE EQUAL 0)
+        file(REMOVE "${GTPIN_ARCHIVE_PART}")
+        message(FATAL_ERROR
+          "GTPin package download failed: ${GTPIN_LINK} (${GTPIN_DOWNLOAD_STATUS}). "
+          "Check your proxy settings, or download the package manually from "
+          "${GTPIN_DOWNLOAD_PAGE}, unpack it and pass -DGTPIN_PATH=<unpacked dir> "
+          "(or -DGTPIN_LINK=<archive file or url>).")
+      endif()
+      file(RENAME "${GTPIN_ARCHIVE_PART}" "${GTPIN_ARCHIVE}")
+    endif()
     include(FetchContent)
     if(${CMAKE_VERSION} VERSION_LESS "3.24.0")
       FetchContent_Declare(
         gtpin_package
-        URL ${GTPIN_LINK}
-SOURCE_DIR ${GTPIN_SOURCE_DIR}
+        URL ${GTPIN_ARCHIVE}
+        SOURCE_DIR ${GTPIN_SOURCE_DIR}
       )
     else()
       FetchContent_Declare(
         gtpin_package
-        URL ${GTPIN_LINK}
+        URL ${GTPIN_ARCHIVE}
         DOWNLOAD_EXTRACT_TIMESTAMP YES
-SOURCE_DIR ${GTPIN_SOURCE_DIR}
+        SOURCE_DIR ${GTPIN_SOURCE_DIR}
       )
     endif()
-    message(STATUS "Download GTPin package link: ${GTPIN_LINK}")
     FetchContent_MakeAvailable(gtpin_package)
     if(UNIX)
       set(GTPIN_PATH ${gtpin_package_SOURCE_DIR})
@@ -485,6 +523,24 @@ macro(FindGTPinLibrary TARGET)
   target_link_libraries(${TARGET} gtpin ged)
 endmacro()
 
+# Installs the GTPin runtime libraries that TARGET needs into a private
+# lib/<TOOL_NAME> directory (one copy per tool, so separate tool packages do not
+# conflict) and points the installed TARGET at it through RPATH. The GTPin
+# license allows redistribution of the unmodified package, provided its license
+# and third-party notices come with it; they are installed to
+# share/doc/<TOOL_NAME>/gtpin. Linux only; Windows installs are unchanged.
+macro(InstallGTPinRuntime TARGET TOOL_NAME)
+  GetGTPinPackage()
+  if(UNIX)
+    set_target_properties(${TARGET} PROPERTIES
+      INSTALL_RPATH "$ORIGIN/../lib/${TOOL_NAME}")
+    file(GLOB GTPIN_RUNTIME_LIBS "${GTPIN_PATH}/Lib/intel64/*.so*")
+    install(FILES ${GTPIN_RUNTIME_LIBS} DESTINATION lib/${TOOL_NAME})
+    install(DIRECTORY "${GTPIN_PATH}/Licensing/"
+            DESTINATION share/doc/${TOOL_NAME}/gtpin)
+  endif()
+endmacro()
+
 macro(FindGTPinHeaders TARGET)
   GetGTPinPackage()
   target_include_directories(${TARGET}
@@ -512,13 +568,11 @@ macro(GetLevelZeroHeaders TARGET)
                       DEPENDS ${L0_INC_PATH}/level_zero/ze_api.h
                               ${L0_INC_PATH}/level_zero/zes_api.h
                               ${L0_INC_PATH}/level_zero/zet_api.h
-                              ${L0_INC_PATH}/level_zero/zer_api.h
                               ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
                               ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h)
     add_custom_command(OUTPUT ${L0_INC_PATH}/level_zero/ze_api.h
                               ${L0_INC_PATH}/level_zero/zes_api.h
                               ${L0_INC_PATH}/level_zero/zet_api.h
-                              ${L0_INC_PATH}/level_zero/zer_api.h
                               ${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h
                               ${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h
                       COMMAND "${PYTHON_EXECUTABLE}" "${PTI_CMAKE_MACRO_DIR}/get_ze_headers.py" ${L0_INC_PATH} ${CMAKE_BINARY_DIR} ${LEVEL_ZERO_COMMIT_ID})
@@ -643,6 +697,11 @@ macro(FindL0HeadersPath TARGET L0_GEN_SCRIPT)
                     DEPENDS ${L0_GEN_INC_PATH}/tracing.gen)
   add_custom_command(OUTPUT ${L0_GEN_INC_PATH}/tracing.gen
                      COMMAND "${PYTHON_EXECUTABLE}" ${L0_GEN_SCRIPT} ${L0_GEN_INC_PATH} "${L0_INC_PATH}/level_zero")
+  if(TARGET level_zero_headers)
+    # The headers are downloaded at build time (FindL0Headers fallback);
+    # generate the callbacks only after they exist.
+    add_dependencies(ze_gen_headers level_zero_headers)
+  endif()
   target_include_directories(${TARGET}
     PUBLIC "${L0_GEN_INC_PATH}")
   add_dependencies(${TARGET}
diff --git a/build_utils/build_utils.py b/build_utils/build_utils.py
index e7fc9663..55e11ff4 100644
--- a/build_utils/build_utils.py
+++ b/build_utils/build_utils.py
@@ -1,12 +1,95 @@
 import os
 import sys
 import shutil
+import stat
 import subprocess
+import time
+
+try:
+  import fcntl
+except ImportError: # Windows
+  fcntl = None
+  import msvcrt
+
+def lock_file(f):
+  if fcntl is not None:
+    fcntl.flock(f, fcntl.LOCK_EX)
+    return
+  # msvcrt.LK_LOCK gives up after about 10 s, and a clone can take longer.
+  while True:
+    try:
+      msvcrt.locking(f.fileno(), msvcrt.LK_LOCK, 1)
+      return
+    except OSError:
+      time.sleep(1)
+
+def unlock_file(f):
+  if fcntl is not None:
+    fcntl.flock(f, fcntl.LOCK_UN)
+  else:
+    f.seek(0)
+    msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
+
+# Make git give up on a transfer that stays below 1 KB/s for 60 s, instead of
+# hanging until the build (or a test timeout) kills it.
+GIT_STALL_OPTIONS = ["-c", "http.lowSpeedLimit=1000", "-c", "http.lowSpeedTime=60"]
+
+# Written into a clone once the requested commit is checked out completely.
+CLONE_STAMP = ".pti-clone-commit"
+
+def git(args, cwd):
+  return subprocess.call(["git"] + GIT_STALL_OPTIONS + args, cwd = cwd) == 0
+
+def remove_tree(path):
+  def make_writable_and_retry(func, failed_path, exc_info):
+    os.chmod(failed_path, stat.S_IWRITE) # read-only git objects on Windows
+    func(failed_path)
+  if os.path.exists(path):
+    shutil.rmtree(path, onerror = make_writable_and_retry)
+
+def is_cloned(clone_path, commit):
+  try:
+    with open(os.path.join(clone_path, CLONE_STAMP)) as f:
+      return f.read().strip() == commit
+  except OSError:
+    return False
 
 def clone(url, commit, clone_path):
-  if (not os.path.exists(clone_path)):
-    subprocess.call(["git", "clone", url, clone_path])
-    subprocess.call(["git", "checkout", commit], cwd = os.path.abspath(clone_path))
+  # Several header scripts may clone the same repository into the same path
+  # (e.g. get_iga_headers.py and get_igc_headers.py) and run concurrently in a
+  # parallel build. Serialize them so nobody copies from a half-done clone.
+  with open(clone_path.rstrip(os.sep) + ".lock", "w") as lock:
+    lock_file(lock)
+    try:
+      if is_cloned(clone_path, commit):
+        return
+      # A clone without the stamp is incomplete (e.g. an interrupted build) or
+      # at another commit: start over.
+      remove_tree(clone_path)
+
+      # Fetch into a temporary directory and move it into place only when
+      # complete. Try a shallow fetch of the commit first (fast), then fall
+      # back to a full clone.
+      tmp_path = clone_path.rstrip(os.sep) + ".partial"
+      remove_tree(tmp_path)
+      os.makedirs(tmp_path)
+      ok = (git(["init", "-q"], tmp_path) and
+            git(["fetch", "-q", "--depth", "1", url, commit], tmp_path) and
+            git(["checkout", "-q", "FETCH_HEAD"], tmp_path))
+      if not ok:
+        remove_tree(tmp_path)
+        ok = (git(["clone", url, tmp_path], None) and
+              git(["checkout", commit], tmp_path))
+      if not ok:
+        remove_tree(tmp_path)
+        raise RuntimeError("Failed to fetch " + url + " at " + commit +
+                           " (check network and proxy settings)")
+
+      with open(os.path.join(tmp_path, CLONE_STAMP), "w") as f:
+        f.write(commit + "\n")
+      os.rename(tmp_path, clone_path)
+    finally:
+      unlock_file(lock)
 
 def copy(src_path, dst_path, file_list):
   for file in file_list:
diff --git a/build_utils/get_cl_headers.py b/build_utils/get_cl_headers.py
index 6044ce0d..736ecbd2 100644
--- a/build_utils/get_cl_headers.py
+++ b/build_utils/get_cl_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/KhronosGroup/OpenCL-Headers.git"
-commit = "dcd5bede6859d26833cd85f0d6bbcee7382dc9b3"
+commit = "6fe718c31a45fe25151362a72ef041c3a1047cbd"  # v2026.05.29
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_compute_runtime_headers.py b/build_utils/get_compute_runtime_headers.py
index e16f1111..20a9d9dd 100644
--- a/build_utils/get_compute_runtime_headers.py
+++ b/build_utils/get_compute_runtime_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/compute-runtime.git"
-commit = "050536ff3b6f830199ec99cff8ffcac3d804c40a"  # release 26.31.39395.14
+commit = "77d21ec752a6abd7f1b34c85decbff25766b64aa"  # 26.44.40734.8
 
 def postprocess(file_path):
     """Post-process header file: remove non-local tracing header includes.
diff --git a/build_utils/get_gmm_headers.py b/build_utils/get_gmm_headers.py
index 649a76e4..9cad33f6 100644
--- a/build_utils/get_gmm_headers.py
+++ b/build_utils/get_gmm_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/gmmlib.git"
-commit = "9290546f493656d80a4aa05b63dfeaf9f8527b0a"
+commit = "733c91a19baa65c40f4b1cf95a3991cc8c84d866"  # intel-gmmlib-22.10.2
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_iga_headers.py b/build_utils/get_iga_headers.py
index ade66891..ac6589e7 100644
--- a/build_utils/get_iga_headers.py
+++ b/build_utils/get_iga_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/intel-graphics-compiler.git"
-commit = "d5bef0c991c41e03a567187eb78fe35b6c116847"
+commit = "68759eeda7094ede9682fe61d647cf53efc3b6fd"  # v2.43.9
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_igc_headers.py b/build_utils/get_igc_headers.py
index 91a6ac71..ca48bbc9 100644
--- a/build_utils/get_igc_headers.py
+++ b/build_utils/get_igc_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/intel-graphics-compiler.git"
-commit = "d5bef0c991c41e03a567187eb78fe35b6c116847"
+commit = "68759eeda7094ede9682fe61d647cf53efc3b6fd"  # v2.43.9
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_itt.py b/build_utils/get_itt.py
index f9349a85..86e64bd1 100644
--- a/build_utils/get_itt.py
+++ b/build_utils/get_itt.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/ittapi.git"
-commit = "83d6ca4bb7df67dfacac7618bd7ef5f12735c8a7"
+commit = "bd72cfb15e34a5fc4c0a8d10f5bb5305d60e1eec"  # v3.28.4
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_md_headers.py b/build_utils/get_md_headers.py
index 25830902..a10ce3fe 100644
--- a/build_utils/get_md_headers.py
+++ b/build_utils/get_md_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/intel/metrics-discovery.git"
-commit = "4ff8df044cbd9b270f2cf9561d1a60f826679f62"
+commit = "1524a7a75f5847c23ea69e1974ec6c4245f53452"  # metrics-discovery-1.14.182
 
 def main():
   if len(sys.argv) < 3:
diff --git a/build_utils/get_ze_headers.py b/build_utils/get_ze_headers.py
index 70029566..fd935afd 100644
--- a/build_utils/get_ze_headers.py
+++ b/build_utils/get_ze_headers.py
@@ -4,7 +4,7 @@
 import build_utils
 
 url = "https://github.com/oneapi-src/level-zero.git"
-default_commit = "a4afcb39ee265e595d3f0aa57b25b5e845fb494c"
+default_commit = "b77ced661af97104f5cda03d49596274392f6aa4"  # v1.29.0
 
 def main():
   if len(sys.argv) < 3:
@@ -30,7 +30,7 @@ def main():
 
   src_path = os.path.join(clone_path, "include")
   build_utils.copy(src_path, dst_path,\
-    ["ze_api.h", "zes_api.h", "zet_api.h", "zer_api.h"])
+    ["ze_api.h", "zes_api.h", "zet_api.h"])
 
   if (not os.path.exists(os.path.join(dst_path, "layers"))):
     os.mkdir(os.path.join(dst_path, "layers"))
diff --git a/cmake/packaging.cmake b/cmake/packaging.cmake
index 7c8e895b..ab79d6c1 100644
--- a/cmake/packaging.cmake
+++ b/cmake/packaging.cmake
@@ -3,6 +3,12 @@
 #
 # SPDX-License-Identifier: MIT
 # =============================================================
+#
+# CPack configuration: one package per tool (TGZ, DEB, RPM on Linux; ZIP on
+# Windows, untested).
+# Expects PTI_GPU_ENABLED_TOOLS from the top-level CMakeLists.txt; each tool
+# is installed as a component of the same name.
+
 if(NOT PTI_PROJECT_LICENSE_FILE)
   if(EXISTS "${PROJECT_SOURCE_DIR}/LICENSE")
     set(PTI_PROJECT_LICENSE_FILE "${PROJECT_SOURCE_DIR}/LICENSE")
@@ -18,22 +24,28 @@ include(ProcessorCount)
 ProcessorCount(NPROC)
 set(CPACK_THREADS ${NPROC})
 
-# TODO: Figure out whether this is desired or not. We have not stripped symbols
-# in the past, so for now, this will be kept OFF. Note, leaving this ON is
-# incompatible with CPACK_DEBIAN_<GROUP>_DEBUGINFO_PACKAGE and
-# CPACK_RPM_<GROUP>_DEBUGINFO_PACKAGE.
 set(CPACK_STRIP_FILES OFF)
 
+if(WIN32)
+  set(CPACK_GENERATOR "ZIP")
+else()
+  set(CPACK_GENERATOR "TGZ;DEB")
+  find_program(PTI_GPU_RPMBUILD rpmbuild)
+  if(PTI_GPU_RPMBUILD)
+    list(APPEND CPACK_GENERATOR "RPM")
+  endif()
+endif()
+
 set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
 set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
 set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
 set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
-set(CPACK_PACKAGE_VENDOR "Intel Corporation")
-set(CPACK_PACKAGE_CONTACT "Intel Corporation <secure@intel.com>")
+set(CPACK_PACKAGE_VENDOR "PTI-GPU fork maintainers")
+set(CPACK_PACKAGE_CONTACT "${PROJECT_HOMEPAGE_URL}/issues")
 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_DESCRIPTION}")
 set(CPACK_PACKAGE_DESCRIPTION
-    "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}. Tools and libraries for Intel trace and profiling."
+    "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}. Tracing and profiling tools for Intel GPUs."
 )
 set(CPACK_PACKAGE_HOMEPAGE_URL "${PROJECT_HOMEPAGE_URL}")
 set(CPACK_PACKAGE_CHECKSUM SHA256)
@@ -41,227 +53,63 @@ if(PTI_PROJECT_LICENSE_FILE)
   set(CPACK_RESOURCE_FILE_LICENSE "${PTI_PROJECT_LICENSE_FILE}")
 endif()
 set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")
-set(CPACK_RESOURCE_FILE_WELCOME "${CPACK_RESOURCE_FILE_README}")
-
-set(CPACK_COMPONENTS_GROUPING ONE_PER_GROUP)
 
-# ################### Package Descriptions ####################
-set(PTI_PKG_RUNTIME_DESCRIPTION
-    "PTI runtime libraries for collecting Intel GPU data")
-set(PTI_PKG_DEVELOPMENT_DESCRIPTION
-    "PTI development files (headers, etc...) for building with PTI")
-set(PTI_PKG_ONEAPI_DESCRIPTION
-    "PTI Intel(R) oneAPI integration files for oneAPI installation")
-set(PTI_PKG_UNITRACE_GROUP_DESCRIPTION
-    "Intel(R) GPU Unitrace profiler tool for collecting Intel GPU data")
-set(PTI_PKG_UNITRACE_SCRIPTS_GROUP_DESCRIPTION
-    "Intel(R) GPU Unitrace analysis scripts for analyzing data collected by Unitrace"
-)
-
-# ################### DEBIAN CPack Configuration ####################
+# One package per tool component.
+set(CPACK_COMPONENTS_ALL ${PTI_GPU_ENABLED_TOOLS})
+set(CPACK_COMPONENTS_GROUPING IGNORE)
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
 set(CPACK_DEB_COMPONENT_INSTALL ON)
-set(CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS ON)
-set(CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
-
-# pti-gpu-sdk
-set(CPACK_DEBIAN_PTI_RUNTIME_GROUP_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-sdk")
-set(CPACK_DEBIAN_PTI_RUNTIME_GROUP_DEBUGINFO_PACKAGE ON)
-set(CPACK_DEBIAN_PTI_RUNTIME_GROUP_DESCRIPTION "${PTI_PKG_RUNTIME_DESCRIPTION}")
-
-# pti-gpu-sdk-dev
-set(CPACK_DEBIAN_PTI_DEVELOPMENT_GROUP_PACKAGE_NAME
-    "${CPACK_PACKAGE_NAME}-sdk-dev")
-set(CPACK_DEBIAN_PTI_DEVELOPMENT_GROUP_PACKAGE_DEPENDS
-    "${CPACK_PACKAGE_NAME}-sdk (= ${CPACK_PACKAGE_VERSION})")
-set(CPACK_DEBIAN_PTI_DEVELOPMENT_GROUP_DESCRIPTION
-    "${PTI_PKG_DEVELOPMENT_DESCRIPTION}")
-
-# pti-gpu-sdk-oneapi
-set(CPACK_DEBIAN_PTI_ONEAPI_GROUP_PACKAGE_NAME
-    "${CPACK_PACKAGE_NAME}-sdk-oneapi")
-set(CPACK_DEBIAN_PTI_ONEAPI_GROUP_PACKAGE_ARCHITECTURE "all")
-set(CPACK_DEBIAN_PTI_ONEAPI_GROUP_PACKAGE_DEPENDS
-    "${CPACK_PACKAGE_NAME}-sdk (= ${CPACK_PACKAGE_VERSION})")
-set(CPACK_DEBIAN_PTI_ONEAPI_GROUP_DESCRIPTION "${PTI_PKG_ONEAPI_DESCRIPTION}")
-
-# pti-gpu-unitrace
-set(CPACK_DEBIAN_UNITRACE_GROUP_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-unitrace")
-set(CPACK_DEBIAN_UNITRACE_GROUP_DEBUGINFO_PACKAGE ON)
-set(CPACK_DEBIAN_UNITRACE_GROUP_DESCRIPTION
-    "${PTI_PKG_UNITRACE_GROUP_DESCRIPTION}")
-
-# pti-gpu-unitrace-scripts
-set(CPACK_DEBIAN_UNITRACE_SCRIPTS_GROUP_PACKAGE_NAME
-    "${CPACK_PACKAGE_NAME}-unitrace-scripts")
-set(CPACK_DEBIAN_UNITRACE_SCRIPTS_GROUP_PACKAGE_ARCHITECTURE "all")
-set(CPACK_DEBIAN_UNITRACE_SCRIPTS_GROUP_PACKAGE_DEPENDS
-    "${CPACK_PACKAGE_NAME}-unitrace (= ${CPACK_PACKAGE_VERSION}), python3 (>= 3.9)"
-)
-set(CPACK_DEBIAN_UNITRACE_SCRIPTS_GROUP_PACKAGE_RECOMMENDS
-    "python3-pandas, python3-matplotlib")
-set(CPACK_DEBIAN_UNITRACE_SCRIPTS_GROUP_DESCRIPTION
-    "${PTI_PKG_UNITRACE_SCRIPTS_GROUP_DESCRIPTION}")
-
-# ################### RPM CPack Configuration ####################
 set(CPACK_RPM_COMPONENT_INSTALL ON)
-set(CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-sdk")
+
+# ################### Tool Descriptions ####################
+set(PTI_PKG_cl_tracer_DESCRIPTION "OpenCL(TM) API and device activity tracer")
+set(PTI_PKG_ze_tracer_DESCRIPTION
+    "oneAPI Level Zero API and device activity tracer")
+set(PTI_PKG_onetrace_DESCRIPTION
+    "Host and device tracing tool for OpenCL(TM) and oneAPI Level Zero")
+set(PTI_PKG_oneprof_DESCRIPTION "GPU HW metrics collection tool")
+set(PTI_PKG_gpuinfo_DESCRIPTION "GPU device and metrics information tool")
+set(PTI_PKG_instcount_DESCRIPTION
+    "GTPin-based GPU kernel instruction counting tool")
+set(PTI_PKG_memaccess_DESCRIPTION "GTPin-based GPU memory access tracing tool")
+set(PTI_PKG_sysmon_DESCRIPTION "GPU system monitoring tool")
+
+# ################### DEB / RPM Configuration ####################
+set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
 set(CPACK_RPM_FILE_NAME RPM-DEFAULT)
-set(CPACK_RPM_MAIN_COMPONENT Pti_Runtime_Group)
 set(CPACK_RPM_PACKAGE_LICENSE "${PTI_PROJECT_LICENSE_SPDX}")
 set(CPACK_RPM_PACKAGE_AUTOREQPROV ON)
 
-set(CPACK_RPM_PTI_RUNTIME_GROUP_PACKAGE_SUMMARY
-    "Intel(R) Profiling Tools Interfaces libraries")
-set(CPACK_RPM_PTI_RUNTIME_GROUP_PACKAGE_DESCRIPTION
-    "${PTI_PKG_RUNTIME_DESCRIPTION}")
-set(CPACK_RPM_PTI_RUNTIME_GROUP_DEBUGINFO_PACKAGE ON)
-
-# pti-gpu-sdk-devel
-set(CPACK_RPM_PTI_DEVELOPMENT_GROUP_PACKAGE_NAME
-    "${CPACK_PACKAGE_NAME}-sdk-devel")
-set(CPACK_RPM_PTI_DEVELOPMENT_GROUP_PACKAGE_SUMMARY
-    "Intel(R) Profiling Tools Interfaces development files")
-set(CPACK_RPM_PTI_DEVELOPMENT_GROUP_PACKAGE_DESCRIPTION
-    "${PTI_PKG_DEVELOPMENT_DESCRIPTION}")
-set(CPACK_RPM_PTI_DEVELOPMENT_GROUP_PACKAGE_REQUIRES
-    "${CPACK_PACKAGE_NAME}-sdk = ${CPACK_PACKAGE_VERSION}")
-
-# pti-gpu-sdk-oneapi
-set(CPACK_RPM_PTI_ONEAPI_GROUP_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-sdk-oneapi")
-set(CPACK_RPM_PTI_ONEAPI_GROUP_PACKAGE_ARCHITECTURE "noarch")
-set(CPACK_RPM_PTI_ONEAPI_GROUP_PACKAGE_SUMMARY
-    "Intel(R) oneAPI files for Intel(R) Profiling Tools Interfaces")
-set(CPACK_RPM_PTI_ONEAPI_GROUP_PACKAGE_DESCRIPTION
-    "${PTI_PKG_ONEAPI_DESCRIPTION}")
-set(CPACK_RPM_PTI_ONEAPI_GROUP_PACKAGE_REQUIRES
-    "${CPACK_PACKAGE_NAME}-sdk = ${CPACK_PACKAGE_VERSION}")
-
-# pti-gpu-unitrace
-set(CPACK_RPM_UNITRACE_GROUP_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-unitrace")
-set(CPACK_RPM_UNITRACE_GROUP_PACKAGE_SUMMARY
-    "Unitrace profiler for Intel(R) GPUs")
-set(CPACK_RPM_UNITRACE_GROUP_PACKAGE_DESCRIPTION
-    "${PTI_PKG_UNITRACE_GROUP_DESCRIPTION}")
-set(CPACK_RPM_UNITRACE_GROUP_DEBUGINFO_PACKAGE ON)
-
-# pti-gpu-unitrace-scripts
-set(CPACK_RPM_UNITRACE_SCRIPTS_GROUP_PACKAGE_NAME
-    "${CPACK_PACKAGE_NAME}-unitrace-scripts")
-set(CPACK_RPM_UNITRACE_SCRIPTS_GROUP_PACKAGE_ARCHITECTURE "noarch")
-set(CPACK_RPM_UNITRACE_SCRIPTS_GROUP_PACKAGE_SUMMARY
-    "Analysis scripts for data collected by unitrace")
-set(CPACK_RPM_UNITRACE_SCRIPTS_GROUP_PACKAGE_DESCRIPTION
-    "${PTI_PKG_UNITRACE_SCRIPTS_GROUP_DESCRIPTION}")
-set(CPACK_RPM_UNITRACE_SCRIPTS_GROUP_PACKAGE_REQUIRES
-    "${CPACK_PACKAGE_NAME}-unitrace = ${CPACK_PACKAGE_VERSION}, python3 >= 3.9")
+foreach(_tool IN LISTS PTI_GPU_ENABLED_TOOLS)
+  string(TOUPPER "${_tool}" _TOOL)
+  set(CPACK_DEBIAN_${_TOOL}_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-${_tool}")
+  set(CPACK_DEBIAN_${_TOOL}_DESCRIPTION "${PTI_PKG_${_tool}_DESCRIPTION}")
+  set(CPACK_RPM_${_TOOL}_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-${_tool}")
+  set(CPACK_RPM_${_TOOL}_PACKAGE_SUMMARY "${PTI_PKG_${_tool}_DESCRIPTION}")
+endforeach()
 
+# Hidden directories (.git, .github, editor and cache dirs, local-only dirs).
 set(CPACK_SOURCE_IGNORE_FILES
-    "/\\.git/"
-    "/\\.github/"
-    "/\\.vscode/"
-    "/\\.vs/"
-    "/\\.vim/"
-    "/\\.cache/"
-    "/\\.venv/"
+    "/\\.[^/]+/"
     "/venv/"
     "/build/"
     "/build-[^/]*/"
-    "/wbr/"
-    "/out/"
-    "/drop_raw/"
-    "/dist/"
     "/__pycache__/"
     "\\.swp$"
     "${PROJECT_BINARY_DIR}/")
 
 include(CPack) # After CPACK_*
 
-# ################### Component Groups ####################
-cpack_add_component_group(
-  Pti_Runtime_Group
-  DISPLAY_NAME "PTI Runtime"
-  DESCRIPTION "PTI Runtime Libraries for collecting Level Zero and SYCL data.")
-
-cpack_add_component_group(
-  Pti_Development_Group
-  DISPLAY_NAME "PTI Development"
-  DESCRIPTION "Files (headers, etc...) needed to build against PTI")
-
-cpack_add_component_group(
-  Pti_oneAPI_Group
-  DISPLAY_NAME "PTI oneAPI-specifics"
-  DESCRIPTION "oneAPI installation files")
-
-cpack_add_component_group(
-  Unitrace_Group
-  DISPLAY_NAME "Unitrace"
-  DESCRIPTION "Unitrace Tool Binaries")
-
-cpack_add_component_group(
-  Unitrace_Scripts_Group
-  DISPLAY_NAME "Unitrace Analysis Scripts"
-  DESCRIPTION "Scripts that analyze the data collected by unitrace")
-
 # ################### Components ####################
-cpack_add_component(
-  Pti_Runtime
-  DISPLAY_NAME "Libraries"
-  DESCRIPTION "Libraries needed at runtime"
-  GROUP Pti_Runtime_Group)
-
-cpack_add_component(
-  Pti_Doc
-  DISPLAY_NAME "Documentation"
-  DESCRIPTION "Documentation related files"
-  GROUP Pti_Runtime_Group
-  DEPENDS Pti_Runtime)
-
-cpack_add_component(
-  Pti_Development
-  DISPLAY_NAME "Development"
-  DESCRIPTION "Header files + configuration files"
-  GROUP Pti_Development_Group
-  DEPENDS Pti_Runtime)
-
-cpack_add_component(
-  Pti_oneAPI
-  DISPLAY_NAME "oneAPI-specifics"
-  DESCRIPTION "files related to oneAPI installation"
-  GROUP Pti_oneAPI_Group
-  DEPENDS Pti_Runtime)
-
-cpack_add_component(
-  Pti_Bom
-  DISPLAY_NAME "oneAPI Bill of Materials"
-  DESCRIPTION "Bill of materials generated for oneAPI drops"
-  GROUP Pti_oneAPI_Group
-  DEPENDS Pti_oneAPI
-  HIDDEN)
-
-cpack_add_component(
-  Unspecified
-  DISPLAY_NAME "Unspecified"
-  DESCRIPTION "Files installed without an explicit component"
-  GROUP Pti_oneAPI_Group
-  HIDDEN)
-
-cpack_add_component(
-  Unitrace_Runtime
-  DISPLAY_NAME "Unitrace Binaries"
-  DESCRIPTION "Unitrace tool and runtime"
-  GROUP Unitrace_Group)
-
-cpack_add_component(
-  Unitrace_Config
-  DISPLAY_NAME "Unitrace Configuration Files"
-  DESCRIPTION "Unitrace configuration files"
-  GROUP Unitrace_Group
-  DEPENDS Unitrace_Runtime)
-
-cpack_add_component(
-  Unitrace_Scripts
-  DISPLAY_NAME "Unitrace Analysis Scripts"
-  DESCRIPTION "Unitrace scripts for analysis of collected data"
-  GROUP Unitrace_Scripts_Group
-  DEPENDS Unitrace_Runtime)
+cpack_add_component_group(
+  Tools
+  DISPLAY_NAME "PTI-GPU Tools"
+  DESCRIPTION "Tracing and profiling tools for Intel GPUs")
+
+foreach(_tool IN LISTS PTI_GPU_ENABLED_TOOLS)
+  cpack_add_component(
+    ${_tool}
+    DISPLAY_NAME "${_tool}"
+    DESCRIPTION "${PTI_PKG_${_tool}_DESCRIPTION}"
+    GROUP Tools)
+endforeach()
diff --git a/samples/cl_debug_info/README.md b/samples/cl_debug_info/README.md
index bbb26e79..d0c1ae7b 100644
--- a/samples/cl_debug_info/README.md
+++ b/samples/cl_debug_info/README.md
@@ -84,7 +84,7 @@ As a result, listing like the following will be printed for each kernel (once pe
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_gemm/README.md b/samples/cl_gemm/README.md
index d3399ace..4cf1f997 100644
--- a/samples/cl_gemm/README.md
+++ b/samples/cl_gemm/README.md
@@ -19,7 +19,7 @@ Total execution time: 0.739879 sec
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_gemm_inst/README.md b/samples/cl_gemm_inst/README.md
index f5011d7e..a07744ce 100644
--- a/samples/cl_gemm_inst/README.md
+++ b/samples/cl_gemm_inst/README.md
@@ -30,7 +30,7 @@ Estimated total number of HW threads: 336
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_gemm_itt/README.md b/samples/cl_gemm_itt/README.md
index b9ac38be..696716bb 100644
--- a/samples/cl_gemm_itt/README.md
+++ b/samples/cl_gemm_itt/README.md
@@ -19,7 +19,7 @@ Total execution time: 0.739879 sec
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_gpu_metrics/README.md b/samples/cl_gpu_metrics/README.md
index b7adee0a..e8ac1b9f 100644
--- a/samples/cl_gpu_metrics/README.md
+++ b/samples/cl_gpu_metrics/README.md
@@ -19,7 +19,7 @@ To set target device and sub-device to collect metrics from one can specify `PTI
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_gpu_query/README.md b/samples/cl_gpu_query/README.md
index 9aae3e7b..4d6735de 100644
--- a/samples/cl_gpu_query/README.md
+++ b/samples/cl_gpu_query/README.md
@@ -19,7 +19,7 @@ To set target device and sub-device to collect metrics from one can specify `PTI
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_hot_functions/README.md b/samples/cl_hot_functions/README.md
index 0b3b6d07..636dcdd8 100644
--- a/samples/cl_hot_functions/README.md
+++ b/samples/cl_hot_functions/README.md
@@ -44,7 +44,7 @@ clCreateCommandQueueWithProperties,           1,                1388,      0.00,
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/cl_hot_kernels/README.md b/samples/cl_hot_kernels/README.md
index 0e604568..2167ddc7 100644
--- a/samples/cl_hot_kernels/README.md
+++ b/samples/cl_hot_kernels/README.md
@@ -20,7 +20,7 @@ Total Device Time for GPU (ns): 174828332
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/samples/dpc_gemm/CMakeLists.txt b/samples/dpc_gemm/CMakeLists.txt
index f0a223c0..c7f25e22 100644
--- a/samples/dpc_gemm/CMakeLists.txt
+++ b/samples/dpc_gemm/CMakeLists.txt
@@ -14,10 +14,12 @@ SetBuildType()
 
 add_executable(dpc_gemm main.cc)
 
-target_compile_options(dpc_gemm PUBLIC -fsycl -gline-tables-only)
+# -g rather than -gline-tables-only: icpx ignores the latter for the SPIR-V
+# device target, and ze_debug_info needs device line info for source mapping.
+target_compile_options(dpc_gemm PUBLIC -fsycl -g)
 
 # target_link_options CMake >= 3.13
-set_target_properties(dpc_gemm PROPERTIES LINK_FLAGS "-fsycl -gline-tables-only")
+set_target_properties(dpc_gemm PROPERTIES LINK_FLAGS "-fsycl -g")
 
 target_include_directories(dpc_gemm
   PRIVATE "${PROJECT_SOURCE_DIR}/../../utils")
diff --git a/samples/dpc_gemm/README.md b/samples/dpc_gemm/README.md
index 7ac5f3ea..32186324 100644
--- a/samples/dpc_gemm/README.md
+++ b/samples/dpc_gemm/README.md
@@ -19,7 +19,7 @@ Total execution time: 0.373728 sec
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Intel(R) oneAPI Base Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html)
@@ -37,7 +37,7 @@ make
 ```
 Use this command line to run the application:
 ```sh
-./dpc_gemm [cpu|gpu|host] [matrix_size] [repeat_count]
+./dpc_gemm [cpu|gpu] [matrix_size] [repeat_count]
 ```
 ### Windows
 Use Microsoft* Visual Studio x64 command prompt to run the following commands and build the sample (make sure you have oneAPI DPC++ Compiler in `PATH` for building):
@@ -52,5 +52,5 @@ cmake --build . --config Release
 Use this command line to run the application:
 ```sh
 cd Release
-dpc_gemm.exe [cpu|gpu|host] [matrix_size] [repeats_count]
+dpc_gemm.exe [cpu|gpu] [matrix_size] [repeats_count]
 ```
\ No newline at end of file
diff --git a/samples/dpc_gemm/main.cc b/samples/dpc_gemm/main.cc
index 828a0fa4..fc45e5bb 100644
--- a/samples/dpc_gemm/main.cc
+++ b/samples/dpc_gemm/main.cc
@@ -110,8 +110,6 @@ int main(int argc, char* argv[]) {
     dev = sycl::device(sycl::gpu_selector_v);
     if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
       dev = sycl::device(sycl::cpu_selector_v);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
     }
   } catch (const sycl::exception& e) {
     std::cerr << "Error: Exception caught while executing SYCL " << e.what() << '\n';
diff --git a/samples/dpc_info/README.md b/samples/dpc_info/README.md
index 493e615a..0e20fbb2 100644
--- a/samples/dpc_info/README.md
+++ b/samples/dpc_info/README.md
@@ -45,7 +45,7 @@ The following modes are implemented:
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Intel(R) oneAPI Base Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html)
diff --git a/samples/dpc_info/main.cc b/samples/dpc_info/main.cc
index 4f59a573..7b6c63b4 100644
--- a/samples/dpc_info/main.cc
+++ b/samples/dpc_info/main.cc
@@ -5,6 +5,13 @@
 
 #include <sycl/sycl.hpp>
 
+// Some descriptors printed below are deprecated in SYCL 2020 and have no
+// drop-in replacement. Keep printing them, but silence the deprecation warning.
+#define PTI_SYCL_DEPRECATED_BEGIN \
+  _Pragma("clang diagnostic push") \
+  _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#define PTI_SYCL_DEPRECATED_END _Pragma("clang diagnostic pop")
+
 #define TAB std::string("  ")
 
 #define TEXT_WIDTH   50
@@ -99,8 +106,10 @@ int main(int argc, char* argv[]) {
       std::cout << std::setw(TEXT_WIDTH) << std::left <<
         TAB + "Platform Vendor " << vendor << std::endl;
 
+      PTI_SYCL_DEPRECATED_BEGIN
       std::string profile =
         platform.get_info<sycl::info::platform::profile>();
+      PTI_SYCL_DEPRECATED_END
       std::cout << std::setw(TEXT_WIDTH) << std::left <<
         TAB + "Platform Profile " << profile << std::endl;
     }
@@ -250,11 +259,18 @@ int main(int argc, char* argv[]) {
         // TODO(matthew.schilling@intel.com): Deprecated, however, I do not
         // know a drop-in replacement.
         // https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#_device_information_descriptors
-        bool preferred_interop_user_sync =
-          device.get_info<sycl::info::device::preferred_interop_user_sync>();
+        // Only the OpenCL backend supports this query; others throw.
         std::cout << std::setw(TEXT_WIDTH) << std::left <<
-          TAB + "Prefer user sync for interop " <<
-          (is_compiler_avilable ? "Yes" : "No") << std::endl;
+          TAB + "Prefer user sync for interop ";
+        if (device.get_backend() == sycl::backend::opencl) {
+          PTI_SYCL_DEPRECATED_BEGIN
+          bool preferred_interop_user_sync =
+            device.get_info<sycl::info::device::preferred_interop_user_sync>();
+          PTI_SYCL_DEPRECATED_END
+          std::cout << (preferred_interop_user_sync ? "Yes" : "No") << std::endl;
+        } else {
+          std::cout << "N/A" << std::endl;
+        }
 
         size_t profiling_timer_resolution =
           device.get_info<sycl::info::device::profiling_timer_resolution>();
@@ -265,8 +281,10 @@ int main(int argc, char* argv[]) {
         // TODO(matthew.schilling@intel.com): Deprecated, however, I do not
         // know a drop-in replacement.
         // https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#_device_information_descriptors
+        PTI_SYCL_DEPRECATED_BEGIN
         size_t printf_buffer_size =
           device.get_info<sycl::info::device::printf_buffer_size>();
+        PTI_SYCL_DEPRECATED_END
         std::cout << std::setw(TEXT_WIDTH) << std::left <<
           TAB + "printf() buffer size" << printf_buffer_size << " (" <<
           ConvertBytesToString(printf_buffer_size) << ")" << std::endl;
@@ -284,8 +302,10 @@ int main(int argc, char* argv[]) {
         // suggested replacement is not 1-for-1. I added the implementation
         // using aspects below. Keeping this for now.
         // https://registry.khronos.org/SYCL/specs/sycl-2020/html/sycl-2020.html#_device_information_descriptors
+        PTI_SYCL_DEPRECATED_BEGIN
         std::vector<std::string> device_extensions =
           device.get_info<sycl::info::device::extensions>();
+        PTI_SYCL_DEPRECATED_END
         std::cout << std::setw(TEXT_WIDTH) << std::left <<
           TAB + "Device Extensions ";
         for (const auto& device_extension : device_extensions) {
diff --git a/samples/gpu_perfmon_set/README.md b/samples/gpu_perfmon_set/README.md
index 16219328..83364ee2 100644
--- a/samples/gpu_perfmon_set/README.md
+++ b/samples/gpu_perfmon_set/README.md
@@ -18,7 +18,7 @@ To read the collected values for the event one should use binary instrumentation
 - Linux
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [libdrm](https://gitlab.freedesktop.org/mesa/drm)
diff --git a/samples/omp_gemm/README.md b/samples/omp_gemm/README.md
index 636d5ee2..1979246d 100644
--- a/samples/omp_gemm/README.md
+++ b/samples/omp_gemm/README.md
@@ -19,7 +19,7 @@ Total execution time: 5.37699 sec
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Intel(R) oneAPI Base Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html)
diff --git a/samples/omp_hot_regions/README.md b/samples/omp_hot_regions/README.md
index 7cd6d531..3b99fabd 100644
--- a/samples/omp_hot_regions/README.md
+++ b/samples/omp_hot_regions/README.md
@@ -19,7 +19,7 @@ Total Region Time (ns): 186811670
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Intel(R) oneAPI Base Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html)
diff --git a/samples/omp_hot_regions/tool.cc b/samples/omp_hot_regions/tool.cc
index afa1719e..b46e4318 100644
--- a/samples/omp_hot_regions/tool.cc
+++ b/samples/omp_hot_regions/tool.cc
@@ -177,6 +177,9 @@ static void Finalize(ompt_data_t* data) {
 
 // Internal Tool Interface ////////////////////////////////////////////////////
 
+// Must be exported: the library is built with -fvisibility=hidden, and the
+// OpenMP runtime looks this symbol up with dlsym().
+extern "C" PTI_EXPORT
 ompt_start_tool_result_t* ompt_start_tool(
     unsigned int omp_version, const char* runtime_version) {
   std::cerr << "[INFO] OMP Runtime Version: " << runtime_version << std::endl;
diff --git a/samples/ze_debug_info/README.md b/samples/ze_debug_info/README.md
index 48f743cc..3f420a98 100644
--- a/samples/ze_debug_info/README.md
+++ b/samples/ze_debug_info/README.md
@@ -91,7 +91,7 @@ As a result, listing like the following will be printed for each kernel (once pe
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_debug_info/tool.cc b/samples/ze_debug_info/tool.cc
index e64f64b3..f25d2222 100644
--- a/samples/ze_debug_info/tool.cc
+++ b/samples/ze_debug_info/tool.cc
@@ -38,7 +38,7 @@ static void PrintResults() {
 
 void EnableProfiling() {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
   collector = ZeDebugInfoCollector::Create();
 }
diff --git a/samples/ze_gemm/README.md b/samples/ze_gemm/README.md
index fd0e056a..ed8241a9 100644
--- a/samples/ze_gemm/README.md
+++ b/samples/ze_gemm/README.md
@@ -21,7 +21,7 @@ To run application on target device and sub-device one can specify `PTI_DEVICE_I
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_gemm/main.cc b/samples/ze_gemm/main.cc
index d8838682..7fcb59d7 100644
--- a/samples/ze_gemm/main.cc
+++ b/samples/ze_gemm/main.cc
@@ -251,7 +251,7 @@ static void Compute(ze_device_handle_t device,
 
 int main(int argc, char* argv[]) {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   ze_device_handle_t device = utils::ze::GetGpuDevice();
diff --git a/samples/ze_hot_functions/README.md b/samples/ze_hot_functions/README.md
index 9a0e4cbe..a6ed20fa 100644
--- a/samples/ze_hot_functions/README.md
+++ b/samples/ze_hot_functions/README.md
@@ -44,7 +44,7 @@ zeCommandQueueExecuteCommandLists,           4,            89169473,     20.72,
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_hot_functions/tool.cc b/samples/ze_hot_functions/tool.cc
index b96944d6..8cc93847 100644
--- a/samples/ze_hot_functions/tool.cc
+++ b/samples/ze_hot_functions/tool.cc
@@ -64,7 +64,7 @@ static void PrintResults() {
 
 void EnableProfiling() {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   collector = ZeApiCollector::Create();
diff --git a/samples/ze_hot_kernels/README.md b/samples/ze_hot_kernels/README.md
index ae5d9d21..331e9e50 100644
--- a/samples/ze_hot_kernels/README.md
+++ b/samples/ze_hot_kernels/README.md
@@ -17,7 +17,7 @@ Total Device Time (ns): 172440915
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_hot_kernels/tool.cc b/samples/ze_hot_kernels/tool.cc
index 5a33467d..1b3d5307 100644
--- a/samples/ze_hot_kernels/tool.cc
+++ b/samples/ze_hot_kernels/tool.cc
@@ -68,7 +68,7 @@ static void PrintResults() {
 
 void EnableProfiling() {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   collector = ZeKernelCollector::Create();
diff --git a/samples/ze_hot_kernels/ze_kernel_collector.h b/samples/ze_hot_kernels/ze_kernel_collector.h
index 1b1ba7c5..857d58b4 100644
--- a/samples/ze_hot_kernels/ze_kernel_collector.h
+++ b/samples/ze_hot_kernels/ze_kernel_collector.h
@@ -149,6 +149,11 @@ class ZeKernelCollector {
     ze_result_t status = ZE_RESULT_SUCCESS;
     status = zelTracerSetEnabled(tracer_, false);
     PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+
+    // Applications that only use synchronous immediate command lists (e.g.
+    // the OpenMP offload runtime) never synchronize or destroy events, so
+    // collect the kernels that have completed but are still pending.
+    ProcessCalls();
   }
 
   const ZeKernelInfoMap& GetKernelInfoMap() const {
diff --git a/samples/ze_info/README.md b/samples/ze_info/README.md
index 644e46d2..0f22a13c 100644
--- a/samples/ze_info/README.md
+++ b/samples/ze_info/README.md
@@ -37,7 +37,7 @@ This sample application provides information on all platforms and devices availa
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_info/main.cc b/samples/ze_info/main.cc
index 547a8376..42146864 100644
--- a/samples/ze_info/main.cc
+++ b/samples/ze_info/main.cc
@@ -378,7 +378,7 @@ int main(int argc, char *argv[]) {
   }
 
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   if (list_mode) {
diff --git a/samples/ze_metric_info/CMakeLists.txt b/samples/ze_metric_info/CMakeLists.txt
index ce32531a..a4821aa8 100644
--- a/samples/ze_metric_info/CMakeLists.txt
+++ b/samples/ze_metric_info/CMakeLists.txt
@@ -17,6 +17,7 @@ endif()
 FindL0Library(ze_metric_info)
 FindL0Headers(ze_metric_info)
 
+GetMDHeaders(ze_metric_info)
 CheckForMDLibrary(ze_metric_info)
 CheckForMetricsLibrary()
 
diff --git a/samples/ze_metric_info/README.md b/samples/ze_metric_info/README.md
index 43c66af7..10c0ed4a 100644
--- a/samples/ze_metric_info/README.md
+++ b/samples/ze_metric_info/README.md
@@ -27,7 +27,7 @@ To set target device and sub-device to collect metric info from one can specify
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_metric_info/main.cc b/samples/ze_metric_info/main.cc
index b8b7756e..e99f9a7e 100644
--- a/samples/ze_metric_info/main.cc
+++ b/samples/ze_metric_info/main.cc
@@ -78,7 +78,7 @@ int main(int argc, char* argv[]) {
   utils::SetEnv("ZET_ENABLE_METRICS", "1");
 
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   ze_device_handle_t device = utils::ze::GetGpuDevice();
diff --git a/samples/ze_metric_query/CMakeLists.txt b/samples/ze_metric_query/CMakeLists.txt
index 8a780509..098eedfb 100644
--- a/samples/ze_metric_query/CMakeLists.txt
+++ b/samples/ze_metric_query/CMakeLists.txt
@@ -19,6 +19,7 @@ endif()
 FindL0Library(zet_metric_query)
 FindL0Headers(zet_metric_query)
 
+GetMDHeaders(zet_metric_query)
 CheckForMDLibrary(zet_metric_query)
 CheckForMetricsLibrary()
 
diff --git a/samples/ze_metric_query/README.md b/samples/ze_metric_query/README.md
index ecd689e1..6382b532 100644
--- a/samples/ze_metric_query/README.md
+++ b/samples/ze_metric_query/README.md
@@ -19,7 +19,7 @@ To set target device and sub-device to collect metrics from one can specify `PTI
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_metric_query/tool.cc b/samples/ze_metric_query/tool.cc
index 7746a30e..ea9bee48 100644
--- a/samples/ze_metric_query/tool.cc
+++ b/samples/ze_metric_query/tool.cc
@@ -186,7 +186,7 @@ static void PrintResults() {
 
 void EnableProfiling() {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   ze_driver_handle_t driver = utils::ze::GetGpuDriver();
diff --git a/samples/ze_metric_streamer/CMakeLists.txt b/samples/ze_metric_streamer/CMakeLists.txt
index d6905c27..c48b49df 100644
--- a/samples/ze_metric_streamer/CMakeLists.txt
+++ b/samples/ze_metric_streamer/CMakeLists.txt
@@ -27,6 +27,7 @@ endif()
 FindL0Library(zet_metric_streamer)
 FindL0Headers(zet_metric_streamer)
 
+GetMDHeaders(zet_metric_streamer)
 CheckForMDLibrary(zet_metric_streamer)
 CheckForMetricsLibrary()
 
diff --git a/samples/ze_metric_streamer/README.md b/samples/ze_metric_streamer/README.md
index 176ea1c9..8ad93725 100644
--- a/samples/ze_metric_streamer/README.md
+++ b/samples/ze_metric_streamer/README.md
@@ -22,7 +22,7 @@ To set target device and sub-device to collect metrics from one can specify `PTI
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_metric_streamer/tool.cc b/samples/ze_metric_streamer/tool.cc
index 6e0e7efa..4bf0802a 100644
--- a/samples/ze_metric_streamer/tool.cc
+++ b/samples/ze_metric_streamer/tool.cc
@@ -222,7 +222,7 @@ static void PrintResults() {
 
 void EnableProfiling() {
   ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   ze_driver_handle_t driver = utils::ze::GetGpuDriver();
diff --git a/samples/ze_sysman/README.md b/samples/ze_sysman/README.md
index 89b569f6..bcec2d18 100644
--- a/samples/ze_sysman/README.md
+++ b/samples/ze_sysman/README.md
@@ -20,7 +20,7 @@ Device: Intel(R) Iris(R) Plus Graphics 655 [0x3ea5]
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/samples/ze_sysman/main.cc b/samples/ze_sysman/main.cc
index 63b73888..e76f7aff 100644
--- a/samples/ze_sysman/main.cc
+++ b/samples/ze_sysman/main.cc
@@ -1,5 +1,6 @@
 #include <iomanip>
 #include <iostream>
+#include <string>
 #include <vector>
 
 #ifdef __linux__
@@ -16,14 +17,65 @@
 
 #define BYTES_IN_MB (1024 * 1024)
 
-int main() {
-  utils::SetEnv("ZES_ENABLE_SYSMAN", "1");
+// Returns the GPU selected by PTI_DEVICE_ID (default 0) using Sysman handles
+// obtained after zesInit().
+static zes_device_handle_t GetSysmanGpuDevice() {
+  std::vector<zes_device_handle_t> gpu_list;
 
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  uint32_t driver_count = 0;
+  ze_result_t status = zesDriverGet(&driver_count, nullptr);
+  if (status != ZE_RESULT_SUCCESS || driver_count == 0) {
+    return nullptr;
+  }
+  std::vector<zes_driver_handle_t> driver_list(driver_count);
+  status = zesDriverGet(&driver_count, driver_list.data());
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
-  ze_device_handle_t device = utils::ze::GetGpuDevice();
+  for (auto driver : driver_list) {
+    uint32_t device_count = 0;
+    status = zesDeviceGet(driver, &device_count, nullptr);
+    if (status != ZE_RESULT_SUCCESS || device_count == 0) {
+      continue;
+    }
+    std::vector<zes_device_handle_t> device_list(device_count);
+    status = zesDeviceGet(driver, &device_count, device_list.data());
+    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+
+    for (auto device : device_list) {
+      zes_device_properties_t props{ZES_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
+      status = zesDeviceGetProperties(device, &props);
+      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+      if (props.core.type == ZE_DEVICE_TYPE_GPU) {
+        gpu_list.push_back(device);
+      }
+    }
+  }
+
+  if (gpu_list.empty()) {
+    return nullptr;
+  }
+
+  std::string value = utils::GetEnv("PTI_DEVICE_ID");
+  uint32_t device_id = value.empty() ? 0 : std::stoul(value);
+  PTI_ASSERT(device_id < gpu_list.size());
+  return gpu_list[device_id];
+}
+
+int main() {
+  zes_device_handle_t device = nullptr;
+
+  ze_result_t status = zesInit(0);
+  if (status == ZE_RESULT_SUCCESS) {
+    device = GetSysmanGpuDevice();
+  } else {
+    // Older loader or driver without zesInit(): use the legacy mode, where
+    // Level Zero core device handles are also valid Sysman handles.
+    utils::SetEnv("ZES_ENABLE_SYSMAN", "1");
+    status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+    device = utils::ze::GetGpuDevice();
+  }
+
   if (device == nullptr) {
     std::cout << "[WARNING] GPU device was not found" << std::endl;
     return 0;
diff --git a/sdk/.editorconfig b/sdk/.editorconfig
deleted file mode 100644
index ee1491f0..00000000
--- a/sdk/.editorconfig
+++ /dev/null
@@ -1,24 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-[*.{c,cc,h}]
-indent_style = space
-indent_size = 2
-max_line_length = 100
-
-[{CMakeLists.txt,*.cmake}]
-indent_style = space
-indent_size = 2
-max_line_length = 80
-
-[*.py]
-indent_style = space
-indent_size = 4
-profile = black
-
-[*.patch]
-trim_trailing_whitespace = false
diff --git a/sdk/.gitignore b/sdk/.gitignore
deleted file mode 100644
index 72700104..00000000
--- a/sdk/.gitignore
+++ /dev/null
@@ -1,21 +0,0 @@
-build*/
-*~
-venv/
-.vscode/
-.vs/
-.vim/
-.cache/
-compile_commands.json
-CMakeUserPresets.json
-error_diff.txt
-
-# Shortened Windows build directory
-wbr
-
-# Common test install directory
-out/
-
-# Raw install/packaging intermediary data
-drop_raw/
-
-dist/
diff --git a/sdk/CMakeLists.txt b/sdk/CMakeLists.txt
deleted file mode 100644
index 6a3449fc..00000000
--- a/sdk/CMakeLists.txt
+++ /dev/null
@@ -1,545 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-                      "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
-
-include(macros)
-cmake_minimum_required(VERSION 3.14)
-
-SetPtiVersion()
-
-project(
-  pti
-  VERSION ${PTI_VERSION}
-  DESCRIPTION "Intel Profiling Tools Interface"
-  HOMEPAGE_URL "https://github.com/intel/pti-gpu"
-  LANGUAGES C CXX
-)
-
-ProjectIsTopLevel()
-SetBuildType()
-
-# Global Settings
-
-if(PROJECT_IS_TOP_LEVEL AND NOT DEFINED PTI_COMMIT_HASH)
-  GetCurrentGitCommit(PTI_COMMIT_HASH)
-endif()
-
-if(NOT DEFINED PTI_COMMIT_HASH OR PTI_COMMIT_HASH STREQUAL "")
-  set(PTI_COMMIT_HASH "unknown")
-endif()
-
-if(PROJECT_IS_TOP_LEVEL)
-  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin CACHE STRING "")
-  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib CACHE STRING "")
-endif()
-
-# For developer use with tools like clangd(can be used by vscode and vim
-# plugins).
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-if(PROJECT_IS_TOP_LEVEL)
-  AddFormatTarget()
-endif()
-
-if(NOT DEFINED CMAKE_CXX_STANDARD)
-  set(CMAKE_CXX_STANDARD 17)
-else()
-  if(CMAKE_CXX_STANDARD LESS 17 OR CMAKE_CXX_STANDARD EQUAL 98)
-    message(FATAL_ERROR "CMAKE_CXX_STANDARD must be at least 17")
-  endif()
-endif()
-
-if(NOT DEFINED CMAKE_CXX_STANDARD_REQUIRED)
-  set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif()
-
-if(NOT DEFINED CMAKE_CXX_EXTENSIONS)
-  set(CMAKE_CXX_EXTENSIONS OFF)
-endif()
-
-if(NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
-  set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
-endif()
-
-if(NOT DEFINED CMAKE_C_STANDARD)
-  # C99 for the C headers in the PTI interface (${PROJECT_SOURCE_DIR}/include).
-  # They include stdint.h.
-  set(CMAKE_C_STANDARD 99)
-endif()
-
-if(NOT DEFINED CMAKE_C_STANDARD_REQUIRED)
-  set(CMAKE_C_STANDARD_REQUIRED ON)
-endif()
-
-if(NOT DEFINED CMAKE_C_EXTENSIONS)
-  set(CMAKE_C_EXTENSIONS OFF)
-endif()
-
-if(NOT DEFINED CMAKE_C_VISIBILITY_PRESET)
-  set(CMAKE_C_VISIBILITY_PRESET "hidden")
-endif()
-
-if(NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
-  set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
-endif()
-
-if(PROJECT_IS_TOP_LEVEL)
-  # Add the current directory to the rpath during the build. On Linux, this
-  # allows dlopen to find the proper modules.
-  if(NOT APPLE)
-    list(APPEND CMAKE_BUILD_RPATH $ORIGIN)
-  endif()
-endif()
-
-option(PTI_BUILD_TESTING "Build PTI tests" ${PROJECT_IS_TOP_LEVEL})
-option(PTI_BUILD_SAMPLES "Build samples with library" ${PROJECT_IS_TOP_LEVEL})
-option(PTI_BUILD_URGEMM "Build urgemm_suite test" ${PROJECT_IS_TOP_LEVEL})
-option(PTI_INSTALL "Install library when invoking --install" ON)
-option(PTI_ENABLE_LOGGING "Enable logging for Pti" OFF)
-option(PTI_FUZZ "Enable Fuzz Pti" OFF)
-option(PTI_API_ID_REGENERATE "Regenerate Apiid files" OFF)
-
-include(GNUInstallDirs)
-
-if(NOT DEFINED PTI_MODULE_SUBDIR)
-  set(PTI_MODULE_SUBDIR "pti")
-endif()
-
-if(NOT DEFINED PTI_INSTALL_CMAKE_DIR)
-  set(PTI_INSTALL_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/pti")
-endif()
-
-if (NOT DEFINED PTI_INSTALL_INCLUDE_DIR)
-  set(PTI_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}")
-endif()
-
-if (NOT DEFINED PTI_INSTALL_LIB_DIR)
-  set(PTI_INSTALL_LIB_DIR "${CMAKE_INSTALL_LIBDIR}")
-endif()
-
-if (NOT DEFINED PTI_INSTALL_BIN_DIR)
-  set(PTI_INSTALL_BIN_DIR "${CMAKE_INSTALL_BINDIR}")
-endif()
-
-if (NOT DEFINED PTI_INSTALL_LIC_DIR)
-  set(PTI_INSTALL_LIC_DIR "${CMAKE_INSTALL_DOCDIR}")
-endif()
-
-if (NOT DEFINED PTI_INSTALL_MODULE_DIR)
-  if (WIN32)
-    set(PTI_INSTALL_MODULE_DIR "${PTI_INSTALL_BIN_DIR}/${PTI_MODULE_SUBDIR}")
-  else()
-    set(PTI_INSTALL_MODULE_DIR "${PTI_INSTALL_LIB_DIR}/${PTI_MODULE_SUBDIR}")
-  endif()
-endif()
-
-set(PTI_API_SOVERSION "${PROJECT_VERSION_MAJOR}")
-
-CheckSOVersion(${PTI_API_SOVERSION})
-CheckExperimentalFilesystem()
-PtiCheckLinkerFlag(EXCLUDE_LIBS_ALL "LINKER:--exclude-libs,ALL")
-PtiCheckLinkerFlag(NODELETE "LINKER:-z,nodelete")
-
-# Check and Get Dependencies
-GetSpdlog()
-
-if(NOT TARGET Xpti::xpti)
-  find_package(Xpti)
-endif()
-if(NOT TARGET Xpti::xpti)
-  find_package(xptifw)
-  if(TARGET xptifw::xptifw)
-    add_library(Xpti::xpti ALIAS xptifw::xptifw)
-  endif()
-endif()
-
-include(cmake/levelzero.cmake)
-
-get_itt()
-
-find_package(Threads REQUIRED)
-
-# Build PTI libraries.
-configure_file(${PROJECT_SOURCE_DIR}/include/pti/pti_version.h.in
-               ${PROJECT_BINARY_DIR}/include/pti/pti_version.h)
-
-# Generate file with configuration information above.
-configure_file(${PROJECT_SOURCE_DIR}/src/utils/platform_config.h.in
-               ${PROJECT_BINARY_DIR}/platform_config.h
-               @ONLY)
-
-# https://cmake.org/cmake/help/latest/guide/importing-exporting/index.html
-add_library(pti_all INTERFACE)
-add_library(Pti::pti_all ALIAS pti_all)
-
-# The ITT collector is only built for the Linux version
-set(PTI_ITT_COLLECTOR_FILE $<$<PLATFORM_ID:Linux>:${PROJECT_SOURCE_DIR}/src/itt/itt_collector.cc>)
-set(PTI_ITT_STUBS_FILE $<$<PLATFORM_ID:Linux>:${PROJECT_SOURCE_DIR}/src/itt/itt_stubs.cc>)
-set(PTI_ITT_ADAPTER_FILE $<$<PLATFORM_ID:Linux>:${PROJECT_SOURCE_DIR}/src/itt/itt_adapter.cc>)
-set(PTI_ITT_LIB_ENV_FILE $<$<PLATFORM_ID:Linux>:${PROJECT_SOURCE_DIR}/src/itt/itt_lib_env.cc>)
-set(PTI_INTEL_LLVM_EXCLUDE_LIBS
-  $<$<AND:$<CXX_COMPILER_ID:IntelLLVM>,$<PLATFORM_ID:Linux>>:-no-intel-lib>
-  $<$<AND:$<CXX_COMPILER_ID:IntelLLVM>,$<PLATFORM_ID:Windows>>:/Qno-intel-lib>)
-
-# Apply -Wno-attributes flag to ITT files only for GCC on Linux
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  set_source_files_properties(${PROJECT_SOURCE_DIR}/src/itt/itt_collector.cc
-                               ${PROJECT_SOURCE_DIR}/src/itt/itt_stubs.cc
-                               ${PROJECT_SOURCE_DIR}/src/itt/itt_adapter.cc
-                               PROPERTIES COMPILE_FLAGS "-Wno-attributes")
-endif()
-
-# Core implementation loaded by pti_view
-add_library(pti MODULE "${PROJECT_SOURCE_DIR}/src/pti_view.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pti.cc"
-                       "${PROJECT_SOURCE_DIR}/src/levelzero/ze_driver_init.cc"
-                       "${PROJECT_SOURCE_DIR}/src/levelzero/ze_command_visitor.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pti_callbacks.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pc_sampling/pti_pc_sampling.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pc_sampling/pti_pc_sampling_collector.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pc_sampling/pti_pc_sampling_aggregator.cc"
-                       "${PROJECT_SOURCE_DIR}/src/metrics/pti_metrics.cc"
-                       "${PROJECT_SOURCE_DIR}/src/metrics/pti_metrics_scope.cc"
-                       "${PROJECT_SOURCE_DIR}/src/metrics/metric_state_manager.cc"
-                       "${PROJECT_SOURCE_DIR}/src/pti_version.cc"
-                       "${PROJECT_SOURCE_DIR}/src/overhead_kinds.cc"
-                       "$<$<TARGET_EXISTS:Xpti::xpti>:${PROJECT_SOURCE_DIR}/src/sycl/sycl_collector.cc>"
-                       "${PTI_ITT_COLLECTOR_FILE}")
-
-# We might want to make our own, but for now use CMake's
-# https://cmake.org/cmake/help/latest/module/GenerateExportHeader.html
-include(GenerateExportHeader)
-generate_export_header(pti EXPORT_FILE_NAME
-                 ${PROJECT_BINARY_DIR}/include/pti/pti_export.h)
-
-# Suspect we need this since we're sharing across multiple targets
-set(PTI_DEFINE_SYMBOL "pti_EXPORTS")
-
-add_library(Pti::pti ALIAS pti)
-
-# Where to find headers that user will include.
-set(PTI_PUBLIC_INCLUDE_DIRS
-  "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>"
-  "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>"
-  "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"
-  "$<INSTALL_INTERFACE:${PTI_INSTALL_INCLUDE_DIR}>"
-)
-
-set(PTI_PRIVATE_INCLUDE_DIRS
-  "${PROJECT_SOURCE_DIR}/src"
-  "${PROJECT_SOURCE_DIR}/src/sycl"
-  "${PROJECT_SOURCE_DIR}/src/levelzero"
-  "${PROJECT_SOURCE_DIR}/src/itt"
-  "${PROJECT_SOURCE_DIR}/src/utils"
-)
-
-target_include_directories(
-  pti
-  PUBLIC ${PTI_PUBLIC_INCLUDE_DIRS}
-  PRIVATE ${PTI_PRIVATE_INCLUDE_DIRS})
-
-set_target_properties(
-  pti
-  PROPERTIES VERSION "${PROJECT_VERSION}"
-             SOVERSION "${PTI_API_SOVERSION}"
-             POSITION_INDEPENDENT_CODE ON
-             LIBRARY_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:pti_view>/${PTI_MODULE_SUBDIR}
-             RUNTIME_OUTPUT_DIRECTORY $<TARGET_FILE_DIR:pti_view>/${PTI_MODULE_SUBDIR})
-
-if (WIN32)
-  set_target_properties(
-    pti
-    PROPERTIES DEBUG_POSTFIX "d"
-  )
-  AddProjectVersionInfo(pti)
-endif()
-
-
-set(XPTI_FRAMEWORK_DISPATCHER_NAME_DEFINE
-  $<$<TARGET_EXISTS:Xpti::xpti>:$<$<CONFIG:Debug>:PTI_XPTI_FRAMEWORK_DISPATCHER_NAME=$<TARGET_FILE_NAME:Xpti::xpti>>>)
-
-# XPTI needs NOMINMAX defined on Windows to avoid conflicts with numerical
-# limits.
-target_compile_definitions(
-  pti
-  PRIVATE $<$<TARGET_EXISTS:Xpti::xpti>:PTI_TRACE_SYCL>
-          $<$<AND:$<TARGET_EXISTS:Xpti::xpti>,$<PLATFORM_ID:Windows>>:NOMINMAX>
-          ${XPTI_FRAMEWORK_DISPATCHER_NAME_DEFINE}
-          $<$<TARGET_EXISTS:LevelZero::level-zero>:PTI_LEVEL_ZERO=1>
-          $<IF:$<BOOL:${PTI_ENABLE_LOGGING}>,
-          SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE,
-          SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_INFO>
-          $<$<PLATFORM_ID:Linux>:PTI_CCL_ITT_COMPILE>
-          PTI_OVERHEAD_TRACKING_ENABLED)
-
-target_link_libraries(
-  pti
-  PUBLIC Threads::Threads
-  PRIVATE $<TARGET_NAME_IF_EXISTS:Xpti::xpti>
-          LevelZero::level-zero
-          LevelZero::level-zero-ext
-          spdlog::spdlog
-          ${CMAKE_DL_LIBS}
-          ${FS_LIB}
-          $<TARGET_NAME_IF_EXISTS:ittapi::headers>)
-
-target_compile_options(pti PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-
-# Since PTI provides callbacks to Level Zero tracing and XPTI framework, it
-# should not be unloaded; therefore, marking it NODELETE.
-target_link_options(pti PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS} ${PTI_EXCLUDE_LIBS_ALL} ${PTI_NODELETE})
-PtiAddVersionScript(pti "${PROJECT_SOURCE_DIR}/src/libpti.map")
-
-FindTracedLibrariesHeaderPaths(
-  pti "${PROJECT_SOURCE_DIR}/src/gen_tracing_callbacks.py"
-  "tracing.gen" gen_tracing_libs_header LevelZero::level-zero)
-
-if(PROJECT_IS_TOP_LEVEL)
-  AddApiGenTarget(
-    "${PROJECT_SOURCE_DIR}/src/gen_tracing_callbacks.py" "tracing.gen" LevelZero::level-zero)
-  add_dependencies(generate-ids gen_tracing_libs_header)
-endif()
-
-# Library that loads core (pti). User links to this one.
-add_library(pti_view SHARED "${PROJECT_SOURCE_DIR}/src/xpti_adapter.cc"
-                            "${PROJECT_SOURCE_DIR}/src/pti.cc"
-                            "${PROJECT_SOURCE_DIR}/src/pti_version.cc"
-                            "${PROJECT_SOURCE_DIR}/src/pti_view_load.cc"
-                            "${PTI_ITT_ADAPTER_FILE}"
-                            "${PTI_ITT_LIB_ENV_FILE}"
-                            "${PTI_ITT_STUBS_FILE}")
-
-add_library(Pti::pti_view ALIAS pti_view)
-
-target_include_directories(
-  pti_view
-  PUBLIC ${PTI_PUBLIC_INCLUDE_DIRS}
-  PRIVATE ${PTI_PRIVATE_INCLUDE_DIRS})
-
-set_target_properties(
-  pti_view
-  PROPERTIES VERSION "${PROJECT_VERSION}"
-             SOVERSION "${PTI_API_SOVERSION}"
-             POSITION_INDEPENDENT_CODE ON
-             DEFINE_SYMBOL "${PTI_DEFINE_SYMBOL}")
-
-if (WIN32)
-  set_target_properties(
-    pti_view
-    PROPERTIES OUTPUT_NAME "pti_view-${PROJECT_VERSION_MAJOR}"
-               DEBUG_POSTFIX "d"
-  )
-
-  AddVersionlessLinkFile(pti_view)
-
-  AddProjectVersionInfo(pti_view)
-endif()
-
-target_compile_definitions(
-  pti_view
-  PRIVATE PTI_VIEW_CORE_LIB_NAME=$<TARGET_FILE_NAME:pti>
-          ${XPTI_FRAMEWORK_DISPATCHER_NAME_DEFINE}
-          $<IF:$<BOOL:${PTI_ENABLE_LOGGING}>,
-          SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE,
-          SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_INFO>
-          $<$<PLATFORM_ID:Linux>:PTI_CCL_ITT_COMPILE>)
-
-target_link_libraries(
-  pti_view
-  PRIVATE spdlog::spdlog
-          ${CMAKE_DL_LIBS}
-          ${FS_LIB}
-          $<TARGET_NAME_IF_EXISTS:ittapi::headers>)
-
-target_compile_options(pti_view PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-
-target_link_options(pti_view PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS} ${PTI_EXCLUDE_LIBS_ALL})
-PtiAddVersionScript(pti_view "${PROJECT_SOURCE_DIR}/src/libpti_view.map")
-
-target_link_libraries(
-  pti_all INTERFACE Pti::pti_view)
-
-include(CTest)
-
-if(BUILD_TESTING AND PTI_BUILD_SAMPLES)
-  # Workaround for crash with tbb_debug in oneAPI < 2026.0
-  # https://github.com/uxlfoundation/oneTBB/commit/d784b628190cbbcb6139916da3efe8c0b60abaa2
-  if(CMAKE_CXX_COMPILER_ID MATCHES "IntelLLVM" AND DEFINED ENV{CMPLR_ROOT})
-    string(REGEX MATCH "compiler/([0-9]+)" ONEAPI_VERSION_MATCH "$ENV{CMPLR_ROOT}")
-    set(ONEAPI_VERSION "${CMAKE_MATCH_1}")
-    if(ONEAPI_VERSION AND ONEAPI_VERSION LESS 2026)
-      set(TBB_FIND_RELEASE_ONLY ON CACHE BOOL "Only use release TBB to workaround crash with tbb_debug" FORCE)
-      message(STATUS "oneAPI ${ONEAPI_VERSION}: Enabling TBB_FIND_RELEASE_ONLY workaround")
-    endif()
-  endif()
-
-  add_subdirectory(samples/dlworkloads)
-  add_subdirectory(samples/dpc_gemm)
-  add_subdirectory(samples/dpc_gemm_threaded)
-  add_subdirectory(samples/view_record_versioned)
-  add_subdirectory(samples/vector_sq_add)
-  add_subdirectory(samples/onemkl_gemm)
-  add_subdirectory(samples/iso3dfd_dpcpp)
-  add_subdirectory(samples/metrics_iso3dfd_dpcpp)
-  add_subdirectory(samples/callback)
-  add_subdirectory(samples/metrics_scope)
-  add_subdirectory(samples/omp_vec_add)
-  add_subdirectory(samples/metrics_perf)
-  add_subdirectory(samples/pc_sampling)
-  add_subdirectory(samples/pc_sampling_profiler)
-  add_subdirectory(samples/itt_ccl)
-endif()
-
-if(BUILD_TESTING AND PTI_BUILD_TESTING)
-  add_subdirectory(test)
-endif()
-
-if(PROJECT_IS_TOP_LEVEL AND BUILD_TESTING)
-  include(cmake/coverage.cmake)
-endif()
-
-if(PROJECT_IS_TOP_LEVEL)
-  include(cmake/docs.cmake)
-endif()
-
-# Targets / Install phase
-export(
-  TARGETS pti_all pti pti_view
-  FILE "${CMAKE_CURRENT_BINARY_DIR}/cmake/PtiTargets.cmake"
-  NAMESPACE Pti::)
-
-if(PTI_INSTALL)
-  include(CMakePackageConfigHelpers)
-
-  write_basic_package_version_file(
-    "${PROJECT_BINARY_DIR}/PtiConfigVersion.cmake"
-    VERSION "${PROJECT_VERSION}"
-    COMPATIBILITY SameMinorVersion)
-
-  install(
-    FILES "${PROJECT_SOURCE_DIR}/PtiConfig.cmake"
-          "${PROJECT_BINARY_DIR}/PtiConfigVersion.cmake"
-    COMPONENT Pti_Development
-    DESTINATION "${PTI_INSTALL_CMAKE_DIR}")
-
-  install(
-    TARGETS pti_all pti_view
-    EXPORT PtiTargets
-    LIBRARY DESTINATION ${PTI_INSTALL_LIB_DIR}
-            COMPONENT Pti_Runtime
-            NAMELINK_COMPONENT Pti_Development
-    ARCHIVE DESTINATION ${PTI_INSTALL_LIB_DIR} COMPONENT Pti_Development
-    RUNTIME DESTINATION ${PTI_INSTALL_BIN_DIR} COMPONENT Pti_Runtime)
-
-  install(
-    TARGETS pti
-    EXPORT PtiTargets
-    LIBRARY DESTINATION ${PTI_INSTALL_MODULE_DIR}
-            COMPONENT Pti_Runtime
-    RUNTIME DESTINATION ${PTI_INSTALL_MODULE_DIR} COMPONENT Pti_Runtime)
-
-  install(
-    DIRECTORY "${PROJECT_BINARY_DIR}/include/pti"
-    DESTINATION "${PTI_INSTALL_INCLUDE_DIR}"
-    COMPONENT Pti_Development
-    FILES_MATCHING
-    PATTERN "*.h")
-
-  install(
-    DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
-    DESTINATION "${PTI_INSTALL_INCLUDE_DIR}"
-    COMPONENT Pti_Development
-    FILES_MATCHING
-    PATTERN "*.h")
-
-  install(
-    EXPORT PtiTargets
-    FILE PtiTargets.cmake
-    NAMESPACE Pti::
-    DESTINATION "${PTI_INSTALL_CMAKE_DIR}"
-    COMPONENT Pti_Development)
-
-  if(WIN32)
-    install(
-      FILES $<TARGET_LINKER_FILE_DIR:pti_view>/pti_view$<$<CONFIG:Debug>:d>${CMAKE_LINK_LIBRARY_SUFFIX}
-      COMPONENT Pti_Development
-      DESTINATION "${PTI_INSTALL_LIB_DIR}")
-  endif()
-
-  if (EXISTS "${PROJECT_SOURCE_DIR}/../LICENSE")
-    install(
-      FILES "../LICENSE"
-      DESTINATION "${PTI_INSTALL_LIC_DIR}"
-      RENAME "LICENSE.txt"
-      COMPONENT Pti_Doc)
-  endif()
-
-  #
-  # This file is only installed in oneAPI drops
-  #
-  if("${PTI_PRESET_USED}" MATCHES "[lw].*-oneAPI-release")
-
-    include(cmake/bom_macro.cmake)
-
-    set(BOMFILE_DIR "drop_raw")
-    set(BOMFILE_DEV "${BOMFILE_DIR}/pti_dev.txt")
-    set(BOMFILE_RUN "${BOMFILE_DIR}/pti_run.txt")
-
-    install(CODE "
-      file(REMOVE ${BOMFILE_DEV}  ${BOMFILE_RUN}) "
-      COMPONENT Pti_Bom)
-
-    if (EXISTS "${PROJECT_SOURCE_DIR}/../third-party-programs.txt")
-      install(
-        FILES "../third-party-programs.txt"
-        DESTINATION "${PTI_INSTALL_LIC_DIR}"
-        COMPONENT Pti_oneAPI)
-    else()
-      message(FATAL_ERROR "The PTI library must be built within the top-level "
-        "repository to ensure a valid installation.")
-    endif()
-
-    if (UNIX)
-      install(FILES "env/vars.sh" DESTINATION "env/" COMPONENT Pti_oneAPI)
-      install(FILES "env/oneapi-vars.sh" DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/pti" RENAME vars.sh COMPONENT Pti_oneAPI)
-      install(DIRECTORY "cmake/tags/" DESTINATION "tags/" FILES_MATCHING PATTERN "lin_*.txt")
-    elseif (WIN32)
-      install(FILES "env/vars.bat" DESTINATION "env/" COMPONENT Pti_oneAPI)
-      install(FILES "env/oneapi-vars.bat" DESTINATION "${CMAKE_INSTALL_SYSCONFDIR}/pti" RENAME vars.bat COMPONENT Pti_oneAPI)
-      install(DIRECTORY "cmake/tags/" DESTINATION "tags/" FILES_MATCHING PATTERN "win_*.txt")
-    endif()
-
-    set(BOMFILE_DIRNULL "NULL")
-    set(BOMFILE_DIRPREFIX "-LIB")
-
-    bomline(${BOMFILE_DIR} ${BOMFILE_DEV} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_INCLUDE_DIR}/pti*.h\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_DEV} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIB_DIR}/cmake/pti/Pti*.cmake\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIC_DIR}/*\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIB_DIR}/libpti*so.[0-9]*\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIB_DIR}/libpti*so\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_DEV} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIB_DIR}/*.lib\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRPREFIX}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_LIB_DIR}/*.dll\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRPREFIX}
-      [[\"\${CMAKE_INSTALL_PREFIX}/${PTI_INSTALL_BIN_DIR}/*.dll\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/env/*\"]])
-    bomline(${BOMFILE_DIR} ${BOMFILE_RUN} ${BOMFILE_DIRNULL}
-      [[\"\${CMAKE_INSTALL_PREFIX}/etc/*\"]])
-
- endif()
-endif()
-
-if(PROJECT_IS_TOP_LEVEL AND PTI_INSTALL)
-  include(cmake/packaging.cmake)
-endif()
diff --git a/sdk/CMakePresets.json b/sdk/CMakePresets.json
deleted file mode 100644
index 5ff4b778..00000000
--- a/sdk/CMakePresets.json
+++ /dev/null
@@ -1,625 +0,0 @@
-{
-  "version": 2,
-  "configurePresets": [
-    {
-      "name": "linux-icpx-release",
-      "displayName": "Linux Release x64 IntelLLVM Ninja Config",
-      "description": "Linux Release x64 Config using Ninja generator and oneAPI compiler",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "-Wall -Wextra -Wextra-semi -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_C_FLAGS": "-Wall -Wextra -Wextra-semi -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_SHARED_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_MODULE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_EXE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1"
-      }
-    },
-    {
-      "name": "linux-icpx-reldebuginfo",
-      "displayName": "Linux Release x64 IntelLLVM Ninja Config",
-      "description": "Linux Release x64 Config using Ninja generator and oneAPI compiler",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "-Wall -Wextra -Wextra-semi -Wformat -Werror -Wformat-security -Werror=format-security -g -fstack-protector-strong -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_C_FLAGS": "-Wall -Wextra -Wextra-semi -Wformat -Werror -Wformat-security -Werror=format-security -g -fstack-protector-strong -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_SHARED_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_MODULE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_EXE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1"
-      }
-    },
-    {
-      "name": "linux-icpx-debug",
-      "displayName": "Linux Debug x64 IntelLLVM Ninja Config",
-      "description": "Linux Debug x64 Config using Ninja generator and oneAPI compiler",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "-Wall -Wextra -Wextra-semi -Wformat -Wformat-security -fno-omit-frame-pointer -fno-optimize-sibling-calls",
-        "CMAKE_C_FLAGS": "-Wall -Wextra -Wextra-semi -Wformat -Wformat-security -fno-omit-frame-pointer -fno-optimize-sibling-calls",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "linux-cov",
-      "displayName": "Linux Code Coverage",
-      "description": "Linux Source-based Code Coverage Config",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Coverage",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS_COVERAGE": "-g3 -O0 -Xarch_host -fprofile-instr-generate -Xarch_host -fcoverage-mapping -Xarch_host -mllvm=-runtime-counter-relocation=true",
-        "CMAKE_C_FLAGS_COVERAGE": "-g3 -O0 -Xarch_host -fprofile-instr-generate -Xarch_host -fcoverage-mapping -Xarch_host -mllvm=-runtime-counter-relocation=true",
-        "CMAKE_SHARED_LINKER_FLAGS_COVERAGE": "-Xarch_host -fprofile-instr-generate",
-        "CMAKE_MODULE_LINKER_FLAGS_COVERAGE": "-Xarch_host -fprofile-instr-generate",
-        "CMAKE_EXE_LINKER_FLAGS_COVERAGE": "-Xarch_host -fprofile-instr-generate",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "linux-icpx-make-release",
-      "inherits": "linux-icpx-release",
-      "displayName": "Linux Release x64 IntelLLVM Make Config",
-      "description": "Linux Release x64 Config using Unix Makefiles generator and oneAPI compiler",
-      "generator": "Unix Makefiles"
-    },
-    {
-      "name": "linux-icpx-make-debug",
-      "inherits": "linux-icpx-debug",
-      "displayName": "Linux Debug x64 IntelLLVM Make Config",
-      "description": "Linux Debug x64 Config using Unix Makefiles generator and oneAPI compiler",
-      "generator": "Unix Makefiles"
-    },
-    {
-      "name": "linux-oneAPI-release",
-      "inherits": "linux-icpx-release",
-      "displayName": "Linux oneAPI x64 Release Config",
-      "description": "Latest known valid configuration for releasing PTI with oneAPI toolkit.",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_INSTALL_LIBDIR": "lib",
-        "CMAKE_DISABLE_FIND_PACKAGE_spdlog": true,
-        "PTI_PRESET_USED": "${presetName}"
-      }
-    },
-    {
-      "name": "linux-asan",
-      "inherits": "linux-icpx-debug",
-      "displayName": "Linux AddressSanitizer Config",
-      "description": "Linux build configuration for testing PTI with AddressSanitizer.",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_asan_toolchain.cmake"
-      },
-      "environment": {
-        "NEOReadDebugKeys": "1",
-        "DisableDeepBind": "1",
-        "PATH": "$penv{CMPLR_ROOT}/bin/compiler:$penv{PATH}",
-        "ASAN_SYMBOLIZER_PATH": "$penv{CMPLR_ROOT}/bin/compiler/llvm-symbolizer",
-        "LSAN_SYMBOLIZER_PATH": "$penv{CMPLR_ROOT}/bin/compiler/llvm-symbolizer",
-        "ASAN_OPTIONS": "suppressions=${sourceDir}/test/suppressions/ASan.supp,detect_leaks=1,check_initialization_order=1,halt_on_error=1,use_sigaltstack=0",
-        "LSAN_OPTIONS": "suppressions=${sourceDir}/test/suppressions/LSan.supp,use_unaligned=1",
-        "UBSAN_OPTIONS": "suppressions=${sourceDir}/test/suppressions/UBSan.supp,print_stacktrace=1,halt_on_error=1",
-        "TBB_ENABLE_SANITIZERS": "1"
-      }
-    },
-    {
-      "name": "linux-fuzz",
-      "inherits": "linux-asan",
-      "displayName": "Linux Fuzz Testing Config",
-      "description": "Linux build configuration for fuzz testing with libFuzzer.",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "PTI_FUZZ": true,
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_fuzz_toolchain.cmake"
-      }
-    },
-    {
-      "name": "linux-tsan",
-      "inherits": "linux-asan",
-      "displayName": "Linux ThreadSanitizer Config",
-      "description": "Linux build configuration for testing PTI with ThreadSanitizer.",
-      "environment": {
-        "ONEAPI_DEVICE_SELECTOR": "level_zero:gpu",
-        "TSAN_OPTIONS": "suppressions=${sourceDir}/test/suppressions/TSan.supp external_symbolizer_path=$penv{CMPLR_ROOT}/bin/compiler/llvm-symbolizer halt_on_error=1 force_seq_cst_atomics=1"
-      },
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_tsan_toolchain.cmake"
-      }
-    },
-    {
-      "name": "linux-clang-release",
-      "inherits": "linux-icpx-release",
-      "displayName": "Linux Release x64 Clang Config",
-      "description": "Linux Release x64 Config using Ninja generator and clang compiler",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/clang_toolchain.cmake"
-      }
-    },
-    {
-      "name": "linux-dpclang-release",
-      "inherits": "linux-icpx-release",
-      "displayName": "Linux Release x64 DPC++ Clang Config",
-      "description": "Linux Release x64 Config using Ninja generator and dpclang compiler",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/dpclang_toolchain.cmake"
-      }
-    },
-    {
-      "name": "linux-clang-debug",
-      "inherits": "linux-icpx-debug",
-      "displayName": "Linux Debug x64 Clang Config",
-      "description": "Linux Debug x64 Config using Ninja generator and clang compiler",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/clang_toolchain.cmake",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "linux-dpclang-debug",
-      "inherits": "linux-icpx-debug",
-      "displayName": "Linux Debug x64 DPC++ Clang Config",
-      "description": "Linux Debug x64 Config using Ninja generator and dpclang compiler",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/dpclang_toolchain.cmake",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "linux-gxx-release",
-      "displayName": "Linux Release x64 GCC Ninja Config",
-      "description": "Linux Release x64 Config using Ninja generator and gcc/g++ compiler",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_C_COMPILER": "gcc",
-        "CMAKE_CXX_COMPILER": "g++",
-        "CMAKE_CXX_FLAGS": "-Wall -Wextra -Wextra-semi -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_C_FLAGS": "-Wall -Wextra -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -O3 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_SHARED_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_MODULE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_EXE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1"
-      }
-    },
-    {
-      "name": "linux-abi",
-      "displayName": "Linux ABI Check x64 GCC Ninja Config",
-      "description": "Library-only build with DWARF for abidw/abidiff and abi-dumper. Release builds strip debug info, which those tools require.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
-        "CMAKE_C_COMPILER": "gcc",
-        "CMAKE_CXX_COMPILER": "g++",
-        "CMAKE_CXX_FLAGS": "-Wall -Wextra -Wformat -Wformat-security -fstack-protector-strong -g -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_C_FLAGS": "-Wall -Wextra -Wformat -Wformat-security -fstack-protector-strong -g -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2",
-        "CMAKE_SHARED_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_MODULE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "CMAKE_EXE_LINKER_FLAGS": "-Wl,-z,relro,-z,now,-z,noexecstack,--build-id=sha1",
-        "PTI_BUILD_SAMPLES": "OFF",
-        "PTI_BUILD_TESTING": "OFF",
-        "PTI_BUILD_URGEMM": "OFF"
-      }
-    },
-    {
-      "name": "windows-icx-debug",
-      "displayName": "Windows Debug x64 IntelLLVM Config",
-      "description": "Windows Debug x64 IntelLLVM Compiler Config. Uses icx and Ninja. Turns on logging.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "/W4 /MDd /EHcs /fp:precise -Qstd:c++17 /sdl /GS /Gy /DYNAMICBASE /guard:cf /RTCsu -Wno-error=character-conversion",
-        "CMAKE_SHARED_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "CMAKE_MODULE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "CMAKE_EXE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "windows-icx-release",
-      "displayName": "Windows Release x64 IntelLLVM Config",
-      "description": "Windows Release x64 IntelLLVM Compiler Config. Uses icx and Ninja.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "/W4 /WX /MD /EHcs /fp:precise -Qstd:c++17 /sdl /GS /Gy /DYNAMICBASE /guard:cf",
-        "CMAKE_SHARED_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf",
-        "CMAKE_MODULE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf",
-        "CMAKE_EXE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf"
-      }
-    },
-    {
-      "name": "windows-icx-reldebuginfo",
-      "displayName": "Windows Release x64 IntelLLVM Config with Debug Info",
-      "description": "Windows Release x64 IntelLLVM Compiler Config with Debug Info. Uses icx and Ninja.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS": "/W4 /WX /MD /EHcs /fp:precise -Qstd:c++17 /sdl /GS /Gy /DYNAMICBASE /guard:cf",
-        "CMAKE_SHARED_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf",
-        "CMAKE_MODULE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf",
-        "CMAKE_EXE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf"
-      }
-    },
-    {
-      "name": "windows-cov",
-      "displayName": "Windows Code Coverage",
-      "description": "Windows Source-based Code Coverage Config",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Coverage",
-        "CMAKE_TOOLCHAIN_FILE": "${sourceDir}/cmake/toolchains/icpx_toolchain.cmake",
-        "CMAKE_CXX_FLAGS_COVERAGE": "/MD /EHcs /fp:precise -Qstd:c++17 /Zi -fprofile-instr-generate -fcoverage-mapping",
-        "CMAKE_SHARED_LINKER_FLAGS_COVERAGE": "-fprofile-instr-generate",
-        "CMAKE_MODULE_LINKER_FLAGS_COVERAGE": "-fprofile-instr-generate",
-        "CMAKE_EXE_LINKER_FLAGS_COVERAGE": "-fprofile-instr-generate",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "windows-ci-release",
-      "displayName": "Windows CI Release Config",
-      "description": "Windows CI Release Config. Uses icx and Ninja.",
-      "inherits": "windows-icx-release",
-      "binaryDir": "${sourceDir}/wbr"
-    },
-    {
-      "name": "windows-oneAPI-release",
-      "displayName": "Windows oneAPI Release Config",
-      "description": "Latest known valid configuration for releasing PTI with oneAPI toolkit.",
-      "inherits": "windows-ci-release",
-      "cacheVariables": {
-        "CMAKE_INSTALL_LIBDIR": "lib",
-        "CMAKE_DISABLE_FIND_PACKAGE_spdlog": true,
-        "CMAKE_DISABLE_FIND_PACKAGE_LevelZero": true,
-        "PTI_PRESET_USED": "${presetName}"
-      }
-    },
-    {
-      "name": "windows-ci-debug",
-      "displayName": "Windows CI Debug Config",
-      "description": "Windows CI Debug Config. Uses icx and Ninja.",
-      "inherits": "windows-icx-debug",
-      "binaryDir": "${sourceDir}/wbd"
-    },
-    {
-      "name": "windows-debug",
-      "displayName": "Windows Debug x64 MSVC Config",
-      "description": "Windows Debug x64 MSVC Compiler Config. Uses cl and Ninja. Turns on logging.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_C_COMPILER": "cl.exe",
-        "CMAKE_CXX_COMPILER": "cl.exe",
-        "CMAKE_CXX_FLAGS": "/MP /W4 /MDd /EHcs /sdl /analyze /wd6326 /wd28020 /Gy /GS /DYNAMICBASE /guard:cf /RTCsu",
-        "CMAKE_SHARED_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "CMAKE_MODULE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "CMAKE_EXE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /guard:cf",
-        "PTI_ENABLE_LOGGING": "ON"
-      }
-    },
-    {
-      "name": "windows-release",
-      "displayName": "Windows Release x64 MSVC Config",
-      "description": "Windows Release x64 MSVC Compiler Config. Uses cl and Ninja. Turns on logging.",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build-${presetName}",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_C_COMPILER": "cl.exe",
-        "CMAKE_CXX_COMPILER": "cl.exe",
-        "CMAKE_CXX_FLAGS": "/MP /W4 /WX /MD /EHcs /sdl /analyze /wd6326 /wd28020 /Gy /GS /DYNAMICBASE /guard:cf",
-        "CMAKE_SHARED_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /LTCG /sdl /guard:cf",
-        "CMAKE_MODULE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /LTCG /sdl /guard:cf",
-        "CMAKE_EXE_LINKER_FLAGS": "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /LTCG /sdl /guard:cf"
-      }
-    }
-  ],
-  "buildPresets": [
-  {
-    "name": "linux-icpx-release",
-    "configurePreset": "linux-icpx-release",
-    "displayName": "Linux Release x64 IntelLLVM Ninja Build"
-  },
-  {
-    "name": "linux-clang-release",
-    "configurePreset": "linux-clang-release",
-    "displayName": "Linux Release x64 Clang Ninja Build"
-  },
-  {
-    "name": "linux-dpclang-release",
-    "configurePreset": "linux-dpclang-release",
-    "displayName": "Linux Release x64 DPC++ Clang Ninja Build"
-  },
-  {
-    "name": "linux-icpx-reldebuginfo",
-    "configurePreset": "linux-icpx-reldebuginfo",
-    "displayName": "Linux Release x64 IntelLLVM Ninja Build"
-  },
-  {
-    "name": "linux-icpx-debug",
-    "configurePreset": "linux-icpx-debug",
-    "displayName": "Linux Debug x64 IntelLLVM Ninja Build"
-  },
-  {
-    "name": "linux-clang-debug",
-    "configurePreset": "linux-clang-debug",
-    "displayName": "Linux Debug x64 Clang Ninja Build"
-  },
-  {
-    "name": "linux-dpclang-debug",
-    "configurePreset": "linux-dpclang-debug",
-    "displayName": "Linux Debug x64 DPC++ Clang Ninja Build"
-  },
-  {
-    "name": "linux-cov",
-    "configurePreset": "linux-cov",
-    "displayName": "Linux Source-Based Code Coverage Build"
-  },
-  {
-    "name": "linux-icpx-make-release",
-    "configurePreset": "linux-icpx-make-release",
-    "displayName": "Linux Release x64 IntelLLVM Make Build"
-  },
-  {
-    "name": "linux-icpx-make-debug",
-    "configurePreset": "linux-icpx-make-debug",
-    "displayName": "Linux Debug x64 IntelLLVM Make Build"
-  },
-  {
-    "name": "linux-oneAPI-release",
-    "configurePreset": "linux-oneAPI-release",
-    "displayName": "Linux oneAPI x64 Release Build"
-  },
-  {
-    "name": "linux-asan",
-    "configurePreset": "linux-asan",
-    "displayName": "Linux AddressSanitizer Build"
-  },
-  {
-    "name": "linux-fuzz",
-    "configurePreset": "linux-fuzz",
-    "displayName": "Linux Fuzz Testing Build"
-  },
-  {
-    "name": "linux-tsan",
-    "configurePreset": "linux-tsan",
-    "displayName": "Linux ThreadSanitizer Build"
-  },
-  {
-    "name": "linux-gxx-release",
-    "configurePreset": "linux-gxx-release",
-    "displayName": "Linux gcc/g++ Build"
-  },
-  {
-    "name": "linux-abi",
-    "configurePreset": "linux-abi",
-    "displayName": "Linux ABI Check Build",
-    "targets": ["pti_view", "pti"]
-  },
-  {
-    "name": "windows-debug",
-    "displayName": "Windows Debug x64 MSVC Build",
-    "configurePreset": "windows-debug"
-  },
-  {
-    "name": "windows-release",
-    "displayName": "Windows Release x64 MSVC Build",
-    "configurePreset": "windows-release"
-  },
-  {
-    "name": "windows-icx-debug",
-    "displayName": "Windows Debug x64 IntelLLVM Build",
-    "configurePreset": "windows-icx-debug"
-  },
-  {
-    "name": "windows-icx-release",
-    "displayName": "Windows Release x64 IntelLLVM Build",
-    "configurePreset": "windows-icx-release"
-  },
-  {
-    "name": "windows-icx-reldebuginfo",
-    "displayName": "Windows Release x64 IntelLLVM Build with Debug Info",
-    "configurePreset": "windows-icx-reldebuginfo"
-  },
-  {
-    "name": "windows-cov",
-    "configurePreset": "windows-cov",
-    "displayName": "Windows Source-Based Code Coverage Build"
-  },
-  {
-    "name": "windows-ci-release",
-    "displayName": "Windows CI Release Build",
-    "configurePreset": "windows-ci-release"
-  },
-  {
-    "name": "windows-oneAPI-release",
-    "configurePreset": "windows-oneAPI-release",
-    "displayName": "Windows oneAPI Release Build"
-  },
-  {
-    "name": "windows-ci-debug",
-    "displayName": "Windows CI Debug Build",
-    "configurePreset": "windows-ci-debug"
-  }
-  ],
-  "testPresets": [
-  {
-    "name": "linux-icpx-release",
-    "configurePreset": "linux-icpx-release",
-    "displayName": "Linux Release x64 IntelLLVM Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-clang-release",
-    "configurePreset": "linux-clang-release",
-    "displayName": "Linux Release x64 Clang Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-dpclang-release",
-    "configurePreset": "linux-dpclang-release",
-    "displayName": "Linux Release x64 DPC++ Clang Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-icpx-reldebuginfo",
-    "configurePreset": "linux-icpx-reldebuginfo",
-    "displayName": "Linux Release x64 IntelLLVM Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-icpx-debug",
-    "configurePreset": "linux-icpx-debug",
-    "displayName": "Linux Debug x64 IntelLLVM Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-clang-debug",
-    "configurePreset": "linux-clang-debug",
-    "displayName": "Linux Debug x64 Clang Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-dpclang-debug",
-    "configurePreset": "linux-dpclang-debug",
-    "displayName": "Linux Debug x64 DPC++ Clang Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-cov",
-    "configurePreset": "linux-cov",
-    "displayName": "Linux Test With Code Coverage",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}",
-      "LLVM_PROFILE_FILE": "${sourceDir}/build-${presetName}/coverage/raw/pti-cov.%p.profraw"
-    }
-  },
-  {
-    "name": "linux-icpx-make-release",
-    "configurePreset": "linux-icpx-make-release",
-    "displayName": "Linux Release x64 IntelLLVM Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-icpx-make-debug",
-    "configurePreset": "linux-icpx-make-debug",
-    "displayName": "Linux Debug x64 IntelLLVM Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-oneAPI-release",
-    "configurePreset": "linux-oneAPI-release",
-    "displayName": "Linux oneAPI x64 Release Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-asan",
-    "configurePreset": "linux-asan",
-    "displayName": "Linux AddressSanitizer Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-fuzz",
-    "configurePreset": "linux-fuzz",
-    "displayName": "Linux Fuzz Testing",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-tsan",
-    "configurePreset": "linux-tsan",
-    "displayName": "Linux ThreadSanitizer Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "linux-gxx-release",
-    "configurePreset": "linux-gxx-release",
-    "displayName": "Linux gcc/g++ Tests",
-    "environment": {
-      "LD_LIBRARY_PATH": "${sourceDir}/build-${presetName}/lib:$penv{LD_LIBRARY_PATH}"
-    }
-  },
-  {
-    "name": "windows-icx-debug",
-    "displayName": "Windows Debug x64 IntelLLVM Test",
-    "configurePreset": "windows-icx-debug"
-  },
-  {
-    "name": "windows-icx-release",
-    "displayName": "Windows Release x64 IntelLLVM Test",
-    "configurePreset": "windows-icx-release"
-  },
-  {
-    "name": "windows-icx-reldebuginfo",
-    "displayName": "Windows Release x64 IntelLLVM Test with Debug Info",
-    "configurePreset": "windows-icx-reldebuginfo"
-  },
-  {
-    "name": "windows-cov",
-    "configurePreset": "windows-cov",
-    "displayName": "Windows Test With Code Coverage",
-    "environment": {
-      "PATH": "${sourceDir}/build-${presetName}/bin;$penv{PATH}",
-      "LLVM_PROFILE_FILE": "${sourceDir}/build-${presetName}/coverage/raw/pti-cov.%p.profraw"
-    }
-  },
-  {
-    "name": "windows-oneAPI-release",
-    "configurePreset": "windows-oneAPI-release",
-    "displayName": "Windows oneAPI Release Test"
-  },
-  {
-    "name": "windows-ci-release",
-    "displayName": "Windows CI Release Test",
-    "configurePreset": "windows-ci-release"
-  },
-  {
-    "name": "windows-ci-debug",
-    "displayName": "Windows CI Debug Test",
-    "configurePreset": "windows-ci-debug"
-  }
-  ]
-}
diff --git a/sdk/INSTALL.md b/sdk/INSTALL.md
deleted file mode 100644
index 7ced682b..00000000
--- a/sdk/INSTALL.md
+++ /dev/null
@@ -1,232 +0,0 @@
-# Building and Installation Guide
-
-This guide provides instructions for building and installing the PTI SDK.
-
-## Table of Contents
-
-- [Prerequisites](#prerequisites)
-- [Building from Source](#building-from-source)
-  - [Linux](#linux)
-  - [Windows](#windows)
-- [Installation](#installation)
-- [Verification](#verification)
-- [Linking PTI SDK in Your Application](#linking-pti-sdk-in-your-application)
-- [Troubleshooting](#troubleshooting)
-
-## Prerequisites
-
-### Common Requirements
-
-- **CMake**: Version 3.14 or higher (3.20+ for CMake presets, 3.23+ for Windows tests)
-- **Git**: Version 1.8 or higher
-- **Ninja**: Version 1.10.1 or higher (optional for Linux, required for Windows)
-- **Intel(R) oneAPI Base Toolkit**: See [tested versions](#tested-versions) below
-- **Level Zero Loader**: headers version 1.32.0 or higher (downloaded automatically by CMake if not found); version 1.14.0 or higher at runtime
-
-### Platform-Specific Requirements
-
-#### Linux
-- GCC or Intel C++ Compiler (icpx)
-- Make or Ninja build system
-
-#### Windows
-- Visual Studio 2022 or higher
-- Ninja build system (version 1.12.1 or higher)
-- Intel C++ Compiler (icpx)
-
-### Tested Versions
-
-#### Intel(R) oneAPI Base Toolkit
-
-| Support | Linux | Windows |
-| -------- | ------- | ------- |
-| Full | 2026.0, 2026.1 | 2026.0 |
-
-**Note**: Full support indicates regular testing with all features.
-
-#### Regularly Tested Configurations
-
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1550
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1100
-- Ubuntu 24.04 with Intel(R) Data Center GPU Max Series
-- Ubuntu 25.10 with Intel(R) Arc(TM) Graphics (A-Series and B-Series)
-- Rocky 9 with Intel(R) Data Center GPU Max Series
-- Windows 11 with Intel(R) Arc(TM) Graphics (A-Series and B-Series)
-- Windows 11 with Intel(R) Data Center GPU Flex Series
-
-## Building from Source
-
-### Environment Setup
-
-**Linux:**
-```bash
-source <path_to_oneapi>/setvars.sh
-cd sdk
-```
-
-**Windows:**
-```cmd
-call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-cd sdk
-```
-
-### Configure Build
-
-**Configure build with testing (debug):**
-```bash
-CC=icx CXX=icpx cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
-```
-
-**Configure build with testing (release):**
-```bash
-CC=icx CXX=icpx cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-```
-
-**Note:** The Intel C++ Compiler (icpx) is recommended. You can also build with GCC by omitting the `CC=icx CXX=icpx` prefix.
-
-### Build
-
-```bash
-cmake --build build --parallel 4
-```
-
-## Verification
-
-### Running Tests
-
-From the build directory:
-
-```bash
-ctest --test-dir build --output-on-failure
-```
-
-## Installation
-
-Most users do not need to install PTI SDK. Installation is only necessary if you want to:
-
-* Install PTI SDK system-wide or to a custom location
-* Use PTI SDK with CMake ``find_package()`` in other projects
-* Package PTI SDK for distribution
-
-From the build directory:
-
-```bash
-cmake --install build --config Release --prefix "../out"
-```
-
-You can specify a different installation prefix:
-
-**Linux:**
-```bash
-cmake --install build --config Release --prefix "/usr/local"
-```
-
-**Windows:**
-```cmd
-cmake --install build --config Release --prefix "C:\Program Files\PTI"
-```
-
-The installation includes:
-- Header files in `<prefix>/include/pti/`
-- Library files in `<prefix>/lib/`
-- CMake configuration files in `<prefix>/lib/cmake/pti/`
-
-### Running Sample Applications
-
-**Linux:**
-```bash
-./build/bin/vector_sq_add
-```
-
-**Windows:**
-```cmd
-build\bin\vector_sq_add.exe
-```
-
-If the sample runs successfully and produces output, your installation is working correctly.
-
-## Linking PTI SDK in Your Application
-
-### Using CMake find_package
-
-Add the following to your `CMakeLists.txt`:
-
-```cmake
-# Set Pti_DIR if you installed in a non-standard location
-set(Pti_DIR <path-to-pti>/lib/cmake/pti)
-
-# Find the package
-find_package(Pti REQUIRED)
-
-# Link against the pti_view library
-target_link_libraries(your_target PUBLIC Pti::pti_view)
-```
-
-### Manual Linking
-
-If not using CMake's `find_package`, you can manually specify:
-
-- **Include directory**: `<install-prefix>/include`
-- **Library directory**: `<install-prefix>/lib`
-- **Library to link**: `pti_view`
-
-Example with g++:
-
-```bash
-g++ -I<install-prefix>/include \
-    -L<install-prefix>/lib \
-    -lpti_view \
-    your_application.cpp -o your_app
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**CMake cannot find oneAPI components:**
-- Ensure you've sourced the oneAPI environment:
-  - Linux: `source <path_to_oneapi>/setvars.sh`
-  - Windows: Run `<path_to_oneapi>\setvars.bat` in cmd
-
-**Level Zero headers not found:**
-- CMake fetches the Level Zero headers when it does not find version >= 1.32.0, so this error means the download failed (for example, an offline build) or an older system Level Zero header set was picked up
-- Install Level Zero loader headers >= 1.32.0, or allow network access during configuration
-- Ensure oneAPI environment is properly sourced/initialized
-
-**Build fails with compiler errors:**
-- Ensure you're using a supported oneAPI version
-- Verify C++17 support is available
-- Try deleting the build directory and reconfiguring
-
-**Windows: Kernel name demangling not available:**
-- This is a known limitation on Windows
-- Kernel names will appear in mangled form
-
-### Getting Help
-
-- Submit issues at: https://github.com/intel/pti-gpu/issues
-- Check existing issues and discussions
-- Refer to the samples directory for usage examples
-
-## Additional Build Options
-
-### Common CMake Options
-
-- `-DCMAKE_BUILD_TYPE=<Debug|Release>`: Set build type
-- `-DCMAKE_CXX_STANDARD=<17|20>`: Set C++ standard (minimum 17)
-- `-DCMAKE_CXX_COMPILER=<compiler>`: Set C++ compiler (e.g., g++, icpx)
-- `-DCMAKE_C_COMPILER=<compiler>`: Set C compiler (e.g., gcc, icx)
-- `-DBUILD_TESTING=<ON|OFF>`: Enable/disable building tests (default: ON)
-
-
-### PTI Custom Options
-
-- `-DPTI_BUILD_SAMPLES=<ON|OFF>`: Enable/disable building samples (default: ON when building as top-level project)
-- `-DPTI_BUILD_TESTING=<ON|OFF>`: Enable/disable building PTI tests (default: ON when building as top-level project)
-- `-DPTI_INSTALL=<ON|OFF>`: Enable/disable library installation when invoking `--install` (default: ON)
-- `-DPTI_ENABLE_LOGGING=<ON|OFF>`: Enable internal logging for PTI (default: OFF)
-
----
-
-For more information, see the [PTI SDK Documentation](https://intel.github.io/pti-gpu/).
diff --git a/sdk/PtiConfig.cmake b/sdk/PtiConfig.cmake
deleted file mode 100644
index 2c7f4222..00000000
--- a/sdk/PtiConfig.cmake
+++ /dev/null
@@ -1,5 +0,0 @@
-# https://cmake.org/cmake/help/latest/guide/importing-exporting/index.html
-include("${CMAKE_CURRENT_LIST_DIR}/PtiTargets.cmake")
-
-include(CMakeFindDependencyMacro)
-find_dependency(Threads)
diff --git a/sdk/README.md b/sdk/README.md
deleted file mode 100644
index d5f1aa32..00000000
--- a/sdk/README.md
+++ /dev/null
@@ -1,200 +0,0 @@
-# Profiling Tools Interfaces SDK
-
-## Overview
-
-This is PTI SDK Proof of Concept.
-
-**PTI SDK** will be a framework for developing profiling tools for applications built on top of oneAPI and running on Intel XPUs.
-
-Today **SDK** POC provides *pti_view* library with an API to trace various tasks of application running on Intel GPU. While the library implementation uses low-level tracing APIs of SYCL run-time and Level-Zero, its own API is  high level.
-
-**SDK** POC is being built on the experience of **PTI-GPU** tools and samples and reuses that code with some modification.
-
-As for the project organization here – SDK folder is self-contained and independent from the rest of repository.
-
-One of the objectives is to extend functionality of PTI SDK and with the time to transform today’s **PTI-GPU** project to an **SDK**.
-
-
-This project is in active development. We decided to open it at this early stage to benefit from feedback and critisim of interested parties and early adopters.
-
-## Recent (version 0.7.0) update
-
-Starting version 0.7.0 **PTI SDK** implements the new functionality of Local collection. It enables starting and stopping collection anytime-anywhere in an application when run on the system with installed Level-Zero runtime supporting [1.9.0 specification](https://spec.oneapi.io/releases/index.html#level-zero-v1-9-0) and higher.
-
-Local collection functionality is transparent and controlled via `ptiViewEnable` and `ptiViewDisable` calls, where the first `ptiViewEnable` (or several of them) called at any place start the Local collection and the last `ptiViewDisable` (or several of them, paired with preceding `ptiViewEnable` calls) stop the Local collection.
-Outside of Local collection regions of interest, PTI SDK maintains zero overhead by not issuing any calls or collecting any data.
-
-On systems with Level-Zero version lower than 1.9.0 **PTI SDK** still operates as before its version 0.7.0: tracing runtime calls and causing the overhead outside of `ptiViewEnable` - `ptiViewDisable` regions, but reporting data only for `ptiViewEnable` - `ptiViewDisable` regions.
-
-## Recent (version 0.9.0) update
-
-- Added function call(s) providing the timestamp and allowing the user to provide
-  their own timestamp via a callback.
-- Windows support added.
-- Various bug fixes and improvements.
-
-## Recent (version 1.1.0) update
-
-- Preliminary Level Zero native graph support added.
-  Requires Intel(R) oneAPI icpx 2026.1.1 compiler and Level Zero (compute-runtime) 1.15.39122+12.
-- With Level Zero (compute-runtime) 1.15.39122+12 SYCL graph support is also
-  enabled. To enable SYCL graph support, set environment variables
-  `NEOReadDebugKeys=1 ExperimentalFlatCommandListApiRecording=1`. (Note: this
-  limitation is *NOT* a part of Level Zero native graph support. Just legacy
-  SYCL graph.)
-
-**Known issues on Windows:**
-
-- Kernel Name Demangling not present.
-- In the current oneAPI release, SYCL runtime records are not present.
-
-## How to contribute
-
-At this stage we do not accept pull requests. We will change this soon.
-
-For now - please, submit issues or start a discussion.
-
-Please, check [TODO](TODO.md) list. We are aware of many shortcomings and inefficiencies and are working on them.
-
-## Supported OS
-
-- Linux
-- Windows
-
-## Regularly Tested Configurations
-
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1550
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1100
-- Rocky 8 with Intel(R) Data Center GPU Max 1100
-- Windows 11 with Intel(R) Arc(TM) A380 Graphics
-
-## Prerequisites
-
-- [CMake](https://cmake.org/) (version 3.14 and above. For presets, >= 3.20)
-- [Git](https://git-scm.com/) (version 1.8 and above)
-- [Ninja](https://github.com/ninja-build/ninja) (optional, version >= 1.10.1)
-- [Intel(R) oneAPI Base Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html) ([version](#intelr-oneapi-base-toolkit-tested-versions))
-- [Level Zero Loader](https://github.com/oneapi-src/level-zero) (>= 1.14.0 at runtime; building requires headers >= 1.32.0, which CMake downloads if they are not found)
-
-> **Note:** For the best experience, use a recent Rolling GPU driver ([compute-runtime](https://github.com/intel/compute-runtime/releases)) and Level Zero loader (for reference, PTI 1.2.0 is validated with Level Zero loader 1.32.0 and compute-runtime 26.31.39395.13). Graph profiling and on-demand collection require Rolling drivers.
-
-### Windows Specific Prerequisites
-
-- [CMake](https://cmake.org/) (For Windows tests version >= 3.23)
-- [Ninja](https://github.com/ninja-build/ninja) (version 1.12.1)
-- [Visual Studio 2022](https://visualstudio.microsoft.com/vs/) (Tested with version >= 17.10.3)
-
-### Intel(R) oneAPI Base Toolkit Tested Version(s)
-
-| Support | Linux | Windows |
-| -------- | ------- | ------- |
-| Full | 2026.0, 2026.1 | 2026.0 |
-
-Full support indicates regular testing with all features.
-
-## Build
-
-### Linux
-
-Build the pti library + tests and samples
-
-```console
->> source <path_to_oneapi>/setvars.sh
->> cd sdk
->> mkdir build
->> cd build
->> cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/icpx_toolchain.cmake ..
->> make -j
-```
-
-### Windows
-
-Using the Intel(R) oneAPI cmd and Visual Studio 2022
-
-```console
-> cd sdk
-> mkdir build
-> cd build
-> cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/icpx_toolchain.cmake -DCMAKE_CXX_FLAGS=/EHcs
-> cmake --build . --parallel 4
-```
-
-## Sample
-
-### Linux
-
-From `build` directory:
-
-```console
->> ./bin/vec_sqadd
-```
-
-### Windows
-
-From `build` directory:
-
-```console
-> bin\vec_sqadd.exe
-```
-
-## Test
-
-### Linux
-
-```console
->> make test
-```
-
-### Windows
-
-```console
->  ninja test
-```
-
-## Install
-
-### Linux
-
-```console
->> mkdir build
->> cd build
->> cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/icpx_toolchain.cmake -DBUILD_TESTING=OFF ..
->> make -j
->> cmake --install . --config Release --prefix "../out"
-```
-
-### Windows
-
-```console
-> mkdir build
-> cd build
-> cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/icpx_toolchain.cmake
-> cmake --build . --parallel 4
-> cmake --install . --config Release --prefix "../out"
-```
-
-## Linking
-
-### find_package
-
-```cmake
-# set Pti_DIR if you install in a nonstandard location.
-set(Pti_DIR <path-to-pti>/lib/cmake/pti)
-
-find_package(Pti X.Y.Z)
-
-target_link_libraries(stuff PUBLIC Pti::pti_view)
-```
-
-## Usage
-
-Use the `samples/` as a guide to developing with this library.
-
-Note:
-
-- Before `ptiViewEnable()` is called, please define
-callbacks and register them with `ptiViewSetCallbacks()`.
-
----
-
-Intel and the Intel logo are trademarks of Intel Corporation or its subsidiaries in the U.S. and/or other countries. Other names and brands may be claimed as the property of others.
diff --git a/sdk/TODO.md b/sdk/TODO.md
deleted file mode 100644
index 8b9a2b42..00000000
--- a/sdk/TODO.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# TODO list for Profiling Tools Interfaces SDK
-
-1. Make a documentation
-2. Clean and optimize View records
-    - Compact them, e.g., remove redundant fields, compact other fields.
-    - If decided to keep - make records fields representing context, device etc. - back-end agnostic
-    - Remove (?) `_process_id` field
-3. Clarify and properly define `pti_view_memcpy_type` and `pti_view_memory_type`
-4. Change type of _pci_address in all records to numerical.
-5. Structurize uuid -- is currently a uint8_t array of PTI_MAX_DEVICE_UUID_SIZE.
-
diff --git a/sdk/VERSION b/sdk/VERSION
deleted file mode 100644
index f0bb29e7..00000000
--- a/sdk/VERSION
+++ /dev/null
@@ -1 +0,0 @@
-1.3.0
diff --git a/sdk/cmake/Modules/FindDevUtilities.cmake b/sdk/cmake/Modules/FindDevUtilities.cmake
deleted file mode 100644
index 100889e0..00000000
--- a/sdk/cmake/Modules/FindDevUtilities.cmake
+++ /dev/null
@@ -1,72 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindDevUtilities
--------
-
-Finds the dpc_common library. This is a library that is part of the standard
-oneAPI installation but is not part of a oneAPI component.
-
-It is a header-only library. This module just finds its include path.
-
-It is primarily used in the
-`oneAPI samples <https://github.com/oneapi-src/oneAPI-samples>`_
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module provides the following imported targets, if found:
-
-``DevUtilities::utils``
-  Common samples include path
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This will define the following variables:
-
-``DevUtilities_FOUND``
-  True if the system has the DevUtilities library.
-``DevUtilities_INCLUDE_DIRS``
-  Include directories needed to use DevUtilities.
-
-Cache Variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``DevUtilities_INCLUDE_DIR``
-  The directory containing ``dpc_common.hpp``.
-
-#]=======================================================================]
-
-# Based on tutorial found in CMake manual:
-# https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
-find_path(
-  DevUtilities_INCLUDE_DIR
-  NAMES dpc_common.hpp
-  HINTS ENV CPATH
-	ENV LD_LIBRARY_PATH
-	ENV CMPLR_ROOT
-  PATHS /opt/intel/oneapi/dev-utilities
-        /opt/intel/oneapi/dev-utilities/latest
-        /opt/intel/oneapi/dev-utilities/linux
-	"C:/Program Files (x86)/Intel/oneAPI/dev-utilities/latest"
-  PATH_SUFFIXES include
-                linux/include)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  DevUtilities
-  FOUND_VAR DevUtilities_FOUND
-  REQUIRED_VARS DevUtilities_INCLUDE_DIR)
-
-if(DevUtilities_FOUND AND NOT TARGET DevUtilities::utils)
-  add_library(DevUtilities::utils INTERFACE IMPORTED)
-  set_target_properties(
-    DevUtilities::utils PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                   "${DevUtilities_INCLUDE_DIR}")
-endif()
-
-mark_as_advanced(DevUtilities_INCLUDE_DIR)
diff --git a/sdk/cmake/Modules/FindLevelZero.cmake b/sdk/cmake/Modules/FindLevelZero.cmake
deleted file mode 100644
index c95ffedd..00000000
--- a/sdk/cmake/Modules/FindLevelZero.cmake
+++ /dev/null
@@ -1,136 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindLevelZero
--------
-
-Finds the LevelZero library.
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module provides the following imported targets, if found:
-
-``LevelZero::level-zero``
-  Level Zero library
-``LevelZero::headers``
-  Level Zero Headers
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This will define the following variables:
-
-``LevelZero_FOUND``
-  True if the system has the LevelZero library.
-``LevelZero_INCLUDE_DIRS``
-  Include directories needed to use LevelZero.
-
-Cache Variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``LevelZero_INCLUDE_DIR``
-  The directory containing ``level_zero/ze_api.h``.
-``LevelZero_LIBRARY``
-  The path to the LevelZero library.
-
-#]=======================================================================]
-
-# Based on tutorial found in CMake manual:
-# https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
-
-# Level Zero provides
-#   * libze_loader.pc
-find_package(PkgConfig)
-pkg_check_modules(PC_ze_loader QUIET libze_loader)
-
-find_path(
-  LevelZero_INCLUDE_DIR
-  NAMES level_zero/ze_api.h
-  HINTS ENV CPATH
-        ${PC_ze_loader_INCLUDE_DIRS}
-        ${PC_ze_loader_INCLUDEDIR}
-  PATHS ${CMAKE_INCLUDE_PATH}
-        ENV LEVEL_ZERO_V1_SDK_PATH
-  PATH_SUFFIXES include
-)
-
-find_library(
-  LevelZero_LIBRARY
-  NAMES ze_loader
-  HINTS ENV LIBRARY_PATH
-        ${PC_ze_loader_LIBRARY_DIRS}
-        ${PC_ze_loader_LIBDIR}
-  PATHS ${CMAKE_LIBRARY_PATH}
-        ENV LEVEL_ZERO_V1_SDK_PATH
-        ENV LD_LIBRARY_PATH
-  PATH_SUFFIXES lib
-)
-
-get_filename_component(LevelZero_LIBRARY_DIR ${LevelZero_LIBRARY} DIRECTORY)
-# AFAIK, version can only be found via pc file. This is part of a regular level
-# zero install.
-find_path(
-  LevelZero_PkgConfig_DIR
-  NAMES libze_loader.pc
-  HINTS ${LevelZero_LIBRARY_DIR}
-  PATH_SUFFIXES pkgconfig
-                lib/pkgconfig
-                lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig
-                ${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig
-                lib64/pkgconfig
-                lib64/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig
-  NO_CMAKE_PATH
-  NO_CMAKE_ENVIRONMENT_PATH
-  NO_SYSTEM_ENVIRONMENT_PATH
-  NO_CMAKE_SYSTEM_PATH
-)
-
-if(LevelZero_PkgConfig_DIR)
-  file(READ "${LevelZero_PkgConfig_DIR}/libze_loader.pc" LevelZero_PkgConfig)
-  string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" LEVEL_ZERO_VER_FOUND "${LevelZero_PkgConfig}")
-  set(LevelZero_VERSION ${LEVEL_ZERO_VER_FOUND})
-endif()
-
-# On Windows, the driver installs a version of the loader sdk without pc file.
-# However, the version can be found in the path to the .lib. The pc file is
-# present when downloading the sdk from GitHub releases:
-# https://github.com/oneapi-src/level-zero/releases
-if(NOT DEFINED LevelZero_VERSION AND WIN32)
-  string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" LEVEL_ZERO_VER_FOUND "${LevelZero_LIBRARY_DIR}")
-  if (DEFINED LEVEL_ZERO_VER_FOUND AND NOT LEVEL_ZERO_VER_FOUND STREQUAL "")
-    set(LevelZero_VERSION ${LEVEL_ZERO_VER_FOUND})
-  endif()
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  LevelZero
-  FOUND_VAR LevelZero_FOUND
-  REQUIRED_VARS LevelZero_INCLUDE_DIR
-  VERSION_VAR LevelZero_VERSION)
-
-if(LevelZero_FOUND AND NOT TARGET LevelZero::level-zero)
-  add_library(LevelZero::level-zero UNKNOWN IMPORTED)
-  set_target_properties(
-    LevelZero::level-zero
-    PROPERTIES IMPORTED_LOCATION "${LevelZero_LIBRARY}"
-               INTERFACE_COMPILE_OPTIONS "${PC_ze_loader_CFLAGS_OTHER}"
-               INTERFACE_INCLUDE_DIRECTORIES "${LevelZero_INCLUDE_DIR}")
-endif()
-
-if(LevelZero_FOUND AND NOT TARGET LevelZero::headers)
-  add_library(LevelZero::headers INTERFACE IMPORTED)
-  set_target_properties(
-    LevelZero::headers
-    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${LevelZero_INCLUDE_DIR}")
-endif()
-
-mark_as_advanced(LevelZero_INCLUDE_DIR LevelZero_LIBRARY)
-
-if(DEFINED LevelZero_VERSION)
-  set(LevelZero_VERSION_STRING ${LevelZero_VERSION})
-endif()
diff --git a/sdk/cmake/Modules/FindXpti.cmake b/sdk/cmake/Modules/FindXpti.cmake
deleted file mode 100644
index e03f6ae3..00000000
--- a/sdk/cmake/Modules/FindXpti.cmake
+++ /dev/null
@@ -1,217 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindXpti
--------
-
-Finds the Xpti library. Xpti is part of the Intel/LLVM project. It is also
-included as part of the standard oneAPI installation.
-
-`Intel/LLVM <https://github.com/intel/llvm>`_
-
-Further documentation on linking and using XPTI can be found here:
-https://github.com/intel/llvm/blob/sycl/xptifw/doc/XPTI_Framework.md.
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module provides the following imported targets, if found:
-
-``Xpti::xpti``
-  XPTI shared
-``Xpti::xpti_static``
-  XPTI static
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This will define the following variables:
-
-``Xpti_FOUND``
-  True if the system has the Xpti library.
-``Xpti_INCLUDE_DIRS``
-  Include directories needed to use Xpti.
-
-Cache Variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``Xpti_INCLUDE_DIR``
-  The directory containing ``xpti_trace_framework.h``.
-``Xpti_Static_LIBRARY``
-  The path to the Xpti static library.
-``Xpti_Shared_LIBRARY``
-  The path to the Xpti shared library.
-
-#]=======================================================================]
-
-# Based on tutorial found in CMake manual:
-# https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
-
-find_path(
-  Xpti_INCLUDE_DIR
-  NAMES xpti/xpti_trace_framework.h
-  HINTS ENV CPLUS_INCLUDE_PATH
-        ENV C_INCLUDE_PATH
-        ENV CPATH
-        ENV INCLUDE
-        ENV CMPLR_ROOT
-  PATH_SUFFIXES include linux/include)
-
-find_library(
-  Xpti_Static_LIBRARY
-  NAMES xpti
-  HINTS ENV CMPLR_ROOT ENV LIBRARY_PATH
-  PATH_SUFFIXES lib linux/lib)
-
-find_library(
-  Xpti_Shared_LIBRARY
-  NAMES xptifw
-  HINTS ENV LIBRARY_PATH
-        ENV LD_LIBRARY_PATH
-        ENV LIB
-        ENV CMPLR_ROOT
-  PATH_SUFFIXES lib linux/lib)
-
-if(WIN32)
-find_library(
-  Xpti_Static_Debug_LIBRARY
-  NAMES xptid
-  HINTS ENV LIB ENV CMPLR_ROOT ENV LIBRARY_PATH
-  PATH_SUFFIXES lib linux/lib)
-
-find_library(
-  Xpti_Shared_Debug_LIBRARY
-  NAMES xptifwd
-  HINTS ENV LIB ENV CMPLR_ROOT ENV LIBRARY_PATH
-  PATH_SUFFIXES lib linux/lib)
-
-find_file(
-  Xpti_Shared_Runtime_LIBRARY
-  NAMES xptifw.dll
-  HINTS ENV PATH ENV CMPLR_ROOT ENV LIBRARY_PATH
-  PATH_SUFFIXES bin windows/bin)
-
-find_file(
-  Xpti_Shared_Debug_Runtime_LIBRARY
-  NAMES xptifwd.dll
-  HINTS ENV PATH ENV CMPLR_ROOT ENV LIBRARY_PATH
-  PATH_SUFFIXES bin windows/bin)
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  Xpti
-  FOUND_VAR Xpti_FOUND
-  REQUIRED_VARS Xpti_Shared_LIBRARY Xpti_INCLUDE_DIR)
-
-if(Xpti_FOUND AND NOT TARGET Xpti::xpti)
-  add_library(Xpti::xpti SHARED IMPORTED)
-  set_target_properties(
-    Xpti::xpti
-    PROPERTIES IMPORTED_LOCATION "${Xpti_Shared_LIBRARY}"
-               INTERFACE_COMPILE_DEFINITIONS
-               "XPTI_API_EXPORTS;XPTI_CALLBACK_API_EXPORTS"
-               INTERFACE_INCLUDE_DIRECTORIES "${Xpti_INCLUDE_DIR}")
-  if(WIN32)
-    set_target_properties(
-      Xpti::xpti
-      PROPERTIES RUNTIME_OUTPUT_NAME "xptifw.dll"
-                 RUNTIME_OUTPUT_NAME_RELEASE "xptifw.dll"
-                 RUNTIME_OUTPUT_NAME_DEBUG "xptifwd.dll")
-  endif()
-
-  if(UNIX)
-    set_target_properties(
-      Xpti::xpti
-      PROPERTIES RUNTIME_OUTPUT_NAME "libxptifw.so"
-                 RUNTIME_OUTPUT_NAME_RELEASE "libxptifw.so"
-                 RUNTIME_OUTPUT_NAME_DEBUG "libxptifw.so")
-  endif()
-
-  # Just a guess, not actually supported.
-  if(APPLE)
-    set_target_properties(
-      Xpti::xpti
-      PROPERTIES RUNTIME_OUTPUT_NAME "libxptifw.dylib"
-                 RUNTIME_OUTPUT_NAME_RELEASE "libxptifw.dylib"
-                 RUNTIME_OUTPUT_NAME_DEBUG "libxptifw.dylib")
-  endif()
-
-  if(WIN32)
-    # Since XPTI on Windows supports multiple configurations (Debug and Release)
-    # we should handle both those cases.
-    # Note the difference between IMPORTED_IMPLIB and IMPORTED_LOCATION. On
-    # Windows, IMPORTED_IMPLIB should be the .lib file and IMPORTED_LOCATION
-    # should be the .dll file for SHARED libraries.
-    if(Xpti_Shared_LIBRARY)
-      set_property(
-        TARGET Xpti::xpti
-        APPEND
-        PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
-      set_target_properties(Xpti::xpti PROPERTIES IMPORTED_IMPLIB
-                                                  "${Xpti_Shared_LIBRARY}"
-                                                  IMPORTED_IMPLIB_RELEASE
-                                                  "${Xpti_Shared_LIBRARY}")
-      if(Xpti_Shared_Runtime_LIBRARY)
-        set_target_properties(
-          Xpti::xpti
-          PROPERTIES IMPORTED_LOCATION "${Xpti_Shared_Runtime_LIBRARY}"
-                     IMPORTED_LOCATION_RELEASE "${Xpti_Shared_Runtime_LIBRARY}")
-      endif()
-    endif()
-
-    if(Xpti_Shared_Debug_LIBRARY)
-      set_property(
-        TARGET Xpti::xpti
-        APPEND
-        PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
-      set_target_properties(
-        Xpti::xpti PROPERTIES IMPORTED_IMPLIB_DEBUG
-                              "${Xpti_Shared_Debug_LIBRARY}")
-      if(Xpti_Shared_Debug_Runtime_LIBRARY)
-        set_target_properties(
-          Xpti::xpti PROPERTIES IMPORTED_LOCATION_DEBUG
-                                "${Xpti_Shared_Debug_Runtime_LIBRARY}")
-      endif()
-    endif()
-  endif()
-endif()
-
-if(Xpti_FOUND AND NOT TARGET Xpti::xpti_static)
-  add_library(Xpti::xpti_static STATIC IMPORTED)
-  set_target_properties(
-    Xpti::xpti_static
-    PROPERTIES IMPORTED_LOCATION "${Xpti_Static_LIBRARY}"
-               INTERFACE_COMPILE_DEFINITIONS "XPTI_STATIC_LIBRARY"
-               INTERFACE_INCLUDE_DIRECTORIES "${Xpti_INCLUDE_DIR}")
-  if(WIN32)
-    if(Xpti_Static_LIBRARY)
-      set_property(
-        TARGET Xpti::xpti_static
-        APPEND
-        PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
-      set_target_properties(
-        Xpti::xpti_static
-        PROPERTIES IMPORTED_IMPLIB "${Xpti_Static_LIBRARY}"
-                   IMPORTED_IMPLIB_RELEASE "${Xpti_Static_LIBRARY}"
-                   IMPORTED_LOCATION "${Xpti_Static_LIBRARY}"
-                   IMPORTED_LOCATION_RELEASE "${Xpti_Static_LIBRARY}")
-    endif()
-
-    if(Xpti_Static_Debug_LIBRARY)
-      set_property(
-        TARGET Xpti::xpti_static
-        APPEND
-        PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
-      set_target_properties(
-        Xpti::xpti_static
-        PROPERTIES IMPORTED_IMPLIB_DEBUG "${Xpti_Static_Debug_LIBRARY}"
-                   IMPORTED_LOCATION_DEBUG "${Xpti_Static_Debug_LIBRARY}")
-    endif()
-  endif()
-endif()
-
-mark_as_advanced(Xpti_INCLUDE_DIR Xpti_Static_LIBRARY Xpti_Shared_LIBRARY)
diff --git a/sdk/cmake/Modules/Findunified-runtime.cmake b/sdk/cmake/Modules/Findunified-runtime.cmake
deleted file mode 100644
index 4c105606..00000000
--- a/sdk/cmake/Modules/Findunified-runtime.cmake
+++ /dev/null
@@ -1,101 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-Findunified-runtime
--------
-
-Imported Targets
-^^^^^^^^^^^^^^^^
-
-This module provides the following imported targets, if found:
-
-``unified-runtime::loader``
-  ur_loader.so
-
-Result Variables
-^^^^^^^^^^^^^^^^
-
-This will define the following variables:
-
-``unified-runtime_FOUND``
-  True if the system has the Ur library.
-``unified-runtime_INCLUDE_DIRS``
-  Include directories needed to use Ur.
-
-Cache Variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``unified-runtime_INCLUDE_DIR``
-  The directory containing ``sycl/ur_api.h``.
-``unified-runtime_LIBRARY``
-The path to the Unified Runtime library.
-
-#]=======================================================================]
-
-# Based on tutorial found in CMake manual:
-# https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
-
-#
-# Note about PATHS:
-#
-# These are specifically hardcoded fallbacks.
-#
-# * `/opt/intel/oneapi/compiler/latest` - common oneAPI installation location on
-#                                         Linux.
-# * `/opt/sycl` - Intel/LLVM open-source compiler container installation location
-#                 on Linux.
-#
-find_library(
-  unified-runtime_LIBRARY
-  NAMES ur_loader
-  HINTS ENV LIBRARY_PATH
-        ENV LD_LIBRARY_PATH
-        ENV LIB
-        ENV CMPLR_ROOT
-  PATHS /opt/intel/oneapi/compiler/latest
-        /opt/intel/oneapi/compiler/latest/linux
-        /opt/sycl
-  PATH_SUFFIXES lib
-                linux/lib
-)
-
-if(unified-runtime_LIBRARY)
-  # Get the root directory of the unified-runtime installation. This will help
-  # us find the include directory, given some versions of the compiler do not
-  # have an environment variable pointing to the installation root.
-  get_filename_component(UNIFIED_RUNTIME_LIB_DIR "${unified-runtime_LIBRARY}" DIRECTORY)
-  get_filename_component(UNIFIED_RUNTIME_ROOT_DIR "${UNIFIED_RUNTIME_LIB_DIR}" DIRECTORY)
-endif()
-
-find_path(
-  unified-runtime_INCLUDE_DIR
-# the file order seems impacts if it finds UR in the dir under CMPLR_ROOT
-  NAMES ur_api.h sycl/ur_api.h
-  HINTS ${UNIFIED_RUNTIME_ROOT_DIR}
-        ENV CPATH
-        ENV C_INCLUDE_PATH
-        ENV CPLUS_INCLUDE_PATH
-        ENV INCLUDE
-        ENV CMPLR_ROOT
-  PATH_SUFFIXES include
-                linux/include
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(
-  unified-runtime
-  FOUND_VAR unified-runtime_FOUND
-  REQUIRED_VARS unified-runtime_LIBRARY unified-runtime_INCLUDE_DIR)
-
-if(unified-runtime_FOUND AND NOT TARGET unified-runtime::loader)
-  add_library(unified-runtime::loader UNKNOWN IMPORTED)
-  set_target_properties(
-    unified-runtime::loader
-    PROPERTIES IMPORTED_LOCATION "${unified-runtime_LIBRARY}"
-               INTERFACE_INCLUDE_DIRECTORIES "${unified-runtime_INCLUDE_DIR}")
-endif()
-
-mark_as_advanced(unified-runtime_INCLUDE_DIR unified-runtime_LIBRARY)
diff --git a/sdk/cmake/Modules/macros.cmake b/sdk/cmake/Modules/macros.cmake
deleted file mode 100644
index 2d6dc2d4..00000000
--- a/sdk/cmake/Modules/macros.cmake
+++ /dev/null
@@ -1,705 +0,0 @@
-set(PTI_CMAKE_MACRO_DIR ${CMAKE_CURRENT_LIST_DIR}/../.. CACHE INTERNAL "")
-
-include(${PTI_CMAKE_MACRO_DIR}/cmake/dependency_pins.cmake)
-
-macro(RequirePythonInterp)
-  if(NOT DEFINED _Python_EXECUTABLE OR NOT TARGET Python::Interpreter)
-    find_package(Python COMPONENTS Interpreter REQUIRED)
-    set(PYTHON_EXECUTABLE "${Python_EXECUTABLE}")
-  else()
-    set(PYTHON_EXECUTABLE "${_Python_EXECUTABLE}")
-  endif()
-endmacro()
-
-macro(SetPtiVersion)
-  file(STRINGS "${PTI_CMAKE_MACRO_DIR}/VERSION" PTI_VERSION)
-  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
-               "${PTI_CMAKE_MACRO_DIR}/VERSION")
-endmacro()
-
-macro(SetBuildType)
-  if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE "Release")
-  endif()
-  message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}")
-
-  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    message(STATUS "Bitness: 64 bits")
-  else()
-    message(FATAL_ERROR "32-bit mode is not supported")
-  endif()
-endmacro()
-
-macro(FindTracedLibrariesHeaderPaths TARGET L0_GEN_SCRIPT GEN_FILE_NAME custom_target L0_TARGET)
-  RequirePythonInterp()
-
-  # Use the target that links level zero to find the level zero library
-  get_target_property(L0_TARGET_PATH ${L0_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
-
-  # HINTS before PATHS
-  find_path(L0_INC_PATH
-    NAMES level_zero/ze_api.h
-    HINTS ${L0_TARGET_PATH}
-    PATHS ENV CPATH)
-  if (NOT L0_INC_PATH)
-    message(FATAL_ERROR
-      "Level Zero headers path is not found.\n"
-      "You may need to install oneAPI Level Zero Driver to fix this issue.")
-  else()
-    message(STATUS "Level Zero headers are found at ${L0_INC_PATH}")
-  endif()
-
-  set(L0_GEN_INC_PATH "${PROJECT_BINARY_DIR}")
-  if (NOT TARGET unified-runtime::loader)
-    find_package(unified-runtime)
-  endif()
-
-  # Fake file path until we stop generating code on each build.
-  set(UR_HEADER_PATH "${PROJECT_SOURCE_DIR}/third-party/unified-runtime/include/unified-runtime/ur_api.h")
-  if (TARGET unified-runtime::loader)
-    get_target_property(UR_HEADER_PATH unified-runtime::loader INTERFACE_INCLUDE_DIRECTORIES)
-  endif()
-
-  add_custom_target(${custom_target} ALL
-                    DEPENDS ${L0_GEN_INC_PATH}/${GEN_FILE_NAME})
-  string(CONCAT PTI_LEVELZERO_COMMIT_INFO "commit: " ${PTI_LEVELZERO_COMMIT} " - v" ${PTI_LEVELZERO_VERSION})
-  add_custom_command(OUTPUT ${L0_GEN_INC_PATH}/${GEN_FILE_NAME}
-                     COMMAND "${PYTHON_EXECUTABLE}" ${L0_GEN_SCRIPT}
-                     ${L0_GEN_INC_PATH} "${L0_INC_PATH}/level_zero"
-                     "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include/pti" ${UR_HEADER_PATH} ${PTI_API_ID_REGENERATE} ${PTI_LEVELZERO_COMMIT_INFO}
-                     DEPENDS ${L0_GEN_SCRIPT})
-  target_include_directories(${TARGET}
-    PUBLIC "$<BUILD_INTERFACE:${L0_GEN_INC_PATH}>")
-  add_dependencies(${TARGET}
-    ${custom_target})
-endmacro()
-
-macro(CheckIfSyclIsAvailable)
-  include(CheckCXXCompilerFlag)
-  include(CheckIncludeFileCXX)
-  CHECK_CXX_COMPILER_FLAG("-fsycl" HAVE_SYCL)
-
-  if(HAVE_SYCL)
-    CHECK_INCLUDE_FILE_CXX("sycl/sycl.hpp" SYCL_IS_AVAILABLE "-fsycl")
-    if(NOT SYCL_IS_AVAILABLE)
-      set(HAVE_SYCL NO)
-    else()
-      message(STATUS "Able to compile sycl code. All samples will be built.")
-    endif()
-  endif()
-
-  if(NOT HAVE_SYCL)
-    message(
-      STATUS
-        "Not able to compile sycl code. Some tests may not run and some samples may not be built."
-    )
-  endif()
-endmacro()
-
-macro(GetSpdlog)
-  if(NOT TARGET spdlog::spdlog)
-    find_package(spdlog ${PTI_SPDLOG_VERSION} QUIET)
-  endif()
-
-  if(NOT TARGET spdlog::spdlog)
-    include(FetchContent)
-    FetchContent_Declare(
-      fmt
-      GIT_REPOSITORY ${PTI_FMT_REPOSITORY}
-      GIT_TAG ${PTI_FMT_COMMIT}
-    )
-    FetchContent_Declare(
-      spdlog
-      GIT_REPOSITORY ${PTI_SPDLOG_REPOSITORY}
-      GIT_TAG ${PTI_SPDLOG_COMMIT}
-    )
-    set(FMT_SYSTEM_HEADERS
-        ON
-        CACHE BOOL "" FORCE)
-    set(FMT_INSTALL
-        OFF
-        CACHE BOOL "" FORCE)
-    set(SPDLOG_BUILD_SHARED
-        OFF
-        CACHE BOOL "" FORCE)
-    set(SPDLOG_BUILD_PIC
-        ON
-        CACHE BOOL "" FORCE)
-    set(SPDLOG_FMT_EXTERNAL_HO
-        ON
-        CACHE BOOL "" FORCE)
-    set(SPDLOG_SYSTEM_INCLUDES
-        ON
-        CACHE BOOL "" FORCE)
-    set(SPDLOG_BUILD_WARNINGS
-        OFF
-        CACHE BOOL "" FORCE)
-    FetchContent_MakeAvailable(fmt spdlog)
-
-    # To keep macro self contained.
-    if (NOT DEFINED PTI_INTEL_LLVM_EXCLUDE_LIBS)
-      set(PTI_INTEL_LLVM_EXCLUDE_LIBS
-        $<$<AND:$<CXX_COMPILER_ID:IntelLLVM>,$<PLATFORM_ID:Linux>>:-no-intel-lib>
-        $<$<AND:$<CXX_COMPILER_ID:IntelLLVM>,$<PLATFORM_ID:Windows>>:/Qno-intel-lib>)
-    endif()
-
-    set(PTI_FMT_COMPILE_OPTIONS
-      $<$<CXX_COMPILER_ID:MSVC>:/wd6285 /wd6294 /wd6240 /wd6031
-      $<$<CONFIG:Release>:/wd4702 /wd6385
-      >>
-    )
-
-    # Prevent fmt from using exceptions because it could throw while logging.
-    # Disable warning in fmt due to our usage of EHsc.
-    set(PTI_FMT_COMPILE_DEFINITIONS
-      FMT_USE_EXCEPTIONS=0
-    )
-
-    # spdlog sets the /MP flag on MSVC which causes a warning on icx.
-    set(PTI_SPDLOG_COMPILE_OPTIONS
-      $<$<CXX_COMPILER_ID:IntelLLVM>:-Wno-unused-command-line-argument>
-    )
-
-    target_compile_definitions(fmt PRIVATE ${PTI_FMT_COMPILE_DEFINITIONS})
-    target_compile_options(fmt PRIVATE ${PTI_FMT_COMPILE_OPTIONS} ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-    target_link_options(fmt PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-
-    target_compile_definitions(fmt-header-only INTERFACE
-      ${PTI_FMT_COMPILE_DEFINITIONS})
-    target_compile_options(fmt-header-only INTERFACE ${PTI_FMT_COMPILE_OPTIONS})
-
-    target_compile_options(spdlog PRIVATE ${PTI_SPDLOG_COMPILE_OPTIONS} ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-    target_link_options(spdlog PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-  endif()
-endmacro()
-
-macro(GetGTest)
-  # TODO(PTI): Use FetchContent find_package mode when we bump minimum CMake
-  # version to 3.24 or higher.
-  if(NOT TARGET GTest::gtest
-      OR NOT TARGET GTest::gtest_main
-      OR NOT TARGET GTest::gmock
-      OR NOT TARGET GTest::gmock_main)
-    find_package(GTest QUIET)
-  endif()
-
-  if(NOT TARGET GTest::gtest
-      OR NOT TARGET GTest::gtest_main
-      OR NOT TARGET GTest::gmock
-      OR NOT TARGET GTest::gmock_main)
-    if(TARGET GTest::gtest AND NOT TARGET GTest::gmock)
-      message(FATAL_ERROR "GTest/GMock mismatch. Uninstall GTest or ensure GMock is available (e.g., install libgmock-dev on Ubuntu)")
-    endif()
-    if(TARGET GTest::gmock AND NOT TARGET GTest::gmock)
-      message(FATAL_ERROR "GTest/GMock mismatch. Uninstall GMock or ensure GTest is available (e.g., install libgtest-dev on Ubuntu)")
-    endif()
-    include(FetchContent)
-    FetchContent_Declare(
-      googletest
-      GIT_REPOSITORY ${PTI_GOOGLETEST_REPOSITORY}
-      GIT_TAG ${PTI_GOOGLETEST_COMMIT}
-    )
-
-    set(INSTALL_GTEST
-        OFF
-        CACHE BOOL "" FORCE)
-    set(gtest_force_shared_crt
-        ON
-        CACHE BOOL "" FORCE)
-    FetchContent_MakeAvailable(googletest)
-
-    set(PTI_GTEST_COMPILE_OPTIONS
-      $<$<OR:$<CXX_COMPILER_ID:IntelLLVM>,$<CXX_COMPILER_ID:Clang>>:
-          -Wno-deprecated-declarations
-          -Wno-character-conversion
-          -Wno-unknown-warning-option
-      >
-      $<$<CXX_COMPILER_ID:MSVC>:/wd6239 /wd6031 /wd6387>
-    )
-
-    set_target_properties(gmock_main gmock gtest gtest_main
-      PROPERTIES
-        COMPILE_OPTIONS "${PTI_GTEST_COMPILE_OPTIONS}")
-  endif()
-endmacro()
-
-macro(CheckSOVersion PROJ_SOVERSION)
-  # Not automatically set because this should be done intentionally.
-  # PTI's rules for backwards compatibility should be re-evaluated upon first
-  # major / production release.
-  # PTI is following [semver](https://semver.org/) versioning and we are using
-  # the SOVERSION to denote backward compatibility.
-  if ("${PROJECT_VERSION}" VERSION_GREATER_EQUAL "1.0.0")
-    if("${PROJ_SOVERSION}" STREQUAL "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
-      message(AUTHOR_WARNING "${PROJECT_NAME} currently has the SOVERSION: "
-                    "${PROJ_SOVERSION}. After the first major release, ${PROJECT_NAME}"
-                    " should have the SOVERSION: ${PROJECT_VERSION_MAJOR}.")
-    endif()
-  endif()
-endmacro()
-
-macro(get_itt)
-  if (NOT TARGET ittapi::ittnotify OR NOT TARGET ittapi::headers)
-    include(FetchContent)
-    FetchContent_Declare(
-      ittapi
-      GIT_REPOSITORY ${PTI_ITTAPI_REPOSITORY}
-      GIT_TAG ${PTI_ITTAPI_COMMIT}
-    )
-
-    set(ITT_API_INSTALL OFF CACHE BOOL "ITT is statically linked - avoid install" FORCE)
-    FetchContent_MakeAvailable(ittapi)
-
-    target_compile_options(ittnotify PRIVATE
-      $<$<C_COMPILER_ID:IntelLLVM>:-Wno-strict-prototypes>
-      $<$<C_COMPILER_ID:Clang>:-Wno-strict-prototypes>
-      $<$<C_COMPILER_ID:GNU>:-Wno-pedantic>
-    )
-
-    target_compile_options(jitprofiling PRIVATE
-      $<$<C_COMPILER_ID:IntelLLVM>:-Wno-strict-prototypes>
-      $<$<C_COMPILER_ID:Clang>:-Wno-strict-prototypes>
-      $<$<C_COMPILER_ID:GNU>:-Wno-pedantic>
-    )
-
-    # Allow rolling back to older versions of ITT without breaking the build.
-    # One can remove later.
-    if (TARGET ittnotify AND NOT TARGET ittapi::ittnotify)
-      add_library(ittapi::ittnotify ALIAS ittnotify)
-    endif()
-
-    if (NOT TARGET ittapi::headers)
-      add_library(ittapi::headers INTERFACE IMPORTED)
-      set_target_properties(
-        ittapi::headers
-        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${ittapi_SOURCE_DIR}/include;${ittapi_SOURCE_DIR}/src/ittnotify")
-    endif()
-  endif()
-endmacro()
-
-macro(RemoveNDebugFlag)
-  if(CMAKE_CXX_COMPILER_ID MATCHES "IntelLLVM" OR CMAKE_CXX_COMPILER_ID MATCHES
-                                                  "Clang")
-    # One must make sure -DNDEBUG is not set if using XPTI filename/linenumber
-    # https://stackoverflow.com/questions/22140520/how-to-enable-assert-in-cmake-release-mode
-    string(REPLACE "-DNDEBUG" "" CMAKE_CXX_FLAGS_RELEASE
-                   "${CMAKE_CXX_FLAGS_RELEASE}")
-    string(REPLACE "-DNDEBUG" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO
-                   "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-  endif()
-endmacro()
-
-macro(ProjectIsTopLevel)
-  if(NOT DEFINED PROJECT_IS_TOP_LEVEL)
-    set(PROJECT_IS_TOP_LEVEL FALSE)
-    get_property(PTI_PROJ_PARENT DIRECTORY PROPERTY PARENT_DIRECTORY)
-    if(PTI_PROJ_PARENT STREQUAL "")
-      set(PROJECT_IS_TOP_LEVEL TRUE)
-    endif()
-  endif()
-endmacro()
-
-macro(AddApiGenTarget L0_GEN_SCRIPT GEN_FILE_NAME L0_TARGET)
-  RequirePythonInterp()
-
-  # Use the target that links level zero to find the level zero library
-  if(TARGET LevelZero::level-zero)
-    get_target_property(L0_TARGET_PATH ${L0_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
-    include(CMakePrintHelpers)
-    cmake_print_variables(PTI_LEVELZERO_VERSION PTI_LEVELZERO_COMMIT L0_TARGET_PATH)
-  endif()
-
-  # HINTS before PATHS
-  find_path(L0_INC_PATH
-    NAMES level_zero/ze_api.h
-    HINTS ${L0_TARGET_PATH}
-    PATHS ENV CPATH)
-  if (NOT L0_INC_PATH)
-    message(FATAL_ERROR
-      "Level Zero headers path is not found.\n"
-      "You may need to install oneAPI Level Zero Driver to fix this issue.")
-  else()
-    message(STATUS "Level Zero headers are found at ${L0_INC_PATH}")
-  endif()
-
-  set(L0_GEN_INC_PATH "${PROJECT_BINARY_DIR}")
-  if (NOT TARGET unified-runtime::loader)
-    find_package(unified-runtime)
-  endif()
-
-  # Temporary until we remove UR build dependency.
-  set(UR_HEADER_PATH "${PROJECT_SOURCE_DIR}/third-party/unified-runtime/include/unified-runtime/ur_api.h")
-  if (TARGET unified-runtime::loader)
-    get_target_property(UR_HEADER_PATH unified-runtime::loader INTERFACE_INCLUDE_DIRECTORIES)
-  endif()
-
-  string(CONCAT PTI_LEVELZERO_COMMIT_INFO "commit: " ${PTI_LEVELZERO_COMMIT} " - v" ${PTI_LEVELZERO_VERSION})
-  add_custom_target(generate-ids
-                    DEPENDS ${L0_GEN_INC_PATH}/${GEN_FILE_NAME}
-                    COMMAND "${PYTHON_EXECUTABLE}" ${L0_GEN_SCRIPT}
-                    ${L0_GEN_INC_PATH} "${L0_INC_PATH}/level_zero"
-                    "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include/pti" ${UR_HEADER_PATH} "ON" ${PTI_LEVELZERO_COMMIT_INFO})
-endmacro()
-
-macro(AddFormatTarget)
-  find_program(CLANG_FORMAT_EXE clang-format)
-  find_program(RUFF_FORMAT_EXE ruff)
-
-  add_custom_target(format)
-  add_custom_target(format-chk)
-
-  cmake_policy(PUSH)
-  cmake_policy(SET CMP0009 NEW)
-  file(GLOB_RECURSE cf_src_files CONFIGURE_DEPENDS "${PROJECT_SOURCE_DIR}/src/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/src/*.h"
-                                  "${PROJECT_SOURCE_DIR}/src/**/*.h"
-                                  "${PROJECT_SOURCE_DIR}/src/**/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/test/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/test/*.h"
-                                  "${PROJECT_SOURCE_DIR}/test/**/*.h"
-                                  "${PROJECT_SOURCE_DIR}/test/**/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/samples/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/samples/*.h"
-                                  "${PROJECT_SOURCE_DIR}/samples/**/*.h"
-                                  "${PROJECT_SOURCE_DIR}/samples/**/*.cc"
-                                  "${PROJECT_SOURCE_DIR}/samples/**/*.c")
-
-  list(FILTER cf_src_files EXCLUDE REGEX
-      "^${PROJECT_SOURCE_DIR}/(build|samples/(dlworkload|iso3d))")
-
-  add_custom_target(format-cpp
-    COMMAND ${CLANG_FORMAT_EXE} -i ${cf_src_files}
-    VERBATIM COMMAND_EXPAND_LISTS USES_TERMINAL)
-
-  add_custom_target(format-cpp-chk
-    COMMAND ${CLANG_FORMAT_EXE} --dry-run --Werror ${cf_src_files}
-    VERBATIM COMMAND_EXPAND_LISTS USES_TERMINAL)
-
-  add_dependencies(format format-cpp)
-  add_dependencies(format-chk format-cpp-chk)
-
-  if(RUFF_FORMAT_EXE)
-    list(APPEND py_src_dirs "${PROJECT_SOURCE_DIR}/cmake"
-                            "${PROJECT_SOURCE_DIR}/src"
-                            "${PROJECT_SOURCE_DIR}/test"
-                            "${PROJECT_SOURCE_DIR}/samples")
-    file(GLOB py_src_dirs_cur "${PROJECT_SOURCE_DIR}/*.py")
-    set(py_src_dirs ${py_src_dirs} ${py_src_dirs_cur})
-    add_custom_target(format-py
-      COMMAND ${RUFF_FORMAT_EXE} format ${py_src_dirs}
-      VERBATIM COMMAND_EXPAND_LISTS USES_TERMINAL)
-
-    add_custom_target(format-py-chk
-      COMMAND ${RUFF_FORMAT_EXE} format --check ${py_src_dirs}
-      VERBATIM COMMAND_EXPAND_LISTS USES_TERMINAL)
-
-    add_dependencies(format format-py)
-    add_dependencies(format-chk format-py-chk)
-    unset(py_src_dirs)
-    unset(py_src_dirs_cur)
-  else()
-    message(STATUS "ruff not found. Python code cannot be formatted.")
-  endif()
-  cmake_policy(POP)
-endmacro()
-
-macro(AddProjectVersionInfo TARGET)
-  if (WIN32)
-    set(PTI_VERSIONINFO_RC "${PROJECT_BINARY_DIR}/$<CONFIG>/${TARGET}_versioninfo.rc")
-    set(PTI_VERSIONINFO_RC_IN "${PROJECT_BINARY_DIR}/${TARGET}_versioninfo.rc.in")
-    set(PTI_VERSIONINFO_RC_IN_INIT "${PROJECT_SOURCE_DIR}/cmake/Modules/pti_versioninfo.rc.in")
-
-    set(INTEL_LIC_PATH "${PTI_CMAKE_MACRO_DIR}/../LICENSE")
-
-    if (EXISTS "${INTEL_LIC_PATH}")
-      file(STRINGS "${INTEL_LIC_PATH}" INTEL_LICENSE_FILE_STRINGS)
-      foreach(PTI_STRING ${INTEL_LICENSE_FILE_STRINGS})
-        string(REGEX MATCH "^Copyright.*" PTI_COPYRIGHT "${PTI_STRING}")
-        if (PTI_COPYRIGHT)
-          break()
-        endif()
-      endforeach()
-    endif()
-
-    if(NOT PTI_COPYRIGHT)
-      message(WARNING "Copyright file not found, Windows versioninfo will be incomplete")
-      set(PTI_COPYRIGHT "Copyright (C) Intel Corporation")
-    endif()
-
-    set(PTI_VERSION_TWEAK "${PROJECT_VERSION_TWEAK}")
-    if(NOT PTI_VERSION_TWEAK)
-      set(PTI_VERSION_TWEAK 0)
-    endif()
-
-    set(TARGET_NAME ${TARGET})
-
-    # https://discourse.cmake.org/t/configuring-a-file-that-has-both-substitution-and-generator-expressions/3064/2
-    configure_file(${PTI_VERSIONINFO_RC_IN_INIT} ${PTI_VERSIONINFO_RC_IN} @ONLY NEWLINE_STYLE CRLF)
-    file(
-      GENERATE
-      OUTPUT ${PTI_VERSIONINFO_RC}
-      INPUT  ${PTI_VERSIONINFO_RC_IN}
-      NEWLINE_STYLE CRLF
-    )
-
-    target_sources(${TARGET} PRIVATE ${PTI_VERSIONINFO_RC})
-  endif()
-endmacro()
-
-#
-# Check whether to use experimental/filesystem or filesystem.
-#
-# defines `PTI_EXPERIMENTAL_FILESYSTEM` if the platform does not
-# support std::filesystem usage.
-# sets `FS_LIB` with proper library to link (empty if not needed).
-#
-macro(CheckExperimentalFilesystem)
-  if(NOT DEFINED PTI_EXPERIMENTAL_FILESYSTEM AND NOT DEFINED FS_LIB)
-    set(FS_LIB "")
-    cmake_policy(PUSH)
-    cmake_policy(SET CMP0067 NEW)
-    include(CMakePushCheckState)
-    cmake_push_check_state()
-    cmake_reset_check_state()
-    include(CheckCXXSourceCompiles)
-    # Check normal case
-    set(code
-      "#include <filesystem>
-      int main()
-      {
-        return std::filesystem::exists(std::filesystem::temp_directory_path());
-      }")
-    set(CMAKE_REQUIRED_LIBRARIES ${FS_LIB})
-    check_cxx_source_compiles("${code}" COMPILES_STD_FILESYSTEM)
-
-    if(NOT COMPILES_STD_FILESYSTEM)
-      cmake_reset_check_state()
-
-      # Check experimental filesystem case
-      set(code
-        "#include <experimental/filesystem>
-        int main()
-        {
-          return std::experimental::filesystem::exists(std::experimental::filesystem::temp_directory_path());
-        }")
-      set(CMAKE_REQUIRED_LIBRARIES ${FS_LIB})
-      check_cxx_source_compiles("${code}" COMPILES_STD_EXPERIMENTAL_FILESYSTEM)
-    endif()
-
-    # Check experimental filesystem glib case
-    if(NOT COMPILES_STD_FILESYSTEM AND NOT COMPILES_STD_EXPERIMENTAL_FILESYSTEM)
-      cmake_reset_check_state()
-      set(FS_LIB stdc++fs)
-      set(CMAKE_REQUIRED_LIBRARIES ${FS_LIB})
-      check_cxx_source_compiles("${code}"
-        COMPILES_STD_EXPERIMENTAL_FILESYSTEM_LIBSTDCXXFS)
-      if(COMPILES_STD_EXPERIMENTAL_FILESYSTEM_LIBSTDCXXFS)
-        set(COMPILES_STD_EXPERIMENTAL_FILESYSTEM TRUE)
-      endif()
-    endif()
-
-    # Check experimental filesystem LLVM case
-    if(NOT COMPILES_STD_FILESYSTEM AND NOT COMPILES_STD_EXPERIMENTAL_FILESYSTEM_LIBSTDCXXFS)
-      cmake_reset_check_state()
-      set(FS_LIB c++fs)
-      set(CMAKE_REQUIRED_LIBRARIES ${FS_LIB})
-      check_cxx_source_compiles("${code}"
-        COMPILES_STD_EXPERIMENTAL_FILESYSTEM_LIBCXXFS)
-      if(COMPILES_STD_EXPERIMENTAL_FILESYSTEM_LIBCXXFS)
-        set(COMPILES_STD_EXPERIMENTAL_FILESYSTEM TRUE)
-      endif()
-    endif()
-
-    cmake_pop_check_state()
-    cmake_policy(POP)
-
-    if(NOT COMPILES_STD_FILESYSTEM)
-      if(NOT COMPILES_STD_EXPERIMENTAL_FILESYSTEM)
-        message(FATAL_ERROR "C++17 filesystem support is required")
-      endif()
-      set(PTI_EXPERIMENTAL_FILESYSTEM ON)
-    else()
-      set(FS_LIB "") # Clear if we have std::filesystem
-      unset(PTI_EXPERIMENTAL_FILESYSTEM)
-    endif()
-  endif()
-endmacro()
-
-macro(AddVersionlessLinkFile MY_TARGET)
-  add_custom_command(TARGET ${MY_TARGET} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_LINKER_FILE:${MY_TARGET}>
-    $<TARGET_LINKER_FILE_DIR:${MY_TARGET}>/${CMAKE_SHARED_LIBRARY_PREFIX}${MY_TARGET}$<$<PLATFORM_ID:Windows>:$<$<CONFIG:Debug>:d>>${CMAKE_LINK_LIBRARY_SUFFIX}
-  )
-endmacro()
-
-function(GetCurrentGitCommit COMMIT_OUTPUT_VAR)
-  set(_OUT_TEMP "")
-  set(_GIT_RESULT_TEMP 1)
-  if (NOT Git_FOUND)
-    find_package(Git)
-  endif()
-  if(Git_FOUND)
-    execute_process(
-      COMMAND "${GIT_EXECUTABLE}" rev-parse HEAD
-      OUTPUT_VARIABLE _OUT_TEMP
-      RESULT_VARIABLE _GIT_RESULT_TEMP
-      ERROR_QUIET
-      OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    if(_GIT_RESULT_TEMP EQUAL 0)
-      set(${COMMIT_OUTPUT_VAR} "${_OUT_TEMP}" PARENT_SCOPE)
-    endif()
-  endif()
-endfunction()
-
-# DetectSystemLevelZeroMetricApi
-#
-# Detects whether the system-installed Level Zero loader exports both on-demand
-# metric enable/disable symbols (zetDeviceEnableMetricsExp and
-# zetDeviceDisableMetricsExp). Sets HAVE_ZET_DEVICE_METRIC_API to TRUE only if
-# both are present, FALSE otherwise. A single variable is used because both
-# symbols must be present for the feature to work — checking one is not enough.
-#
-# Always probes the SYSTEM loader, not the one potentially built from FetchContent
-# into _deps. The fetched loader is always a recent version that exports the
-# symbols, but the runtime driver may not — probing the fetched binary would give
-# a false positive.
-#
-# NO_CMAKE_PATH and NO_CMAKE_ENVIRONMENT_PATH prevent accidentally finding the
-# FetchContent copy if CMAKE_PREFIX_PATH points into _deps.
-#
-# Platform notes:
-#   Linux:   finds libze_loader.so in system lib dirs (/usr/lib, /usr/lib64, etc.)
-#   Windows: finds ze_loader.dll in %SystemRoot%\System32 (installed by GPU driver).
-#            CMAKE_FIND_LIBRARY_SUFFIXES is overridden to .dll since find_library
-#            defaults to .lib on Windows.
-macro(DetectSystemLevelZeroMetricApi)
-  if(WIN32)
-    # find_library on Windows appends CMAKE_FIND_LIBRARY_SUFFIXES (.lib by default).
-    # Override to .dll so we find ze_loader.dll in System32 as installed by the GPU driver.
-    set(_saved_suffixes ${CMAKE_FIND_LIBRARY_SUFFIXES})
-    set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll")
-    find_library(_system_ze_loader
-      NAMES ze_loader
-      PATHS $ENV{SystemRoot}/System32
-      NO_DEFAULT_PATH
-    )
-    set(CMAKE_FIND_LIBRARY_SUFFIXES ${_saved_suffixes})
-    unset(_saved_suffixes)
-  else()
-    find_library(_system_ze_loader
-      NAMES ze_loader
-      NO_CMAKE_PATH
-      NO_CMAKE_ENVIRONMENT_PATH
-    )
-  endif()
-
-  if(_system_ze_loader)
-    if(WIN32)
-      # check_library_exists cannot link against a DLL; use dumpbin /EXPORTS instead
-      find_program(_dumpbin dumpbin)
-      if(_dumpbin)
-        execute_process(
-          COMMAND ${_dumpbin} /EXPORTS ${_system_ze_loader}
-          OUTPUT_VARIABLE _dumpbin_output
-          ERROR_VARIABLE  _dumpbin_error
-          RESULT_VARIABLE _dumpbin_result
-          OUTPUT_STRIP_TRAILING_WHITESPACE
-        )
-        if(NOT _dumpbin_result EQUAL 0)
-          message(WARNING "Level Zero: dumpbin failed (exit ${_dumpbin_result}): ${_dumpbin_error} -- assuming APIs not supported")
-          set(_symbols_found FALSE)
-        else()
-          string(FIND "${_dumpbin_output}" "zetDeviceEnableMetricsExp"  _have_ze_enable)
-          string(FIND "${_dumpbin_output}" "zetDeviceDisableMetricsExp" _have_ze_disable)
-          if(NOT _have_ze_enable EQUAL -1 AND NOT _have_ze_disable EQUAL -1)
-            set(_symbols_found TRUE)
-          else()
-            set(_symbols_found FALSE)
-          endif()
-        endif()
-        unset(_dumpbin_output)
-        unset(_dumpbin_error)
-        unset(_dumpbin_result)
-      else()
-        message(WARNING "Level Zero: dumpbin not found -- cannot check DLL exports, assuming APIs not supported")
-        set(_symbols_found FALSE)
-      endif()
-      unset(_dumpbin CACHE)
-    else()
-      include(CheckLibraryExists)
-      check_library_exists("${_system_ze_loader}" zetDeviceEnableMetricsExp ""
-                           _have_ze_enable)
-      check_library_exists("${_system_ze_loader}" zetDeviceDisableMetricsExp ""
-                           _have_ze_disable)
-      if(_have_ze_enable AND _have_ze_disable)
-        set(_symbols_found TRUE)
-      else()
-        set(_symbols_found FALSE)
-      endif()
-      unset(_have_ze_enable CACHE)
-      unset(_have_ze_enable)
-      unset(_have_ze_disable CACHE)
-      unset(_have_ze_disable)
-    endif()
-
-    if(_symbols_found)
-      set(HAVE_ZET_DEVICE_METRIC_API TRUE CACHE BOOL "" FORCE)
-      message(STATUS "Level Zero: zetDeviceEnableMetricsExp/zetDeviceDisableMetricsExp found in system loader -- on-demand metric enable supported")
-    else()
-      set(HAVE_ZET_DEVICE_METRIC_API FALSE CACHE BOOL "" FORCE)
-      message(STATUS "Level Zero: zetDeviceEnableMetricsExp/zetDeviceDisableMetricsExp NOT found in system loader -- ZET_ENABLE_METRICS=1 required at runtime")
-    endif()
-    unset(_symbols_found)
-  else()
-    set(HAVE_ZET_DEVICE_METRIC_API FALSE CACHE BOOL "" FORCE)
-    message(STATUS "Level Zero: system loader not found -- assuming ZET_ENABLE_METRICS=1 required at runtime")
-  endif()
-  unset(_system_ze_loader CACHE)
-  unset(_system_ze_loader)
-endmacro()
-
-function(PtiCheckLinkerFlag FLAG_NAME FLAG_VALUE)
-  if(DEFINED PTI_${FLAG_NAME})
-    return()
-  endif()
-  include(CMakePushCheckState)
-  cmake_push_check_state(RESET)
-  if(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
-    set(CMAKE_REQUIRED_FLAGS "/WX")
-  else()
-    set(CMAKE_REQUIRED_FLAGS "-Werror")
-  endif()
-  set(_link_option "${FLAG_VALUE}")
-  set(CMAKE_REQUIRED_LINK_OPTIONS "${_link_option}")
-  include(CheckCXXSourceCompiles)
-  set(_code
-        "int main()
-        {
-          return 0;
-        }")
-  check_cxx_source_compiles("${_code}" PTI_HAVE_${FLAG_NAME})
-  cmake_pop_check_state()
-  if(PTI_HAVE_${FLAG_NAME})
-    set(PTI_${FLAG_NAME} "${_link_option}" CACHE INTERNAL "")
-  else()
-    set(PTI_${FLAG_NAME} "" CACHE INTERNAL "")
-  endif()
-endfunction()
-
-function(PtiCheckVersionScript)
-  if (NOT DEFINED PTI_VERSION_SCRIPT)
-    # Avoid silently failing if map file is not found or corrupted.
-    set(_map_file "${PROJECT_BINARY_DIR}/pti_fake_version_script_check.map")
-    file(WRITE "${_map_file}" "{ local: *; };\n")
-    PtiCheckLinkerFlag(VERSION_SCRIPT "LINKER:--version-script,${_map_file}")
-  endif()
-endfunction()
-
-function(PtiAddVersionScript TARGET MAP_FILE)
-  PtiCheckVersionScript()
-  if(PTI_VERSION_SCRIPT)
-    target_link_options(${TARGET} PRIVATE "LINKER:--version-script,${MAP_FILE}")
-    set_property(TARGET ${TARGET} APPEND PROPERTY LINK_DEPENDS "${MAP_FILE}")
-  endif()
-endfunction()
diff --git a/sdk/cmake/Modules/pti_versioninfo.rc.in b/sdk/cmake/Modules/pti_versioninfo.rc.in
deleted file mode 100644
index d5781ed8..00000000
--- a/sdk/cmake/Modules/pti_versioninfo.rc.in
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <winver.h>
-
-#define VER_COMMENTS_STR               "@PROJECT_HOMEPAGE_URL@ Commit: @PTI_COMMIT_HASH@\0"
-
-#define VER_COMPANY_NAME_STR           "Intel Corporation\0"
-
-#define VER_PRODUCT_DESCRIPTION_STR    "@PROJECT_DESCRIPTION@\0"
-
-#define VER_INTERNAL_NAME_STR          "@PROJECT_NAME@\0"
-
-#define VER_LEGAL_COPYRIGHT_STR        "@PTI_COPYRIGHT@\0"
-
-#define VER_ORIGINAL_FILENAME_STR      "$<TARGET_FILE_NAME:@TARGET_NAME@>\0"
-
-#define VER_PRODUCT_NAME_STR           "Profiling Tools Interface\0"
-
-#define VER_FILEVERSION                @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@PTI_VERSION_TWEAK@
-#define VER_FILEVERSION_STR            "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@\0"
-
-
-#define VER_PRODUCTVERSION             @PROJECT_VERSION_MAJOR@,@PROJECT_VERSION_MINOR@,@PROJECT_VERSION_PATCH@,@PTI_VERSION_TWEAK@
-#define VER_PRODUCTVERSION_STR         "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@\0"
-
-#ifdef _DEBUG
-#define VER_DEBUG   VS_FF_DEBUG
-#else
-#define VER_DEBUG   0
-#endif
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION    VER_FILEVERSION
- PRODUCTVERSION VER_PRODUCTVERSION
- FILEFLAGSMASK  VS_FFI_FILEFLAGSMASK
- FILEFLAGS      VER_DEBUG
- FILEOS         VOS_NT_WINDOWS32
- FILETYPE       VFT_DLL
- FILESUBTYPE    VFT2_UNKNOWN
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "Comments", VER_COMMENTS_STR
-            VALUE "CompanyName", VER_COMPANY_NAME_STR
-            VALUE "FileDescription", VER_PRODUCT_DESCRIPTION_STR
-            VALUE "FileVersion", VER_FILEVERSION_STR
-            VALUE "InternalName", VER_INTERNAL_NAME_STR
-            VALUE "LegalCopyright", VER_LEGAL_COPYRIGHT_STR
-            VALUE "OriginalFilename", VER_ORIGINAL_FILENAME_STR
-            VALUE "ProductName", VER_PRODUCT_NAME_STR
-            VALUE "ProductVersion", VER_PRODUCTVERSION_STR
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
diff --git a/sdk/cmake/bom_line.bash b/sdk/cmake/bom_line.bash
deleted file mode 100755
index 8e82f34a..00000000
--- a/sdk/cmake/bom_line.bash
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/bin/bash
-BOM_DIR=$1
-echo BOM_DIR $BOM_DIR
-TGT_BOM=$2
-echo TGT_BOM $TGT_BOM
-INST_DIR=$3
-echo INST_DIR $INST_DIR
-BRK_TOKEN=$4
-echo BRK_TOKEN $BRK_TOKEN
-TGT_FILE=$5
-echo TGT_FILE $TGT_FILE
-
-[ "$INST_DIR" = "NULL" ] && INST_DIR=""
-
-
-[[ -d ${BOM_DIR} ]] || mkdir ${BOM_DIR}
-echo ALL $@
-
-STG1=${TGT_FILE##*/${BRK_TOKEN}/}
-STRIPPED_NAME=${STG1#$BRK_TOKEN/}
-echo STG1= ${STG1} STRIPPED_NAME ${STRIPPED_NAME}
-
-if [[ -L "$TGT_FILE" ]]; then
-  echo "<N/A>"$':'"INS"${INST_DIR}/${STRIPPED_NAME}$':'CKSUM$':'ONE$'::'INT$':'755$':'$(readlink $TGT_FILE) >> ${TGT_BOM}
-else
-  echo "DEL"/${STRIPPED_NAME}$':'"INS"${INST_DIR}/${STRIPPED_NAME}$':'CKSUM$':'ONE$':'$':'INT$':'$(stat -c '%a' ${TGT_FILE}) >> ${TGT_BOM}
-fi
diff --git a/sdk/cmake/bom_line_win.bat b/sdk/cmake/bom_line_win.bat
deleted file mode 100644
index 885eb207..00000000
--- a/sdk/cmake/bom_line_win.bat
+++ /dev/null
@@ -1 +0,0 @@
-bash cmake\bom_line.bash %*
diff --git a/sdk/cmake/bom_macro.cmake b/sdk/cmake/bom_macro.cmake
deleted file mode 100644
index 8f9bde45..00000000
--- a/sdk/cmake/bom_macro.cmake
+++ /dev/null
@@ -1,21 +0,0 @@
-macro(bomline bomDir class dirPrefix tgtMatch)
-  install(CODE "
-    file(
-      GLOB_RECURSE CMAKE_FILES_LIST
-      ${tgtMatch}
-    )
-    message(STATUS \"BEFORE CMAKE\" ${class})
-    foreach(FILE \${CMAKE_FILES_LIST})
-        message(STATUS \"Installed file1: \${FILE}\")
-	if (UNIX)
-		execute_process(COMMAND cmake/bom_line.bash ${bomDir} ${class} ${dirPrefix} \${CMAKE_INSTALL_PREFIX} \${FILE})
-	else()
-		execute_process(COMMAND [[cmake\\bom_line_win.bat]] ${bomDir} ${class} ${dirPrefix} \${CMAKE_INSTALL_PREFIX} \${FILE})
-	endif()
-    endforeach()
-    message(STATUS \"OUTSIDE CMAKE\" ${class})
-    "
-    COMPONENT Pti_Bom)
-endmacro()
-
-
diff --git a/sdk/cmake/coverage.cmake b/sdk/cmake/coverage.cmake
deleted file mode 100644
index 05fc639e..00000000
--- a/sdk/cmake/coverage.cmake
+++ /dev/null
@@ -1,128 +0,0 @@
-RequirePythonInterp()
-
-if(DEFINED PTI_INSTALL)
-  set(PTI_INSTALL_COVERAGE
-      ${PTI_INSTALL}
-      CACHE
-      BOOL
-      "Option to install coverage artifacts.")
-else()
-  set(PTI_INSTALL_COVERAGE
-      ON
-      CACHE
-      BOOL
-      "Option to install coverage artifacts.")
-endif()
-
-set(DEFAULT_PROFDATA_MERGE_FILENAME
-	"pti-cov.profdata"
-	CACHE
-	STRING
-	"Default filename of merged data (i.e., output from llvm-profdata)")
-
-#
-# Source coverage file structure
-#
-# <src>
-# <src>/<bin>/coverage
-# <src>/<bin>/coverage/raw (raw data generated from tests)
-# <src>/<bin>/coverage/html (html report)
-# <src>/<bin>/coverage/*.info (exported lcov for 3rd party integration)
-# <src>/<bin>/coverage/*.profdata (merged raw data use to generate output)
-#
-
-if(NOT PTI_COVERAGE_DIR)
-  set(PTI_COVERAGE_DIR ${PROJECT_BINARY_DIR}/coverage)
-  set(PTI_COVERAGE_RAW_DIR ${PTI_COVERAGE_DIR}/raw)
-endif()
-
-if(NOT PTI_PROFDATA_MERGE_FILENAME)
-  set(PTI_PROFDATA_MERGE_FILENAME ${DEFAULT_PROFDATA_MERGE_FILENAME})
-endif()
-
-set(PTI_PROFDATA_MERGE_OUTPUT
-    ${PTI_COVERAGE_DIR}/${PTI_PROFDATA_MERGE_FILENAME})
-
-set(THIRD_PARTY_SRC_DIR ".*_deps*")
-
-if(FETCHCONTENT_BASE_DIR)
-  set(THIRD_PARTY_SRC_DIR "${THIRD_PARTY_SRC_DIR}|${FETCHCONTENT_BASE_DIR}/*")
-  file(TO_NATIVE_PATH "${THIRD_PARTY_SRC_DIR}" THIRD_PARTY_SRC_DIR)
-endif()
-
-# CMPLR_ROOT -> prefer Intel oneAPI compiler bundled llvm
-if(NOT LLVM_PROFDATA_PROG)
-  find_program(
-    LLVM_PROFDATA_PROG llvm-profdata
-    HINTS ENV CMPLR_ROOT
-    PATH_SUFFIXES bin bin/compiler)
-endif()
-
-if(NOT LLVM_COV_PROG)
-  find_program(
-    LLVM_COV_PROG llvm-cov
-    HINTS ENV CMPLR_ROOT
-    PATH_SUFFIXES bin bin/compiler)
-endif()
-
-if(NOT LLVM_PROFDATA_PROG)
-  return()
-endif()
-
-if(NOT LLVM_COV_PROG)
-  return()
-endif()
-
-add_custom_command(
-  OUTPUT ${PTI_PROFDATA_MERGE_OUTPUT}
-  COMMAND ${LLVM_PROFDATA_PROG} merge -output=${PTI_PROFDATA_MERGE_OUTPUT}
-          ${PTI_COVERAGE_RAW_DIR}/*.profraw
-  DEPENDS ${PTI_COVERAGE_RAW_DIR})
-
-set(CODE_COVERAGE_BASE_CMD
-    ${Python_EXECUTABLE}
-    ${PROJECT_SOURCE_DIR}/cmake/coverage_report.py
-    generate
-    --llvm-cov
-    ${LLVM_COV_PROG}
-    --objects
-    ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-    ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-    "$<TARGET_FILE_DIR:pti>"
-    --data
-    ${PTI_PROFDATA_MERGE_OUTPUT}
-    --sources
-    ${PROJECT_SOURCE_DIR}/include
-    ${PROJECT_SOURCE_DIR}/src
-    ${PROJECT_BINARY_DIR}
-    --extra=-ignore-filename-regex=${THIRD_PARTY_SRC_DIR})
-
-add_custom_target(
-  coverage_summary
-  COMMAND ${CODE_COVERAGE_BASE_CMD} --summary
-  DEPENDS ${PTI_PROFDATA_MERGE_OUTPUT}
-  COMMENT "Generate coverage summary"
-  VERBATIM)
-
-add_custom_target(
-  coverage_report
-  COMMAND ${CODE_COVERAGE_BASE_CMD} --lcov ${PTI_COVERAGE_DIR}/coverage.info
-  COMMAND ${CODE_COVERAGE_BASE_CMD} --json ${PTI_COVERAGE_DIR}/coverage.json
-  COMMAND ${CODE_COVERAGE_BASE_CMD} --output-dir ${PTI_COVERAGE_DIR}/html
-  DEPENDS ${PTI_PROFDATA_MERGE_OUTPUT}
-  COMMENT "Generate HTML coverage report along with lcov and JSON summary export data."
-  VERBATIM)
-
-if(PTI_INSTALL_COVERAGE)
-  install(
-    DIRECTORY "${PTI_COVERAGE_DIR}/"
-    CONFIGURATIONS Coverage
-    DESTINATION coverage
-    COMPONENT Pti_Coverage_Data)
-
-  install(
-    DIRECTORY "${PTI_COVERAGE_DIR}/html"
-    CONFIGURATIONS Coverage
-    DESTINATION ${CMAKE_INSTALL_DOCDIR}/coverage
-    COMPONENT Pti_Coverage_HTML)
-endif()
diff --git a/sdk/cmake/coverage_report.py b/sdk/cmake/coverage_report.py
deleted file mode 100644
index 07f574a3..00000000
--- a/sdk/cmake/coverage_report.py
+++ /dev/null
@@ -1,308 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-"""
-Script for generating coverage reports with LLVM's source-based code coverage.
-
-https://clang.llvm.org/docs/SourceBasedCodeCoverage.html
-
-The motivation for this script is providing a wrapper for llvm-cov. This
-utility is cumbersome to use with multiple binaries, e.g., if your project has
- many test binaries, one must pass `--object <BIN>` (without globs)
-into llvm-cov.
-
-Before using this script, make sure you run the `llvm-profdata` merge tool and
-get a profdata file. Also, I would generally recommend aggregating binaries
-into a single directory.
-"""
-
-import argparse
-import pathlib
-import subprocess
-
-DEFAULT_LLVM_COV = "llvm-cov"
-# These are most likely not binaries w/ coverage data
-DEFAULT_OBJECT_EXTENSION_EXCLUSION = [
-    ".cc",
-    ".cpp",
-    ".cmake",
-    ".txt",
-    ".cxx",
-    ".h",
-    ".in",
-    ".hpp",
-    ".spv",
-    ".a",
-    ".cl",
-    ".pdb",
-    ".lib",
-    ".profraw",
-    ".profdata",
-]
-DEFAULT_OUTPUT_DIR = pathlib.Path("./coverage")
-DEFAULT_COVERAGE_DATA_FILE = pathlib.Path("./cov.profdata")
-DEFAULT_LCOV_EXPORT_FILE = pathlib.Path("./cov.info")
-
-
-def gen_object_list(obj_arg, extension_filter):
-    """Generate list of objects to pass to llvm-cov
-
-    obj_arg - user arg with either file (object) or directory with objects
-    extension_filter - extensions to ignore.
-    """
-
-    obj_list = []
-
-    for obj in obj_arg:
-        if not obj.exists():
-            continue
-        if obj.is_file() and obj.suffix not in extension_filter:
-            obj_list.append(obj)
-        if obj.is_dir():
-            # Recursive support?
-            obj_list.extend(
-                [
-                    dir_file
-                    for dir_file in obj.iterdir()
-                    if dir_file.exists()
-                    and dir_file.is_file()
-                    and dir_file.suffix not in extension_filter
-                ]
-            )
-
-    return obj_list
-
-
-def base_llvm_cmd(cov_cmd, subcommand, merge_data, objects, sources, extra):
-    """Return common llvm-cov command as list"""
-
-    cmd = []
-    cmd.append(f"{cov_cmd!s}")
-    cmd.append(subcommand)
-    cmd.append(f"--instr-profile={merge_data!s}")
-    cmd.extend([f"--object={my_obj!s}" for my_obj in objects])
-
-    if sources is not None:
-        cmd.append("--sources")
-        cmd.extend([f"{sources_dir!s}" for sources_dir in sources])
-
-    if extra is not None:
-        cmd.extend(extra.split(";"))
-
-    return cmd
-
-
-class LlvmCovHelper:
-    """
-    Helper class to generate coverage reports using llvm-cov.
-
-    This class provides methods to generate HTML coverage reports,
-    summarize coverage, and export coverage data in lcov format.
-    """
-
-    def __init__(
-        self, cov_cmd, merge_data, objects, sources=None, extra=None, verbose=True
-    ):
-        self.verbose = verbose
-        self.show_cmd = base_llvm_cmd(
-            cov_cmd, "show", merge_data, objects, sources, extra
-        )
-        self.export_cmd = base_llvm_cmd(
-            cov_cmd, "export", merge_data, objects, sources, extra
-        )
-        self.report_cmd = base_llvm_cmd(
-            cov_cmd, "report", merge_data, objects, sources, extra
-        )
-
-    def __run_cmd(self, cmd):
-        """Helper function to run llvm-cov command with verbosity"""
-
-        if self.verbose:
-            print(*cmd)
-
-        subprocess.run(cmd, check=True)
-
-    def __export_to_file(self, cmd, file_name):
-        """Helper function to export llvm-cov output to file"""
-
-        if self.verbose:
-            print(*cmd)
-
-        exported_data = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            universal_newlines=True,
-            check=True,
-        )
-
-        with file_name.open("w") as export_file:
-            export_file.write(exported_data.stdout)
-
-    def html(self, outputdir):
-        """Generate html with source-based coverage"""
-
-        html_cmd = self.show_cmd + ["--format=html"] + [f"--output-dir={outputdir!s}"]
-
-        self.__run_cmd(html_cmd)
-
-    def summary(self):
-        """Generate a console summary with source-based coverage"""
-
-        self.__run_cmd(self.report_cmd)
-
-    def export_lcov(self, file_name):
-        """Export source-based coverage data into lcov format."""
-
-        lcov_cmd = self.export_cmd + ["--format=lcov"]
-
-        self.__export_to_file(lcov_cmd, file_name)
-
-    def export_json(self, file_name):
-        """Export source-based coverage data into JSON format (summary only)."""
-
-        json_cmd = self.export_cmd + ["--format=text", "--summary-only"]
-
-        self.__export_to_file(json_cmd, file_name)
-
-
-def generate_subcommand(args):
-    """Coverage report generation subcommand entry"""
-
-    obj_list = gen_object_list(args.objects, args.exclude)
-
-    coverage_generation = LlvmCovHelper(
-        args.llvm_cov, args.data, obj_list, args.sources, args.extra, args.verbose
-    )
-
-    if args.summary:
-        coverage_generation.summary()
-        return
-
-    if args.lcov:
-        coverage_generation.export_lcov(args.lcov)
-        return
-
-    if args.json:
-        coverage_generation.export_json(args.json)
-        return
-
-    coverage_generation.html(args.output_dir)
-
-
-def main():
-    """
-    Entry point to the program.
-
-    Run with --help for detailed usage information
-    """
-
-    parser = argparse.ArgumentParser(
-        description="Utility for working with coverage reports from llvm-cov."
-    )
-
-    subparsers = parser.add_subparsers(dest="command")
-
-    generate_parser = subparsers.add_parser(
-        "generate", help="Generate coverage reports."
-    )
-
-    generate_parser.add_argument(
-        "--llvm-cov",
-        type=pathlib.Path,
-        default=DEFAULT_LLVM_COV,
-        help=f"Default llvm-cov command. Defaults to {DEFAULT_LLVM_COV}",
-    )
-
-    generate_parser.add_argument(
-        "--objects",
-        nargs="+",
-        required=True,
-        type=pathlib.Path,
-        help=(
-            "Objects to generate report with (pass into llvm-cov..)."
-            " Can either be a directory or binary file."
-        ),
-    )
-
-    generate_parser.add_argument(
-        "--data",
-        type=pathlib.Path,
-        default=DEFAULT_COVERAGE_DATA_FILE,
-        help=(
-            "Merged coverage data (profdata format)."
-            f" Defaults to {DEFAULT_COVERAGE_DATA_FILE}"
-        ),
-    )
-    generate_parser.add_argument(
-        "--exclude",
-        nargs="+",
-        default=DEFAULT_OBJECT_EXTENSION_EXCLUSION,
-        help="List of extensions to exclude from objects.",
-    )
-    generate_parser.add_argument(
-        "--lcov",
-        type=pathlib.Path,
-        required=False,
-        help=(
-            "File in lcov format to export coverage data into"
-            " (e.g. coverage.info file one can pass into `genhtml`)."
-        ),
-    )
-
-    generate_parser.add_argument(
-        "--json",
-        type=pathlib.Path,
-        required=False,
-        help=(
-            "JSON file to export coverage summary into (i.e., results of"
-            " llvm-cov export with --summary-only)."
-        ),
-    )
-
-    generate_parser.add_argument(
-        "--summary",
-        action="store_true",
-        help="Generate coverage summary Report.",
-    )
-
-    generate_parser.add_argument(
-        "--sources",
-        nargs="+",
-        type=pathlib.Path,
-        help="Source code to generate coverage data.",
-    )
-
-    generate_parser.add_argument(
-        "--output-dir",
-        type=pathlib.Path,
-        default=DEFAULT_OUTPUT_DIR,
-        help="Default output directory for html reports (default: coverage).",
-    )
-
-    generate_parser.add_argument(
-        "--extra",
-        type=str,
-        help=(
-            "Semi-colon separated list of extra args to pass to llvm-cov."
-            " Must use '=' instead of ' ', e.g., --extra=\"-args\"."
-        ),
-    )
-
-    generate_parser.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        help="Verbose output.",
-    )
-
-    args = parser.parse_args()
-
-    if args.command == "generate":
-        generate_subcommand(args)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/sdk/cmake/dependency_pins.cmake b/sdk/cmake/dependency_pins.cmake
deleted file mode 100644
index 6fe86194..00000000
--- a/sdk/cmake/dependency_pins.cmake
+++ /dev/null
@@ -1,27 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Contains pinned versions for each dependency used in the project.
-# PTI_<FETCHCONTENTNAME>_<PROPERTY>
-set(PTI_FMT_REPOSITORY https://github.com/fmtlib/fmt)
-set(PTI_FMT_VERSION 12.1.0)
-set(PTI_FMT_COMMIT 407c905e45ad75fc29bf0f9bb7c5c2fd3475976f)
-
-set(PTI_SPDLOG_REPOSITORY https://github.com/gabime/spdlog)
-set(PTI_SPDLOG_VERSION 1.17.0)
-set(PTI_SPDLOG_COMMIT 79524ddd08a4ec981b7fea76afd08ee05f83755d)
-
-set(PTI_GOOGLETEST_REPOSITORY https://github.com/google/googletest)
-set(PTI_GOOGLETEST_VERSION 1.17.0)
-set(PTI_GOOGLETEST_COMMIT 52eb8108c5bdec04579160ae17225d66034bd723)
-
-set(PTI_LEVELZERO_REPOSITORY https://github.com/oneapi-src/level-zero.git)
-set(PTI_LEVELZERO_VERSION 1.32.0)
-set(PTI_LEVELZERO_COMMIT d3b3efbdaa27a0aef9a9812cc8fa4260557c1e7c)
-
-set(PTI_ITTAPI_REPOSITORY https://github.com/intel/ittapi.git)
-set(PTI_ITTAPI_VERSION 3.26.8)
-set(PTI_ITTAPI_COMMIT 2369c7eb60bbe5db9f0996b0366c68c4c0950100)
diff --git a/sdk/cmake/docs.cmake b/sdk/cmake/docs.cmake
deleted file mode 100644
index cfe675d9..00000000
--- a/sdk/cmake/docs.cmake
+++ /dev/null
@@ -1,80 +0,0 @@
-# Find Doxygen
-find_package(Doxygen)
-
-if(NOT Doxygen_FOUND)
-  message(STATUS "Doxygen not found - documentation targets will not be available")
-  return()
-endif()
-
-# Find Sphinx
-find_program(SPHINX_BUILD sphinx-build)
-
-if(NOT SPHINX_BUILD)
-  message(STATUS "Sphinx not found - documentation targets will not be available")
-  return()
-endif()
-
-# Set documentation directories
-set(PTI_DOCS_SOURCE_DIR "${PROJECT_SOURCE_DIR}/docs")
-set(PTI_DOXYGEN_SOURCE_DIR "${PTI_DOCS_SOURCE_DIR}/doxygen")
-set(PTI_SPHINX_SOURCE_DIR "${PTI_DOCS_SOURCE_DIR}/sphinx")
-set(PTI_DOCS_OUTPUT_DIR "${PROJECT_BINARY_DIR}/docs")
-set(PTI_DOXYGEN_OUTPUT_DIR "${PTI_DOCS_OUTPUT_DIR}/doxygen")
-set(PTI_SPHINX_OUTPUT_DIR "${PTI_DOCS_OUTPUT_DIR}/sphinx/build/html")
-
-# Documentation output files
-set(PTI_DOXYGEN_INDEX "${PTI_DOXYGEN_OUTPUT_DIR}/html/index.html")
-set(PTI_SPHINX_INDEX "${PTI_SPHINX_OUTPUT_DIR}/index.html")
-
-# Collect source files for dependency tracking
-file(GLOB_RECURSE PTI_HEADERS "${PROJECT_SOURCE_DIR}/include/*.h")
-file(GLOB_RECURSE SPHINX_SOURCES "${PTI_SPHINX_SOURCE_DIR}/source/*.rst")
-
-# Configure Doxyfile with CMake-controlled output directory
-configure_file(
-  ${PTI_DOXYGEN_SOURCE_DIR}/Doxyfile.in
-  ${PROJECT_BINARY_DIR}/Doxyfile
-  @ONLY)
-
-# Custom command to build Doxygen documentation
-add_custom_command(
-  OUTPUT ${PTI_DOXYGEN_INDEX}
-  COMMAND ${CMAKE_COMMAND} -E make_directory ${PTI_DOXYGEN_OUTPUT_DIR}
-  COMMAND ${DOXYGEN_EXECUTABLE} ${PROJECT_BINARY_DIR}/Doxyfile
-  WORKING_DIRECTORY ${PTI_DOXYGEN_SOURCE_DIR}
-  DEPENDS ${PROJECT_BINARY_DIR}/Doxyfile
-          ${PTI_DOXYGEN_SOURCE_DIR}/Doxyfile.in
-          ${PTI_HEADERS}
-  COMMENT "Generate Doxygen documentation"
-  VERBATIM)
-
-# Custom target for Doxygen
-add_custom_target(
-  docs_doxygen
-  DEPENDS ${PTI_DOXYGEN_INDEX}
-  COMMENT "Build Doxygen documentation")
-
-# Custom command to build Sphinx documentation
-add_custom_command(
-  OUTPUT ${PTI_SPHINX_INDEX}
-  COMMAND ${SPHINX_BUILD} -b html
-          -D breathe_projects.ptilib=${PTI_DOXYGEN_OUTPUT_DIR}/xml
-          ${PTI_SPHINX_SOURCE_DIR}/source ${PTI_SPHINX_OUTPUT_DIR}
-  WORKING_DIRECTORY ${PTI_SPHINX_SOURCE_DIR}
-  DEPENDS ${PTI_DOXYGEN_INDEX}
-          ${SPHINX_SOURCES}
-          ${PTI_SPHINX_SOURCE_DIR}/source/conf.py
-  COMMENT "Generate Sphinx documentation"
-  VERBATIM)
-
-# Custom target for Sphinx (depends on Doxygen output file)
-add_custom_target(
-  docs_sphinx
-  DEPENDS ${PTI_SPHINX_INDEX}
-  COMMENT "Build Sphinx documentation")
-
-# Convenience target to build all documentation
-add_custom_target(
-  docs
-  DEPENDS docs_sphinx
-  COMMENT "Build all documentation (Doxygen + Sphinx)")
diff --git a/sdk/cmake/levelzero.cmake b/sdk/cmake/levelzero.cmake
deleted file mode 100644
index 84849e84..00000000
--- a/sdk/cmake/levelzero.cmake
+++ /dev/null
@@ -1,138 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-include_guard(GLOBAL)
-
-include(${CMAKE_CURRENT_LIST_DIR}/dependency_pins.cmake)
-
-macro(GetLevelZero)
-  if (NOT TARGET LevelZero::level-zero)
-    # Need zelEnableTracingLayer
-    message("-- Fetching L0: ${PTI_LEVELZERO_VERSION}")
-    string(REPLACE "." ";" LZ_TMP_LIST ${PTI_LEVELZERO_VERSION})
-    list(GET LZ_TMP_LIST 2 LZ_VER_PATCH)
-    set(LZ_BASE_DIR ${CMAKE_CURRENT_BINARY_DIR}/_deps)
-
-    if(FETCHCONTENT_BASE_DIR)
-      set(LZ_BASE_DIR ${FETCHCONTENT_BASE_DIR})
-    endif()
-
-    if (NOT Git_FOUND)
-      find_package(Git REQUIRED)
-    endif()
-
-    include(FetchContent)
-    FetchContent_Declare(
-      LevelZero
-      GIT_REPOSITORY ${PTI_LEVELZERO_REPOSITORY}
-      GIT_TAG ${PTI_LEVELZERO_COMMIT}
-    )
-    # Prevent content from automatically being installed with PTI
-    FetchContent_GetProperties(LevelZero)
-    if(NOT levelzero_POPULATED)
-        FetchContent_Populate(LevelZero)
-        # Add patch to L0 build
-        file(WRITE "${levelzero_SOURCE_DIR}/VERSION_PATCH" ${LZ_VER_PATCH})
-        add_subdirectory(${levelzero_SOURCE_DIR} ${levelzero_BINARY_DIR} EXCLUDE_FROM_ALL)
-    endif()
-
-    get_target_property(PTI_ZE_LOADER_RUNTIME_DIR ze_loader RUNTIME_OUTPUT_DIRECTORY)
-
-    # Create new target to treat level zero loader as an external dependency.
-    # This prevents it from being added to the export set.
-    # (Basically treat as if including via find_package)
-    add_library(pti_ze_loader INTERFACE IMPORTED)
-    add_dependencies(pti_ze_loader ze_tracing_layer ze_validation_layer)
-
-    set(PTI_LZ_COMPILE_OPTIONS
-        $<$<CXX_COMPILER_ID:IntelLLVM>:
-            -Wno-error
-            -Wno-unused-parameter
-            -Wno-unused-function
-            -Wno-cast-function-type-mismatch
-            -Wno-extra-semi
-            $<$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,19.0.0>:-Wno-variadic-macro-arguments-omitted>
-        >
-        $<$<CXX_COMPILER_ID:MSVC>:
-            /wd6285 /wd6246 /wd6031 /wd6386
-            $<$<CONFIG:Release>:/wd4702 /wd6385 /wd6386>
-        >
-        $<$<CXX_COMPILER_ID:GNU>:
-            -Wno-error
-            -Wno-unused-parameter
-            $<$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,8.0.0>:-Wno-extra-semi>
-            $<$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,4.8.0>:-Wno-pedantic>
-        >
-        $<$<CXX_COMPILER_ID:Clang>:
-            -Wno-error
-            -Wno-unused-parameter
-            -Wno-unused-function
-            $<$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,3.0.0>:-Wno-extra-semi>
-            $<$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,19.0.0>:-Wno-variadic-macro-arguments-omitted>
-        >
-    )
-
-    # Silence Warnings from Level Zero Loader. Allows us to better detect PTI
-    # warnings and errors.
-    set_target_properties(ze_loader ze_tracing_layer ze_null ze_validation_layer level_zero_utils
-      PROPERTIES
-        COMPILE_OPTIONS "${PTI_LZ_COMPILE_OPTIONS}"
-        RUNTIME_OUTPUT_DIRECTORY "${PTI_ZE_LOADER_RUNTIME_DIR}/loader")
-
-    # Pull Headers out of source tree and add them to level_zero/
-    # This allows us to keep the normal way to include level zero
-    file(GLOB_RECURSE L0_DL_HEADERS
-        LIST_DIRECTORIES TRUE
-        "${levelzero_SOURCE_DIR}/include/*")
-
-    file(COPY ${L0_DL_HEADERS}
-        DESTINATION
-       ${LZ_BASE_DIR}/levelzero-headers/include/level_zero/)
-
-    # Add new header path to our new target
-    find_path(LZ_INCLUDE_DIR
-      NAMES level_zero/ze_api.h
-      HINTS ${LZ_BASE_DIR}/levelzero-headers
-      PATH_SUFFIXES include
-      NO_PACKAGE_ROOT_PATH
-      NO_CMAKE_PATH
-      NO_CMAKE_ENVIRONMENT_PATH
-      NO_SYSTEM_ENVIRONMENT_PATH
-      NO_CMAKE_SYSTEM_PATH
-      NO_CMAKE_FIND_ROOT_PATH
-    )
-
-    set_target_properties(pti_ze_loader PROPERTIES
-                            INTERFACE_INCLUDE_DIRECTORIES ${LZ_INCLUDE_DIR})
-
-    target_link_libraries(pti_ze_loader INTERFACE
-                            $<BUILD_INTERFACE:ze_loader>)
-    add_library(LevelZero::level-zero ALIAS pti_ze_loader)
-    add_library(LevelZero::headers INTERFACE IMPORTED)
-    set_target_properties(
-      LevelZero::headers
-      PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${LZ_INCLUDE_DIR}")
-  endif()
-endmacro()
-
-macro(GetLevelZeroExtensions)
-  if (NOT TARGET LevelZero::level-zero-ext)
-    add_library(level-zero-ext INTERFACE)
-    add_library(LevelZero::level-zero-ext ALIAS level-zero-ext)
-
-    target_include_directories(level-zero-ext SYSTEM INTERFACE
-      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third-party/compute-runtime/level_zero/include>)
-
-    target_link_libraries(level-zero-ext INTERFACE LevelZero::headers)
-  endif()
-endmacro()
-
-if(NOT TARGET LevelZero::level-zero)
-  find_package(LevelZero ${PTI_LEVELZERO_VERSION})
-endif()
-
-GetLevelZero()
-GetLevelZeroExtensions()
diff --git a/sdk/cmake/packaging.cmake b/sdk/cmake/packaging.cmake
deleted file mode 100644
index 4feac64f..00000000
--- a/sdk/cmake/packaging.cmake
+++ /dev/null
@@ -1,95 +0,0 @@
-if(NOT PTI_PROJECT_LICENSE_FILE)
-  if(EXISTS "${PROJECT_SOURCE_DIR}/../LICENSE")
-    set(PTI_PROJECT_LICENSE_FILE "${PROJECT_SOURCE_DIR}/../LICENSE")
-  endif()
-endif()
-
-#################### Generic CPack Configuration ####################
-include(ProcessorCount)
-ProcessorCount(NPROC)
-set(CPACK_THREADS ${NPROC})
-
-# TODO: Figure out whether this is desired or not. We have not stripped symbols
-# in the past, so for now, this will be kept OFF. Note, leaving this ON is
-# incompatible with CPACK_DEBIAN_RUNTIME_DEBUGINFO_PACKAGE and
-# CPACK_RPM_RUNTIME_DEBUGINFO_PACKAGE.
-set(CPACK_STRIP_FILES OFF)
-
-set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
-set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
-set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
-set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
-set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
-set(CPACK_PACKAGE_VENDOR "Intel Corporation")
-set(CPACK_PACKAGE_CONTACT "${PROJECT_HOMEPAGE_URL}")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_DESCRIPTION}")
-set(CPACK_PACKAGE_DESCRIPTION
-  "${CPACK_PACKAGE_DESCRIPTION_SUMMARY}. Library for Intel trace and profiling.")
-set(CPACK_PACKAGE_HOMEPAGE_URL "${PROJECT_HOMEPAGE_URL}")
-set(CPACK_PACKAGE_CHECKSUM SHA256)
-if (PTI_PROJECT_LICENSE_FILE)
-  set(CPACK_RESOURCE_FILE_LICENSE "${PTI_PROJECT_LICENSE_FILE}")
-endif()
-set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")
-set(CPACK_RESOURCE_FILE_WELCOME "${CPACK_RESOURCE_FILE_README}")
-
-set(CPACK_SOURCE_IGNORE_FILES ${CMAKE_CURRENT_BINARY_DIR} .git .cache venv .venv)
-
-#################### DEBIAN CPack Configuration ####################
-set(CPACK_DEB_COMPONENT_INSTALL ON)
-set(CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS ON)
-set(CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-set(CPACK_DEBIAN_RUNTIME_DEBUGINFO_PACKAGE ON)
-set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-set(CPACK_DEBIAN_DEVELOPMENT_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-dev")
-set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
-set(CPACK_DEBIAN_DEVELOPMENT_PACKAGE_DEPENDS
-  "${CPACK_PACKAGE_NAME} (=${CPACK_PACKAGE_VERSION})")
-
-#################### RPM CPack Configuration ####################
-set(CPACK_RPM_COMPONENT_INSTALL ON)
-set(CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-set(CPACK_RPM_RUNTIME_DEBUGINFO_PACKAGE ON)
-set(CPACK_RPM_RUNTIME_PACKAGE_NAME "${CPACK_PACKAGE_NAME}")
-set(CPACK_RPM_DEVELOPMENT_PACKAGE_NAME "${CPACK_PACKAGE_NAME}-devel")
-set(CPACK_RPM_FILE_NAME RPM-DEFAULT)
-set(CPACK_RPM_MAIN_COMPONENT Runtime)
-if (CPACK_RESOURCE_FILE_LICENSE)
-  set(CPACK_RPM_PACKAGE_LICENSE "${CPACK_RESOURCE_FILE_LICENSE}")
-endif()
-set(CPACK_RPM_RUNTIME_PACKAGE_AUTOREQPROV ON)
-set(CPACK_RPM_DEVELOPMENT_PACKAGE_AUTOREQPROV ON)
-set(CPACK_RPM_DEVELOPMENT_PACKAGE_REQUIRES "${CPACK_PACKAGE_NAME} = ${CPACK_PACKAGE_VERSION}")
-
-include(CPack) # After CPACK_*
-
-cpack_add_component(
-  Pti_Runtime
-  DISPLAY_NAME "Libraries"
-  DESCRIPTION "Libraries used to link"
-  GROUP Runtime
-)
-
-cpack_add_component(
-  Pti_Development
-  DISPLAY_NAME "Development"
-  DESCRIPTION "Header files + configuration files"
-  GROUP Development
-  DEPENDS Pti_Runtime
-)
-
-cpack_add_component(
-  Pti_Doc
-  DISPLAY_NAME "Documentation"
-  DESCRIPTION "Documentation related files"
-  GROUP Doc
-  DEPENDS Pti_Runtime
-)
-
-cpack_add_component(
-  Pti_oneAPI
-  DISPLAY_NAME "oneAPI-specifics"
-  DESCRIPTION "files related to oneAPI installation"
-  GROUP oneAPI
-  DEPENDS Pti_Runtime
-)
diff --git a/sdk/cmake/tags/lin_conda_tags.txt b/sdk/cmake/tags/lin_conda_tags.txt
deleted file mode 100644
index 1f212fe9..00000000
--- a/sdk/cmake/tags/lin_conda_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= 
diff --git a/sdk/cmake/tags/lin_def_tags.txt b/sdk/cmake/tags/lin_def_tags.txt
deleted file mode 100644
index 1f212fe9..00000000
--- a/sdk/cmake/tags/lin_def_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= 
diff --git a/sdk/cmake/tags/lin_pip_tags.txt b/sdk/cmake/tags/lin_pip_tags.txt
deleted file mode 100644
index 1f212fe9..00000000
--- a/sdk/cmake/tags/lin_pip_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= 
diff --git a/sdk/cmake/tags/win_conda_tags.txt b/sdk/cmake/tags/win_conda_tags.txt
deleted file mode 100644
index 1f212fe9..00000000
--- a/sdk/cmake/tags/win_conda_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= 
diff --git a/sdk/cmake/tags/win_def_tags.txt b/sdk/cmake/tags/win_def_tags.txt
deleted file mode 100644
index 1f212fe9..00000000
--- a/sdk/cmake/tags/win_def_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= 
diff --git a/sdk/cmake/tags/win_pip_tags.txt b/sdk/cmake/tags/win_pip_tags.txt
deleted file mode 100644
index a8834484..00000000
--- a/sdk/cmake/tags/win_pip_tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-path_to_components	= /Library
diff --git a/sdk/cmake/toolchains/clang_toolchain.cmake b/sdk/cmake/toolchains/clang_toolchain.cmake
deleted file mode 100644
index 2f95dfea..00000000
--- a/sdk/cmake/toolchains/clang_toolchain.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-set(CMAKE_C_COMPILER "clang")
-set(CMAKE_CXX_COMPILER "clang++")
-
-find_program(CLANGXX_PATH NAMES clang++)
-get_filename_component(_bin_dir ${CLANGXX_PATH} DIRECTORY)
-get_filename_component(_prefix  "${_bin_dir}" DIRECTORY)
-list(PREPEND CMAKE_PREFIX_PATH "${_prefix}")
diff --git a/sdk/cmake/toolchains/dpclang_toolchain.cmake b/sdk/cmake/toolchains/dpclang_toolchain.cmake
deleted file mode 100644
index 02dd407b..00000000
--- a/sdk/cmake/toolchains/dpclang_toolchain.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-set(CMAKE_C_COMPILER "dpclang")
-set(CMAKE_CXX_COMPILER "dpclang++")
-
-find_program(DPCLANGXX_PATH NAMES dpclang++)
-get_filename_component(_bin_dir ${DPCLANGXX_PATH} DIRECTORY)
-get_filename_component(_prefix  "${_bin_dir}" DIRECTORY)
-list(PREPEND CMAKE_PREFIX_PATH "${_prefix}")
diff --git a/sdk/cmake/toolchains/icpx_asan_toolchain.cmake b/sdk/cmake/toolchains/icpx_asan_toolchain.cmake
deleted file mode 100644
index 93850e38..00000000
--- a/sdk/cmake/toolchains/icpx_asan_toolchain.cmake
+++ /dev/null
@@ -1,14 +0,0 @@
-if (UNIX)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icpx)
-endif()
-
-if (WIN32)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icx)
-endif()
-
-set(CMAKE_CXX_FLAGS_DEBUG_INIT "-Xarch_host -fsanitize=address -Xarch_host -fsanitize=undefined -fno-omit-frame-pointer -fno-optimize-sibling-calls")
-set(CMAKE_C_FLAGS_DEBUG_INIT "-Xarch_host -fsanitize=address -Xarch_host -fsanitize=undefined")
-
-set(PTI_SANITIZER ON CACHE BOOL "Build uses sanitizers")
diff --git a/sdk/cmake/toolchains/icpx_fuzz_toolchain.cmake b/sdk/cmake/toolchains/icpx_fuzz_toolchain.cmake
deleted file mode 100644
index 39f4932a..00000000
--- a/sdk/cmake/toolchains/icpx_fuzz_toolchain.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-if(UNIX)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icpx)
-
-  # Work around for not having libubsan on some platforms.
-  find_library(
-    Ubsan_LIBRARY
-    NAMES ubsan libubsan.so.1
-    HINTS ENV LIBRARY_PATH
-    PATHS ${CMAKE_LIBRARY_PATH}
-          ENV LD_LIBRARY_PATH
-          /usr/lib/x86_64-linux-gnu
-          /usr/lib64
-          /usr/lib
-    PATH_SUFFIXES lib
-                  lib/${CMAKE_LIBRARY_ARCHITECTURE}
-                  lib/x86_64-linux-gnu
-                  lib64
-                  lib64/${CMAKE_LIBRARY_ARCHITECTURE}
-                  lib64/x86_64-linux-gnu
-    NO_CMAKE_FIND_ROOT_PATH
-  )
-
-  if (Ubsan_LIBRARY)
-    # This seems related? https://github.com/google/oss-fuzz/issues/713
-    set(CMAKE_C_STANDARD_LIBRARIES "-lubsan")
-  endif()
-endif()
-
-if(WIN32)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icx)
-endif()
-
-set(CMAKE_CXX_FLAGS_DEBUG_INIT
-    "-Xarch_host -fsanitize=address -Xarch_host -fsanitize=undefined -fno-omit-frame-pointer -fno-optimize-sibling-calls -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/test/fuzz/ubsan-ignore.txt"
-)
-set(CMAKE_C_FLAGS_DEBUG_INIT
-    "-Xarch_host -fsanitize=address -Xarch_host -fsanitize=undefined")
-
-set(PTI_SANITIZER ON CACHE BOOL "Build uses sanitizers")
diff --git a/sdk/cmake/toolchains/icpx_toolchain.cmake b/sdk/cmake/toolchains/icpx_toolchain.cmake
deleted file mode 100644
index 493e927d..00000000
--- a/sdk/cmake/toolchains/icpx_toolchain.cmake
+++ /dev/null
@@ -1,9 +0,0 @@
-if (UNIX)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icpx)
-endif()
-
-if (WIN32)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icx)
-endif()
diff --git a/sdk/cmake/toolchains/icpx_tsan_toolchain.cmake b/sdk/cmake/toolchains/icpx_tsan_toolchain.cmake
deleted file mode 100644
index 3ce5ff43..00000000
--- a/sdk/cmake/toolchains/icpx_tsan_toolchain.cmake
+++ /dev/null
@@ -1,14 +0,0 @@
-if (UNIX)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icpx)
-endif()
-
-if (WIN32)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icx)
-endif()
-
-set(CMAKE_CXX_FLAGS_DEBUG_INIT "-fno-omit-frame-pointer -Xarch_host -fsanitize=thread -fsanitize-ignorelist=${CMAKE_CURRENT_LIST_DIR}/tsan-ignore.txt -fsanitize-recover=all")
-set(CMAKE_C_FLAGS_DEBUG_INIT " -fno-omit-frame-pointer -Xarch_host -fsanitize=thread -fsanitize-recover=all")
-
-set(PTI_SANITIZER ON CACHE BOOL "Build uses sanitizers")
diff --git a/sdk/cmake/toolchains/scikit-build.cmake b/sdk/cmake/toolchains/scikit-build.cmake
deleted file mode 100644
index af7a9930..00000000
--- a/sdk/cmake/toolchains/scikit-build.cmake
+++ /dev/null
@@ -1,15 +0,0 @@
-if (UNIX)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icpx)
-endif()
-
-if (WIN32)
-  set(CMAKE_C_COMPILER icx)
-  set(CMAKE_CXX_COMPILER icx)
-endif()
-
-set(CMAKE_INSTALL_LIBDIR     "${SKBUILD_DATA_DIR}/lib"     CACHE PATH "")
-set(CMAKE_INSTALL_INCLUDEDIR "${SKBUILD_DATA_DIR}/include" CACHE PATH "")
-set(CMAKE_INSTALL_BINDIR     "${SKBUILD_DATA_DIR}/bin"     CACHE PATH "")
-set(CMAKE_INSTALL_DOCDIR     "${SKBUILD_DATA_DIR}/share"   CACHE PATH "")
-set(CMAKE_INSTALL_RPATH      "$ORIGIN"                     CACHE STRING "")
diff --git a/sdk/cmake/toolchains/tsan-ignore.txt b/sdk/cmake/toolchains/tsan-ignore.txt
deleted file mode 100644
index f84ac47f..00000000
--- a/sdk/cmake/toolchains/tsan-ignore.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-# Functions excluded from ThreadSanitizer (TSan) instrumentation.
-# Exclude ZeCollector methods that access GPU memory/timestamps
-fun:*ZeCollector*ProcessCallTimestamp*
-fun:*ZeCollector*ProcessCallCommand*
-fun:*ZeCollector*ProcessCalls*
diff --git a/sdk/docker/docker.mk b/sdk/docker/docker.mk
deleted file mode 100644
index 0f8a2ec0..00000000
--- a/sdk/docker/docker.mk
+++ /dev/null
@@ -1,93 +0,0 @@
-USE_BUILDKIT := 1
-
-REL_UBUNTU_24:= ubuntu-24-04
-REL_UBUNTU_24_CLIENT:= ubuntu-24-04-client
-REL_UBUNTU_26_CLIENT:= ubuntu-26-04-client
-
-REL_ROCKY:= rocky-8
-SERVER_TARGETS:= ${REL_UBUNTU_24} ${REL_ROCKY}
-CLIENT_TARGETS:= ${REL_UBUNTU_24_CLIENT} ${REL_UBUNTU_26_CLIENT}
-.PHONY:${SERVER_TARGETS} ${CLIENT_TARGETS}
-
-ONEAPI_VER=2026.1
-
-targets: ${SERVER_TARGETS} ${CLIENT_TARGETS}
-	@echo BUILT ${SERVER_TARGETS} ${CLIENT_TARGETS}
-
-OS_TARGETS_MIN:=$(foreach os, ${SERVER_TARGETS} ${CLIENT_TARGETS} ,  min_os_${os})
-
-.PHONY: min_os_all
-min_os_all: ${OS_TARGETS_MIN}
-
-VER_UBUNTU_24:=10
-VER_UBUNTU_24_CLIENT:=10
-VER_UBUNTU_26_CLIENT:=10
-VER_ROCKY:=10
-define getOsVer
-	$(if $(filter $1, ${REL_UBUNTU_24}),${VER_UBUNTU_24},\
-	$(if $(filter $1, ${REL_UBUNTU_24_CLIENT}),${VER_UBUNTU_24_CLIENT},\
-	$(if $(filter $1, ${REL_UBUNTU_26_CLIENT}),${VER_UBUNTU_26_CLIENT},\
-	$(if $(filter $1, ${REL_ROCKY}),${VER_ROCKY},\
-	$(error "Undefined target $1 in getOsVer function") \
-	))))
-endef
-
-define ERROR_MESSAGE_PTI_CONTAINER
-PTI_CONTAINER_NAME variable must be defined.
-It is the name for the container we are building for PTI.
-The invocation should be:
-PTI_CONTAINER_NAME=NAME make -f docker.mk
-
-endef
-
-ifndef PTI_CONTAINER_NAME
-$(error $(ERROR_MESSAGE_PTI_CONTAINER))
-endif
-
-define WARNING_MESSAGE_PROXY
-PROXY is not set.
-If you wish to set the proxy for the docker build
-
-PROXY='http_proxy=YOUR_PROXY_ADDRESS,https_proxy=YOUR_PROXY_ADDRESS ' PTI_CONTAINER_NAME=NAME_OF_IMAGE make -f docker.mk
-
-
-endef
-
-ifndef PROXY
-$(warning $(WARNING_MESSAGE_PROXY))
-endif
-
-.PHONY: help
-help:
-	@echo Possible invocations are
-	@echo PTI_CONTAINER_NAME=<NAME> PROXY='<http_proxy=X,https_proxy=Y>' make -f docker.mk ubuntu-24-04
-	@echo PTI_CONTAINER_NAME=<NAME> PROXY='<http_proxy=X,https_proxy=Y>' make -f docker.mk ubuntu-24-04-client
-	@echo PTI_CONTAINER_NAME=<NAME> PROXY='<http_proxy=X,https_proxy=Y>' make -f docker.mk ubuntu-26-04-client
-	@echo PTI_CONTAINER_NAME=<NAME>  PROXY='<PROXY_SETTINGS>' make -f docker.mk
-
-
-PARSED_PROXY:=$(shell IFS=','; for i in  $${PROXY}; do echo -n " --build-arg " $$i; done)
-
-# Rule to build the minimal OS image for each target.
-# This builds a Docker image using the min_os.Dockerfile for the given OS.
-# This allows invocations like this one:
-# 	PROXY='http_proxy=XX,https_proxy=YY' PTI_CONTAINER_NAME=pti_container make -f docker.mk  min_os_ubuntu-24-04
-min_os_%:
-	@echo Building $@
-	@DOCKER_BUILDKIT=${USE_BUILDKIT} docker build \
-	--file $(patsubst min_os_%,%,$@)/min_os.Dockerfile ${PARSED_PROXY} \
-	--tag ""${PTI_CONTAINER_NAME}_min_os:$(strip $(call getOsVer, $(patsubst min_os_%,%, $@)))-$(patsubst min_os_%,%, $@)"" .
-
-# For each OS target, define a rule that depends on its minimal OS image.
-# Then build the full image using bldrun.Dockerfile, passing the minimal image as a build argument.
-# Also prints proxy settings and tags the resulting image with version and oneAPI version.
-# This allows invocations like this one:
-#   PROXY='http_proxy=XX,https_proxy=YY' PTI_CONTAINER_NAME=pti_container make -f docker.mk  ubuntu-24-04
-$(foreach os,$(SERVER_TARGETS) $(CLIENT_TARGETS),$(eval $(os): min_os_$(os) ;\
-	@echo "Building $(os) from min_os_$(os)" ; \
-	echo "Proxy setting:" ${PARSED_PROXY}  ; \
-	DOCKER_BUILDKIT=${USE_BUILDKIT} docker build \
-	--file $(os)/bldrun.Dockerfile ${PARSED_PROXY} \
-	--build-arg MIN_OS_CONTAINER=""${PTI_CONTAINER_NAME}_min_os:$(strip $(call getOsVer, $(os)))-$(os)"" \
-	--tag ""${PTI_CONTAINER_NAME}:$(strip $(call getOsVer, $(os)))-$(os)_${ONEAPI_VER}"" . \
-))
diff --git a/sdk/docker/rocky-8/bldrun.Dockerfile b/sdk/docker/rocky-8/bldrun.Dockerfile
deleted file mode 100644
index 09db5ca0..00000000
--- a/sdk/docker/rocky-8/bldrun.Dockerfile
+++ /dev/null
@@ -1,52 +0,0 @@
-# syntax=docker/dockerfile:1.3
-
-ARG MIN_OS_CONTAINER
-FROM ${MIN_OS_CONTAINER}
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-WORKDIR /tmp
-
-USER root
-
-#
-# Install the essential packages from oneAPI to build pti
-# instead of intel-oneapi-base-toolkit
-#
-RUN echo '[oneAPI]' > /etc/yum.repos.d/oneAPI.repo; \
-    echo 'name=Intel® oneAPI repository' >> /etc/yum.repos.d/oneAPI.repo; \
-    echo 'baseurl=https://yum.repos.intel.com/oneapi' >> /etc/yum.repos.d/oneAPI.repo; \
-    echo 'enabled=1' >> /etc/yum.repos.d/oneAPI.repo; \
-    echo 'gpgcheck=1' >> /etc/yum.repos.d/oneAPI.repo; \
-    echo 'repo_gpgcheck=1' >> /etc/yum.repos.d/oneAPI.repo; \
-    echo 'gpgkey=https://yum.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB' >> /etc/yum.repos.d/oneAPI.repo && \
-    dnf install -y intel-dpcpp-cpp-compiler-2026.1 \
-                    intel-oneapi-mkl-devel-2026.1 \
-                    intel-oneapi-dnnl-devel-2026.0 \
-                    intel-oneapi-ccl-devel-2022.1 && \
-    dnf clean all
-
-#
-# Setup the appropriate repos for GPU
-# We must use -f to force the Rocky installation of the Rhel driver
-#
-RUN wget https://repositories.intel.com/gpu/rhel/8.10/intel-gpu-rhel-8.10.run && \
-  chmod +x intel-gpu-rhel-8.10.run && \
-  ./intel-gpu-rhel-8.10.run -f -y && \
-  rm ./intel-gpu-rhel-8.10.run
-
-RUN dnf install -y --setopt=tsflags=nodocs \
-  intel-opencl intel-media libmfxgen1 libvpl2 \
-  level-zero intel-level-zero-gpu mesa-dri-drivers mesa-vulkan-drivers \
-  mesa-vdpau-drivers libdrm mesa-libEGL mesa-libgbm mesa-libGL \
-  mesa-libxatracker libvpl-tools \
-  intel-igc-core intel-igc-cm \
-  libva libva-utils intel-gmmlib libmetee intel-gsc intel-ocloc \
-  intel-igc-opencl-devel level-zero-devel intel-gsc-devel libmetee-devel \
-  level-zero-devel \
-  intel-metrics-discovery \
-  intel-metrics-discovery-devel \
-  intel-metrics-library \
-  intel-metrics-library-devel  && \
-  dnf clean all
-
diff --git a/sdk/docker/rocky-8/min_os.Dockerfile b/sdk/docker/rocky-8/min_os.Dockerfile
deleted file mode 100644
index b1ecf27a..00000000
--- a/sdk/docker/rocky-8/min_os.Dockerfile
+++ /dev/null
@@ -1,34 +0,0 @@
-# syntax=docker/dockerfile:1.3
-
-FROM rockylinux:8.9
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-WORKDIR /tmp
-
-USER root
-
-RUN dnf -y --setopt=tsflags=nodocs --nogpgcheck update && \
-    dnf install -y --setopt=tsflags=nodocs --nogpgcheck 'dnf-command(config-manager)' && \
-    dnf -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm && \
-    dnf install -y --setopt=tsflags=nodocs --nogpgcheck dnf-plugins-core && \
-    dnf config-manager --set-enabled powertools && \
-    dnf -y --setopt=tsflags=nodocs --nogpgcheck update && \
-    dnf clean all
-
-#hadolint ignore=DL3008
-RUN dnf install -y --setopt=tsflags=nodocs  \
-    gcc-c++ \
-    procps-ng \
-    cmake \
-    wget \
-    ninja-build \
-    which \
-    git \
-    vim \
-    findutils \
-    sudo \
-    python3.12 && \
-    dnf clean all
-
-RUN ln -s /usr/bin/python3.12 /usr/bin/python
diff --git a/sdk/docker/ubuntu-24-04-client/bldrun.Dockerfile b/sdk/docker/ubuntu-24-04-client/bldrun.Dockerfile
deleted file mode 100644
index 30117b21..00000000
--- a/sdk/docker/ubuntu-24-04-client/bldrun.Dockerfile
+++ /dev/null
@@ -1,34 +0,0 @@
-# syntax=docker/dockerfile:1.3
-
-# hadolint ignore=DL3007
-
-ARG MIN_OS_CONTAINER
-FROM ${MIN_OS_CONTAINER}
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-RUN apt-get update && \
-    apt-get install -y \
-        libze-intel-gpu1 libze1 intel-metrics-discovery intel-opencl-icd clinfo intel-gsc \
-        intel-media-va-driver-non-free libmfx-gen1 libvpl2 libvpl-tools libva-glx2 va-driver-all vainfo \
-        libze-dev intel-ocloc \
-        libze-intel-gpu-raytracing \
-        intel-metrics-discovery-dev intel-metrics-library intel-metrics-library-dev && \
-    apt-get clean -y
-
-#
-# One could install intel-oneapi-base-toolkit-2025.X
-# but there are a number of oneapi packages not needed for pti. 
-# These are the minimum.
-#
-RUN apt update -y && \
-    apt install -y intel-dpcpp-cpp-compiler-2026.1 \
-      intel-oneapi-mkl-devel-2026.1 \
-      intel-oneapi-dnnl-devel-2026.0 \
-      intel-oneapi-ccl-devel-2022.1 && \
-    apt-get clean -y
-
-#RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3.12 10
-
diff --git a/sdk/docker/ubuntu-24-04-client/min_os.Dockerfile b/sdk/docker/ubuntu-24-04-client/min_os.Dockerfile
deleted file mode 100644
index 16f1d9ed..00000000
--- a/sdk/docker/ubuntu-24-04-client/min_os.Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-# syntax=docker/dockerfile:1.4
-
-# hadolint ignore=DL3007
-
-# This is ubuntu:24.04
-FROM ubuntu:noble
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-#hadolint ignore=DL3008
-RUN apt-get update -y && \
-    apt-get upgrade --no-install-recommends  -y && \
-    apt-get install --no-install-recommends -y \
-    cmake \
-    ninja-build \
-    ncurses* \
-    wget \
-    gpg \
-    git \
-    gpg-agent \
-    vim \
-    make \
-    sudo \
-    g++ \
-    python3.12 \
-    python3-pip \
-    python3.12-venv \
-    ca-certificates && \
-    apt-get clean -y
-
-
-# Setup the appropriate repos for oneAPI
-#
-RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | \
-    gpg --dearmor | \
-    tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null && \
-    echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | \
-     tee /etc/apt/sources.list.d/oneAPI.list
-
-#
-# Setup the appropriate repos for GPU
-#
-RUN apt-get update && apt-get install -y software-properties-common && \
-    add-apt-repository -y ppa:kobuk-team/intel-graphics-testing \
-    --component main \
-    --component "main/debug"
-
-RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3 10
-
diff --git a/sdk/docker/ubuntu-24-04/bldrun.Dockerfile b/sdk/docker/ubuntu-24-04/bldrun.Dockerfile
deleted file mode 100644
index b3510751..00000000
--- a/sdk/docker/ubuntu-24-04/bldrun.Dockerfile
+++ /dev/null
@@ -1,37 +0,0 @@
-# syntax=docker/dockerfile:1.3
-
-# hadolint ignore=DL3007
-
-ARG MIN_OS_CONTAINER
-FROM ${MIN_OS_CONTAINER}
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-RUN apt update -y && \
-    apt install -y \
-    intel-opencl-icd libze-intel-gpu1 libze1 \
-    intel-media-va-driver-non-free libmfx-gen1 libvpl2 \
-    libegl-mesa0 libegl1-mesa-dev libgbm1 libgl1-mesa-dev libgl1-mesa-dri \
-    libglapi-mesa libgles2-mesa-dev libglx-mesa0 libigdgmm12 libxatracker2 mesa-va-drivers \
-    mesa-vdpau-drivers mesa-vulkan-drivers va-driver-all vainfo hwinfo clinfo \
-    libigc-dev intel-igc-cm libigdfcl-dev libigfxcmrt-dev libze-dev \
-    intel-ocloc \
-    intel-metrics-discovery intel-metrics-discovery-dev \
-    intel-metrics-library intel-metrics-library-dev && \
-    apt-get clean -y
-
-#
-# One coulde install intel-oneapi-base-toolkit-2025.X
-# but there are a number of oneapi packages not needed for pti. 
-# These are the minimum
-#
-RUN apt update -y && \
-    apt install -y intel-dpcpp-cpp-compiler-2026.1 \
-      intel-oneapi-mkl-devel-2026.1 \
-      intel-oneapi-dnnl-devel-2026.0 \
-      intel-oneapi-ccl-devel-2022.1
-
-RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3.12 10
-
diff --git a/sdk/docker/ubuntu-24-04/min_os.Dockerfile b/sdk/docker/ubuntu-24-04/min_os.Dockerfile
deleted file mode 100644
index 9eea9c4f..00000000
--- a/sdk/docker/ubuntu-24-04/min_os.Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-# syntax=docker/dockerfile:1.4
-
-# hadolint ignore=DL3007
-
-# This is ubuntu:24.04
-FROM ubuntu:noble
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-#hadolint ignore=DL3008
-RUN apt-get update -y && \
-    apt-get upgrade --no-install-recommends  -y && \
-    apt-get install --no-install-recommends -y \
-    cmake \
-    ninja-build \
-    ncurses* \
-    wget \
-    gpg \
-    git \
-    gpg-agent \
-    vim \
-    make \
-    sudo \
-    g++ \
-    python3.12 \
-    python3-pip \
-    python3.12-venv \
-    ca-certificates && \
-    apt-get clean -y
-
-
-# Setup the appropriate repos for oneAPI
-#
-RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | \
-    gpg --dearmor | \
-    tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null && \
-    echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | \
-     tee /etc/apt/sources.list.d/oneAPI.list
-
-#
-# Setup the appropriate repos for GPU
-#
-RUN wget -qO - https://repositories.intel.com/gpu/intel-graphics.key | \
-    gpg --yes --dearmor --output /usr/share/keyrings/intel-graphics.gpg && \
-    echo "deb [arch=amd64 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/gpu/ubuntu noble unified" | \
-    tee /etc/apt/sources.list.d/intel-gpu-noble.list
-
-RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3 10
-
diff --git a/sdk/docker/ubuntu-26-04-client/bldrun.Dockerfile b/sdk/docker/ubuntu-26-04-client/bldrun.Dockerfile
deleted file mode 100644
index ac96052c..00000000
--- a/sdk/docker/ubuntu-26-04-client/bldrun.Dockerfile
+++ /dev/null
@@ -1,35 +0,0 @@
-# syntax=docker/dockerfile:1.3
-
-# hadolint ignore=DL3007
-
-ARG MIN_OS_CONTAINER
-FROM ${MIN_OS_CONTAINER}
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-RUN apt-get update && \
-    apt-get install -y \
-        libze-intel-gpu1 libze1 intel-metrics-discovery intel-opencl-icd clinfo intel-gsc \
-        intel-media-va-driver-non-free libmfx-gen1 libvpl2 libvpl-tools libva-glx2 va-driver-all vainfo \
-        libze-dev intel-ocloc \
-        libze-intel-gpu-raytracing \
-        intel-metrics-discovery-dev intel-metrics-library intel-metrics-library-dev && \
-    apt-get clean -y
-
-#
-# One could install intel-oneapi-base-toolkit-2025.X
-# but there are a number of oneapi packages not needed for pti. 
-# These are the minimum.
-#
-RUN apt update -y && \
-    apt install -y \
-      intel-dpcpp-cpp-compiler-2026.1 \
-      intel-oneapi-mkl-devel-2026.1 \
-      intel-oneapi-dnnl-devel-2026.0 \
-      intel-oneapi-ccl-devel-2022.1 && \
-    apt-get clean -y
-
-RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3 10
-
diff --git a/sdk/docker/ubuntu-26-04-client/min_os.Dockerfile b/sdk/docker/ubuntu-26-04-client/min_os.Dockerfile
deleted file mode 100644
index 3a47b7e6..00000000
--- a/sdk/docker/ubuntu-26-04-client/min_os.Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-# syntax=docker/dockerfile:1.4
-
-# hadolint ignore=DL3007
-
-# This is ubuntu:26.04
-FROM ubuntu:resolute
-
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-
-USER root
-
-#hadolint ignore=DL3008
-RUN apt-get update -y && \
-    apt-get upgrade --no-install-recommends  -y && \
-    apt-get install --no-install-recommends -y \
-    cmake \
-    ninja-build \
-    ncurses* \
-    wget \
-    gpg \
-    git \
-    gpg-agent \
-    vim \
-    make \
-    sudo \
-    g++ \
-    python3 \
-    python3-pip \
-    python3-venv \
-    ca-certificates && \
-    apt-get clean -y
-
-
-# Setup the appropriate repos for oneAPI
-#
-RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | \
-    gpg --dearmor | \
-    tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null && \
-    echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | \
-     tee /etc/apt/sources.list.d/oneAPI.list
-
-#
-# Setup the appropriate repos for GPU
-#
-RUN apt-get update && apt-get install -y software-properties-common && \
-    add-apt-repository -y ppa:kobuk-team/intel-graphics-testing \
-    --component main \
-    --component "main/debug"
-
-RUN update-alternatives --install /usr/local/bin/python python /usr/bin/python3 10
-
diff --git a/sdk/docs/README.md b/sdk/docs/README.md
deleted file mode 100644
index ceff329c..00000000
--- a/sdk/docs/README.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# How to build PTI Library documentation
-
-Our documentation is written in restructured text markup (.rst) and built using [Sphinx](http://www.sphinx-doc.org/en/master/). 
-
-This document explains how to build PTI Library documentation locally. 
-
-## Prerequisites
-```
-apt install doxygen
-pip install -r requirements.txt
-```
-
-## Build documentation
-
-Do the following to generate HTML output of the documentation: 
-
-1. Clone PTI repository:
-
-```
-git clone https://github.com/intel/pti-gpu
-```
-
-2. Go to the `sdk/docs/sphinx` folder:
-
-```
-cd sdk/docs/sphinx
-```
-
-3. Run in the command line:
-
-```
-make html
-```
-
-
-That's it! Your built documentation is located in the ``build/html`` folder. 
\ No newline at end of file
diff --git a/sdk/docs/doxygen/Doxyfile.in b/sdk/docs/doxygen/Doxyfile.in
deleted file mode 100644
index 43c73466..00000000
--- a/sdk/docs/doxygen/Doxyfile.in
+++ /dev/null
@@ -1,2535 +0,0 @@
-# Doxyfile 1.8.17
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the configuration
-# file that follow. The default is UTF-8 which is also the encoding used for all
-# text before the first occurrence of this tag. Doxygen uses libiconv (or the
-# iconv built into libc) for the transcoding. See
-# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = "PTI Library"
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         = @PROJECT_VERSION@
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          = "Profiling Tools Interfaces Library"
-
-# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
-# in the documentation. The maximum height of the logo should not exceed 55
-# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
-# the logo to the output directory.
-
-PROJECT_LOGO           =
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = @PTI_DOXYGEN_OUTPUT_DIR@ 
-
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all generated output in the proper direction.
-# Possible values are: None, LTR, RTL and Context.
-# The default value is: None.
-
-#OUTPUT_TEXT_DIRECTION  = None
-
-# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = NO # YES
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        =
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    =
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
-# such as
-# /***************
-# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
-# Javadoc-style will behave just like regular comments and it will not be
-# interpreted by doxygen.
-# The default value is: NO.
-
-JAVADOC_BANNER         = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
-# page for each member. If set to NO, the documentation of a member will be part
-# of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines (in the resulting output). You can put ^^ in the value part of an
-# alias to insert a newline as if a physical newline was in the original file.
-# When you need a literal { or } or , in the value part of an alias you have to
-# escape them by means of a backslash (\), this can lead to conflicts with the
-# commands \{ and \} for these it is advised to use the version @{ and @} or use
-# a double escape (\\{ and \\})
-
-ALIASES                =
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-#TCL_SUBST              =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
-# sources only. Doxygen will then generate output that is more tailored for that
-# language. For instance, namespaces will be presented as modules, types will be
-# separated into more groups, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_SLICE  = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
-# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
-# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
-# tries to guess whether the code is fixed or free formatted code, this is the
-# default for Fortran type files), VHDL, tcl. For instance to make doxygen treat
-# .inc files as Fortran files (default is PHP), and .f files as C (default is
-# Fortran), use: inc=Fortran f=C.
-#
-# Note: For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
-
-EXTENSION_MAPPING      =
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See https://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
-# to that level are automatically included in the table of contents, even if
-# they do not have an id attribute.
-# Note: This feature currently applies only to Markdown headings.
-# Minimum value: 0, maximum value: 99, default value: 5.
-# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
-
-TOC_INCLUDE_HEADINGS   = 5
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by putting a % sign in front of the word or
-# globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# If one adds a struct or class to a group and this option is enabled, then also
-# any nested class or struct is added to the same group. By default this option
-# is disabled and one has to add nested compounds explicitly via \ingroup.
-# The default value is: NO.
-
-GROUP_NESTED_COMPOUNDS = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = YES
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = YES
-
-# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = YES
-
-# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
-# methods of a class will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIV_VIRTUAL   = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO,
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. If set to YES, local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO, only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = YES
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO, these classes will be included in the various overviews. This option
-# has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# declarations. If set to NO, these declarations will be included in the
-# documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO, these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# (including Cygwin) ands Mac users are advised to set this option to NO.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = YES
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES, the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
-# append additional text to a page's title, such as Class Reference. If set to
-# YES the compound reference will be hidden.
-# The default value is: NO.
-
-HIDE_COMPOUND_REFERENCE= NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
-# list. This list is created by putting \todo commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
-# list. This list is created by putting \test commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       =
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES, the
-# list will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = NO
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    =
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            =
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. See also \cite for info how to create references.
-
-CITE_BIB_FILES         =
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation. If
-# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
-# The default value is: NO.
-
-WARN_AS_ERROR          = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = ../../include/pti 
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
-# possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# read by doxygen.
-#
-# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
-# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
-# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen
-# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f, *.for, *.tcl, *.vhd,
-# *.vhdl, *.ucf, *.qsf and *.ice.
-
-FILE_PATTERNS          = *.h
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = NO
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                =
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       =
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-# Internal compile-time assertion macro, not part of the public API.
-EXCLUDE_SYMBOLS        = PTI_STATIC_ASSERT
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           =
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             =
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-INPUT_FILTER           =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-FILTER_PATTERNS        =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS =
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE =
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = YES
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# entity all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see https://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse_libclang=ON option for CMake.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          =
-
-# If clang assisted parsing is enabled you can provide the clang parser with the
-# path to the compilation database (see:
-# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files
-# were built. This is equivalent to specifying the "-p" option to a clang tool,
-# such as clang-check. These options will then be passed to the parser.
-# Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse_libclang=ON option for CMake.
-
-CLANG_DATABASE_PATH    =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            =
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            =
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        =
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# cascading style sheets that are included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefore more robust against future updates.
-# Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list). For an example see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  =
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       =
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to YES can help to show when doxygen was last run and thus if the
-# documentation is up to date.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = NO
-
-# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
-# documentation will contain a main index with vertical navigation menus that
-# are dynamically created via JavaScript. If disabled, the navigation index will
-# consists of multiple levels of tabs that are statically embedded in every HTML
-# page. Disable this option to support browsers that do not have JavaScript,
-# like the Qt help browser.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_MENUS     = YES
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: https://developer.apple.com/xcode/), introduced with OSX
-# 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
-# genXcode/_index.html for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               =
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler (hhc.exe). If non-empty,
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           =
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     =
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated
-# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               =
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-
-# folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   =
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  =
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  =
-
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           =
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = NO
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
-# to create new LaTeX commands to be used in formulas as building blocks. See
-# the section "Including formulas" for details.
-
-FORMULA_MACROFILE      =
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# https://www.mathjax.org) which uses client side JavaScript for the rendering
-# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     =
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       =
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = YES
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using JavaScript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: https://xapian.org/). See the section "External Indexing and
-# Searching" for details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       =
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     =
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when not enabling USE_PDFLATEX the default is latex when enabling
-# USE_PDFLATEX the default is pdflatex and when in the later case latex is
-# chosen this is overwritten by pdflatex. For specific output languages the
-# default can have been set differently, this depends on the implementation of
-# the output language.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         =
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# Note: This tag is used in the Makefile / make.bat.
-# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
-# (.tex).
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
-# generate index for LaTeX. In case there is no backslash (\) as first character
-# it will be automatically added in the LaTeX code.
-# Note: This tag is used in the generated output file (.tex).
-# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
-# The default value is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_MAKEINDEX_CMD    = makeindex
-
-# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. The package can be specified just
-# by its name or with the correct syntax as to be used with the LaTeX
-# \usepackage command. To get the times font for instance you can specify :
-# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
-# To use the option intlimits with the amsmath package you can specify:
-# EXTRA_PACKAGES=[intlimits]{amsmath}
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           =
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
-# LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           =
-
-# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# LaTeX style sheets that are included after the standard style sheets created
-# by doxygen. Using this option one can overrule certain style aspects. Doxygen
-# will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_STYLESHEET =
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_TIMESTAMP        = NO
-
-# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
-# path from which the emoji images will be read. If a relative path is entered,
-# it will be relative to the LATEX_OUTPUT directory. If left blank the
-# LATEX_OUTPUT directory will be used.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EMOJI_DIRECTORY  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
-# configuration file, i.e. a series of assignments. You only have to provide
-# replacements, missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    =
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's configuration file. A template extensions file can be
-# generated using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    =
-
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             =
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = YES # NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
-# namespace members in file scope as well, matching the HTML output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_NS_MEMB_FILE_SCOPE = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
-# the structure of the code including all documentation. Note that this feature
-# is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO, the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
-# in the source code. If set to NO, only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = YES
-
-
-# If the SEARCH_INCLUDES tag is set to YES, the include files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           =
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  =
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             = PTI_EXPORT=
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      =
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       =
-
-# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
-# the class index. If set to NO, only the inherited external classes will be
-# listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = NO
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               =
-
-# If set to YES the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: YES.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           =
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command. Disabling a call graph can be
-# accomplished by means of the command \hidecallgraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command. Disabling a caller graph can be
-# accomplished by means of the command \hidecallergraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. For an explanation of the image formats see the section
-# output formats in the documentation of the dot tool (Graphviz (see:
-# http://www.graphviz.org/)).
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd,
-# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo,
-# gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, png:cairo,
-# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
-# png:gdiplus:gdiplus.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           =
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           =
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           =
-
-# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
-
-PLANTUML_JAR_PATH      =
-
-# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
-# configuration file for plantuml.
-
-PLANTUML_CFG_FILE      =
-
-# When using plantuml, the specified paths are searched for files specified by
-# the !include statement in a plantuml block.
-
-PLANTUML_INCLUDE_PATH  =
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
-# files that are used to generate the various graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_CLEANUP            = YES
diff --git a/sdk/docs/requirements.txt b/sdk/docs/requirements.txt
deleted file mode 100644
index ef57387f..00000000
--- a/sdk/docs/requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-breathe
-sphinx
-sphinx-book-theme
diff --git a/sdk/docs/sphinx/Makefile b/sdk/docs/sphinx/Makefile
deleted file mode 100644
index d0c3cbf1..00000000
--- a/sdk/docs/sphinx/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line, and also
-# from the environment for the first two.
-SPHINXOPTS    ?=
-SPHINXBUILD   ?= sphinx-build
-SOURCEDIR     = source
-BUILDDIR      = build
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/sdk/docs/sphinx/source/_static/custom.css b/sdk/docs/sphinx/source/_static/custom.css
deleted file mode 100644
index 3c24b0e8..00000000
--- a/sdk/docs/sphinx/source/_static/custom.css
+++ /dev/null
@@ -1,3 +0,0 @@
-pre {                                 
-    white-space: pre-wrap !important;
-}
diff --git a/sdk/docs/sphinx/source/_static/favicons.png b/sdk/docs/sphinx/source/_static/favicons.png
deleted file mode 100644
index f450376b..00000000
Binary files a/sdk/docs/sphinx/source/_static/favicons.png and /dev/null differ
diff --git a/sdk/docs/sphinx/source/_static/oneAPI-rgb-rev-100.png b/sdk/docs/sphinx/source/_static/oneAPI-rgb-rev-100.png
deleted file mode 100644
index 58d2d5c5..00000000
Binary files a/sdk/docs/sphinx/source/_static/oneAPI-rgb-rev-100.png and /dev/null differ
diff --git a/sdk/docs/sphinx/source/about.rst b/sdk/docs/sphinx/source/about.rst
deleted file mode 100644
index 84e64698..00000000
--- a/sdk/docs/sphinx/source/about.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-======
-About
-======
-
-.. toctree::
-   :maxdepth: 1
-
-   intro
-   whatsnew
-   systemreqs
-   knownissues
-   license
diff --git a/sdk/docs/sphinx/source/api_reference.rst b/sdk/docs/sphinx/source/api_reference.rst
deleted file mode 100644
index b96faf90..00000000
--- a/sdk/docs/sphinx/source/api_reference.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-===============
-API Reference
-===============
-
-.. toctree::
-   :maxdepth: 1
-
-   view_api_ref
-   metrics_scope
-   metrics
-   pc_sampling_api_ref
-   callback_api
diff --git a/sdk/docs/sphinx/source/build_and_install.rst b/sdk/docs/sphinx/source/build_and_install.rst
deleted file mode 100644
index afbdd205..00000000
--- a/sdk/docs/sphinx/source/build_and_install.rst
+++ /dev/null
@@ -1,198 +0,0 @@
-============================
-Building and Installing
-============================
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-Using Pre-built Binaries
-=======================================
-
-The easiest way to use PTI SDK is to install the pre-built package from PyPI:
-
-.. code-block:: bash
-
-   pip install intel-pti
-
-After installation, the PTI libraries will be available in your Python environment.
-
-
-Building from Source
-====================
-
-If you need to build PTI SDK from source (for development or custom configurations), follow these instructions.
-
-Prerequisites
--------------
-
-* **CMake**: Version 3.14 or higher
-* **Git**: Version 1.8 or higher
-* **Intel(R) oneAPI Base Toolkit**: 2026.0 or higher (PTI is tested with 2026.x; see :ref:`tested versions <oneAPITestedVersions>`)
-* **Level Zero Loader**: version 1.14.0 or higher at runtime; building requires headers version 1.32.0 or higher (downloaded automatically by CMake if not found)
-* **C++17 compatible compiler**: GCC, Intel C++ Compiler (icpx), or the open-source DPC++ compiler
-
-**Platform-Specific:**
-
-* **Linux**: GCC or Intel C++ Compiler (icpx)
-* **Windows**: Visual Studio 2022 or higher, Intel C++ Compiler (icpx), Ninja build system
-
-See `INSTALL.md <https://github.com/intel/pti-gpu/blob/master/sdk/INSTALL.md>`_ for detailed prerequisites and tested configurations.
-
-Environment Setup
------------------
-
-**Linux:**
-
-.. code-block:: bash
-
-   source <path_to_oneapi>/setvars.sh
-   cd sdk
-
-**Windows:**
-
-.. code-block:: batch
-
-   call "C:\Program Files (x86)\Intel\oneAPI\setvars-vcvarsall.bat"
-   call "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
-   cd sdk
-
-Configure and Build
--------------------
-
-**Configure (Debug):**
-
-.. code-block:: bash
-
-   CC=icx CXX=icpx cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
-
-**Configure (Release):**
-
-.. code-block:: bash
-
-   CC=icx CXX=icpx cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-
-.. note::
-   You can build with GCC by omitting the ``CC=icx CXX=icpx`` prefix.
-
-**Build:**
-
-.. code-block:: bash
-
-   cmake --build build --parallel 4
-
-Running Tests
-=============
-
-After building, verify the build by running the test suite:
-
-.. code-block:: bash
-
-   ctest --test-dir build --output-on-failure
-
-**Running Sample Applications:**
-
-**Linux:**
-
-.. code-block:: bash
-
-   ./build/bin/vec_sqadd
-
-**Windows:**
-
-.. code-block:: batch
-
-   build\bin\vec_sqadd.exe
-
-If the sample runs successfully and produces output, your build is working correctly.
-
-Installation (Advanced)
-=======================
-
-Most users do not need to install PTI SDK. Installation is only necessary if you want to:
-
-* Install PTI SDK system-wide or to a custom location
-* Use PTI SDK with CMake ``find_package()`` in other projects
-* Package PTI SDK for distribution
-
-From the build directory:
-
-.. code-block:: bash
-
-   cmake --install build --config Release --prefix "../out"
-
-You can specify a different installation prefix:
-
-**Linux:**
-
-.. code-block:: bash
-
-   cmake --install build --config Release --prefix "/usr/local"
-
-**Windows:**
-
-.. code-block:: batch
-
-   cmake --install build --config Release --prefix "C:\Program Files\PTI"
-
-The installation includes:
-
-* Header files in ``<prefix>/include/pti/``
-* Library files in ``<prefix>/lib/``
-* CMake configuration files in ``<prefix>/lib/cmake/pti/``
-
-Build Options
-=============
-
-Common CMake Options
---------------------
-
-* ``-DCMAKE_BUILD_TYPE=<Debug|Release>`` - Set build type
-* ``-DCMAKE_CXX_STANDARD=<17|20>`` - Set C++ standard (minimum 17)
-* ``-DCMAKE_CXX_COMPILER=<compiler>`` - Set C++ compiler (e.g., g++, icpx)
-* ``-DCMAKE_C_COMPILER=<compiler>`` - Set C compiler (e.g., gcc, icx)
-* ``-DBUILD_TESTING=<ON|OFF>`` - Enable/disable building tests (default: ON)
-
-PTI Custom Options
-------------------
-
-* ``-DPTI_BUILD_SAMPLES=<ON|OFF>`` - Enable/disable building samples (default: ON when building as top-level project)
-* ``-DPTI_BUILD_TESTING=<ON|OFF>`` - Enable/disable building PTI tests (default: ON when building as top-level project)
-* ``-DPTI_INSTALL=<ON|OFF>`` - Enable/disable library installation when invoking ``--install`` (default: ON)
-* ``-DPTI_ENABLE_LOGGING=<ON|OFF>`` - Enable internal logging for PTI (default: OFF)
-
-**Example - Build library only without tests or samples:**
-
-.. code-block:: bash
-
-   cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
-         -DBUILD_TESTING=OFF \
-         -DPTI_BUILD_SAMPLES=OFF
-
-Troubleshooting
-===============
-
-CMake cannot find oneAPI components
-------------------------------------
-
-Ensure you've sourced the oneAPI environment:
-
-* **Linux**: ``source <path_to_oneapi>/setvars.sh``
-* **Windows**: Run ``<path_to_oneapi>\setvars.bat`` in cmd
-
-Level Zero headers not found
------------------------------
-
-* CMake fetches the Level Zero headers when it does not find version >= 1.32.0, so this error means
-  the download failed (for example, an offline build) or an older system Level Zero header set was picked up
-* Install Level Zero loader headers >= 1.32.0, or allow network access during configuration
-* The runtime Level Zero loader itself only needs version >= 1.14.0
-* Ensure oneAPI environment is properly sourced/initialized
-
-Build fails with compiler errors
----------------------------------
-
-* Ensure you're using a supported oneAPI version (2026.x)
-* Verify C++17 support is available
-* Try cleaning the build directory and reconfiguring
-
-For more detailed instructions and troubleshooting, see `INSTALL.md <https://github.com/intel/pti-gpu/blob/master/sdk/INSTALL.md>`_.
diff --git a/sdk/docs/sphinx/source/callback_api.rst b/sdk/docs/sphinx/source/callback_api.rst
deleted file mode 100644
index e84b01fe..00000000
--- a/sdk/docs/sphinx/source/callback_api.rst
+++ /dev/null
@@ -1,93 +0,0 @@
-PTI Callback API Reference (Experimental)
-##########################################
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-.. warning::
-   The Callback API is **EXPERIMENTAL** and subject to change. APIs and data structures may change in future releases without notice. Use with caution in production environments.
-
-This section provides API documentation for the PTI Callback API (synchronous GPU operation notifications).
-
-.. note::
-   Most users should use the :doc:`view_api_ref` (View API) instead. The Callback API is only necessary when you need synchronous callbacks during GPU operation lifecycle events.
-
-Overview
-========
-
-The PTI Callback API provides a low-level subscription mechanism for receiving notifications about GPU operations as they are appended or completed, and about kernels as they are created or destroyed. Append and kernel creation/destruction callbacks are synchronous: they run inside the Level Zero API call. GPU operation completion callbacks are asynchronous: they are delivered later, from the exit of the API call in which PTI collects the completed operations. Unlike the View API which delivers buffered profiling records, the Callback API delivers real-time callbacks during specific GPU operation lifecycle events.
-
-The Callback API is primarily designed for:
-
-* **Internal PTI infrastructure** - Used internally by :doc:`metrics_scope` for per-kernel metrics collection
-* **Advanced profiling tools** - Tools requiring immediate notification of GPU operations
-* **Custom correlation systems** - Applications needing to inject custom correlation IDs at precise moments
-* **Low-latency monitoring** - Systems requiring minimal delay between operation and notification
-
-The API includes:
-
-* **Core Functions** - Subscribe/unsubscribe, enable/disable callback domains
-* **Helper Functions** - Convert callback domain and phase enums to strings
-* **Structures** - Callback data structures for GPU operations
-* **Enumerators** - Callback domains, phases, operation kinds
-* **Type Definitions** - Subscriber handles and callback function pointers
-
-----
-
-Detailed API Documentation
-===========================
-
-Core Functions
---------------
-
-.. doxygenfunction:: ptiCallbackSubscribe
-
-.. doxygenfunction:: ptiCallbackUnsubscribe
-
-.. doxygenfunction:: ptiCallbackEnableDomain
-
-.. doxygenfunction:: ptiCallbackDisableDomain
-
-.. doxygenfunction:: ptiCallbackDisableAllDomains
-
-Helper Functions
-----------------
-
-.. doxygenfunction:: ptiCallbackDomainTypeToString
-
-.. doxygenfunction:: ptiCallbackPhaseTypeToString
-
-Structures
-----------
-
-.. doxygenstruct:: pti_callback_gpu_op_data
-   :members:
-
-.. doxygenstruct:: pti_callback_kernel_data
-   :members:
-
-.. doxygenstruct:: pti_gpu_op_details
-   :members:
-
-.. doxygenstruct:: pti_internal_callback_data
-   :members:
-
-Enumerators
------------
-
-.. doxygenenum:: pti_callback_domain
-
-.. doxygenenum:: pti_callback_phase
-
-.. doxygenenum:: pti_backend_command_list_type
-
-.. doxygenenum:: pti_internal_event_type
-
-.. doxygenenum:: pti_gpu_operation_kind
-
-Type Definitions
-----------------
-
-.. doxygentypedef:: pti_callback_subscriber_handle
-
-.. doxygentypedef:: pti_callback_function
diff --git a/sdk/docs/sphinx/source/conf.py b/sdk/docs/sphinx/source/conf.py
deleted file mode 100644
index f1b8442e..00000000
--- a/sdk/docs/sphinx/source/conf.py
+++ /dev/null
@@ -1,95 +0,0 @@
-# Configuration file for the Sphinx documentation builder.
-#
-# This file only contains a selection of the most common options. For a full
-# list see the documentation:
-# https://www.sphinx-doc.org/en/master/usage/configuration.html
-
-# -- Path setup --------------------------------------------------------------
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-# import os
-# import sys
-# sys.path.insert(0, os.path.abspath('.'))
-
-
-# -- Project information -----------------------------------------------------
-
-project = 'PTI'
-copyright = '2026, Intel Corporation'
-author = 'Intel Corporation'
-
-with open('../../../VERSION') as versionfile:
-    release = versionfile.readline().strip()
-    version = '.'.join(release.split('.')[:2])
-
-# -- General configuration ---------------------------------------------------
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    'sphinx.ext.autodoc',
-    'sphinx.ext.doctest',
-    'sphinx.ext.mathjax',
-    'sphinx.ext.viewcode',
-    'sphinx.ext.imgmath', 
-    'sphinx.ext.todo',
-    'breathe'
-]
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This pattern also affects html_static_path and html_extra_path.
-exclude_patterns = []
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-html_theme = 'sphinx_book_theme'
-
-html_theme_options = {
-    'repository_url': 'https://github.com/intel/pti-gpu',
-    'path_to_docs': 'sdk/docs/sphinx/source',
-    'use_issues_button': True,
-    'use_edit_page_button': True,
-    'repository_branch': 'master',
-    'logo': {
-        'text': 'PTI Documentation',
-    }
-}
-html_logo = '_static/oneAPI-rgb-rev-100.png'
-html_favicon = '_static/favicons.png'
-
-# Override title to hide version from header (per oneAPI guidelines)
-html_title = "PTI Documentation"
-
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-html_css_files = ['custom.css']
-
-# Syntax highlighting for the :: directive
-highlight_language = 'c' 
-
-# -- Extension configuration -------------------------------------------------
-
-breathe_projects = { "ptilib": "../../../build/docs/doxygen/xml/" }
-breathe_default_project = "ptilib"
-#exhale_args = {
-#   "containmentFolder":    "./api",
-#    "rootFileName":         "library_root.rst",
-#    "afterTitleDescription": "The library to build performance tools",
-#    "doxygenStripFromPath": "..",
-#    "rootFileTitle":        "PTI Library API"
-#}
diff --git a/sdk/docs/sphinx/source/get_started.rst b/sdk/docs/sphinx/source/get_started.rst
deleted file mode 100644
index bc3bb1d2..00000000
--- a/sdk/docs/sphinx/source/get_started.rst
+++ /dev/null
@@ -1,11 +0,0 @@
-=============
-Get Started
-=============
-
-.. toctree::
-   :maxdepth: 1
-
-   build_and_install
-   linking
-   quickstart
-   samples
diff --git a/sdk/docs/sphinx/source/index.rst b/sdk/docs/sphinx/source/index.rst
deleted file mode 100644
index fc25a491..00000000
--- a/sdk/docs/sphinx/source/index.rst
+++ /dev/null
@@ -1,29 +0,0 @@
-PTI Documentation
-==================
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-**Source Repository:** https://github.com/intel/pti-gpu/tree/master/sdk
-
-Overview
---------
-
-Intel Profiling Tools Interfaces for GPU SDK (hereafter PTI SDK) enables development of profiling tools for compute applications or frameworks using Intel oneAPI and running on Intel GPUs.
-PTI SDK consists of a C API library and the supporting modules it relies on.
-
-PTI SDK abstracts details of the runtime and driver stack and makes it easy to pick the desired level of profiling: for example, trace GPU device kernel execution, memory transfers,
-SYCL Runtime calls, Level-Zero calls on the host, and/or collect GPU hardware metrics.
-
-The API is the same for Linux and Windows operating systems and supports a range of client and data center Intel GPUs (see :doc:`Supported Hardware <systemreqs>`).
-
-.. include:: toctree.rst
-
-----
-
-Notices and Disclaimers
-========================
-
-© Intel Corporation. Intel, the Intel logo and other Intel marks are trademarks of Intel Corporation or its subsidiaries. Other names and brands may be claimed as the property of others.
-
-No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document, with the sole exception that code included in this document is licensed subject to the Zero-Clause BSD open-source license (0BSD), http://opensource.org/licenses/0BSD.
diff --git a/sdk/docs/sphinx/source/intro.rst b/sdk/docs/sphinx/source/intro.rst
deleted file mode 100644
index eab3fd28..00000000
--- a/sdk/docs/sphinx/source/intro.rst
+++ /dev/null
@@ -1,58 +0,0 @@
-#####################
-Introduction
-#####################
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-PTI SDK is a software package for developing profiling tools for applications built on oneAPI and running on Intel GPUs.
-
-The SDK provides the ``pti_view`` library with a set of APIs defined in header files, ``pti`` module, samples and tests.
-These APIs allow a user to trace various host and device operations, such as GPU kernel executions, memory transfers, and runtime/driver calls, and to collect GPU hardware performance metrics. The library is designed to be used by profiling tools to analyze the performance of applications running on Intel GPUs.
-The library implementation uses low-level tracing APIs of SYCL runtime and Level-Zero.
-
-PTI SDK provides the following groups of APIs:
-
-* ``ptiView`` - to trace GPU device kernels and memory transfers, host runtime and driver function calls, and deliver the data about traced instances, while the application runs, via registered callbacks in batches;
-* ``ptiMetricsScope`` - to collect and annotate GPU kernel instances with GPU hardware performance metrics, such as EU utilization, memory bandwidth, cache statistics, and others;
-* ``ptiMetrics`` - to discover available GPU hardware performance metrics and metrics sets, and collect them over time;
-* ``ptiPcSampling`` - to collect statistical per-instruction stall sampling data for GPU kernels, enabling fine-grained performance analysis by identifying instruction-level bottlenecks and stall reasons (Experimental);
-* ``ptiCallback`` - to subscribe to the notifications about GPU resources and operation lifecycle events (append, complete) and kernel creation and destruction, with a low-level callback API (Experimental). Append and kernel creation/destruction callbacks are synchronous; completion callbacks are asynchronous.
-
-PTI SDK supports **on-demand** profiling for most use cases - the application can start and stop profiling with ``ptiViewEnable()`` and ``ptiViewDisable()`` calls correspondingly.
-Outside the profiled region(s), PTI SDK incurs zero overhead.
-``ptiView`` API, among other things, allows users to correlate GPU activities with application-level operations via external correlation IDs,
-which helps to connect GPU activities with higher-level application logic and analyze performance in the context of the application behavior.
-
-For ``ptiView`` the user controls the buffers management for the profiling records delivery, and can choose to flush the buffers at any time with ``ptiFlushAllViews()`` to get the collected data delivered
-to the registered callbacks.
-
-For the APIs whose profiling results require significant post-processing, such as ``ptiMetricsScope`` and ``ptiMetrics``, the results delivery is done as the post-collection step.
-
-
-Getting Started with PTI SDK
-=============================
-
-There are two ways to use PTI SDK:
-
-**Using Pre-built Binaries**
-  Pre-built binaries are available from PyPI. See :doc:`build_and_install` for installation instructions and :doc:`linking` for instructions on how to link PTI SDK in your application.
-
-**Building from Source**
-  To build PTI SDK from source, follow the build instructions in :doc:`build_and_install`. The build process will create the necessary libraries and sample executables.
-
-Next Steps
-==========
-
-After installation (either from binaries or by building from source):
-
-1. Review the :doc:`quickstart` guide for an introduction
-2. Explore the samples in the ``samples/`` directory - see :doc:`samples` for descriptions
-3. Check out the API documentation:
-
-   * :doc:`view_api_ref` - PTI View API for tracing GPU operations
-   * :doc:`metrics_scope` - Metrics Scope API for per-kernel hardware metrics
-   * :doc:`metrics` - Device-level metrics API for continuous sampling
-   * :doc:`pc_sampling_api_ref` - PC Sampling API for instruction-level stall sampling (Experimental)
-   * :doc:`callback_api` - Callback API for synchronous GPU operation notifications (Experimental)
-
diff --git a/sdk/docs/sphinx/source/knownissues.rst b/sdk/docs/sphinx/source/knownissues.rst
deleted file mode 100644
index 1e9b6b78..00000000
--- a/sdk/docs/sphinx/source/knownissues.rst
+++ /dev/null
@@ -1,20 +0,0 @@
-==============
-Known Issues
-==============
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-1. Metrics collection requires metrics to be enabled on the device, either by calling ``ptiMetricsEnable`` (``ptiMetricsScopeEnable`` and ``ptiPcSamplingEnable`` do this internally) or by setting the ``ZET_ENABLE_METRICS=1`` environment variable. Drivers that do not support enabling metrics at runtime make ``ptiMetricsEnable`` return ``PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED``; on those drivers the environment variable is still required.
-
-2. Communication tracing (``PTI_VIEW_COMMUNICATION``) automatically registers ``libpti_view.so`` through ``INTEL_LIBITTNOTIFY64`` when the variable is unset. If it already identifies the loaded ``libpti_view.so``, PTI communication tracing remains available. If it identifies another collector, PTI leaves it unchanged, and ``ptiViewEnable(PTI_VIEW_COMMUNICATION)`` returns ``PTI_ERROR_COLLECTOR_UNAVAILABLE`` with a warning identifying the configured collector and PTI collector paths. The same error is returned if the configured collector path does not exist or collector configuration fails. Because ``libpti_view.so`` self-registers whenever it is loaded, applications that link it unconditionally cause ITT to be loaded even when communication tracing is disabled, and child processes inherit the variable. To opt out, set ``INTEL_LIBITTNOTIFY64`` to another collector before the process starts. oneCCL tracing remains controlled through the normal PTI view enable/disable mechanisms, and PTI limits additional overhead by disabling non-oneCCL ITT domains during collector initialization.
-
-   Collector names without a directory separator, such as ``libpti_view.so.1``, are identified through the dynamic loader among modules already loaded into the process. PTI does not load another collector to identify it. If the name cannot be identified, enabling communication tracing returns ``PTI_ERROR_COLLECTOR_UNAVAILABLE`` with a warning that the name could not be identified among loaded modules; this does not establish whether the library exists on the loader's search paths.
-
-3. Significant CPU overhead is currently observed when tracing workloads that frequently submit short kernels to the GPU. Optimization efforts continue both in the library as well as in the underlying layers of the software stack.
-
-4. For ``on-demand`` collection mode, Rolling drivers are required. Older LTS drivers do not support it, and instead require Level Zero tracing to be globally enabled via the ``ZE_ENABLE_TRACING_LAYER=1`` environment variable.
-
-5. Kernel name demangling is not supported on Windows.
-
-6. The first execution of a Level Zero native graph is slow while device tracing is active. When measuring graph overhead, treat the first execution as a warm-up and exclude it.
diff --git a/sdk/docs/sphinx/source/license.rst b/sdk/docs/sphinx/source/license.rst
deleted file mode 100644
index c37239a5..00000000
--- a/sdk/docs/sphinx/source/license.rst
+++ /dev/null
@@ -1,25 +0,0 @@
-=========
-License
-=========
-
-MIT License
-
-Copyright (C) Intel Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/sdk/docs/sphinx/source/linking.rst b/sdk/docs/sphinx/source/linking.rst
deleted file mode 100644
index e3cf5ef5..00000000
--- a/sdk/docs/sphinx/source/linking.rst
+++ /dev/null
@@ -1,30 +0,0 @@
-=========
-Linking
-=========
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-Use CMake ``find_package``
-
-.. code-block:: cmake
-
-   # Set Pti_DIR if you install in a nonstandard location.
-   set(Pti_DIR <path-to-pti>/lib/cmake/pti)
-
-   # Find the PTI package (version is optional)
-   find_package(Pti REQUIRED)
-
-   # Link against PTI library
-   target_link_libraries(your_target PUBLIC Pti::pti_view)
-
-Available CMake Targets
------------------------
-
-After ``find_package(Pti)``, the following targets are available:
-
-* ``Pti::pti_view`` - Main PTI View library for tracing and profiling
-* ``Pti::pti`` - PTI core library (module library)
-* ``Pti::pti_all`` - Interface target including all PTI components
-
-For most applications, use ``Pti::pti_view``.
diff --git a/sdk/docs/sphinx/source/metrics.rst b/sdk/docs/sphinx/source/metrics.rst
deleted file mode 100644
index 38f9e00d..00000000
--- a/sdk/docs/sphinx/source/metrics.rst
+++ /dev/null
@@ -1,114 +0,0 @@
-PTI Metrics API Reference
-##########################
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-This section provides API documentation for the PTI Metrics API (device-level metrics sampling).
-
-.. note::
-   This page documents the **Metrics API** for device-level time-based and event-based metrics sampling. For per-kernel metrics collection, see :doc:`metrics_scope`.
-
-Overview
-========
-
-The **Metrics API** provides time-based and event-based sampling of hardware performance metrics across application runtime. This API provides system-level performance monitoring without kernel-level granularity.
-
-The API includes:
-
-* **Enable/Disable Functions** - Turn metrics collection on and off on the devices at runtime
-* **Device Discovery Functions** - Enumerate devices that support metrics collection
-* **Metric Discovery Functions** - Discover available metric groups and individual metrics
-* **Collection Control Functions** - Configure, start, stop, pause, and resume collection
-* **Data Retrieval Functions** - Retrieve calculated metrics data
-* **Structures** - Device properties, metric properties, and collection parameters
-* **Enumerators** - Metric group types, metric types, and value types
-
-----
-
-Detailed API Documentation
-===========================
-
-Enable/Disable Functions
-------------------------
-
-Metrics must be enabled before any other Metrics API function is called, either by calling
-``ptiMetricsEnable`` or by setting the ``ZET_ENABLE_METRICS=1`` environment variable before the process
-starts. ``ptiMetricsEnable`` works only if the installed driver supports enabling metrics at runtime;
-otherwise it returns ``PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED`` and the environment variable must
-be used instead (this is the case with LTS drivers).
-
-Calls are reference counted per device, so every ``ptiMetricsEnable`` call must be matched with a
-``ptiMetricsDisable`` call. Metrics are disabled on a device only once its last reference is released.
-
-.. doxygenfunction:: ptiMetricsEnable
-
-.. doxygenfunction:: ptiMetricsDisable
-
-Device Discovery Functions
---------------------------
-
-.. doxygenfunction:: ptiMetricsGetDevices
-
-Metric Discovery Functions
---------------------------
-
-.. doxygenfunction:: ptiMetricsGetMetricGroups
-
-.. doxygenfunction:: ptiMetricsGetMetricsProperties
-
-Collection Control Functions
-----------------------------
-
-.. doxygenfunction:: ptiMetricsConfigureCollection
-
-.. doxygenfunction:: ptiMetricsStartCollection
-
-.. doxygenfunction:: ptiMetricsStartCollectionPaused
-
-.. doxygenfunction:: ptiMetricsPauseCollection
-
-.. doxygenfunction:: ptiMetricsResumeCollection
-
-.. doxygenfunction:: ptiMetricsStopCollection
-
-Data Retrieval Functions
--------------------------
-
-.. doxygenfunction:: ptiMetricsGetCalculatedData
-
-Structures
-----------
-
-.. doxygenstruct:: pti_device_properties_t
-   :members:
-
-.. doxygenstruct:: pti_pci_properties_t
-   :members:
-
-.. doxygenstruct:: pti_metric_properties_t
-   :members:
-
-.. doxygenstruct:: pti_metrics_group_properties_t
-   :members:
-
-.. doxygenstruct:: pti_metrics_group_collection_params_t
-   :members:
-
-.. doxygenunion:: pti_value_t
-
-Enumerators
------------
-
-.. doxygenenum:: pti_metrics_group_type
-
-.. doxygenenum:: pti_metric_type
-
-.. doxygenenum:: pti_metric_value_type
-
-Type Definitions
-----------------
-
-.. doxygentypedef:: pti_device_handle_t
-
-.. doxygentypedef:: pti_metrics_group_handle_t
diff --git a/sdk/docs/sphinx/source/metrics_scope.rst b/sdk/docs/sphinx/source/metrics_scope.rst
deleted file mode 100644
index 12c829a2..00000000
--- a/sdk/docs/sphinx/source/metrics_scope.rst
+++ /dev/null
@@ -1,92 +0,0 @@
-PTI Metrics Scope API Reference
-################################
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-This section provides API documentation for the PTI Metrics Scope API (per-kernel hardware metrics collection).
-
-.. note::
-   This page documents the **Metrics Scope API** for per-kernel hardware metrics collection. For device-level metrics sampling, see :doc:`metrics`.
-
-Overview
-========
-
-The **Metrics Scope API** enables per-kernel hardware metrics collection for Intel GPUs. This API correlates hardware performance counters with individual kernel executions.
-
-One MetricsScope collection can profile several devices at once, provided they all report the same ``_model_name`` in ``pti_device_properties_t``. Pass an explicit list of devices to ``ptiMetricsScopeConfigure``, or pass none to profile every device the workload uses. When no devices are passed, the same-model check covers every device returned by ``ptiMetricsGetDevices``, not only the ones the workload uses, so on a system with mixed GPU models pass an explicit list of same-model devices (use ``ptiMetricsGetDevices`` to group the handles by model). Each collection buffer holds data for a single device; use ``ptiMetricsScopeGetCollectionBufferProperties`` to find which one. ``ptiMetricsScopeEnable`` enables metrics on all devices itself (see ``ptiMetricsEnable`` in :doc:`metrics`).
-
-A Level Zero GPU view kind (for example ``PTI_VIEW_DEVICE_GPU_KERNEL``; see ``ptiCallbackSubscribe`` in :doc:`callback_api` for the list) must be enabled with ``ptiViewEnable`` before ``ptiMetricsScopeStartCollection``; otherwise it returns ``PTI_ERROR_NO_GPU_VIEWS_ENABLED``.
-
-Metric values are returned as ``pti_value_t``, typed by ``pti_metric_value_type``; see :doc:`metrics`.
-
-The API includes:
-
-* **Configuration Functions** - Enable metrics scope, configure devices and metrics
-* **Collection Control Functions** - Start and stop metrics collection
-* **Data Retrieval Functions** - Retrieve and process collected metrics data
-* **Structures** - Data structures for metrics records and metadata
-* **Enumerators** - Collection modes
-* **Type Definitions** - Handle types for scope collection
-
-----
-
-Detailed API Documentation
-===========================
-
-Configuration Functions
------------------------
-
-.. doxygenfunction:: ptiMetricsScopeEnable
-
-.. doxygenfunction:: ptiMetricsScopeConfigure
-
-.. doxygenfunction:: ptiMetricsScopeQueryCollectionBufferSize
-
-.. doxygenfunction:: ptiMetricsScopeSetCollectionBufferSize
-
-Collection Control Functions
-----------------------------
-
-.. doxygenfunction:: ptiMetricsScopeStartCollection
-
-.. doxygenfunction:: ptiMetricsScopeStopCollection
-
-Data Retrieval Functions
--------------------------
-
-.. doxygenfunction:: ptiMetricsScopeGetCollectionBuffersCount
-
-.. doxygenfunction:: ptiMetricsScopeGetCollectionBuffer
-
-.. doxygenfunction:: ptiMetricsScopeGetCollectionBufferProperties
-
-.. doxygenfunction:: ptiMetricsScopeQueryMetricsBufferSize
-
-.. doxygenfunction:: ptiMetricsScopeCalculateMetrics
-
-.. doxygenfunction:: ptiMetricsScopeGetMetricsMetadata
-
-.. doxygenfunction:: ptiMetricsScopeDisable
-
-Structures
-----------
-
-.. doxygenstruct:: pti_metrics_scope_record_t
-   :members:
-
-.. doxygenstruct:: pti_metrics_scope_record_metadata_t
-   :members:
-
-.. doxygenstruct:: pti_metrics_scope_collection_buffer_properties_t
-   :members:
-
-Enumerators
------------
-
-.. doxygenenum:: pti_metrics_scope_mode_t
-
-Type Definitions
-----------------
-
-.. doxygentypedef:: pti_scope_collection_handle_t
diff --git a/sdk/docs/sphinx/source/pc_sampling_api_ref.rst b/sdk/docs/sphinx/source/pc_sampling_api_ref.rst
deleted file mode 100644
index cc4c6e8f..00000000
--- a/sdk/docs/sphinx/source/pc_sampling_api_ref.rst
+++ /dev/null
@@ -1,169 +0,0 @@
-PTI PC Sampling API Reference (Experimental)
-############################################
-
-.. warning::
-   **EXPERIMENTAL API** - This API is experimental and subject to change without deprecation in future releases.
-
-This section provides API documentation for the PTI PC Sampling API (GPU EU Stall Sampling).
-
-Overview
-========
-
-The PTI PC Sampling API provides statistical per-instruction sampling of active execution and stall reasons on GPU kernels. This enables fine-grained performance analysis by identifying instruction-level bottlenecks and stall reasons.
-
-The API includes:
-
-* **Configuration Functions** - Enable, configure, and set buffer sizes
-* **Collection Control Functions** - Start and stop sampling
-* **Data Retrieval Functions** - Get devices, kernels, stall reasons, and sample data
-* **Cleanup Functions** - Disable and free resources
-* **Structures** - Kernel info, stall reasons, instruction data, device status
-* **Type Definitions** - Handle types for PC sampling
-
-Configuration Functions
-=======================
-
-* :ref:`ptiPcSamplingEnable <ptiPcSamplingEnable>` - Create a collection handle
-* :ref:`ptiPcSamplingConfigure <ptiPcSamplingConfigure>` - Configure the device and sampling period (optional)
-* :ref:`ptiPcSamplingQueryCollectionBufferSize <ptiPcSamplingQueryCollectionBufferSize>` - Query the effective collection buffer size
-* :ref:`ptiPcSamplingSetCollectionBufferSize <ptiPcSamplingSetCollectionBufferSize>` - Set the collection buffer size
-
-Collection buffer size
-----------------------
-
-The collection buffer defaults to 4 KiB. Use ``ptiPcSamplingSetCollectionBufferSize``
-before ``ptiPcSamplingStartCollection`` to set it, and
-``ptiPcSamplingQueryCollectionBufferSize`` to query the effective size in bytes.
-The size must be a multiple of 64 bytes, from 64 bytes through 64 MiB.
-
-The ``PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE`` environment variable can also set
-the buffer size. Its value must be a decimal size in bytes, a multiple of 64,
-from 64 bytes through 64 MiB.
-A valid value takes precedence over the API setting, and
-``ptiPcSamplingSetCollectionBufferSize`` returns
-``PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV`` when the environment
-variable overrides the requested size. If the variable is unset or invalid, the
-API setting (or the default size) is used.
-
-.. note::
-   ``ptiPcSamplingConfigure`` is optional and is only needed to override the defaults. When it is
-   skipped, ``ptiPcSamplingStartCollection`` applies the default configuration: the first device
-   that supports PC sampling and the default sampling period of 100000 ns. Only one device is
-   sampled per handle; pass an explicit list to ``ptiPcSamplingConfigure`` to choose another (the
-   first supported device in the list is used). The collection lifecycle is therefore
-   ``ptiPcSamplingEnable`` → ``ptiPcSamplingConfigure`` (optional) → ``ptiPcSamplingStartCollection``
-   → ``ptiPcSamplingStopCollection``.
-
-Collection Control Functions
-============================
-
-* :ref:`ptiPcSamplingStartCollection <ptiPcSamplingStartCollection>` - Begin sampling
-* :ref:`ptiPcSamplingStopCollection <ptiPcSamplingStopCollection>` - End sampling
-
-Data Retrieval Functions
-=========================
-
-* :ref:`ptiPcSamplingGetStallReasons <ptiPcSamplingGetStallReasons>` - Get stall reason information
-* :ref:`ptiPcSamplingGetProfiledDevices <ptiPcSamplingGetProfiledDevices>` - Get profiled device handles
-* :ref:`ptiPcSamplingGetDeviceStatus <ptiPcSamplingGetDeviceStatus>` - Get per-device collection status
-* :ref:`ptiPcSamplingGetObservedKernelHandles <ptiPcSamplingGetObservedKernelHandles>` - Get kernel handles with samples
-* :ref:`ptiPcSamplingGetObservedKernelInfo <ptiPcSamplingGetObservedKernelInfo>` - Get kernel metadata and aggregated samples
-* :ref:`ptiPcSamplingGetSamplesPerInstruction <ptiPcSamplingGetSamplesPerInstruction>` - Get instruction-level sampling data
-
-Cleanup Functions
-=================
-
-* :ref:`ptiPcSamplingDisable <ptiPcSamplingDisable>` - Free all resources
-
-Structures
-==========
-
-Data structures for PC sampling:
-
-* :ref:`pti_pc_sampling_stall_reason_info_t <pti_pc_sampling_stall_reason_info_t>` - Stall reason name and description
-* :ref:`pti_pc_sampling_source_info_t <pti_pc_sampling_source_info_t>` - Source file and line information
-* :ref:`pti_pc_sampling_instruction_t <pti_pc_sampling_instruction_t>` - Per-instruction sampling metrics
-* :ref:`pti_pc_sampling_kernel_info_t <pti_pc_sampling_kernel_info_t>` - Kernel information and aggregated samples
-* :ref:`pti_pc_sampling_device_status_t <pti_pc_sampling_device_status_t>` - Per-device collection status
-
-.. note::
-   The ``pti_pc_sampling_handle_t`` is an opaque handle type used to identify a PC sampling session. It is created by ``ptiPcSamplingEnable()`` and destroyed by ``ptiPcSamplingDisable()``.
-
-----
-
-Detailed API Documentation
-===========================
-
-Configuration Functions
------------------------
-
-.. _ptiPcSamplingEnable:
-.. doxygenfunction:: ptiPcSamplingEnable
-
-.. _ptiPcSamplingConfigure:
-.. doxygenfunction:: ptiPcSamplingConfigure
-
-.. _ptiPcSamplingQueryCollectionBufferSize:
-.. doxygenfunction:: ptiPcSamplingQueryCollectionBufferSize
-
-.. _ptiPcSamplingSetCollectionBufferSize:
-.. doxygenfunction:: ptiPcSamplingSetCollectionBufferSize
-
-Collection Control Functions
-----------------------------
-
-.. _ptiPcSamplingStartCollection:
-.. doxygenfunction:: ptiPcSamplingStartCollection
-
-.. _ptiPcSamplingStopCollection:
-.. doxygenfunction:: ptiPcSamplingStopCollection
-
-Data Retrieval Functions
--------------------------
-
-.. _ptiPcSamplingGetStallReasons:
-.. doxygenfunction:: ptiPcSamplingGetStallReasons
-
-.. _ptiPcSamplingGetProfiledDevices:
-.. doxygenfunction:: ptiPcSamplingGetProfiledDevices
-
-.. _ptiPcSamplingGetDeviceStatus:
-.. doxygenfunction:: ptiPcSamplingGetDeviceStatus
-
-.. _ptiPcSamplingGetObservedKernelHandles:
-.. doxygenfunction:: ptiPcSamplingGetObservedKernelHandles
-
-.. _ptiPcSamplingGetObservedKernelInfo:
-.. doxygenfunction:: ptiPcSamplingGetObservedKernelInfo
-
-.. _ptiPcSamplingGetSamplesPerInstruction:
-.. doxygenfunction:: ptiPcSamplingGetSamplesPerInstruction
-
-Cleanup Functions
------------------
-
-.. _ptiPcSamplingDisable:
-.. doxygenfunction:: ptiPcSamplingDisable
-
-Structures
-----------
-
-.. _pti_pc_sampling_stall_reason_info_t:
-.. doxygenstruct:: pti_pc_sampling_stall_reason_info_t
-   :members:
-
-.. _pti_pc_sampling_source_info_t:
-.. doxygenstruct:: pti_pc_sampling_source_info_t
-   :members:
-
-.. _pti_pc_sampling_instruction_t:
-.. doxygenstruct:: pti_pc_sampling_instruction_t
-   :members:
-
-.. _pti_pc_sampling_kernel_info_t:
-.. doxygenstruct:: pti_pc_sampling_kernel_info_t
-   :members:
-
-.. _pti_pc_sampling_device_status_t:
-.. doxygenstruct:: pti_pc_sampling_device_status_t
-   :members:
diff --git a/sdk/docs/sphinx/source/quickstart.rst b/sdk/docs/sphinx/source/quickstart.rst
deleted file mode 100644
index 59476638..00000000
--- a/sdk/docs/sphinx/source/quickstart.rst
+++ /dev/null
@@ -1,288 +0,0 @@
-============================
-Quick Start with ptiView API
-============================
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-This guide will help you get started with PTI SDK. By the end, you'll be able to trace GPU kernels and understand the basic API workflow.
-
-Prerequisites
--------------
-
-Before starting, ensure PTI SDK is installed. See :doc:`build_and_install` for installation instructions.
-
-Environment Setup
------------------
-
-Set up the Intel(R) oneAPI environment:
-
-**Linux:**
-
-.. code-block:: bash
-
-   source <path_to_oneapi>/setvars.sh
-
-**Windows:**
-
-Open the Intel(R) oneAPI Command Prompt.
-
-Basic Usage Pattern
--------------------
-
-The ``ptiView`` API follows this pattern:
-
-1. **Define callbacks** for buffer allocation and data processing
-2. **Register callbacks** with ``ptiViewSetCallbacks()``
-3. **Enable tracing** with ``ptiViewEnable()``
-4. **Run your application**
-5. **Disable tracing** with ``ptiViewDisable()``
-6. **Flush remaining data** with ``ptiFlushAllViews()``
-
-Running Your First Sample
---------------------------
-
-Let's run the vector square-add sample to see PTI SDK in action.
-
-**Step 1: Navigate to the build directory**
-
-.. code-block:: bash
-
-   cd build
-
-**Step 2: Run the sample**
-
-**Linux:**
-
-.. code-block:: bash
-
-   ./bin/vec_sqadd
-
-**Windows:**
-
-.. code-block:: batch
-
-   bin\vec_sqadd.exe
-
-Understanding the Output
-------------------------
-
-The sample will display:
-
-1. **Device Information**: GPU device being used
-2. **Kernel Traces**: Information about GPU kernels executed
-3. **Memory Operations**: Data transfers between host and device
-4. **Timing Information**: Timestamps and durations
-
-Example output:
-
-.. code-block:: text
-
-   >>>> [123456789] zeKernelCreate: zeKernel = 0xdeadbeef
-   >>>> [123456790] zeCommandListAppendLaunchKernel
-   Kernel: VecSq, Duration: 1234 ns
-   >>>> [123456800] zeCommandListAppendMemoryCopy
-   Memory Copy: Host->Device, Size: 20000 bytes, Duration: 567 ns
-
-Basic API Example
------------------
-
-Here's a minimal example showing the PTI SDK API usage:
-
-.. code-block:: c++
-
-   #include "pti/pti_view.h"
-   #include <iostream>
-
-   // Callback to allocate buffer
-   void BufferRequested(unsigned char** buf, size_t* buf_size) {
-       *buf_size = 1024 * 1024;  // 1 MB
-       *buf = new unsigned char[*buf_size];
-   }
-
-   // Callback to process collected data
-   void BufferCompleted(unsigned char* buf, size_t buf_size, size_t valid_buf_size) {
-       if (!buf || !valid_buf_size) return;
-
-       pti_view_record_base* ptr = nullptr;
-       while (true) {
-           auto status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-           if (status == PTI_STATUS_END_OF_BUFFER) break;
-           if (status != PTI_SUCCESS) {
-               std::cerr << "Error reading record" << std::endl;
-               break;
-           }
-
-           if (ptr->_view_kind == PTI_VIEW_DEVICE_GPU_KERNEL) {
-               auto* kernel = reinterpret_cast<pti_view_record_kernel*>(ptr);
-               std::cout << "Kernel: " << kernel->_name
-                         << ", Duration: " << (kernel->_end_timestamp - kernel->_start_timestamp)
-                         << " ns" << std::endl;
-           }
-       }
-       delete[] buf;
-   }
-
-   int main() {
-       // 1. Register callbacks for buffer allocation and data processing
-       ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-
-       // 2. Enable tracing for kernels
-       ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-       // 3. Run your SYCL/Level-Zero application
-       // ... your GPU workload here ...
-
-       // 4. Disable tracing
-       ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-       // 5. Flush any remaining buffered data
-       ptiFlushAllViews();
-
-       return 0;
-   }
-
-Available Tracing Views
------------------------
-
-PTI SDK supports tracing different types of activities:
-
-**Device Operations:**
-
-* ``PTI_VIEW_DEVICE_GPU_KERNEL`` - GPU kernel execution on the device
-* ``PTI_VIEW_DEVICE_GPU_MEM_COPY`` - Memory copy operations between host and device
-* ``PTI_VIEW_DEVICE_GPU_MEM_FILL`` - Memory fill operations on the device
-* ``PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P`` - Peer-to-peer memory copies between devices
-* ``PTI_VIEW_DEVICE_SYNCHRONIZATION`` - Synchronization operations on host and GPU (barriers, fences, events)
-
-**API Tracing:**
-
-* ``PTI_VIEW_RUNTIME_API`` - Runtime API calls (SYCL)
-* ``PTI_VIEW_DRIVER_API`` - Driver/back-end API calls (Level-Zero)
-
-**Profiling Support:**
-
-* ``PTI_VIEW_EXTERNAL_CORRELATION`` - Application-level correlation IDs for connecting GPU activities with user annotations
-* ``PTI_VIEW_COLLECTION_OVERHEAD`` - Profiling overhead tracking
-
-**Communication:**
-
-* ``PTI_VIEW_COMMUNICATION`` - Communication operations via Intel® oneCCL (Linux only)
-
-You can enable multiple views simultaneously:
-
-.. code-block:: c++
-
-   ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL);
-   ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-   ptiViewEnable(PTI_VIEW_RUNTIME_API);
-
-Running Tests
--------------
-
-To verify your PTI SDK installation, run the test suite:
-
-**Linux:**
-
-.. code-block:: bash
-
-   cd build
-   make test
-
-Or with CTest for detailed output:
-
-.. code-block:: bash
-
-   ctest --output-on-failure
-
-**Windows:**
-
-.. code-block:: batch
-
-   cd build
-   ninja test
-
-Or with CTest:
-
-.. code-block:: batch
-
-   ctest --output-on-failure
-
-On-Demand Collection
----------------------
-
-PTI SDK supports **on-demand** profiling for zero overhead outside the profiled regions.
-You can enable and disable tracing around specific code sections to focus on areas of interest:
-
-.. code-block:: c++
-
-   // Application initialization
-   setup_callbacks();
-
-   // No overhead here - tracing is not enabled
-   some_work();
-
-   // Start tracing - this is where collection begins
-   ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-   // Trace this section
-   important_work();
-
-   // Stop tracing - zero overhead resumes
-   ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-   // Flush remaining buffered data
-   ptiFlushAllViews();
-
-   // No overhead here again
-   more_work();
-
-Next Steps
-----------
-
-Now that you've run your first sample, explore more:
-
-1. **Examine the samples** in ``samples/`` directory:
-
-   * ``vector_sq_add`` - Basic tracing
-   * ``dpc_gemm`` - GEMM with performance tracking
-   * ``callback`` - Advanced callback usage
-   * ``metrics_scope`` - Hardware metrics collection
-
-2. **Check the API Reference** for detailed documentation:
-
-   * :doc:`view_api_ref` - Complete PTI View API for tracing
-   * :doc:`metrics_scope` - Per-kernel hardware metrics collection
-   * :doc:`metrics` - Device-level metrics collection
-   * :doc:`callback_api` - Advanced callback patterns
-   * Function signatures
-   * Data structure definitions
-
-4. **Browse sample code** at ``samples/`` for real-world usage patterns
-
-Troubleshooting
----------------
-
-**No output from sample:**
-   - Ensure oneAPI environment is set up (``setvars.sh``)
-   - Verify GPU drivers are installed
-   - Check that Level-Zero loader is available
-
-**Callbacks not called:**
-   - Ensure ``ptiViewSetCallbacks()`` is called **before** ``ptiViewEnable()``
-   - Verify callbacks are properly registered
-   - Check that you're enabling the correct view types
-
-**Build errors:**
-   - See the :doc:`build_and_install` guide for build requirements
-   - Ensure C++17 support is available
-
-**Performance issues:**
-   - Use on-demand collection (``ptiViewEnable``/``ptiViewDisable``) to reduce overhead
-   - Consider reducing callback complexity
-   - Profile only regions of interest
-
-For more help, see the `GitHub repository <https://github.com/intel/pti-gpu>`_ or submit an issue.
-
-
-
diff --git a/sdk/docs/sphinx/source/samples.rst b/sdk/docs/sphinx/source/samples.rst
deleted file mode 100644
index 38beb18d..00000000
--- a/sdk/docs/sphinx/source/samples.rst
+++ /dev/null
@@ -1,101 +0,0 @@
-============
-Code Samples
-============
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-Sample applications demonstrate how to use PTI SDK tracing and profiling capabilities. All samples are located in the ``samples/`` directory of the repository.
-
-**Repository Location:**
-
-* Local: ``sdk/samples/``
-* GitHub: https://github.com/intel/pti-gpu/tree/master/sdk/samples
-
-
-``ptiView`` API Samples
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Demonstrates how to use the :doc:`ptiView API <view_api_ref>` for tracing GPU operations, including kernel execution, memory copies, and API calls.
-
-.. list-table::
-   :widths: 20 35 45
-   :header-rows: 1
-
-   * - Sample
-     - Description
-     - ``PTI_VIEW_...``
-   * - **vector_sq_add**
-     - SYCL vector square-add kernel (binary: ``vec_sqadd``)
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``RUNTIME_API``, ``EXTERNAL_CORRELATION``
-   * - **dpc_gemm**
-     - DPC++ matrix multiplication with comprehensive tracing
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``RUNTIME_API``, ``DRIVER_API``, ``EXTERNAL_CORRELATION``, ``COLLECTION_OVERHEAD``
-   * - **onemkl_gemm**
-     - Matrix multiplication using Intel(R) oneMKL library
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``RUNTIME_API``
-   * - **itt_ccl**
-     - Intel(R) oneCCL library operations tracing (Linux only)
-     - ``COMMUNICATION``
-   * - **dpc_gemm_threaded**
-     - DPC++ matrix multiplication submitted to GPU from multiple host threads concurrently
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``RUNTIME_API``, ``DRIVER_API``, ``COLLECTION_OVERHEAD``
-   * - **omp_vec_add**
-     - C-language OpenMP sample with GPU offload
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``DRIVER_API``
-   * - **view_record_versioned**
-     - Version-aware tracing that handles v1 and v2 view record structures using ``ptiVersion()``
-     - ``DEVICE_GPU_KERNEL``, ``DEVICE_GPU_MEM_COPY``, ``DEVICE_GPU_MEM_FILL``, ``RUNTIME_API``, ``DRIVER_API``, ``COLLECTION_OVERHEAD``
-
-``ptiCallback`` API Sample
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-**callback**
-   Demonstrates the experimental :doc:`ptiCallback API <callback_api>` for synchronous GPU operation notifications.
-
-   .. warning::
-      The ``ptiCallback`` API is experimental and subject to change. See :doc:`callback_api` for documentation.
-
-GPU Hardware Metrics Collection Samples
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-**metrics_scope**
-   Per-kernel hardware metrics collection using :doc:`ptiMetricsScope API <metrics_scope>`.
-
-**metrics_perf**
-   Device-level time-based metrics sampling using the :doc:`ptiMetrics API <metrics>`. Use the ``--list-metrics`` option to output all available metrics sets and metrics on the system GPUs.
-
-**metrics_iso3dfd_dpcpp**
-   Hardware metrics collection in ISO3DFD stencil computation workload.
-
-
-Building Samples
-================
-
-Samples are built automatically with PTI SDK. See :doc:`build_and_install` for build instructions.
-
-From the SDK build directory:
-
-**Linux:**
-
-.. code-block:: bash
-
-   ./build/bin/vec_sqadd
-   ./build/bin/dpc_gemm
-   ./build/bin/metrics_scope
-
-**Windows:**
-
-.. code-block:: batch
-
-   build\bin\vec_sqadd.exe
-   build\bin\dpc_gemm.exe
-   build\bin\metrics_scope.exe
-
-Next Steps
-==========
-
-* :doc:`view_api_ref` - PTI View API for tracing
-* :doc:`metrics_scope` - Per-kernel metrics collection
-* :doc:`metrics` - Device-level metrics collection
-* :doc:`callback_api` - Callback API documentation
diff --git a/sdk/docs/sphinx/source/systemreqs.rst b/sdk/docs/sphinx/source/systemreqs.rst
deleted file mode 100644
index cbb33a8d..00000000
--- a/sdk/docs/sphinx/source/systemreqs.rst
+++ /dev/null
@@ -1,90 +0,0 @@
-=====================
-System Requirements
-=====================
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-Supported Hardware
-------------------
-
-PTI SDK supports the following Intel GPUs:
-
-**Intel(R) Data Center GPUs:**
-
-* Intel(R) Data Center GPU Max Series (Max 1550, Max 1100)
-* Intel(R) Data Center GPU Flex Series
-
-**Intel(R) Client GPUs:**
-
-* Intel(R) Arc(TM) Graphics (A-Series and B-Series)
-
-Prerequisites
----------------
-
-* `Intel(R) oneAPI Base Toolkit <https://software.intel.com/content/www/us/en/develop/tools/oneapi/base-toolkit.html>`_ (:ref:`versions <oneAPITestedVersions>`)
-* `Level Zero Loader <https://github.com/oneapi-src/level-zero>`_ (version >= 1.14.0 at runtime; building requires headers >= 1.32.0, which CMake downloads if they are not found)
-
-.. note::
-   For the best experience, use a recent Rolling GPU driver and Level Zero loader (for reference, PTI 1.2.0 is validated with Level Zero loader 1.32.0 and Intel(R) compute-runtime 26.31.39395.13). Graph profiling and on-demand collection require Rolling drivers.
-
-Intel(R) oneAPI Base Toolkit Tested Versions
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. _oneAPITestedVersions:
-
-.. list-table::
-   :widths: 25 25 25
-   :header-rows: 1
-
-   * - Support
-     - Linux
-     - Windows
-   * - Full
-     - 2026.0, 2026.1
-     - 2026.0
-
-OS Specific
-^^^^^^^^^^^^^
-.. list-table::
-   :widths: 25 25 25
-   :header-rows: 1
-
-   * -
-     - Linux
-     - Windows
-   * - `CMake <https://cmake.org/>`_
-     - version 3.14 and above. For presets, >= 3.20
-     - version >= 3.23
-   * - `Ninja <https://github.com/ninja-build/ninja>`_
-     - version >= 1.10.1 (optional)
-     - version 1.12.1
-   * - `Git <https://git-scm.com/>`_
-     - version 1.8 and above
-     - N/A
-   * - `Visual Studio 2022 <https://visualstudio.microsoft.com/vs/>`_
-     - N/A
-     - version >= 17.10.3
-
-Supported Operating Systems
------------------------------
-
-* Ubuntu 22.04, 24.04
-* Rocky 8, Rocky 9
-* RHEL 8, RHEL 9
-* SLES 15
-* Windows 11
-
-Regularly Tested Configurations
----------------------------------
-
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1550
-- Ubuntu 22.04 with Intel(R) Data Center GPU Max 1100
-- Ubuntu 24.04 with Intel(R) Data Center GPU Max Series
-- Ubuntu 25.10 with Intel(R) Arc(TM) Graphics (A-Series and B-Series)
-- Rocky 9 with Intel(R) Data Center GPU Max Series
-- Windows 11 with Intel(R) Arc(TM) Graphics (A-Series and B-Series)
-- Windows 11 with Intel(R) Data Center GPU Flex Series
-
-
-
diff --git a/sdk/docs/sphinx/source/toctree.rst b/sdk/docs/sphinx/source/toctree.rst
deleted file mode 100644
index 60d2c9b7..00000000
--- a/sdk/docs/sphinx/source/toctree.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-.. toctree::
-   :maxdepth: 2
-   :titlesonly:
-
-   about
-   get_started
-   api_reference
-
diff --git a/sdk/docs/sphinx/source/view_api_ref.rst b/sdk/docs/sphinx/source/view_api_ref.rst
deleted file mode 100644
index babb4464..00000000
--- a/sdk/docs/sphinx/source/view_api_ref.rst
+++ /dev/null
@@ -1,251 +0,0 @@
-PTI View API Reference
-######################
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-This section provides API documentation for the PTI View API (tracing and profiling).
-
-.. note::
-   This page documents the **PTI View API** for tracing GPU activities. For hardware metrics collection, see :doc:`metrics_scope` and :doc:`metrics`.
-
-Overview
-========
-
-The PTI View API provides tracing capabilities for GPU operations. The API includes:
-
-* **Core Functions** - Enable/disable tracing, set callbacks, manage views
-* **Helper Functions** - Utility functions for string conversion
-* **Structures** - Data structures for profiling records
-* **Enumerators** - View types, result codes, memory types
-* **Function Pointers** - Callback function signatures
-
-Core Functions
-==============
-
-* :ref:`ptiViewSetCallbacks <ptiViewSetCallbacks>` - Register callback functions
-* :ref:`ptiViewEnable <ptiViewEnable>` - Enable a profiling view
-* :ref:`ptiViewDisable <ptiViewDisable>` - Disable a profiling view
-* :ref:`ptiViewGPULocalAvailable <ptiViewGPULocalAvailable>` - Check on-demand collection support
-* :ref:`ptiFlushAllViews <ptiFlushAllViews>` - Flush all pending records
-* :ref:`ptiViewGetNextRecord <ptiViewGetNextRecord>` - Retrieve next record
-* :ref:`ptiViewPushExternalCorrelationId <ptiViewPushExternalCorrelationId>` - Push correlation ID
-* :ref:`ptiViewPopExternalCorrelationId <ptiViewPopExternalCorrelationId>` - Pop correlation ID
-* :ref:`ptiViewGetTimestamp <ptiViewGetTimestamp>` - Get current timestamp
-* :ref:`ptiViewSetTimestampCallback <ptiViewSetTimestampCallback>` - Set custom timestamp function
-* :ref:`ptiViewGetApiIdName <ptiViewGetApiIdName>` - Get API name from ID
-* :ref:`ptiViewEnableDriverApi <ptiViewEnableDriverApi>` - Enable/disable specific driver API
-* :ref:`ptiViewEnableRuntimeApi <ptiViewEnableRuntimeApi>` - Enable/disable specific runtime API
-* :ref:`ptiViewEnableDriverApiClass <ptiViewEnableDriverApiClass>` - Enable/disable driver API class
-* :ref:`ptiViewEnableRuntimeApiClass <ptiViewEnableRuntimeApiClass>` - Enable/disable runtime API class
-
-Helper Functions
-================
-
-* :ref:`ptiViewOverheadKindToString <ptiViewOverheadKindToString>` - Convert overhead kind to string
-* :ref:`ptiViewMemoryTypeToString <ptiViewMemoryTypeToString>` - Convert memory type to string
-* :ref:`ptiViewMemcpyTypeToString <ptiViewMemcpyTypeToString>` - Convert memcpy type to string
-
-Structures
-==========
-
-Record structures contain profiling data passed to callbacks:
-
-* :ref:`pti_view_record_base <pti_view_record_base>` - Base record structure
-* :ref:`pti_view_record_api <pti_view_record_api>` - Runtime API call record
-* :ref:`pti_view_record_kernel <pti_view_record_kernel>` - GPU kernel record
-* :ref:`pti_view_record_kernel_v2 <pti_view_record_kernel_v2>` - GPU kernel record v2 (extended)
-* :ref:`pti_view_record_memory_copy <pti_view_record_memory_copy>` - Memory copy record
-* :ref:`pti_view_record_memory_copy_v2 <pti_view_record_memory_copy_v2>` - Memory copy record v2 (extended)
-* :ref:`pti_view_record_memory_copy_p2p <pti_view_record_memory_copy_p2p>` - Peer-to-peer copy record
-* :ref:`pti_view_record_memory_copy_p2p_v2 <pti_view_record_memory_copy_p2p_v2>` - Peer-to-peer copy record v2 (extended)
-* :ref:`pti_view_record_memory_fill <pti_view_record_memory_fill>` - Memory fill record
-* :ref:`pti_view_record_memory_fill_v2 <pti_view_record_memory_fill_v2>` - Memory fill record v2 (extended)
-* :ref:`pti_view_record_synchronization <pti_view_record_synchronization>` - Synchronization record
-* :ref:`pti_view_record_external_correlation <pti_view_record_external_correlation>` - External correlation record
-* :ref:`pti_view_record_overhead <pti_view_record_overhead>` - Overhead record
-* :ref:`pti_view_record_comms <pti_view_record_comms>` - Communication record (oneCCL, Linux only)
-
-Enumerators
-===========
-
-* :ref:`pti_result <pti_result>` - Function return status codes
-* :ref:`pti_view_kind <pti_view_kind>` - View type identifiers
-* :ref:`pti_view_external_kind <pti_view_external_kind>` - External correlation types
-* :ref:`pti_view_overhead_kind <pti_view_overhead_kind>` - Overhead types
-* :ref:`pti_view_memory_type <pti_view_memory_type>` - Memory location types
-* :ref:`pti_view_memcpy_type <pti_view_memcpy_type>` - Memory copy direction types
-* :ref:`pti_view_synchronization_type <pti_view_synchronization_type>` - Synchronization operation types
-* :ref:`pti_api_group_id <pti_api_group_id>` - API group identifiers (Level-Zero, SYCL, OpenCL)
-* :ref:`pti_api_class <pti_api_class>` - API class categories for filtering
-
-Function Pointer Typedefs
-==========================
-
-Callback function signatures:
-
-* :ref:`pti_fptr_buffer_completed <pti_fptr_buffer_completed>` - Buffer completed callback
-* :ref:`pti_fptr_buffer_requested <pti_fptr_buffer_requested>` - Buffer requested callback
-
-----
-
-Detailed API Documentation
-===========================
-
-Core Functions
---------------
-
-.. _ptiViewSetCallbacks:
-.. doxygenfunction:: ptiViewSetCallbacks
-
-.. _ptiViewEnable:
-.. doxygenfunction:: ptiViewEnable
-
-.. _ptiViewDisable:
-.. doxygenfunction:: ptiViewDisable
-
-.. _ptiViewGPULocalAvailable:
-.. doxygenfunction:: ptiViewGPULocalAvailable
-
-.. _ptiFlushAllViews:
-.. doxygenfunction:: ptiFlushAllViews
-
-.. _ptiViewGetNextRecord:
-.. doxygenfunction:: ptiViewGetNextRecord
-
-.. _ptiViewPushExternalCorrelationId:
-.. doxygenfunction:: ptiViewPushExternalCorrelationId
-
-.. _ptiViewPopExternalCorrelationId:
-.. doxygenfunction:: ptiViewPopExternalCorrelationId
-
-.. _ptiViewGetTimestamp:
-.. doxygenfunction:: ptiViewGetTimestamp
-
-.. _ptiViewSetTimestampCallback:
-.. doxygenfunction:: ptiViewSetTimestampCallback
-
-.. _ptiViewGetApiIdName:
-.. doxygenfunction:: ptiViewGetApiIdName
-
-.. _ptiViewEnableDriverApi:
-.. doxygenfunction:: ptiViewEnableDriverApi
-
-.. _ptiViewEnableRuntimeApi:
-.. doxygenfunction:: ptiViewEnableRuntimeApi
-
-.. _ptiViewEnableDriverApiClass:
-.. doxygenfunction:: ptiViewEnableDriverApiClass
-
-.. _ptiViewEnableRuntimeApiClass:
-.. doxygenfunction:: ptiViewEnableRuntimeApiClass
-
-Helper Functions
-----------------
-
-.. _ptiViewOverheadKindToString:
-.. doxygenfunction:: ptiViewOverheadKindToString
-
-.. _ptiViewMemoryTypeToString:
-.. doxygenfunction:: ptiViewMemoryTypeToString
-
-.. _ptiViewMemcpyTypeToString:
-.. doxygenfunction:: ptiViewMemcpyTypeToString
-
-Structures
-----------
-
-.. _pti_view_record_base:
-.. doxygenstruct::   pti_view_record_base
-   :members:
-
-.. _pti_view_record_api:
-.. doxygenstruct::   pti_view_record_api
-   :members:
-
-.. _pti_view_record_kernel:
-.. doxygenstruct::   pti_view_record_kernel
-   :members:
-
-.. _pti_view_record_kernel_v2:
-.. doxygenstruct::   pti_view_record_kernel_v2
-   :members:
-
-.. _pti_view_record_memory_copy:
-.. doxygenstruct::   pti_view_record_memory_copy
-   :members:
-
-.. _pti_view_record_memory_copy_v2:
-.. doxygenstruct::   pti_view_record_memory_copy_v2
-   :members:
-
-.. _pti_view_record_memory_copy_p2p:
-.. doxygenstruct::   pti_view_record_memory_copy_p2p
-   :members:
-
-.. _pti_view_record_memory_copy_p2p_v2:
-.. doxygenstruct::   pti_view_record_memory_copy_p2p_v2
-   :members:
-
-.. _pti_view_record_memory_fill:
-.. doxygenstruct::   pti_view_record_memory_fill
-   :members:
-
-.. _pti_view_record_memory_fill_v2:
-.. doxygenstruct::   pti_view_record_memory_fill_v2
-   :members:
-
-.. _pti_view_record_synchronization:
-.. doxygenstruct::   pti_view_record_synchronization
-   :members:
-
-.. _pti_view_record_external_correlation:
-.. doxygenstruct::   pti_view_record_external_correlation
-   :members:
-
-.. _pti_view_record_overhead:
-.. doxygenstruct::   pti_view_record_overhead
-   :members:
-
-.. _pti_view_record_comms:
-.. doxygenstruct::   pti_view_record_comms
-   :members:
-
-Enumerators
------------
-
-.. _pti_result:
-.. doxygenenum:: pti_result
-
-.. _pti_view_kind:
-.. doxygenenum:: pti_view_kind
-
-.. _pti_view_external_kind:
-.. doxygenenum:: pti_view_external_kind
-
-.. _pti_view_overhead_kind:
-.. doxygenenum:: pti_view_overhead_kind
-
-.. _pti_view_memory_type:
-.. doxygenenum:: pti_view_memory_type
-
-.. _pti_view_memcpy_type:
-.. doxygenenum:: pti_view_memcpy_type
-
-.. _pti_view_synchronization_type:
-.. doxygenenum:: pti_view_synchronization_type
-
-.. _pti_api_group_id:
-.. doxygenenum:: pti_api_group_id
-
-.. _pti_api_class:
-.. doxygenenum:: pti_api_class
-
-Function Pointer Typedefs
---------------------------
-
-.. _pti_fptr_buffer_completed:
-.. doxygentypedef:: pti_fptr_buffer_completed
-
-.. _pti_fptr_buffer_requested:
-.. doxygentypedef:: pti_fptr_buffer_requested
diff --git a/sdk/docs/sphinx/source/whatsnew.rst b/sdk/docs/sphinx/source/whatsnew.rst
deleted file mode 100644
index 417721a3..00000000
--- a/sdk/docs/sphinx/source/whatsnew.rst
+++ /dev/null
@@ -1,80 +0,0 @@
-==============
-What's New
-==============
-
-.. warning::
-   **DRAFT DOCUMENTATION** - This documentation is currently in draft status and subject to change.
-
-Version 1.3.0
----------------
-
-*Current release*
-
-**Updates in this release:**
-
-* **Behavior change:** ``ptiViewEnable(PTI_VIEW_COMMUNICATION)`` now returns the new ``PTI_ERROR_COLLECTOR_UNAVAILABLE`` result code and logs a descriptive warning when ``INTEL_LIBITTNOTIFY64`` selects another collector, the configured collector path does not exist, a bare collector name cannot be identified among loaded modules, or collector configuration fails. Previously, enabling the view returned ``PTI_SUCCESS`` even though PTI could not collect communication records. Callers that require successful enablement, including the oneCCL tracing samples, now fail at enablement. API signatures and the ABI are unchanged.
-* Implement ``ptiPcSamplingQueryCollectionBufferSize`` and ``ptiPcSamplingSetCollectionBufferSize`` to query and configure the PC Sampling collection buffer. Sizes must be multiples of 64 bytes from 64 bytes through 64 MiB. The ``PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE`` environment variable overrides the API setting when valid; in that case, the setter returns ``PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV``.
-
-Version 1.2.0
----------------
-
-**Updates in this release:**
-
-* Add the new ``ptiMetricsEnable`` and ``ptiMetricsDisable`` APIs, which enable metrics collection at runtime and remove the need to set the ``ZET_ENABLE_METRICS=1`` environment variable before the process starts. Calls are reference counted per device and must be matched. ``ptiMetricsEnable`` returns the new ``PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED`` result code when the installed driver does not support runtime enabling, in which case the environment variable is still required; other driver failures of both APIs are reported as ``PTI_ERROR_DRIVER``. The new ``PTI_ERROR_METRICS_ENABLE_FAILED`` result code is also added, for metrics that could not be enabled on all devices.
-* Make ``ptiPcSamplingConfigure`` optional. If it is not called, ``ptiPcSamplingStartCollection`` applies the default configuration (the first device that supports PC sampling, sampling period of 100000 ns). Configuration failures are now reported with the new ``PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL`` result code; ``PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED`` is kept for backward compatibility.
-* **Behavior change:** ``libpti_view.so`` now registers itself as the ITT collector at load time, so oneCCL communication tracing works without extra environment setup. When ``INTEL_LIBITTNOTIFY64`` is unset, a static initializer sets it to the absolute path of ``libpti_view.so`` before ``main()``. As a result, ITT is loaded in every process that loads ``libpti_view.so``, even if ``PTI_VIEW_COMMUNICATION`` is never enabled, and child processes (for example ``torchrun`` or ``mpirun`` workers) inherit the variable. To opt out, set the variable to another collector before the process starts; PTI then leaves it unchanged and disables its own oneCCL tracing. See :doc:`knownissues`.
-* Significantly reduce tracing overhead for Level Zero native graph execution (about 40% lower in internal measurements) by gathering the timestamps of the whole graph in one batched submission and removing an unnecessary wait on in-order command lists. The first graph execution under device tracing is still slow; see :doc:`knownissues`.
-* **Behavior change:** Add ``zeCommandQueueExecuteCommandLists`` to the ``PTI_API_CLASS_GPU_OPERATION_CORE`` API class, covering applications that submit work through non-immediate command lists. Applications that enable this class with ``ptiViewEnableDriverApiClass`` now receive additional ``PTI_VIEW_DRIVER_API`` records (and the associated overhead) for these calls.
-* **Behavior change:** ``ptiViewOverheadKindToString`` now returns ``"Instrumentation"`` for ``PTI_VIEW_OVERHEAD_KIND_TIME`` (previously ``"BUFFER_TIME"``). Code that compares the returned string must be updated; compare the enum value where possible.
-* Fix a stale external correlation ID being reported alongside the live one when an ID is popped inside a ``ptiCallback`` subscriber callback.
-* Fix duplicate kernel records when tracing Level Zero graph creation with compute-runtime 26.31 and later.
-* Add build support for the open-source DPC++/DPCLang compiler (DPC++ 7.0), Rocky Linux 8, and building PTI as a CMake subproject, and fix compilation errors with the Intel oneAPI Compiler 2026.2.
-
-Version 1.1.0
----------------
-
-**Updates in this release:**
-
-* Add support for on-demand profiling of Level Zero native graphs, validated on Intel(R) Arc(TM) B-Series (BMG) with a single GPU. Requires Intel oneAPI DPC++/C++ Compiler 2026.1.1 and compute-runtime 1.15.39122+12 or newer.
-* Update to Level Zero Loader version 1.32.0 and add the new Level Zero graph and SYCL Unified Runtime API IDs to ``pti_driver_levelzero_api_ids.h`` and ``pti_runtime_sycl_api_ids.h``.
-* Intern kernel names to avoid unbounded memory growth in applications that launch many kernels.
-* Keep demangled kernel names in aggregated ``ptiPcSampling`` results.
-* Fix a data race on the buffer handoff between the thread producing records and the thread delivering buffers to the user.
-* Remove the obsolete bridge kernel GPU tracing path; the ``PTI_FORCE_BRIDGE_COMMANDS`` environment variable no longer has any effect.
-* Fix loading the PTI core library from the Python wheel: the dependencies it cannot find through its own RPATH are now pre-loaded by the PTI interface library. Fix builds with Intel oneAPI Compiler 2025.x and 2026.0.
-
-Version 1.0.1
----------------
-
-**Updates in this release:**
-
-* Document that ``ptiPcSamplingEnable`` returns ``PTI_ERROR_PC_SAMPLING_UNSUPPORTED`` when PC sampling is not supported on the system.
-* Fix undefined symbols when running with LTS drivers on Intel(R) Data Center GPU Max Series: Level Zero symbols newer than loader version 1.14.0 are loaded dynamically.
-* Fix a crash on Windows when the PTI library is unloaded.
-* Fix builds with newer Level Zero Loader headers and MSVC Debug builds, and reconfigure the build when the ``VERSION`` file changes.
-
-Version 1.0.0
----------------
-
-**Updates in this release:**
-
-* Declare the ``ptiView`` API stable for the 1.0 release, with fixed 4-byte enum sizes for a stable ABI.
-* Extend the ``pti_view_record_kernel``, ``pti_view_record_memory_copy``, ``pti_view_record_memory_copy_p2p``, and ``pti_view_record_memory_fill`` records with new device handle and engine (ordinal and index) fields, defined as the new ``_v2`` record structures ``pti_view_record_kernel_v2``, ``pti_view_record_memory_copy_v2``, ``pti_view_record_memory_copy_p2p_v2``, and ``pti_view_record_memory_fill_v2``. The previous records remain compatible with the new ones.
-* Add a proof-of-concept of GPU PC Sampling via the new ``ptiPcSampling`` API (Experimental) for statistical per-instruction stall sampling on GPU kernels. The API is complete, but the functionality is not: specifically, "address to source line mapping" is not yet implemented and is expected in the next version.
-* Add the new ``ptiCallback`` API (Experimental), providing synchronous notifications for GPU operation lifecycle events, with kernel handle context and driver/kernel callback domains.
-* Extend ``ptiMetricsScope`` with multi-device support, including multi-process auto-mode collection running in parallel.
-* Add an initial proof-of-concept for on-demand SYCL Graph profiling with reduced overhead for repeatedly executed graphs.
-* Reduce host-side runtime collection overhead significantly, in part by switching to GPU-time interpolation. Further reduction is in progress.
-* Fix device timestamp desynchronization that could produce incorrect kernel start/end times when the device submit time exceeded the device start time.
-* Improve tracing of Intel(R) oneCCL library operations.
-* Add compatibility with Intel oneAPI Compiler 2026.0 and 2026.1, the open-source DPC++ compiler, and newer Level Zero Loader headers, including the Level Zero driver extension headers.
-
-Version 0.17.0
----------------
-
-**Updates in this release:**
-
-* Add support for tracing Intel(R) oneCCL library operations (via ``ptiViewEnable(PTI_VIEW_COMMUNICATION)``)
-* Add tracing of SYCL Graph operations with capture of repeatedly executed command lists. Improvements of this capability are in progress.
-* Add compatibility with Intel oneAPI Compiler 2026.
-* Update to Level Zero Loader version 1.28.0.
diff --git a/sdk/env/oneapi-vars.bat b/sdk/env/oneapi-vars.bat
deleted file mode 100644
index af93d592..00000000
--- a/sdk/env/oneapi-vars.bat
+++ /dev/null
@@ -1,40 +0,0 @@
-@echo off
-REM
-REM Copyright (c) 2024 Intel Corporation
-REM
-REM Licensed under the Apache License, Version 2.0 (the "License");
-REM you may not use this file except in compliance with the License.
-REM You may obtain a copy of the License at
-REM
-REM     http://www.apache.org/licenses/LICENSE-2.0
-REM
-REM Unless required by applicable law or agreed to in writing, software
-REM distributed under the License is distributed on an "AS IS" BASIS,
-REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-REM See the License for the specific language governing permissions and
-REM limitations under the License.
-REM
-
-if not defined SETVARS_CALL (
-    echo:
-    echo :: ERROR: This script must be executed by setvars.bat.
-    echo:   Try '[install-dir]\setvars.bat --help' for help.
-    echo:
-    exit /b 255
-)
-
-if not defined ONEAPI_ROOT (
-    echo:
-    echo :: ERROR: This script requires that the ONEAPI_ROOT env variable is set."
-    echo:   Try '[install-dir]\setvars.bat --help' for help.
-    echo:
-    exit /b 254
-)
-
-set "PTI_ROOT=%ONEAPI_ROOT%"
-set "CMAKE_PREFIX_PATH=%PTI_ROOT%\lib\cmake\pti;%CMAKE_PREFIX_PATH%"
-set "CPATH=%PTI_ROOT%\include;%CPATH%"
-
-set "Pti_DIR=%PTI_ROOT%\lib\cmake\pti"
-
-exit /B 0
diff --git a/sdk/env/oneapi-vars.sh b/sdk/env/oneapi-vars.sh
deleted file mode 100644
index 1235c7cd..00000000
--- a/sdk/env/oneapi-vars.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/sh
-# shellcheck shell=sh
-
-##===----------------------------------------------------------------------===##
-#
-# Copyright (C) 2024 Intel Corporation
-#
-# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-#
-# This file incorporates work covered by the following copyright and permission
-# notice:
-#
-# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-# See https://llvm.org/LICENSE.txt for license information.
-#
-##===----------------------------------------------------------------------===##
-
-if [ -z "${SETVARS_CALL:-}" ] ; then
-  >&2 echo " "
-  >&2 echo ":: ERROR: This script must be sourced by oneapi-vars.sh."
-  >&2 echo "   Try 'source <install-dir>/oneapi-vars.sh --help' for help."
-  >&2 echo " "
-  return 255
-fi
-
-if [ -z "${ONEAPI_ROOT:-}" ] ; then
-  >&2 echo " "
-  >&2 echo ":: ERROR: This script requires that the ONEAPI_ROOT env variable is set."
-  >&2 echo "   Try 'source <install-dir>\oneapi-vars.sh --help' for help."
-  >&2 echo " "
-  return 254
-fi
-
-# ############################################################################
-
-CMAKE_PREFIX_PATH=$(prepend_path "${component_root}/lib/cmake/pti" "${CMAKE_PREFIX_PATH:-}") ; export CMAKE_PREFIX_PATH
-
-C_INCLUDE_PATH=$(prepend_path "${component_root}/include" "${C_INCLUDE_PATH:-}") ; export C_INCLUDE_PATH
-CPLUS_INCLUDE_PATH=$(prepend_path "${component_root}/include" "${CPLUS_INCLUDE_PATH:-}") ; export CPLUS_INCLUDE_PATH
-
-Pti_DIR=${ONEAPI_ROOT}/lib/cmake/pti; export Pti_DIR
-
-
diff --git a/sdk/env/vars.bat b/sdk/env/vars.bat
deleted file mode 100644
index 16c948e5..00000000
--- a/sdk/env/vars.bat
+++ /dev/null
@@ -1,48 +0,0 @@
-@echo off
-
-rem Copyright 2024 Intel Corporation
-rem SPDX-License-Identifier: MIT
-
-rem Permission is hereby granted, free of charge, to any person obtaining a copy
-rem of this software and associated documentation files (the "Software"), to deal
-rem in the Software without restriction, including without limitation the rights
-rem to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-rem copies of the Software, and to permit persons to whom the Software is
-rem furnished to do so, subject to the following conditions:
-rem
-rem The above copyright notice and this permission notice shall be included in all
-rem copies or substantial portions of the Software.
-rem
-rem THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-rem IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-rem FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-rem AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-rem LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-rem OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-rem SOFTWARE.
-
-
-setlocal EnableDelayedExpansion
-
-set "__this_dir_path=%~dp0"
-set "__this_dir_path=%__this_dir_path:~0,-1%"
-
-set "PTI_ROOT=%__this_dir_path%\.."
-
-endlocal & set "PTI_ROOT=%PTI_ROOT%"
-
-set "PATH=%PTI_ROOT%\bin;%PATH%"
-set "CPATH=%PTI_ROOT%\include;%CPATH%"
-set "CMAKE_PREFIX_PATH=%PTI_ROOT%\lib\cmake\pti;%CMAKE_PREFIX_PATH%"
-set "LIB=%PTI_ROOT%\lib;%LIB%"
-set "LIBRARY_PATH=%PTI_ROOT%\lib;%LIBRARY_PATH%"
-set "INCLUDE=%PTI_ROOT%\include;%INCLUDE%"
-
-rem
-rem This variable allows cmake to find PTI in conda environments to
-rem bypass the overwriting of the LD_LIBRARY_PATH
-rem
-set "Pti_DIR=%PTI_ROOT%\lib\cmake\pti"
-
-set "PTI_ROOT="
-set "__this_dir_path="
diff --git a/sdk/env/vars.sh b/sdk/env/vars.sh
deleted file mode 100644
index 9c0e8b89..00000000
--- a/sdk/env/vars.sh
+++ /dev/null
@@ -1,241 +0,0 @@
-#!/bin/sh
-# shellcheck shell=sh
-
-# Copyright 2024 Intel Corporation
-# SPDX-License-Identifier: MIT
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-
-# ############################################################################
-
-# Get absolute path to this script.
-# Uses `readlink` to remove links and `pwd -P` to turn into an absolute path.
-
-# Usage:
-#   script_dir=$(get_script_path "$script_rel_path")
-#
-# Inputs:
-#   script/relative/pathname/scriptname
-#
-# Outputs:
-#   /script/absolute/pathname
-
-# executing function in a *subshell* to localize vars and effects on `cd`
-
-# The sequence `builtin cd` needs to be used with zsh instead of `command cd`
-# to remove alias/function redefinitions of the `cd` command. This is because
-# `command` only works with external commands in the zsh shell. Unfortunately,
-# `builtin` is not recognized by `dash` and fails. Thus it is necessary to
-# create two branches in the function to insure that an existing redefinition
-# of `cd` (alias or function) does not interfere.
-
-get_script_path() (
-  script="$1"
-  while [ -L "$script" ] ; do
-    script_dir=$(command dirname -- "$script")
-    # see also: https://superuser.com/a/1574553/229501
-    if [ -n "${ZSH_VERSION:-}" ] ; then
-      script_dir=$(builtin cd "$script_dir" && command pwd -P)
-    else
-      script_dir=$(command cd "$script_dir" && command pwd -P)
-    fi
-    script="$(readlink "$script")"
-    case $script in
-      (/*) ;;
-       (*) script="$script_dir/$script" ;;
-    esac
-  done
-  script_dir=$(command dirname -- "$script")
-  if [ -n "${ZSH_VERSION:-}" ] ; then
-    script_dir=$(builtin cd "$script_dir" && command pwd -P)
-  else
-    script_dir=$(command cd "$script_dir" && command pwd -P)
-  fi
-  printf "%s" "$script_dir"
-)
-
-
-# ############################################################################
-
-# Determine if we are being executed or sourced. Need to detect being sourced
-# within an executed script, which can happen on a CI system. We also must
-# detect being sourced at a shell prompt (CLI). The setvars.sh script will
-# always source this script, but this script can also be called directly.
-
-# We are assuming we know the name of this script, which is a reasonable
-# assumption. This script _must_ be named "vars.sh" or it will not work
-# with the top-level setvars.sh script. Making this assumption simplifies
-# the process of detecting if the script has been sourced or executed. It
-# also simplifies the process of detecting the location of this script.
-
-# Using `readlink` to remove possible symlinks in the name of the script.
-# Also, "ps -o comm=" is limited to a 15 character result, but it works
-# fine here, because we are only looking for the name of this script or the
-# name of the execution shell, both always fit into fifteen characters.
-
-_vars_get_proc_name() {
-  if [ -n "${ZSH_VERSION:-}" ] ; then
-    script="$(ps -p "$$" -o comm=)"
-  else
-    script="$1"
-    while [ -L "$script" ] ; do
-      script="$(readlink "$script")"
-    done
-  fi
-  basename -- "$script"
-}
-
-_vars_this_script_name="vars.sh"
-if [ "$_vars_this_script_name" = "$(_vars_get_proc_name "$0")" ] ; then
-  echo "   ERROR: Incorrect usage: this script must be sourced."
-  echo "   Usage: . path/to/${_vars_this_script_name}"
-  return 255 2>/dev/null || exit 255
-fi
-
-
-# ############################################################################
-
-# Prepend path segment(s) to path-like env vars (PATH, CPATH, etc.).
-
-# prepend_path() avoids dangling ":" that affects some env vars (PATH and CPATH)
-# prepend_manpath() includes dangling ":" needed by MANPATH.
-# PATH > https://www.gnu.org/software/libc/manual/html_node/Standard-Environment.html
-# MANPATH > https://manpages.debian.org/stretch/man-db/manpath.1.en.html
-
-# Usage:
-#   env_var=$(prepend_path "$prepend_to_var" "$existing_env_var")
-#   export env_var
-#
-#   env_var=$(prepend_manpath "$prepend_to_var" "$existing_env_var")
-#   export env_var
-#
-# Inputs:
-#   $1 == path segment to be prepended to $2
-#   $2 == value of existing path-like environment variable
-
-prepend_path() (
-  path_to_add="$1"
-  path_is_now="$2"
-
-  if [ "" = "${path_is_now}" ] ; then   # avoid dangling ":"
-    printf "%s" "${path_to_add}"
-  else
-    printf "%s" "${path_to_add}:${path_is_now}"
-  fi
-)
-
-prepend_manpath() (
-  path_to_add="$1"
-  path_is_now="$2"
-
-  if [ "" = "${path_is_now}" ] ; then   # include dangling ":"
-    printf "%s" "${path_to_add}:"
-  else
-    printf "%s" "${path_to_add}:${path_is_now}"
-  fi
-)
-
-
-# ############################################################################
-
-# Extract the name and location of this sourced script.
-
-# Generally, "ps -o comm=" is limited to a 15 character result, but it works
-# fine for this usage, because we are primarily interested in finding the name
-# of the execution shell, not the name of any calling script.
-
-vars_script_name=""
-vars_script_shell="$(ps -p "$$" -o comm=)"
-# ${var:-} needed to pass "set -eu" checks
-# see https://unix.stackexchange.com/a/381465/103967
-# see https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_02
-if [ -n "${ZSH_VERSION:-}" ] && [ -n "${ZSH_EVAL_CONTEXT:-}" ] ; then     # zsh 5.x and later
-  # shellcheck disable=SC2249,SC2296
-  case $ZSH_EVAL_CONTEXT in (*:file*) vars_script_name="${(%):-%x}" ;; esac ;
-elif [ -n "${KSH_VERSION:-}" ] ; then                                     # ksh, mksh or lksh
-  if [ "$(set | grep -Fq "KSH_VERSION=.sh.version" ; echo $?)" -eq 0 ] ; then # ksh
-    # shellcheck disable=SC2296
-    vars_script_name="${.sh.file}" ;
-  else # mksh or lksh or [lm]ksh masquerading as ksh or sh
-    # shellcheck disable=SC2296
-    # force [lm]ksh to issue error msg; which contains this script's path/filename, e.g.:
-    # mksh: /home/ubuntu/intel/oneapi/vars.sh[137]: ${.sh.file}: bad substitution
-    vars_script_name="$( (echo "${.sh.file}") 2>&1 )" || : ;
-    vars_script_name="$(expr "${vars_script_name:-}" : '^.*sh: \(.*\)\[[0-9]*\]:')" ;
-  fi
-elif [ -n "${BASH_VERSION:-}" ] ; then        # bash
-  # shellcheck disable=SC2128,SC3028
-  (return 0 2>/dev/null) && vars_script_name="${BASH_SOURCE}" ;
-elif [ "dash" = "$vars_script_shell" ] ; then # dash
-  # shellcheck disable=SC2296
-  # force dash to issue error msg; which contains this script's rel/path/filename, e.g.:
-  # dash: 146: /home/ubuntu/intel/oneapi/vars.sh: Bad substitution
-  vars_script_name="$( (echo "${.sh.file}") 2>&1 )" || : ;
-  vars_script_name="$(expr "${vars_script_name:-}" : '^.*dash: [0-9]*: \(.*\):')" ;
-elif [ "sh" = "$vars_script_shell" ] ; then   # could be dash masquerading as /bin/sh
-  # shellcheck disable=SC2296
-  # force a shell error msg; which should contain this script's path/filename
-  # sample error msg shown; assume this file is named "vars.sh"; as required by setvars.sh
-  vars_script_name="$( (echo "${.sh.file}") 2>&1 )" || : ;
-  if [ "$(printf "%s" "$vars_script_name" | grep -Eq "sh: [0-9]+: .*vars\.sh: " ; echo $?)" -eq 0 ] ; then # dash as sh
-    # sh: 155: /home/ubuntu/intel/oneapi/vars.sh: Bad substitution
-    vars_script_name="$(expr "${vars_script_name:-}" : '^.*sh: [0-9]*: \(.*\):')" ;
-  fi
-else  # unrecognized shell or dash being sourced from within a user's script
-  # shellcheck disable=SC2296
-  # force a shell error msg; which should contain this script's path/filename
-  # sample error msg shown; assume this file is named "vars.sh"; as required by setvars.sh
-  vars_script_name="$( (echo "${.sh.file}") 2>&1 )" || : ;
-  if [ "$(printf "%s" "$vars_script_name" | grep -Eq "^.+: [0-9]+: .*vars\.sh: " ; echo $?)" -eq 0 ] ; then # dash
-    # .*: 164: intel/oneapi/vars.sh: Bad substitution
-    vars_script_name="$(expr "${vars_script_name:-}" : '^.*: [0-9]*: \(.*\):')" ;
-  else
-    vars_script_name="" ;
-  fi
-fi
-
-if [ "" = "$vars_script_name" ] ; then
-  >&2 echo "   ERROR: Unable to proceed: possible causes listed below."
-  >&2 echo "   This script must be sourced. Did you execute or source this script?" ;
-  >&2 echo "   Unrecognized/unsupported shell (supported: bash, zsh, ksh, m/lksh, dash)." ;
-  >&2 echo "   May fail in dash if you rename this script (assumes \"vars.sh\")." ;
-  >&2 echo "   Can be caused by sourcing from ZSH version 4.x or older." ;
-  return 255 2>/dev/null || exit 255
-fi
-
-
-my_script_name=$(basename -- "${vars_script_name:-}")
-my_script_path=$(get_script_path "${vars_script_name:-}")
-component_root=$(dirname -- "${my_script_path}")
-
-C_INCLUDE_PATH=$(prepend_path "${component_root}/include" "${C_INCLUDE_PATH:-}") ; export C_INCLUDE_PATH
-CPLUS_INCLUDE_PATH=$(prepend_path "${component_root}/include" "${CPLUS_INCLUDE_PATH:-}") ; export CPLUS_INCLUDE_PATH
-
-CMAKE_PREFIX_PATH=$(prepend_path "${component_root}/lib/cmake/pti" "${CMAKE_PREFIX_PATH:-}") ; export CMAKE_PREFIX_PATH
-
-LD_LIBRARY_PATH=$(prepend_path "${component_root}/lib" "${LD_LIBRARY_PATH:-}") ; export LD_LIBRARY_PATH
-
-LIBRARY_PATH=$(prepend_path "${component_root}/lib" "${LIBRARY_PATH:-}") ; export LIBRARY_PATH
-
-#
-# This variable allows cmake to find PTI in conda environments to
-# bypass the overwriting of the LD_LIBRARY_PATH
-#
-Pti_DIR=${component_root}/lib/cmake/pti; export Pti_DIR
diff --git a/sdk/include/pti/pti.h b/sdk/include/pti/pti.h
deleted file mode 100644
index 650d28e3..00000000
--- a/sdk/include/pti/pti.h
+++ /dev/null
@@ -1,152 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef INCLUDE_PTI_H_
-#define INCLUDE_PTI_H_
-
-#include "pti/pti_export.h"
-#include "pti/pti_version.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/* @brief Maximum device UUID size in bytes. */
-#define PTI_MAX_DEVICE_UUID_SIZE  16
-
-/**
- * @brief ABI compatibility/static assert helper for public PTI types
- *
- * If any of these assertions fail, it indicates an ABI-breaking change
- * in a public PTI API type or definition.
- */
-#if defined(__cplusplus)
-#define PTI_STATIC_ASSERT(cond, msg) static_assert(cond, msg)
-#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
-#define PTI_STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
-#else
-/* Fallback for pre-C11: declares an array with a negative size, so a false
-   condition is a compile error. Repeatedly declaring one extern array with a
-   compatible type is valid C89/C99, so this needs no per-assertion unique name;
-   a typedef-based form would need one, and can only be safely redefined in C11
-   (-Wtypedef-redefinition). Deriving that name from __LINE__ collides whenever
-   two PTI headers assert on the same line, and __COUNTER__ is diagnosed under
-   -pedantic by compilers that expose it as a C2y extension. */
-#define PTI_STATIC_ASSERT(cond, msg) \
-    extern char pti_static_assertion_failed[(cond) ? 1 : -1]
-#endif
-
-/**
- * @brief Return/Error codes
- */
-typedef enum {
-  PTI_SUCCESS = 0,                        //!< success
-  PTI_STATUS_END_OF_BUFFER = 1,           //!< end of buffer reached, e.g., in ptiViewGetNextRecord
-  PTI_ERROR_NOT_IMPLEMENTED = 2,          //!< functionality not implemented
-  PTI_ERROR_BAD_ARGUMENT = 3,             //!< invalid argument
-  PTI_ERROR_NO_CALLBACKS_SET = 4,         //!< error due to no callbacks set via ptiViewSetCallbacks
-  PTI_ERROR_EXTERNAL_ID_QUEUE_EMPTY = 5,  //!< empty external ID-queue while working with
-                                          //!< PTI_VIEW_EXTERNAL_CORRELATION
-  PTI_ERROR_BAD_TIMESTAMP = 6,            //!< error in timestamp conversion, might be related with the user
-                                          //!< provided TimestampCallback
-  PTI_ERROR_BAD_API_ID = 7,               //!< invalid api_id when enable/disable runtime/driver specific api_id
-  PTI_ERROR_NO_GPU_VIEWS_ENABLED = 8,     //!< at least one Level Zero GPU view kind must be enabled
-                                          //!< (see ptiCallbackSubscribe for the list)
-  PTI_ERROR_COLLECTOR_UNAVAILABLE = 9,  //!< collector required for the requested tracing
-                                         //!< is unavailable
-
-  PTI_ERROR_DRIVER = 50,                  //!< unknown driver error
-  PTI_ERROR_TRACING_NOT_INITIALIZED = 51,  //!< installed driver requires tracing enabling with
-                                           //!< setting environment variable ZE_ENABLE_TRACING_LAYER
-                                           //!< to 1
-  PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED = 52,  //!< no Local profiling support in the installed
-                                                    //!< driver
-  PTI_ERROR_METRICS_ENABLE_FAILED = 98,  //!< metrics collection could not be enabled on all devices
-                                         //!< present in the system, see ptiMetricsEnable
-  PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED = 99,  //!< installed driver does not support
-                                                      //!< enabling metrics collection at runtime
-                                                      //!< via ptiMetricsEnable; metrics must
-                                                      //!< instead be enabled at process startup by
-                                                      //!< setting the environment variable
-                                                      //!< ZET_ENABLE_METRICS to 1
-  PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED = 100, //!< metrics collection not running
-  PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED = 101, //!< metrics collection not stopped
-  PTI_ERROR_METRICS_COLLECTION_NOT_PAUSED = 102, //!< metrics collection not paused
-  PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED = 103, //!< metrics collection already paused
-  PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED = 104, //!< metrics collection already running
-  PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION = 105, //!< bad metrics collection configuration
-  PTI_ERROR_METRICS_NO_DATA_COLLECTED = 106, //!< Calculate called on empty collection
-
-  PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND = 151, //!< One or more requested metrics not found across all metrics groups
-  PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP = 152, //!< When requested metrics cannot be collected within one metrics group
-
-  PTI_ERROR_METRICS_SCOPE_OUT_OF_MEMORY = 153, //!< Out of memory during metrics scope operation
-  PTI_ERROR_METRICS_SCOPE_COLLECTION_BUFFER_TOO_SMALL = 154, //!< Size of the buffer is not enough 
-                                                             //!< to fit even one Metrics Scope collection
-  PTI_ERROR_METRICS_SCOPE_INSUFFICIENT_BUFFER = 155, //!< Insufficient buffer for metrics scope operation
-  PTI_ERROR_METRICS_SCOPE_INVALID_COLLECTION_BUFFER = 156,  //!< Invalid collection buffer in metrics scope
-  PTI_WARN_METRICS_SCOPE_PARTIAL_BUFFER = 157,  //!< Warning: partial buffer populated in metrics scope
-  PTI_WARN_BUFFER_NOT_FINALIZED = 158, //!< Warning: current buffer not finalized, cannot create new buffer
-  PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM = 159, //!< Requested devices are not the same type
-
-  PTI_ERROR_INTERNAL = 200,  //!< internal error
-
-  PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED = 250,  //!< another PC sampling handle is already enabled
-  PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED = 251,  //!< handle is not in the required configuration state;
-                                               //!< kept for backward compatibility, configuration
-                                               //!< failures are reported with
-                                               //!< PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL
-  PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED = 252,  //!< handle is already configured - not in the initial state for configuration
-  PTI_ERROR_PC_SAMPLING_ALREADY_STARTED = 253,  //!< collection is already running
-  PTI_ERROR_PC_SAMPLING_NOT_STARTED = 254,  //!< collection has not started yet
-  PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED = 255,  //!< collection is already stopped
-  PTI_ERROR_PC_SAMPLING_NOT_STOPPED = 256,  //!< collection is not stopped yet
-  PTI_ERROR_PC_SAMPLING_UNSUPPORTED = 257,  //!< PC sampling is not supported on the current system configuration (e.g. no devices with EUStallSampling support found)
-  PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL = 258,  //!< PC sampling configuration failed, e.g. none of the requested devices supports PC sampling
-  PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED = 259,  //!< Warning: collection stopped, but no EU stall data was received; the profiling window may be too short
-  PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV = 260,  //!< collection buffer size is overridden by PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE
-
-  PTI_RESULT_FORCE_UINT32 = 0x7fffffff
-} pti_result;
-
-PTI_STATIC_ASSERT(sizeof(pti_result) == sizeof(uint32_t), "pti_result enum should be equal to size of uint32_t");
-
-/**
- * @brief Helper function to return stringified enum members for pti_result
- *
- * @return const char*
- */
-PTI_EXPORT const char* ptiResultTypeToString(pti_result result_value);
-
-
-/**
- * @brief Abstraction for backend-specific objects.
- *
- * Level Zero is currently the only supported backend. However, these types will attempt to serve other backends.
- * In case the other backend supported - the same types will serve it.
- */
-
-typedef void* pti_device_handle_t;  //!< Device handle
-
-typedef void* pti_backend_ctx_t;    //!< Backend context handle
-
-typedef void* pti_backend_queue_t;  //!< Backend queue handle
-
-typedef void* pti_backend_evt_t;    //!< Backend event handle
-
-typedef void* pti_backend_command_list_t; //!< Backend command list handle
-
-typedef void* pti_backend_kernel_t; //!< Backend kernel object handle
-
-typedef void* pti_backend_module_t; //!< Backend module object handle
-
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // INCLUDE_PTI_H_
diff --git a/sdk/include/pti/pti_callback.h b/sdk/include/pti/pti_callback.h
deleted file mode 100644
index efd1892c..00000000
--- a/sdk/include/pti/pti_callback.h
+++ /dev/null
@@ -1,281 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_CALLBACK_H_
-#define PTI_CALLBACK_H_
-
-#include <stdint.h>
-
-#include "pti/pti.h"
-#include "pti/pti_view.h"
-
-/**
- * This file contains APIs that are so far experimental in PTI.
- * APIs and data structures in this file are work-in-progress and subject to change!
- * All content in this file concerns the Callback API.
- *
- * The Callback API is useful for many purposes,
- * including the implementation of `MetricsScope` functionality that needs to subscribe to
- * domains such as kernel append to a command list, and potentially other domains.
- * `MetricsScope` and `PcSampling` are internal users of the Callback API.
- */
-
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-typedef struct _pti_callback_subscriber* pti_callback_subscriber_handle;
-
-typedef enum _pti_callback_domain {
-  PTI_CB_DOMAIN_INVALID                            = 0,
-  PTI_CB_DOMAIN_DRIVER_CONTEXT_CREATED             = 1, //!< Not implemented yet
-                                                     //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-
-  PTI_CB_DOMAIN_DRIVER_MODULE_LOADED               = 2, //!< Not implemented yet
-                                                     //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-
-  PTI_CB_DOMAIN_DRIVER_MODULE_UNLOADED             = 3, //!< Not implemented yet
-                                                     //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-
-  PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED      = 4, //!< Synchronous callback
-                                                     //!< This also serves as PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED
-                                                     //!< when appended to Immediate Command List,
-                                                     //!< which means no separate callback PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED
-
-  PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED    = 5, //!< Not implemented yet
-                                                     //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-
-  PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED     = 6, //!< Asynchronous callback, always has only EXIT phase of some API,
-                                                      //!< where completed operations are collected and reported
-
-  PTI_CB_DOMAIN_DRIVER_HOST_SYNCHRONIZATION        = 7, //!< Not implemented yet
-                                                     //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-
-  PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED              = 8, //!< Synchronous callback fired around
-                                                     //!< kernel creation. Carries the freshly created
-                                                     //!< kernel handle, owning module, and kernel name.
-
-  PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED            = 9, //!< Synchronous callback fired around
-                                                     //!< kernel destruction. Carries the kernel handle being
-                                                     //!< destroyed.
-
-  PTI_CB_DOMAIN_DRIVER_API                         = 1023, //!< Not implemented yet,
-                                                        //!< attempt to enable it will return PTI_ERROR_NOT_IMPLEMENTED
-                                                        //!< Callback created for all Driver APIs
-  // below domains to inform user about PTI internal events
-  PTI_CB_DOMAIN_INTERNAL_THREADS                = 1024, //!< Not implemented yet
-  PTI_CB_DOMAIN_INTERNAL_EVENT                  = 1025, //!< Not implemented yet
-
-  PTI_CB_DOMAIN_MAX                             = 0x7fffffff
-} pti_callback_domain;
-
-PTI_STATIC_ASSERT(sizeof(pti_callback_domain) == sizeof(uint32_t), "pti_callback_domain enum should be equal to size of uint32_t");
-
-typedef enum _pti_callback_phase {
-  PTI_CB_PHASE_INVALID                 = 0,
-  PTI_CB_PHASE_API_ENTER               = 1,
-  PTI_CB_PHASE_API_EXIT                = 2,
-  PTI_CB_PHASE_INTERNAL_THREAD_START   = 3,
-  PTI_CB_PHASE_INTERNAL_THREAD_END     = 4,
-  PTI_CB_PHASE_INTERNAL_EVENT          = 5,
-
-  PTI_CB_PHASE_MAX                     = 0x7fffffff
-} pti_callback_phase;
-
-PTI_STATIC_ASSERT(sizeof(pti_callback_phase) == sizeof(uint32_t), "pti_callback_phase enum should be equal to size of uint32_t");
-
-typedef enum _pti_backend_command_list_type {
-  PTI_BACKEND_COMMAND_LIST_TYPE_UNKNOWN   = (1<<0),
-  PTI_BACKEND_COMMAND_LIST_TYPE_IMMEDIATE = (1<<1),
-  PTI_BACKEND_COMMAND_LIST_TYPE_MUTABLE   = (1<<2),
-
-  PTI_BACKEND_COMMAND_LIST_TYPE_MAX       = 0x7fffffff
-} pti_backend_command_list_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_backend_command_list_type) == sizeof(uint32_t), "pti_backend_command_list_type enum should be equal to size of uint32_t");
-
-/**
- * A user can subscribe to notifications about non-standard situations from PTI
- * when it collects or processes the data
- */
-typedef enum _pti_internal_event_type {
-  PTI_INTERNAL_EVENT_TYPE_INFO       = 0,
-  PTI_INTERNAL_EVENT_TYPE_WARNING    = 1, // one or a few records data inconsistencies, or other
-                                          // collection is safe to continue
-  PTI_INTERNAL_EVENT_TYPE_CRITICAL   = 2, // critical error after which further collected data are invalid
-
-  PTI_INTERNAL_EVENT_TYPE_MAX        = 0x7fffffff
-} pti_internal_event_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_internal_event_type) == sizeof(uint32_t), "pti_internal_event_type enum should be equal to size of uint32_t");
-
-typedef enum _pti_gpu_operation_kind {
-  PTI_GPU_OPERATION_KIND_INVALID         = 0,
-  PTI_GPU_OPERATION_KIND_KERNEL          = 1,
-  PTI_GPU_OPERATION_KIND_MEMORY          = 2,
-  PTI_GPU_OPERATION_KIND_OTHER           = 3,
-
-  PTI_GPU_OPERATION_KIND_MAX             = 0x7fffffff
-} pti_gpu_operation_kind;
-
-PTI_STATIC_ASSERT(sizeof(pti_gpu_operation_kind) == sizeof(uint32_t), "pti_gpu_operation_kind enum should be equal to size of uint32_t");
-
-typedef struct _pti_gpu_op_details {
-  pti_gpu_operation_kind             _operation_kind; //!< Kind of the operation: kernel, mem op
-  uint64_t                           _operation_id;   //!< GPU kernel or memory operation instance ID,
-                                                      //!< uniquely throughout the process
-  uint64_t                           _kernel_handle;  //!< a handle uniquely identifying kernel object as
-                                                      //!< contained in the module at the specific offset
-                                                      //!< it will be zero in case of not implemented yet or
-                                                      //!< for memory operations
-  const char*                        _name;           //!< symbolic name of a kernel or memcpy operation
-} pti_gpu_op_details;
-
-typedef struct _pti_callback_gpu_op_data {
-  pti_callback_domain             _domain;              //!< domain of the callback
-  pti_backend_command_list_type   _cmd_list_properties; //!< immediate, mutable,..
-  pti_backend_command_list_t      _cmd_list_handle;     //!< Device back-end command list handle,
-                                                        //!< could be nullptr if unknown or
-                                                        //!< when several operations with different command lists
-                                                        //!< reported together
-  pti_backend_queue_t             _queue_handle;        //!< Device back-end queue handle,
-                                                        //!< could be nullptr if unknown
-                                                        //!< when several operations with different command lists
-                                                        //!< reported together
-  pti_device_handle_t             _device_handle;       //!< Device handle
-  pti_callback_phase              _phase;               //!< PTI_CB_PHASE_API_ENTER/EXIT
-  uint32_t                        _return_code;         //!< will be valid only for L0 API EXIT, for others will be zero
-  uint32_t                  _correlation_id;    //!< ID that corresponds to the same call reported by View API records
-  uint32_t                  _operation_count;   //!< number of operations appended or dispatched to the GPU
-  pti_gpu_op_details*       _operation_details; //!< pointer to details of operation(s) appended, dispatched or completed
-} pti_callback_gpu_op_data;
-
-typedef struct _pti_callback_kernel_data {
-  pti_callback_domain  _domain;          //!< PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED or
-                                         //!< PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED
-  pti_callback_phase   _phase;           //!< PTI_CB_PHASE_API_ENTER / PTI_CB_PHASE_API_EXIT
-  uint32_t             _return_code;     //!< Driver return code; valid only on EXIT phase, 0 otherwise
-  uint32_t             _correlation_id;  //!< Correlation id matching driver API view records
-  uint64_t             _kernel_handle;   //!< a handle uniquely identifying kernel object as
-                                         //!< contained in the module at the specific offset
-                                         //!< it will be zero in case of not implemented yet
-  pti_backend_kernel_t _device_kernel_handle; //!< Per device kernel object handle.
-                                         //!<   - CREATED, ENTER : nullptr (not yet created)
-                                         //!<   - CREATED, EXIT  : non-null on success, nullptr otherwise
-                                         //!<   - DESTROYED, ENTER/EXIT : the handle being destroyed
-  pti_device_handle_t _device_handle;    //!< Device handle associated with the kernel
-  pti_backend_module_t _module_handle;   //!< Owning module handle. Populated for KERNEL_CREATED,
-                                         //!< nullptr for KERNEL_DESTROYED.
-  const char*          _name;            //!< Kernel name (lifetime: valid only during the callback).
-                                         //!< Populated for KERNEL_CREATED (from kernel descriptor).
-                                         //!< nullptr for KERNEL_DESTROYED.
-} pti_callback_kernel_data;
-
-typedef struct _pti_internal_callback_data {
-  pti_callback_domain  _domain;       //!< domain of the callback
-  pti_callback_phase   _phase;        //!< THREAD START/END or INTERNAL EVENT
-  uint32_t             _detail;       //!< depending on the domain should be casted/interpreted
-                                      //!< as a purpose of an internal PTI thread or
-                                      //!< pti_internal_event_type
-  const char*          _message;      //!< explains details
-} pti_internal_callback_data;
-
-typedef void (*pti_callback_function)(
-  pti_callback_domain  domain,
-  pti_api_group_id     driver_api_group_id, //!< driver API group ID, keep it to distinguish between L0 and OpenCL
-                                            //!< although the current implementation is only for L0
-  uint32_t             driver_api_id,
-  pti_backend_ctx_t    backend_context,     //!< Driver (L0) level context handle
-  void*                cb_data, //!< depending on the domain, it should be type-casted to the pointer to:
-                                //!<   - pti_callback_gpu_op_data for GPU_OPERATION_APPENDED / GPU_OPERATION_COMPLETED
-                                //!<   - pti_callback_kernel_data for KERNEL_CREATED / KERNEL_DESTROYED
-                                //!<   - pti_internal_callback_data for the internal domains
-  void*                global_user_data,    //!< Any global data defined by user returned
-                                            //!< to every callback from a same subscriber
-  void**         instance_user_data);       //!< Data that could be passed between ENTER and EXIT
-                                            //!< phases of one API call
-
-/**
- * Callback API functions
- * None of the PTI API functions should be called from within a Callback function.
- * Exceptions are helper functions that return character representations of enums,
- * and ptiViewPushExternalCorrelationId / ptiViewPopExternalCorrelationId.
- */
-
-/**
- * @brief Initialize Callback subscriber
- *
- * A Level Zero GPU view kind must be enabled with ptiViewEnable first. These are:
- * PTI_VIEW_DEVICE_GPU_KERNEL, PTI_VIEW_DEVICE_GPU_MEM_COPY, PTI_VIEW_DEVICE_GPU_MEM_FILL,
- * PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P, PTI_VIEW_DEVICE_SYNCHRONIZATION and PTI_VIEW_DRIVER_API.
- * PTI_VIEW_RUNTIME_API and PTI_VIEW_EXTERNAL_CORRELATION do not count.
- *
- * @param subscriber - subscriber handle
- * @param callback   - pointer to the callback function
- * @param user_data  - user data to be passed to the callback function
- * @return pti_result
- *         - PTI_ERROR_NO_GPU_VIEWS_ENABLED if none of the Level Zero GPU view kinds listed above is enabled
- */
-pti_result PTI_EXPORT
-ptiCallbackSubscribe(pti_callback_subscriber_handle* subscriber,
-                     pti_callback_function    callback,
-                     void* user_data);
-
-/**
- * @brief Unsubscribe Callback subscriber. This unsubscribes from all domains, disables the callback,
- *        cleans up all resources related to the subscriber handle, and invalidates the handle.
- */
-pti_result PTI_EXPORT
-ptiCallbackUnsubscribe(pti_callback_subscriber_handle subscriber);
-
-/**
- * @brief Enables callbacks on specific domain
- *
- * @param subscriber - subscriber handle
- * @param domain     - domain to enable
- * @param enter_cb   - indicate if callback called on enter/start: 0-no, 1-yes; used only for domains with 2 phases
- * @param exit_cb    - indicates if callback is called on exit/end: 0-no, 1-yes; used only for domains with 2 phases
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiCallbackEnableDomain(pti_callback_subscriber_handle subscriber,
-                        pti_callback_domain  domain,
-                        uint32_t enter_cb,
-                        uint32_t exit_cb);
-
-/**
- * @brief Disables callbacks for specific domain
- */
-pti_result PTI_EXPORT
-ptiCallbackDisableDomain(pti_callback_subscriber_handle subscriber,
-                         pti_callback_domain  domain);
-
-/**
- * @brief Disables the callback of the subscriber for all domains
- */
-pti_result PTI_EXPORT
-ptiCallbackDisableAllDomains(pti_callback_subscriber_handle subscriber);
-
-/**
- * @brief Helper function to return stringified enum members for pti_callback_domain
- *
- * @return const char*
- */
-PTI_EXPORT const char* ptiCallbackDomainTypeToString(pti_callback_domain domain);
-
-/**
- * @brief Helper function to return stringified enum members for pti_callback_phase
- *
- * @return const char*
- */
-PTI_EXPORT const char* ptiCallbackPhaseTypeToString(pti_callback_phase phase);
-
-#if defined(__cplusplus)
-}
-#endif
-#endif  // PTI_CALLBACK_H_
diff --git a/sdk/include/pti/pti_driver_levelzero_api_ids.h b/sdk/include/pti/pti_driver_levelzero_api_ids.h
deleted file mode 100644
index 23bee4de..00000000
--- a/sdk/include/pti/pti_driver_levelzero_api_ids.h
+++ /dev/null
@@ -1,273 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_API_ID_DRIVER_LEVELZERO_H_
-#define PTI_API_ID_DRIVER_LEVELZERO_H_
-
-// ========= This file is autogenerated - do not modify ========
-// ========= Api file version used for generation: =============
-//    ApiFile: ze_api.h
-// ApiVersion: * @version v1.17-r1.17.24
-
-//             https://github.com/oneapi-src/level-zero.git
-//             commit: d3b3efbdaa27a0aef9a9812cc8fa4260557c1e7c - v1.32.0
-
-
-typedef enum _pti_api_id_driver_levelzero {
-    reserved_driver_levelzero_id=0,
-    zeInit_id=1,
-    zeDriverGet_id=2,
-    zeDriverGetApiVersion_id=3,
-    zeDriverGetProperties_id=4,
-    zeDriverGetIpcProperties_id=5,
-    zeDriverGetExtensionProperties_id=6,
-    zeDeviceGet_id=7,
-    zeDeviceGetSubDevices_id=8,
-    zeDeviceGetProperties_id=9,
-    zeDeviceGetComputeProperties_id=10,
-    zeDeviceGetModuleProperties_id=11,
-    zeDeviceGetCommandQueueGroupProperties_id=12,
-    zeDeviceGetMemoryProperties_id=13,
-    zeDeviceGetMemoryAccessProperties_id=14,
-    zeDeviceGetCacheProperties_id=15,
-    zeDeviceGetImageProperties_id=16,
-    zeDeviceGetExternalMemoryProperties_id=17,
-    zeDeviceGetP2PProperties_id=18,
-    zeDeviceCanAccessPeer_id=19,
-    zeDeviceGetStatus_id=20,
-    zeContextCreate_id=21,
-    zeContextDestroy_id=22,
-    zeContextGetStatus_id=23,
-    zeContextSystemBarrier_id=24,
-    zeContextMakeMemoryResident_id=25,
-    zeContextEvictMemory_id=26,
-    zeContextMakeImageResident_id=27,
-    zeContextEvictImage_id=28,
-    zeCommandQueueCreate_id=29,
-    zeCommandQueueDestroy_id=30,
-    zeCommandQueueExecuteCommandLists_id=31,
-    zeCommandQueueSynchronize_id=32,
-    zeCommandListCreate_id=33,
-    zeCommandListCreateImmediate_id=34,
-    zeCommandListDestroy_id=35,
-    zeCommandListClose_id=36,
-    zeCommandListReset_id=37,
-    zeCommandListAppendWriteGlobalTimestamp_id=38,
-    zeCommandListAppendBarrier_id=39,
-    zeCommandListAppendMemoryRangesBarrier_id=40,
-    zeCommandListAppendMemoryCopy_id=41,
-    zeCommandListAppendMemoryFill_id=42,
-    zeCommandListAppendMemoryCopyRegion_id=43,
-    zeCommandListAppendMemoryCopyFromContext_id=44,
-    zeCommandListAppendImageCopy_id=45,
-    zeCommandListAppendImageCopyRegion_id=46,
-    zeCommandListAppendImageCopyToMemory_id=47,
-    zeCommandListAppendImageCopyFromMemory_id=48,
-    zeCommandListAppendMemoryPrefetch_id=49,
-    zeCommandListAppendMemAdvise_id=50,
-    zeCommandListAppendSignalEvent_id=51,
-    zeCommandListAppendWaitOnEvents_id=52,
-    zeCommandListAppendEventReset_id=53,
-    zeCommandListAppendQueryKernelTimestamps_id=54,
-    zeCommandListAppendLaunchKernel_id=55,
-    zeCommandListAppendLaunchCooperativeKernel_id=56,
-    zeCommandListAppendLaunchKernelIndirect_id=57,
-    zeCommandListAppendLaunchMultipleKernelsIndirect_id=58,
-    zeImageGetProperties_id=59,
-    zeImageCreate_id=60,
-    zeImageDestroy_id=61,
-    zeMemAllocShared_id=62,
-    zeMemAllocDevice_id=63,
-    zeMemAllocHost_id=64,
-    zeMemFree_id=65,
-    zeMemGetAllocProperties_id=66,
-    zeMemGetAddressRange_id=67,
-    zeMemGetIpcHandle_id=68,
-    zeMemOpenIpcHandle_id=69,
-    zeMemCloseIpcHandle_id=70,
-    zeFenceCreate_id=71,
-    zeFenceDestroy_id=72,
-    zeFenceHostSynchronize_id=73,
-    zeFenceQueryStatus_id=74,
-    zeFenceReset_id=75,
-    zeEventPoolCreate_id=76,
-    zeEventPoolDestroy_id=77,
-    zeEventPoolGetIpcHandle_id=78,
-    zeEventPoolOpenIpcHandle_id=79,
-    zeEventPoolCloseIpcHandle_id=80,
-    zeEventCreate_id=81,
-    zeEventDestroy_id=82,
-    zeEventHostSignal_id=83,
-    zeEventHostSynchronize_id=84,
-    zeEventQueryStatus_id=85,
-    zeEventHostReset_id=86,
-    zeEventQueryKernelTimestamp_id=87,
-    zeModuleCreate_id=88,
-    zeModuleDestroy_id=89,
-    zeModuleDynamicLink_id=90,
-    zeModuleGetNativeBinary_id=91,
-    zeModuleGetGlobalPointer_id=92,
-    zeModuleGetKernelNames_id=93,
-    zeModuleGetProperties_id=94,
-    zeModuleGetFunctionPointer_id=95,
-    zeModuleBuildLogDestroy_id=96,
-    zeModuleBuildLogGetString_id=97,
-    zeKernelCreate_id=98,
-    zeKernelDestroy_id=99,
-    zeKernelSetCacheConfig_id=100,
-    zeKernelSetGroupSize_id=101,
-    zeKernelSuggestGroupSize_id=102,
-    zeKernelSuggestMaxCooperativeGroupCount_id=103,
-    zeKernelSetArgumentValue_id=104,
-    zeKernelSetIndirectAccess_id=105,
-    zeKernelGetIndirectAccess_id=106,
-    zeKernelGetSourceAttributes_id=107,
-    zeKernelGetProperties_id=108,
-    zeKernelGetName_id=109,
-    zeSamplerCreate_id=110,
-    zeSamplerDestroy_id=111,
-    zePhysicalMemCreate_id=112,
-    zePhysicalMemDestroy_id=113,
-    zeVirtualMemReserve_id=114,
-    zeVirtualMemFree_id=115,
-    zeVirtualMemQueryPageSize_id=116,
-    zeVirtualMemMap_id=117,
-    zeVirtualMemUnmap_id=118,
-    zeVirtualMemSetAccessAttribute_id=119,
-    zeVirtualMemGetAccessAttribute_id=120,
-    zeInitDrivers_id=121,
-    zeRTASBuilderCreateExp_id=122,
-    zeRTASBuilderGetBuildPropertiesExp_id=123,
-    zeRTASBuilderBuildExp_id=124,
-    zeRTASBuilderDestroyExp_id=125,
-    zeRTASParallelOperationCreateExp_id=126,
-    zeRTASParallelOperationGetPropertiesExp_id=127,
-    zeRTASParallelOperationJoinExp_id=128,
-    zeRTASParallelOperationDestroyExp_id=129,
-    zeDriverGetExtensionFunctionAddress_id=130,
-    zeDriverGetLastErrorDescription_id=131,
-    zeDriverRTASFormatCompatibilityCheckExp_id=132,
-    zeDeviceGetGlobalTimestamps_id=133,
-    zeDeviceImportExternalSemaphoreExt_id=134,
-    zeDeviceReleaseExternalSemaphoreExt_id=135,
-    zeDeviceReserveCacheExt_id=136,
-    zeDeviceSetCacheAdviceExt_id=137,
-    zeDevicePciGetPropertiesExt_id=138,
-    zeDeviceGetFabricVertexExp_id=139,
-    zeDeviceGetRootDevice_id=140,
-    zeContextCreateEx_id=141,
-    zeCommandQueueGetOrdinal_id=142,
-    zeCommandQueueGetIndex_id=143,
-    zeCommandListGetNextCommandIdWithKernelsExp_id=144,
-    zeCommandListUpdateMutableCommandKernelsExp_id=145,
-    zeCommandListAppendSignalExternalSemaphoreExt_id=146,
-    zeCommandListAppendWaitExternalSemaphoreExt_id=147,
-    zeCommandListAppendImageCopyToMemoryExt_id=148,
-    zeCommandListAppendImageCopyFromMemoryExt_id=149,
-    zeCommandListHostSynchronize_id=150,
-    zeCommandListCreateCloneExp_id=151,
-    zeCommandListGetDeviceHandle_id=152,
-    zeCommandListGetContextHandle_id=153,
-    zeCommandListGetOrdinal_id=154,
-    zeCommandListImmediateGetIndex_id=155,
-    zeCommandListIsImmediate_id=156,
-    zeCommandListImmediateAppendCommandListsExp_id=157,
-    zeCommandListGetNextCommandIdExp_id=158,
-    zeCommandListUpdateMutableCommandsExp_id=159,
-    zeCommandListUpdateMutableCommandSignalEventExp_id=160,
-    zeCommandListUpdateMutableCommandWaitEventsExp_id=161,
-    zeEventQueryTimestampsExp_id=162,
-    zeEventQueryKernelTimestampsExt_id=163,
-    zeEventGetEventPool_id=164,
-    zeEventGetSignalScope_id=165,
-    zeEventGetWaitScope_id=166,
-    zeEventPoolPutIpcHandle_id=167,
-    zeEventPoolGetContextHandle_id=168,
-    zeEventPoolGetFlags_id=169,
-    zeImageGetMemoryPropertiesExp_id=170,
-    zeImageViewCreateExp_id=171,
-    zeImageGetAllocPropertiesExt_id=172,
-    zeImageViewCreateExt_id=173,
-    zeImageGetDeviceOffsetExp_id=174,
-    zeKernelSetGlobalOffsetExp_id=175,
-    zeKernelGetBinaryExp_id=176,
-    zeKernelSchedulingHintExp_id=177,
-    zeMemFreeExt_id=178,
-    zeMemGetIpcHandleFromFileDescriptorExp_id=179,
-    zeMemGetFileDescriptorFromIpcHandleExp_id=180,
-    zeMemPutIpcHandle_id=181,
-    zeMemSetAtomicAccessAttributeExp_id=182,
-    zeMemGetAtomicAccessAttributeExp_id=183,
-    zeMemGetPitchFor2dImage_id=184,
-    zeModuleInspectLinkageExt_id=185,
-    zeFabricEdgeGetExp_id=186,
-    zeFabricEdgeGetVerticesExp_id=187,
-    zeFabricEdgeGetPropertiesExp_id=188,
-    zeFabricVertexGetExp_id=189,
-    zeFabricVertexGetSubVerticesExp_id=190,
-    zeFabricVertexGetPropertiesExp_id=191,
-    zeFabricVertexGetDeviceExp_id=192,
-    zelTracerSetEnabled_id=193,
-    zelTracerCreate_id=194,
-    zeRTASBuilderCreateExt_id=195,
-    zeRTASBuilderGetBuildPropertiesExt_id=196,
-    zeRTASBuilderBuildExt_id=197,
-    zeRTASBuilderCommandListAppendCopyExt_id=198,
-    zeRTASBuilderDestroyExt_id=199,
-    zeRTASParallelOperationCreateExt_id=200,
-    zeRTASParallelOperationGetPropertiesExt_id=201,
-    zeRTASParallelOperationJoinExt_id=202,
-    zeRTASParallelOperationDestroyExt_id=203,
-    zeDriverRTASFormatCompatibilityCheckExt_id=204,
-    zeDeviceGetVectorWidthPropertiesExt_id=205,
-    zeDeviceSynchronize_id=206,
-    zeDriverGetDefaultContext_id=207,
-    zeCommandListAppendLaunchKernelWithParameters_id=208,
-    zeCommandListAppendLaunchKernelWithArguments_id=209,
-    zeKernelGetAllocationPropertiesExp_id=210,
-    zeDeviceGetAggregatedCopyOffloadIncrementValue_id=211,
-    zeEventCounterBasedCreate_id=212,
-    zeEventCounterBasedGetIpcHandle_id=213,
-    zeEventCounterBasedOpenIpcHandle_id=214,
-    zeEventCounterBasedCloseIpcHandle_id=215,
-    zeEventCounterBasedGetDeviceAddress_id=216,
-    zeMemGetIpcHandleWithProperties_id=217,
-    zePhysicalMemGetProperties_id=218,
-    zeDeviceGetRuntimeRequirements_id=219,
-    zeDeviceGetRuntimeRequirementsKey_id=220,
-    zeDeviceValidateRuntimeRequirements_id=221,
-    zeDeviceGetCounterBasedEventMaxValue_id=222,
-    zeCommandQueueGetFlags_id=223,
-    zeCommandQueueGetMode_id=224,
-    zeCommandQueueGetPriority_id=225,
-    zeCommandListAppendMemoryCopyWithParameters_id=226,
-    zeCommandListAppendMemoryFillWithParameters_id=227,
-    zeCommandListImmediateAppendCommandListsWithParameters_id=228,
-    zeCommandListGetFlags_id=229,
-    zeCommandListImmediateGetFlags_id=230,
-    zeCommandListImmediateGetMode_id=231,
-    zeCommandListImmediateGetPriority_id=232,
-    zeCommandListIsMutableExp_id=233,
-    zeCommandListBeginGraphCaptureExt_id=234,
-    zeCommandListBeginCaptureIntoGraphExt_id=235,
-    zeCommandListIsGraphCaptureEnabledExt_id=236,
-    zeCommandListEndGraphCaptureExt_id=237,
-    zeCommandListGetGraphExt_id=238,
-    zeCommandListAppendGraphExt_id=239,
-    zeCommandListAppendHostFunction_id=240,
-    zeEventGetCounterBasedFlags_id=241,
-    zeExecutableGraphGetSourceGraphExt_id=242,
-    zeExecutableGraphDestroyExt_id=243,
-    zeGraphCreateExt_id=244,
-    zeGraphGetPrimaryCommandListExt_id=245,
-    zeGraphSetDestructionCallbackExt_id=246,
-    zeGraphInstantiateExt_id=247,
-    zeGraphIsEmptyExt_id=248,
-    zeGraphDumpContentsExt_id=249,
-    zeGraphDestroyExt_id=250,
- } pti_api_id_driver_levelzero;
-
-#endif
diff --git a/sdk/include/pti/pti_metrics.h b/sdk/include/pti/pti_metrics.h
deleted file mode 100644
index 6cdfd6a9..00000000
--- a/sdk/include/pti/pti_metrics.h
+++ /dev/null
@@ -1,344 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef INCLUDE_PTI_METRICS_H_
-#define INCLUDE_PTI_METRICS_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "pti/pti.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/*****************************************************************************
-                                 DEVICE
-*****************************************************************************/
-
-typedef struct _pti_pci_properties_t {
-  uint8_t _domain;
-  uint8_t _bus;
-  uint8_t _device;
-  uint8_t _function;
-} pti_pci_properties_t;
-
-typedef struct _pti_device_properties_t {
-  pti_device_handle_t _handle;                    //!< Internal handle to device
-  pti_pci_properties_t _address;                  //!< PCI device properties
-  const char* _model_name;                        //!< Model name of the device
-  uint8_t _uuid[PTI_MAX_DEVICE_UUID_SIZE];        //!< Universal unique identifier
-  /* we can also get number of sub devices, serial number (char[]), board number(char[]), brand name(char[]),
-  vendor name(char[]), driver version(char[]), device type and flags */
-} pti_device_properties_t;
-
-
-/*****************************************************************************
-                           METRIC ENABLE/DISABLE
-*****************************************************************************/
-
-/**
- * @brief Enable metrics collection for a device or all devices
- *
- * This function enables metrics collection on the specified device. Before calling ptiMetricsGetDevices and
- * other similar functions, ptiMetricsEnable must be called.
- *
- * @param[in] device                        Device handle. If NULL, enables metrics for all devices.
- *
- * @return pti_result
- *         - PTI_SUCCESS: Metrics enabled successfully
- *         - PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED: Feature not supported by driver; env ZET_ENABLE_METRICS=1 needs to be set
- *         - PTI_ERROR_DRIVER: Driver error during enable operation, or no devices found
- *         - PTI_ERROR_NOT_IMPLEMENTED: pti library not loaded or does not export this API
- *         - PTI_ERROR_INTERNAL: Internal error
- */
-pti_result PTI_EXPORT
-ptiMetricsEnable(pti_device_handle_t device);
-
-/**
- * @brief Disable metrics collection for a device or all devices
- *
- * This function disables metrics collection on the specified device. Every ptiMetricsEnable call
- * must be matched with a ptiMetricsDisable call.
- *
- * @param[in] device                        Device handle. If NULL, disables metrics for all devices.
- *
- * @return pti_result
- *         - PTI_SUCCESS: Metrics disabled successfully (or reference count decremented)
- *         - PTI_ERROR_DRIVER: Driver error during disable operation
- *         - PTI_ERROR_NOT_IMPLEMENTED: pti library not loaded or does not export this API
- *         - PTI_ERROR_INTERNAL: Internal error
- */
-pti_result PTI_EXPORT
-ptiMetricsDisable(pti_device_handle_t device);
-
-
-/*****************************************************************************
-                                 METRIC
-*****************************************************************************/
-
-typedef void* pti_metric_handle_t; //!< Abstraction of a metric handle within PTI
-
-/// @brief Supported value types
-typedef enum _pti_metric_value_type {
-  PTI_METRIC_VALUE_TYPE_UINT32 = 0,              //!< 32-bit unsigned-integer
-  PTI_METRIC_VALUE_TYPE_UINT64 = 1,              //!< 64-bit unsigned-integer
-  PTI_METRIC_VALUE_TYPE_FLOAT32 = 2,             //!< 32-bit floating-point
-  PTI_METRIC_VALUE_TYPE_FLOAT64 = 3,             //!< 64-bit floating-point
-  PTI_METRIC_VALUE_TYPE_BOOL8 = 4,               //!< 8-bit boolean
-  PTI_METRIC_VALUE_TYPE_STRING = 5,              //!< C string
-  PTI_METRIC_VALUE_TYPE_UINT8 = 6,               //!< 8-bit unsigned-integer
-  PTI_METRIC_VALUE_TYPE_UINT16 = 7,              //!< 16-bit unsigned-integer
-
-  PTI_METRIC_VALUE_TYPE_FORCE_UINT32 = 0x7fffffff
-} pti_metric_value_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_metric_value_type) == sizeof(uint32_t), "pti_metric_value_type enum should be equal to size of uint32_t");
-
-/// @brief Metric types
-typedef enum _pti_metric_type {
-  PTI_METRIC_TYPE_DURATION = 0,                  //!< duration
-  PTI_METRIC_TYPE_EVENT = 1,                     //!< event
-  PTI_METRIC_TYPE_EVENT_WITH_RANGE = 2,          //!< event with range
-  PTI_METRIC_TYPE_THROUGHPUT = 3,                //!< throughput
-  PTI_METRIC_TYPE_TIMESTAMP = 4,                 //!< timestamp
-  PTI_METRIC_TYPE_FLAG = 5,                      //!< flag
-  PTI_METRIC_TYPE_RATIO = 6,                     //!< ratio
-  PTI_METRIC_TYPE_RAW = 7,                       //!< raw
-  PTI_METRIC_TYPE_IP = 0x7ffffffe,               //!< instruction pointer
-
-  PTI_METRIC_TYPE_FORCE_UINT32 = 0x7fffffff
-
-} pti_metric_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_metric_type) == sizeof(uint32_t), "pti_metric_type enum should be equal to size of uint32_t");
-
-typedef union _pti_value_t {
-    uint32_t ui32;                               //!< 32-bit unsigned-integer
-    uint64_t ui64;                               //!< 64-bit unsigned-integer
-    float fp32;                                  //!< 32-bit floating-point
-    double fp64;                                 //!< 64-bit floating-point
-    bool b8;                                     //!< 8-bit boolean
-} pti_value_t;
-
-typedef struct _pti_metric_properties_t {
-  pti_metric_handle_t _handle;                   //!< Internal handle for the metric
-  const char* _name;                             //!< Name of the metric
-  const char* _description;                      //!< Description of the metric
-  /* Can also get Component and tier number*/
-  pti_metric_type _metric_type;                  //!< Type of the metric
-  pti_metric_value_type _value_type;             //!< Value type of the metric
-  const char* _units;                            //!< The units of the metric result values
-} pti_metric_properties_t;
-
-/*******************************************************************************
-                                 METRIC GROUP
-*******************************************************************************/
-
-typedef void* pti_metrics_group_handle_t; //!< Abstraction of a metric group handle within PTI
-
-typedef enum _pti_metrics_group_type {
-  PTI_METRIC_GROUP_TYPE_EVENT_BASED = 0x01,    //!< Event based sampling (Query)
-  PTI_METRIC_GROUP_TYPE_TIME_BASED = 0x02,     //!< Time based sampling (Stream)
-  PTI_METRIC_GROUP_TYPE_TRACE_BASED = 0x04,    //!< Not supported
-
-  PTI_METRIC_GROUP_TYPE_FORCE_UINT32 = 0x7fffffff
-} pti_metrics_group_type;
-
-typedef struct _pti_metrics_group_properties_t {
-  pti_metrics_group_handle_t _handle;            //!< Internal handle for the metric group
-  pti_metrics_group_type _type;                  //!< Sampling type of the metric group
-  uint32_t _domain;                              //!< Hardware domain responsible for collecting the metric group
-  uint32_t _metric_count;                        //!< Number of metrics in the metric group
-  pti_metric_properties_t* _metric_properties;   //!< Convenience pointer to buffer where metric properties in the metric group can be saved
-                                                 // The pointer is initialized to null. User is responsible for allocating buffer of size _metric_count
-                                                 // and calling the ptiMetricsGetMetricsProperties function to get the metric properties populated
-                                                 // This pointer does not need to be used, it is part of the pti_metrics_group_properties_t for convenience
-                                                 // only. It is useful when traversing the buffer of metric group properties and then metric properties in
-                                                 // each group without needing to keep additional maps. User may choose to use a different pointer for metric
-                                                 // properties.
-  const char* _name;                             //!< Name of the metric group
-  const char* _description;                      //!< Description of the metric group
-} pti_metrics_group_properties_t;
-
-/**
- * @brief Get the properties of all devices on the system on which metric collection can be done
- * usage: 1- Call ptiMetricsEnable(NULL) to enable metrics collection on all devices, before calling ptiMetricsGetDevices.
- *        2- Call ptiMetricsGetDevices(NULL, device_count) to discover the required buffer size; the required buffer size will be written to device_count.
- *        3- Allocate devices buffer of size sizeof(pti_device_properties_t) * device_count
- *        4- Call ptiMetricsGetDevices(devices, device_count) to get the properties of the discovered devices written to devices
- *
- * @param[in/out] devices                   Pointer to the array of devices. If NULL, the number of devices is returned in *device_count
- *                                          if not NULL, it should point to the buffer of size: sizeof(pti_device_properties_t) * (*device_count)
- * @param[in/out] device_count              Number of devices
- *                                          in - if devices is NULL or if device_count is less than the required minimum buffer size,
- *                                          device_count will contain the required buffer size
- *                                          out - devices buffer size used
- *                                          Note: device_count cannot be NULL
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsGetDevices(pti_device_properties_t* devices,
-                       uint32_t* device_count);
-
-/**
- * @brief Get the properties of the metric groups supported by the device
- * Usage: 1- Call ptiMetricsEnable(NULL) to enable metrics collection on all devices, before calling ptiMetricsGetMetricGroups.
- *        2- Call ptiMetricsGetMetricGroups(device_handle, null, metrics_group_count) to discover the required buffer size; the required buffer size will be written
- *        to metrics_group_count.
- *        3- Allocate metrics_groups buffer of size sizeof(pti_metrics_group_properties_t) * metrics_group_count
- *        4- Call ptiMetricsGetMetricGroups(device_handle, metrics_groups, metrics_group_count) again to get the properties of the discovered metric groups written
- *           to the supplied buffer
- *
- * @param[in] device_handle                  Device handle
- * @param[in/out] metrics_groups             Buffer where to save metric group properties for the metric groups that can be collected.
- *                                           Set to null to discover the required buffer size
- * @param[in/out] metrics_group_count        If metrics_groups is set to null or metrics_group_count is less than the required minimum buffer size,
- *                                           metrics_group_count will contain the metric group count
- *                                           Otherwise, metrics_group_count will contain actual metric group count
- *                                           Note: metrics_group_count cannot be null
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsGetMetricGroups(pti_device_handle_t device_handle,
-                            pti_metrics_group_properties_t* metrics_groups,
-                            uint32_t *metrics_group_count);
-
-/**
- * @brief Get properties for all metrics in a metric group.
- * Usage: 1- Call ptiMetricsEnable(NULL) to enable metrics collection on all devices, before calling ptiMetricsGetMetricsProperties.
- *        2- Get available metric groups on a specified device using ptiMetricsGetMetricGroups
- *        3- In the metric group properties structure of the metric group of interest, allocate buffer _metric_properties of size sizeof(pti_metric_properties_t) * _metric_count
- *        4- call ptiMetricsGetMetricsProperties(metrics_group_handle, _metric_properties) to get the metric properties written to the supplied buffer
- *
- * @param[in] metrics_group_handle           Metric group handle
- * @param[in/out] metrics                    Buffer where to save metric properties for the specified metric group
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsGetMetricsProperties(pti_metrics_group_handle_t metrics_group_handle,
-                                pti_metric_properties_t* metrics);
-
-typedef struct _pti_metrics_group_collection_params_t {
-  size_t _struct_size;                            //!< [in] Size of the pti_metrics_group_collection_params_t struct used for backwards compatibility
-  pti_metrics_group_handle_t _group_handle;       //!< [in] Metric group handle.
-  uint32_t _sampling_interval;                    //!< [in] Set the sampling interval in nsec.
-                                                  //!<      This field is applicable for PTI_METRIC_GROUP_TYPE_TIME_BASED metrics groups only.
-  uint64_t _time_aggr_window;                     //!< [in] Unused, ignored.
-} pti_metrics_group_collection_params_t;
-
-/**
- * @brief Configure metric groups of interest. Call ptiMetricsEnable to enable metrics collection before calling ptiMetricsConfigureCollection.
- * Note: only 1 metric group can be specified at this time (metrics_group_count must be 1).
- * Time-based and event-based metric groups are supported.
- *
- * @param[in] device_handle                  Device handle
- * @param[in] metrics_group_collection_params Buffer of input parameters structures. Note: only 1 is supported at this time
- * @param[in] metrics_group_count            Number of configuration structures in the configuration buffer
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsConfigureCollection(pti_device_handle_t device_handle,
-                                pti_metrics_group_collection_params_t *metrics_group_collection_params,
-                                uint32_t metrics_group_count);
-
-/**
- * @brief Start metrics collection on specified device
- * Note:
- * 1. Call ptiMetricsEnable to enable metrics collection before starting the collection.
- * 2. ptiMetricsConfigureCollection must be called first to configure the metric group(s) of interest
- *
- * @param[in] device_handle                  Device handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsStartCollection(pti_device_handle_t device_handle);
-
-/**
- * @brief Start metrics collection on specified device in paused mode
- * Note:
- * 1. Call ptiMetricsEnable to enable metrics collection before starting the collection.
- * 2. ptiMetricsConfigureCollection must be called first to configure the metric group(s) of interest
- *
- * @param[in] device_handle                  Device handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsStartCollectionPaused(pti_device_handle_t device_handle);
-
-/**
- * @brief Pause metrics collection on specified device
- * Note: Collection  must be started first
- *
- * @param[in] device_handle                  Device handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsPauseCollection(pti_device_handle_t device_handle);
-
-/**
- * @brief Resume metrics collection on specified device
- * Note: Collection must be started and paused
- *
- * @param[in] device_handle                  Device handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsResumeCollection(pti_device_handle_t device_handle);
-
-/**
- * @brief stop metrics collection on specified device
- * Note: ptiMetricsStartCollection must be called first to start the collection
- * This function terminates the collection but does not process the data
- * @param[in] device_handle                  Device handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsStopCollection(pti_device_handle_t device_handle);
-
-/**
- * @brief process and dump collected data on specified device
- * Note: ptiMetricsStopCollection must be called first to process collected data
- * ptiMetricsGetCalculatedData can only be called once after the collection is stopped and cannot be called between pause and resume
- *
- * usage: 1- Call ptiMetricsGetCalculatedData(device_handle, metrics_group_handle, NULL, metrics_values_count) to discover the required buffer size for
- *           data collected for the specified metric group on on the specified device ;
- *           the required buffer size will be written to value_count in multiples of pti_value_t.
- *        2- Allocate metrics_values_buffer for holding  metrics_values_count values
- *        3- Call ptiMetricsGetCalculatedData(device_handle, metrics_group_handle, metrics_values_buffer, metrics_values_count) to get the values written to buffer
- * A sample contains a 64bit value container for each metric in the metric group.
- * based on the metric's value type, the 64bit value container should be converted appropriately.
- *
- * @param[in] device_handle                 Device handle
- * @param[in] metrics_group_handle          Metric Group handle
- * @param[in/out] metrics_values_buffer     Buffer where to save collected samples
- *                                          Set to null to discover the required buffer size
- * @param[in/out] metrics_values_count      If metrics_values_buffer is set to null, metrics_values_count will contain the number of pti_value_t
- *                                          values the buffer needs to be able to hold
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsGetCalculatedData(pti_device_handle_t device_handle,
-                          pti_metrics_group_handle_t metrics_group_handle,
-                          pti_value_t* metrics_values_buffer,
-                          uint32_t* metrics_values_count);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // INCLUDE_PTI_METRICS_H_
diff --git a/sdk/include/pti/pti_metrics_scope.h b/sdk/include/pti/pti_metrics_scope.h
deleted file mode 100644
index f32275a2..00000000
--- a/sdk/include/pti/pti_metrics_scope.h
+++ /dev/null
@@ -1,336 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_API_PTI_METRICS_SCOPE_H_
-#define SRC_API_PTI_METRICS_SCOPE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "pti/pti.h"
-#include "pti/pti_metrics.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/**
- * This file contains the PTI MetricsScope API that enables collecting GPU hardware metrics for
- * individual GPU kernels submitted by the application.
- * Such collection might be more practical for users than time-based collection.
- *
- * MetricsScope operates in three phases:
- * - Configuration
- * - Collection
- * - Metrics evaluation
- *
- * Configuration flow:
- *   0. Enable a Level Zero GPU view kind with ptiViewEnable (e.g. PTI_VIEW_DEVICE_GPU_KERNEL;
- *      see ptiCallbackSubscribe in pti_callback.h for the list); ptiMetricsScopeStartCollection
- *      fails with PTI_ERROR_NO_GPU_VIEWS_ENABLED otherwise
- *   1. Call ptiMetricsScopeEnable to create a scope collection handle
- *   2. (optional) Call ptiMetricsGetDevices to get available devices (defined in pti_metrics.h);
- *                 needed only to profile an explicit list of devices
- *   3. Call ptiMetricsScopeConfigure to pass the desired metrics and the devices to profile:
- *                 either an explicit list of devices, or none to profile every device the workload uses
- *   4. (optional) Call ptiMetricsScopeQueryCollectionBufferSize to query the estimated buffer size
- *   5. (optional) Call ptiMetricsScopeSetCollectionBufferSize to set the desired collection buffer size;
- *                 a default of 2048 bytes is used if this is skipped
- *
- * Collection is initiated by calling ptiMetricsScopeStartCollection
- * and ended by calling ptiMetricsScopeStopCollection.
- *
- * For the Collection and Metrics evaluation phases, there are 2 types of buffers that MetricsScope deals with:
- *  Collection buffers - buffers that accumulate raw data during collection;
- *                       mostly black boxes for users;
- *                       one buffer contains data for one specific device;
- *                       owned by PTI;
- *                       buffer size (same for all) is setup by the user during the configuration phase;
- *                       PTI allocates buffers on demand during collection
- *
- *  Metrics buffers    - buffers where PTI populates requested metrics after collection has stopped,
- *                       taking collection buffer(s) as input;
- *                       owned by the user;
- *                       contain a set of uniform records of pti_metrics_scope_record_t type
- */
-
-typedef struct _pti_scope_collection_handle_t* pti_scope_collection_handle_t;
-
-/**
- * @brief MetricsScope collection modes
- */
-typedef enum _pti_metrics_scope_mode_t {
-    PTI_METRICS_SCOPE_INVALID_MODE = 0,          //!< Invalid mode
-    PTI_METRICS_SCOPE_AUTO_KERNEL = 1,           //!< Automatic per GPU kernel collection
-    PTI_METRICS_SCOPE_USER = 2,                  //!< User-controlled scope (not implemented at the moment)
-
-    PTI_METRICS_SCOPE_MODE_FORCE_UINT32 = 0x7fffffff
-} pti_metrics_scope_mode_t;
-
-PTI_STATIC_ASSERT(sizeof(pti_metrics_scope_mode_t) == sizeof(uint32_t), "pti_metrics_scope_mode_t enum should be equal to size of uint32_t");
-
-/**
- * @brief Collection Buffer properties structure
- */
-typedef struct _pti_metrics_scope_collection_buffer_properties_t {
-    size_t              _struct_size;                   //!< To be set by the user prior to passing a pointer to this structure to the PTI API
-    pti_device_handle_t _device_handle;                 //!< Device for which data is contained in the buffer
-    size_t              _num_scopes;                    //!< Number of scopes/records in the buffer
-    size_t              _buffer_size;                   //!< Size of the collection buffer used in bytes
-    uint64_t            _host_time_first_scope_append;  //!< Currently not populated
-    uint64_t            _host_time_last_scope_append;   //!< Currently not populated
-    const char*         _metric_group_name;             //!< Pointer to Metrics Group name; can be used for informational purposes;
-                                                        //!< valid until ptiMetricsScopeDisable is called
-} pti_metrics_scope_collection_buffer_properties_t;
-
-/**
- * @brief Scope record structure
- *
- * Its size depends on the number of requested metrics.
- * These records are uniformly populated in the Metrics Buffer
- */
-typedef struct _pti_metrics_scope_record_t {
-    uint64_t            _kernel_id;                  //!< Unique identifier for the kernel instance
-    pti_backend_queue_t _queue;                      //!< Command queue handle
-    const char*         _kernel_name;                //!< Pointer to kernel name,
-                                                     //!< guaranteed to be valid for the lifetime of the parent MetricsScope
-    pti_value_t*        _metrics_values;             //!< Array of metric values
-} pti_metrics_scope_record_t;
-
-/**
- * @brief Scope record metadata structure that describes the metrics stored in pti_metrics_scope_record_t
- */
-typedef struct _pti_metrics_scope_record_metadata_t {
-    size_t                  _struct_size;        //!< To be set by the user prior to passing a pointer to this structure to the PTI API
-    size_t                  _metrics_count;      //!< Number of metrics per scope record
-                                                 //!< and size of each of the three following arrays
-    pti_metric_value_type*  _value_types;        //!< Array of metric value types
-                                                 //!< valid until ptiMetricsScopeDisable is called
-    const char**            _metric_names;       //!< Array of metric names
-                                                 //!< valid until ptiMetricsScopeDisable is called
-    const char**            _metric_units;       //!< Array of metric units
-                                                 //!< valid until ptiMetricsScopeDisable is called
-} pti_metrics_scope_record_metadata_t;
-
-/**
- * @brief Allocate and initialize the scope collection handle
- * Usage: Call this function first to create a scope collection handle before configuring metrics collection
- *
- * @param[out] scope_collection_handle       Pointer to store the scope collection handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeEnable(pti_scope_collection_handle_t* scope_collection_handle);
-
-/**
- * @brief Configure MetricsScope collection
- *
- * @param[in] scope_collection_handle        Scope collection handle obtained from ptiMetricsScopeEnable
- * @param[in] collection_mode                Collection mode;
- *                                           currently only PTI_METRICS_SCOPE_AUTO_KERNEL is supported
- * @param[in] devices_to_profile             Array of device handles for target devices;
- *                                           NULL (with device_count 0) profiles every device the workload uses;
- *                                           all devices profiled by one MetricsScope must report the same
- *                                           _model_name in pti_device_properties_t. With NULL, this is checked
- *                                           across every device returned by ptiMetricsGetDevices, not only the
- *                                           ones the workload uses; on systems with mixed GPU models, pass an
- *                                           explicit list of same-model devices
- * @param[in] device_count                   Number of devices in the devices_to_profile array;
- *                                           must be 0 if devices_to_profile is NULL
- * @param[in] metric_names                   Array of metric names to collect
- * @param[in] metric_count                   Number of metric names in the metric_names array
- *
- * @return pti_result
- *         - PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM if the devices to profile (with NULL, all devices
- *           returned by ptiMetricsGetDevices) do not all report the same _model_name
- *
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeConfigure(pti_scope_collection_handle_t scope_collection_handle,
-                         pti_metrics_scope_mode_t collection_mode,
-                         pti_device_handle_t* devices_to_profile,
-                         uint32_t device_count,
-                         const char** metric_names,
-                         size_t metric_count);
-
-/**
- * @brief Query the estimated collection buffer size required for collecting metrics for the specified scope count
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] scopes_number                  Number of scopes to estimate collection buffer size
- * @param[out] estimated_buffer_size         Pointer to store the estimated collection buffer size in bytes
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeQueryCollectionBufferSize(pti_scope_collection_handle_t scope_collection_handle,
-                                         size_t scopes_number,
-                                         size_t* estimated_buffer_size);
-
-/**
- * @brief Set the collection buffer size to be used during collection
- * Note: As soon as the first such buffer is full, PTI will allocate a second one and so on.
- * Calling this is optional; a default of 2048 bytes is used otherwise.
- * Values below 2048 bytes (including 0) are clamped up to 2048.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] buffer_size                    Size of the collection buffer in bytes for later allocation
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeSetCollectionBufferSize(pti_scope_collection_handle_t scope_collection_handle,
-                                       size_t buffer_size);
-
-
-/**
- * @brief Start metrics scope collection
- *
- * @param[in] scope_collection_handle        Scope collection handle
- *
- * @return pti_result
- *         - PTI_ERROR_NO_GPU_VIEWS_ENABLED if no Level Zero GPU view kind is enabled
- *           (see ptiCallbackSubscribe in pti_callback.h for the list)
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeStartCollection(pti_scope_collection_handle_t scope_collection_handle);
-
-/**
- * @brief Stop metrics scope collection
- *
- * @param[in] scope_collection_handle        Scope collection handle
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeStopCollection(pti_scope_collection_handle_t scope_collection_handle);
-
-/**
- * @brief Disable MetricsScope and free all associated resources
- *
- * @param[in] scope_collection_handle        Scope collection handle to cleanup
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeDisable(pti_scope_collection_handle_t scope_collection_handle);
-
-/**
- * @brief Get the number of collection buffers available
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[out] buffer_count                  Pointer to store the number of available collection buffers
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeGetCollectionBuffersCount(pti_scope_collection_handle_t scope_collection_handle,
-                                         size_t* buffer_count);
-
-/**
- * @brief Get the collection buffer of the specified index and its size
- * Note: The size might be handy for future usage when such buffers might be stored by the user
- * for fully offline processing.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] buffer_index                   Index of the collection buffer to retrieve
- * @param[out] buffer                        Pointer to store the collection buffer address
- * @param[out] buffer_size                   Pointer to store the collection buffer size in bytes
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeGetCollectionBuffer(pti_scope_collection_handle_t scope_collection_handle,
-                                   size_t buffer_index,
-                                   void** buffer,
-                                   size_t* buffer_size);
-
-/**
- * @brief Get information about the collection buffer
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] collection_buffer              Collection buffer to query properties for
- * @param[in/out] props                      Pointer to store the collection buffer properties;
- *                                           user must not forget to initialize props->_struct_size prior to the call
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeGetCollectionBufferProperties(
-    pti_scope_collection_handle_t scope_collection_handle,
-    void* collection_buffer,
-    pti_metrics_scope_collection_buffer_properties_t* props);
-
-/**
- * @brief Query for the required metrics buffer size for storing calculated metrics records
- *
- * This function calculates the exact metrics buffer size needed to store all records
- * from a collection buffer, including space for strings and metric values.
- *
- * @param[in] scope_collection_handle           Scope collection handle
- * @param[in] collection_buffer                 Collection buffer to query
- * @param[out] required_metrics_buffer_size     Required metrics buffer size in bytes
- * @param[out] records_count                    Number of records that will be stored
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeQueryMetricsBufferSize(pti_scope_collection_handle_t scope_collection_handle,
-                                     void* collection_buffer,
-                                     size_t* required_metrics_buffer_size,
-                                     size_t* records_count);
-
-/**
- * @brief Calculate metrics from collection data and populate into user-provided metrics buffer
- * Usage:   The user must first call ptiMetricsScopeQueryMetricsBufferSize to determine
- *          the required metrics buffer size, then allocate the metrics buffer and call this function.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] collection_buffer              Collection buffer containing raw metrics data
- * @param[in] metrics_buffer                 User metrics buffer for storing records
- * @param[in] metrics_buffer_size            Size of metrics_buffer in bytes
- * @param[out] records_count                 Number of records that will be/were written to the metrics buffer
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeCalculateMetrics(pti_scope_collection_handle_t scope_collection_handle,
-                                void* collection_buffer,
-                                void* metrics_buffer,
-                                size_t metrics_buffer_size,
-                                size_t* records_count);
-
-
-/**
- * @brief Get metadata for user's metrics buffer in a scope collection
- * This function provides type and unit information for all requested metrics.
- * Call this function to get metadata per scope that applies to all records in all buffers.
- *
- * The metadata structure contains direct pointers to metric information stored within the 
- * scope collection handle. These pointers remain valid until ptiMetricsScopeDisable is called.
- * 
- * Usage:
- *  - User must set metadata->_struct_size = sizeof(pti_metrics_scope_record_metadata_t) before calling
- *  - Function populates metadata->_metrics_count and the three array pointers
- *  - No memory allocation is performed by this function
- *  - Returned pointers reference internal scope collection data (no copying)
- *
- * @param[in] scope_collection_handle    Scope collection handle
- * @param[out] metadata                  Metadata structure to populate
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiMetricsScopeGetMetricsMetadata(pti_scope_collection_handle_t scope_collection_handle,
-                                  pti_metrics_scope_record_metadata_t* metadata);
-
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // SRC_API_PTI_METRICS_SCOPE_H_
diff --git a/sdk/include/pti/pti_pc_sampling.h b/sdk/include/pti/pti_pc_sampling.h
deleted file mode 100644
index ce8e2ab2..00000000
--- a/sdk/include/pti/pti_pc_sampling.h
+++ /dev/null
@@ -1,409 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_H_
-#define PTI_PC_SAMPLING_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "pti/pti.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/**
- * This file defines the PTI PC Sampling (GPU EU Stall Sampling) API for collecting statistical
- * per-instruction active or categorized stall samples.
- * 
- * This API is experimental and subject to change without deprecation in future releases.
- *
- * Configuration:
- *   1. Call ptiPcSamplingEnable to create a collection handle
- *   2. Call ptiPcSamplingConfigure to select the device to profile and the sampling period (optional).
- *      Skip it to collect with the default configuration: the first device that supports PC sampling
- *      and the default sampling period of 100000 ns. When used, it must be called before
- *      ptiPcSamplingStartCollection.
- *   3. Call ptiPcSamplingQueryCollectionBufferSize to query the effective collection buffer size (optional)
- *   4. Call ptiPcSamplingSetCollectionBufferSize to set the collection buffer size (optional)
- *
- * Collection:
- *   5. Call ptiPcSamplingStartCollection to begin sampling
- *   6. Call ptiPcSamplingStopCollection to end sampling
- *
- * Data retrieval (called only after ptiPcSamplingStopCollection):
- *   7. Call ptiPcSamplingGetStallReasons to obtain stall reason information shared by all profiled devices (optional)
- *   8. Call ptiPcSamplingGetProfiledDevices to obtain profiled devices
- *   9. Call ptiPcSamplingGetDeviceStatus to obtain per-device collection status (optional)
- *  10. For each profiled device, call ptiPcSamplingGetObservedKernelHandles to obtain kernel handles with samples
- *  11. For each kernel handle, call ptiPcSamplingGetObservedKernelInfo to obtain kernel metadata
- *  12. For each kernel handle, call ptiPcSamplingGetSamplesPerInstruction to collect instruction-level sampling data
- *
- * Cleanup:
- *  13. Call ptiPcSamplingDisable to free all PTI-owned resources
- *
- * Device support:
- *   - Only one device is sampled per collection handle. With no configuration (or devices == NULL)
- *     PTI picks the first device that supports PC sampling, in Level Zero enumeration order;
- *     pass an explicit list to choose another (the first supported device in the list is used).
- *   - Future multi-device support is expected to provide two flows:
- *     1. The caller explicitly selects devices to profile.
- *     2. The caller passes NULL for the device array and PTI profiles devices
- *        that execute compute workloads.
- *
- * Memory ownership:
- *   - The caller allocates and frees all caller-owned buffers.
- *   - All const char* pointers returned by PTI remain valid until PTI library
- *     teardown, even if reached through PTI-owned structures (like pti_pc_sampling_source_info_t)
- *     that are valid until ptiPcSamplingDisable.
- *   - PTI-managed per-device collection buffers remain valid until
- *     ptiPcSamplingDisable.
- *
- * Array count semantics:
- *   Many functions in this API follow a two-call pattern: first query the
- *   required output count, then call again with a caller-allocated buffer.
- *   The second call should ideally use the same count returned by the first
- *   call. If a different count is supplied:
- *   - If the supplied count is smaller than required, PTI fills only that many
- *     result entries.
- *   - If the supplied count is larger than required, PTI updates only the
- *     output count to the actual number of result entries.
- *
- */
-
-typedef struct _pti_pc_sampling_handle_t* pti_pc_sampling_handle_t;
-
-/**
- * @brief Stall reason name and description entry
- */
-typedef struct _pti_pc_sampling_stall_reason_info_t {
-  size_t  _struct_size;                           //!< Size of this structure; user settable; required
-  const char*  _name;                             //!< Reason name; owned by PTI
-  const char*  _description;                      //!< Reason description; owned by PTI
-} pti_pc_sampling_stall_reason_info_t;
-
-/**
- * @brief Source information for a single instruction.
- * Owned by PTI; valid until ptiPcSamplingDisable.
- */
-typedef struct _pti_pc_sampling_source_info_t {
-  const char*  _file_path;                        //!< Source file path; null if unavailable; owned by PTI
-  uint64_t  _file_line;                           //!< Source line number; 0 if unavailable
-} pti_pc_sampling_source_info_t;
-
-/**
- * @brief Per-instruction sampling metrics
- */
-typedef struct _pti_pc_sampling_instruction_t {
-  uint64_t  _instruction_offset;                  //!< Instruction offset within kernel
-  pti_pc_sampling_source_info_t*  _source_info;   //!< Source information; currently always null (source line mapping is not implemented yet)
-} pti_pc_sampling_instruction_t;
-
-/**
- * @brief Kernel information returned by ptiPcSamplingGetObservedKernelInfo
- */
-typedef struct _pti_pc_sampling_kernel_info_t {
-  size_t  _struct_size;                           //!< Size of this structure; user settable; required
-  pti_device_handle_t  _device;                   //!< Device on which the kernel ran
-  uint64_t  _kernel_handle;                       //!< Unique kernel identifier
-  const char*  _kernel_name;                      //!< Kernel name; owned by PTI
-  size_t  _reason_count;                          //!< Number of stall reasons with samples for this kernel
-  size_t  _instructions_with_samples_count;       //!< Count of instructions that have samples for this kernel
-  uint64_t* _aggregated_samples;                  //!< Array of size _reason_count aggregating stall-sample data for this kernel
-} pti_pc_sampling_kernel_info_t;
-
-/**
- * @brief Per-device PC Sampling collection status
- */
-typedef struct _pti_pc_sampling_device_status_t {
-  size_t  _struct_size;                           //!< Size of this structure; user settable; required
-  pti_device_handle_t  _device;                   //!< Device for which the status is reported
-  uint32_t  _samples_dropped;                     //!< 1 if samples were dropped for the device; 0 otherwise
-  uint64_t  _total_sample_count;                  //!< Total number of collected samples for the device
-  uint64_t  _total_pc_count;                      //!< Total number of sampled PCs for the device
-} pti_pc_sampling_device_status_t;
-
-/**
- * @brief Create a PC Sampling collection handle
- *
- * @param[out] handle            Pointer to store the created handle
- *
- * @return PTI_SUCCESS on successful handle creation
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED if another PC sampling handle is still enabled
- * @return PTI_ERROR_INTERNAL if PTI cannot allocate the collection handle
- * @return PTI_ERROR_PC_SAMPLING_UNSUPPORTED if the PC Sampling is not supported on the current system
- * @return PTI_ERROR_NO_GPU_VIEWS_ENABLED if no Level Zero GPU view kind is enabled (see ptiCallbackSubscribe for the list)
- * @return PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED if the driver cannot enable metrics at runtime;
- *         set ZET_ENABLE_METRICS=1 before the process starts instead
- * @return PTI_ERROR_DRIVER if enabling metrics fails in the driver
- */
-pti_result PTI_EXPORT
-ptiPcSamplingEnable(pti_pc_sampling_handle_t* handle);
-
-/**
- * @brief Configure PC Sampling for a collection handle
- *
- * This call is optional; use it when you need to override the default configuration.
- * It can be called only once and only right after ptiPcSamplingEnable, that is before
- * ptiPcSamplingStartCollection.
- *
- * @param[in] handle               Collection handle
- * @param[in] devices              Device filter; NULL selects the first device that supports PC sampling;
- *                                 otherwise the first supported device in the list is used and unsupported devices are ignored
- * @param[in] device_count         Number of entries in devices; ignored when devices is NULL
- * @param[in] sampling_period_ns   Sampling period in nanoseconds for all selected devices; 0 makes PTI use the default period of 100000 ns
- *
- * @return PTI_SUCCESS on successful configuration
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL or devices is not NULL while device_count is 0
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED if handle is already configured (explicitly or by ptiPcSamplingStartCollection) or otherwise not in the initial state required for configuration
- * @return PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL if none of the requested devices supports PC Sampling
- * @return PTI_ERROR_NOT_IMPLEMENTED if API is not present.
- */
-pti_result PTI_EXPORT
-ptiPcSamplingConfigure(pti_pc_sampling_handle_t handle,
-                       const pti_device_handle_t* devices,
-                       size_t device_count,
-                       uint32_t sampling_period_ns);
-
-/**
- * @brief Query the PC Sampling collection buffer size
- *
- * Optional call, returns the collection buffer size that will be used for PC Sampling collection.
- *
- * @param[in]  handle          Collection handle
- * @param[out] buffer_size     Pointer to store the collection buffer size in bytes; cannot be NULL
- *
- * @return PTI_SUCCESS on success
- * @return PTI_ERROR_BAD_ARGUMENT if handle or buffer_size is NULL
- */
-pti_result PTI_EXPORT
-ptiPcSamplingQueryCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                       size_t* buffer_size);
-
-/**
- * @brief Set the PC Sampling collection buffer size
- *
- * Sets the size of the reusable host buffer that drains raw metric reports
- * from the driver. Must be called before ptiPcSamplingStartCollection.
- * A valid PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE environment variable takes
- * precedence; in that case the requested size is ignored.
- *
- * @param[in] handle          Collection handle
- * @param[in] buffer_size     Collection buffer size in bytes for all configured devices;
- *                            must be a positive multiple of 64 bytes, at most 64 MiB
- *
- * @return PTI_SUCCESS on success
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL or buffer_size is out of range or not a multiple of 64 bytes
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_STARTED if collection is running
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED if collection has already been stopped
- * @return PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV if PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE
- *         holds a valid value that overrides buffer_size
- */
-pti_result PTI_EXPORT
-ptiPcSamplingSetCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                     size_t buffer_size);
-
-/**
- * @brief Start PC Sampling collection
- *
- * Applies the default configuration, by calling ptiPcSamplingConfigure with default params,
- * if user does not configure before manually.
- *
- * @param[in] handle             Collection handle
- *
- * @return PTI_SUCCESS when collection is started
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL
- * @return PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL if the default configuration cannot be applied because no device supporting PC Sampling is available
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_STARTED if collection is already running
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED if collection was already stopped
- */
-pti_result PTI_EXPORT
-ptiPcSamplingStartCollection(pti_pc_sampling_handle_t handle);
-
-/**
- * @brief Stop collection
- *
- * Ends the sampling session and makes post-stop query APIs valid. Raw data
- * loading and aggregation are deferred until a later query requests them.
- *
- * @param[in] handle             Collection handle
- *
- * @return PTI_SUCCESS when collection is successfully stopped
- * @return PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED when collection is stopped, but no PC Sampling data was collected
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL
- * @return PTI_ERROR_PC_SAMPLING_NOT_STARTED if collection has not started yet
- * @return PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED if collection was already stopped
- */
-pti_result PTI_EXPORT
-ptiPcSamplingStopCollection(pti_pc_sampling_handle_t handle);
-
-/**
- * @brief Retrieve reason names and descriptions common across all profiled devices
- *
- * This query is independent of collection lifecycle and may be called immediately after
- * ptiPcSamplingEnable succeeds.
- * 
- * Usage: 1- Call ptiPcSamplingGetStallReasons(handle, NULL, reason_count) to discover the required count; the required count will be written to reason_count.
- *        2- Allocate reasons buffer of size sizeof(pti_pc_sampling_stall_reason_info_t) * (*reason_count) and set _struct_size on each element.
- *        3- Call ptiPcSamplingGetStallReasons(handle, reasons, reason_count) again to get the reason information written to the supplied buffer.
- *
- * @param[in]     handle         Collection handle
- * @param[in,out] reasons        Caller-allocated array of *reason_count elements; set to NULL to query the required count
- * @param[in,out] reason_count   In: size of reasons array; Out: required or actual number of reasons; cannot be NULL
- *
- * @return PTI_SUCCESS after successful retrieval of the stall-reason count or entries
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL or reason_count is NULL
- * @return PTI_ERROR_INTERNAL if stall-reason metadata cannot be derived from the configured metric group
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetStallReasons(pti_pc_sampling_handle_t handle,
-                             pti_pc_sampling_stall_reason_info_t* reasons,
-                             size_t* reason_count);
-
-/**
- * @brief Get profiled devices with observed kernels
- *
- * Usage: 1- Call ptiPcSamplingGetProfiledDevices(handle, NULL, device_count) to discover the required count; the required count will be written to device_count.
- *        2- Allocate devices buffer of size sizeof(pti_device_handle_t) * (*device_count).
- *        3- Call ptiPcSamplingGetProfiledDevices(handle, devices, device_count) again to get the profiled device handles.
- *
- * Note that this function will return all devices that could have samples.
- * If there were kernels visible to PTI but no samples were collected for them (e.g. due to short execution time),
- * those devices will still be returned by this function.
- *
- * @param[in]     handle         Collection handle
- * @param[in,out] devices        Caller-allocated array of *device_count elements; set to NULL to query the required count
- * @param[in,out] device_count   In: size of devices array; Out: required or actual number of devices; cannot be NULL
- *
- * @return PTI_SUCCESS after successful retrieval of profiled device information for a stopped collection
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL or device_count is NULL
- * @return PTI_ERROR_PC_SAMPLING_NOT_STOPPED if collection has not reached the stopped state yet
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetProfiledDevices(pti_pc_sampling_handle_t handle,
-                                pti_device_handle_t* devices,
-                                size_t* device_count);
-
-/**
- * @brief Retrieve observed kernel handles for a profiled device
- *
- * Usage: 1- Call ptiPcSamplingGetObservedKernelHandles(handle, device, NULL, kernel_count) to discover the required number of kernel handles.
- *        2- Allocate kernel_handles buffer of size sizeof(uint64_t) * (*kernel_count).
- *        3- Call ptiPcSamplingGetObservedKernelHandles(handle, device, kernel_handles, kernel_count) again to get the kernel handles written to the supplied buffer.
- *
- * @param[in]     handle           Collection handle
- * @param[in]     device           Profiled device handle
- * @param[in,out] kernel_handles   Caller-allocated array of *kernel_count elements; set to NULL to query the required count
- * @param[in,out] kernel_count     In: size of kernel_handles array; Out: required or actual number of kernel handles; cannot be NULL
- *
- * @return PTI_SUCCESS after successful retrieval of the kernel-handle count or entries
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL, kernel_count is NULL, or device does not match the configured device
- * @return PTI_ERROR_PC_SAMPLING_NOT_STOPPED if collection has not reached the stopped state yet
- * @return PTI_ERROR_INTERNAL if cannot collect the kernel-handle count or entries
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetObservedKernelHandles(pti_pc_sampling_handle_t handle,
-                                      pti_device_handle_t device,
-                                      uint64_t* kernel_handles,
-                                      size_t* kernel_count);
-
-/**
- * @brief Retrieve kernel metadata for one observed kernel
- *
- * Caller allocates kernel_info, must set _struct_size, and allocates an
- * _aggregated_samples array of size reason_count from ptiPcSamplingGetStallReasons.
- * If _aggregated_samples is NULL, it is ignored and not populated.
- *
- * @param[in]     handle          Collection handle
- * @param[in]     device          Profiled device handle
- * @param[in]     kernel_handle   Kernel handle returned by ptiPcSamplingGetObservedKernelHandles
- * @param[in,out] kernel_info     Caller-allocated kernel info structure;
- *
- * @return PTI_SUCCESS after successful retrieval of the observed-kernel metadata
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL, device does not match the configured device, kernel_info is NULL, or kernel_info->_struct_size is too small
- * @return PTI_ERROR_PC_SAMPLING_NOT_STOPPED if collection has not reached the stopped state yet
- * @return PTI_ERROR_BAD_ARGUMENT if kernel_handle was not observed during the collection
- * @return PTI_ERROR_INTERNAL if cannot collect the observed-kernel metadata
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetObservedKernelInfo(pti_pc_sampling_handle_t handle,
-                                   pti_device_handle_t device,
-                                   uint64_t kernel_handle,
-                                   pti_pc_sampling_kernel_info_t* kernel_info);
-
-/**
- * @brief Retrieve instruction-level PC Sampling data for one observed kernel on a profiled device
- *
- * Called after ptiPcSamplingGetObservedKernelInfo. The caller allocates:
- *   - instruction_buffer for kernel_info._instructions_with_samples_count elements
- *   - samples_buffer for kernel_info._instructions_with_samples_count * kernel_info._reason_count elements
- *
- * The caller can access the sample count for instruction i and stall reason j with:
- * samples_buffer[i * kernel_info._reason_count + j]
- *
- * @param[in]     handle                   Collection handle
- * @param[in]     device                   Profiled device handle
- * @param[in]     kernel_handle            Kernel handle returned by ptiPcSamplingGetObservedKernelHandles
- * @param[out]    instruction_buffer       Caller-allocated instruction buffer
- * @param[in]     instruction_buffer_count Size of instruction_buffer array
- * @param[out]    samples_buffer           Caller-allocated flattened sample-count buffer
- * @param[in]     samples_buffer_count     Size of samples_buffer array
- *
- * @return PTI_SUCCESS after successful retrieval of the persisted instruction offsets and sample counts
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL, device is NULL, samples_buffer is NULL, instruction_buffer is NULL,
- *                                or device does not match the configured device
- * @return PTI_ERROR_PC_SAMPLING_NOT_STOPPED if collection has not reached the stopped state yet
- * @return PTI_ERROR_INTERNAL if cannot collect the persisted instruction offsets and sample counts
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetSamplesPerInstruction(pti_pc_sampling_handle_t handle,
-                                      pti_device_handle_t device,
-                                      uint64_t kernel_handle,
-                                      pti_pc_sampling_instruction_t* instruction_buffer,
-                                      size_t instruction_buffer_count,
-                                      uint64_t* samples_buffer,
-                                      size_t samples_buffer_count);
-
-/**
- * @brief Retrieve PC Sampling collection status for a profiled device.
- *
- * The returned status reports whether samples were dropped and provides
- * per-device totals for collected samples and sampled PCs.
- *
- * @param[in]     handle            Collection handle
- * @param[in]     device            Profiled device handle
- * @param[in,out] device_status     Caller-allocated device status structure; set _struct_size
- *
- * @return PTI_SUCCESS after successful status retrieval
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL, device is NULL, device_status is NULL,
- *                                or device does not match the configured PC sampling device
- * @return PTI_ERROR_PC_SAMPLING_NOT_STOPPED if collection has not reached the stopped state yet
- * @return PTI_ERROR_INTERNAL if cannot collect device status
- */
-pti_result PTI_EXPORT
-ptiPcSamplingGetDeviceStatus(pti_pc_sampling_handle_t handle,
-                             pti_device_handle_t device,
-                             pti_pc_sampling_device_status_t* device_status);
-
-/**
- * @brief Disable collection and free PTI resources associated with this handle
- *
- * @param[in] handle    Collection handle
- *
- * @return PTI_SUCCESS on successful cleanup
- * @return PTI_ERROR_BAD_ARGUMENT if handle is NULL
- */
-pti_result PTI_EXPORT
-ptiPcSamplingDisable(pti_pc_sampling_handle_t handle);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // PTI_PC_SAMPLING_H_
diff --git a/sdk/include/pti/pti_runtime_sycl_api_ids.h b/sdk/include/pti/pti_runtime_sycl_api_ids.h
deleted file mode 100644
index f2de1a89..00000000
--- a/sdk/include/pti/pti_runtime_sycl_api_ids.h
+++ /dev/null
@@ -1,299 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_API_ID_RUNTIME_SYCL_H_
-#define PTI_API_ID_RUNTIME_SYCL_H_
-
-// ========= This file is autogenerated - do not modify ========
-// ========= Api file version used for generation: =============
-//    ApiFile: ur_api.h
-// ApiVersion:* @version v0.12-r0
-//             https://github.com/oneapi-src/unified-runtime.git
-//             
-
-
-typedef enum _pti_api_id_runtime_sycl {
-    reserved_runtime_sycl_id=0,
-    urContextCreate_id=1,
-    urContextRetain_id=2,
-    urContextRelease_id=3,
-    urContextGetInfo_id=4,
-    urContextGetNativeHandle_id=5,
-    urContextCreateWithNativeHandle_id=6,
-    urContextSetExtendedDeleter_id=7,
-    urDeviceGet_id=8,
-    urDeviceGetInfo_id=9,
-    urDeviceRetain_id=10,
-    urDeviceRelease_id=11,
-    urDevicePartition_id=12,
-    urDeviceSelectBinary_id=13,
-    urDeviceGetNativeHandle_id=14,
-    urDeviceCreateWithNativeHandle_id=15,
-    urDeviceGetGlobalTimestamps_id=16,
-    urEnqueueKernelLaunch_id=17,
-    urEnqueueEventsWait_id=18,
-    urEnqueueEventsWaitWithBarrier_id=19,
-    urEnqueueMemBufferRead_id=20,
-    urEnqueueMemBufferWrite_id=21,
-    urEnqueueMemBufferReadRect_id=22,
-    urEnqueueMemBufferWriteRect_id=23,
-    urEnqueueMemBufferCopy_id=24,
-    urEnqueueMemBufferCopyRect_id=25,
-    urEnqueueMemBufferFill_id=26,
-    urEnqueueMemImageRead_id=27,
-    urEnqueueMemImageWrite_id=28,
-    urEnqueueMemImageCopy_id=29,
-    urEnqueueMemBufferMap_id=30,
-    urEnqueueMemUnmap_id=31,
-    urEnqueueUSMFill_id=32,
-    urEnqueueUSMMemcpy_id=33,
-    urEnqueueUSMPrefetch_id=34,
-    urEnqueueUSMAdvise_id=35,
-    urEnqueueDeviceGlobalVariableWrite_id=38,
-    urEnqueueDeviceGlobalVariableRead_id=39,
-    urEventGetInfo_id=40,
-    urEventGetProfilingInfo_id=41,
-    urEventWait_id=42,
-    urEventRetain_id=43,
-    urEventRelease_id=44,
-    urEventGetNativeHandle_id=45,
-    urEventCreateWithNativeHandle_id=46,
-    urEventSetCallback_id=47,
-    urKernelCreate_id=48,
-    urKernelSetArgValue_id=49,
-    urKernelSetArgLocal_id=50,
-    urKernelGetInfo_id=51,
-    urKernelGetGroupInfo_id=52,
-    urKernelGetSubGroupInfo_id=53,
-    urKernelRetain_id=54,
-    urKernelRelease_id=55,
-    urKernelSetArgPointer_id=56,
-    urKernelSetExecInfo_id=57,
-    urKernelSetArgSampler_id=58,
-    urKernelSetArgMemObj_id=59,
-    urKernelSetSpecializationConstants_id=60,
-    urKernelGetNativeHandle_id=61,
-    urKernelCreateWithNativeHandle_id=62,
-    urMemImageCreate_id=63,
-    urMemBufferCreate_id=64,
-    urMemRetain_id=65,
-    urMemRelease_id=66,
-    urMemBufferPartition_id=67,
-    urMemGetNativeHandle_id=68,
-    urEnqueueReadHostPipe_id=69,
-    urMemGetInfo_id=70,
-    urMemImageGetInfo_id=71,
-    urPlatformGet_id=72,
-    urPlatformGetInfo_id=73,
-    urPlatformGetApiVersion_id=74,
-    urPlatformGetNativeHandle_id=75,
-    urPlatformCreateWithNativeHandle_id=76,
-    urProgramCreateWithIL_id=78,
-    urProgramCreateWithBinary_id=79,
-    urProgramBuild_id=80,
-    urProgramCompile_id=81,
-    urProgramLink_id=82,
-    urProgramRetain_id=83,
-    urProgramRelease_id=84,
-    urProgramGetFunctionPointer_id=85,
-    urProgramGetInfo_id=86,
-    urProgramGetBuildInfo_id=87,
-    urProgramSetSpecializationConstants_id=88,
-    urProgramGetNativeHandle_id=89,
-    urProgramCreateWithNativeHandle_id=90,
-    urQueueGetInfo_id=91,
-    urQueueCreate_id=92,
-    urQueueRetain_id=93,
-    urQueueRelease_id=94,
-    urQueueGetNativeHandle_id=95,
-    urQueueCreateWithNativeHandle_id=96,
-    urQueueFinish_id=97,
-    urQueueFlush_id=98,
-    urSamplerCreate_id=101,
-    urSamplerRetain_id=102,
-    urSamplerRelease_id=103,
-    urSamplerGetInfo_id=104,
-    urSamplerGetNativeHandle_id=105,
-    urSamplerCreateWithNativeHandle_id=106,
-    urUSMHostAlloc_id=107,
-    urUSMDeviceAlloc_id=108,
-    urUSMSharedAlloc_id=109,
-    urUSMFree_id=110,
-    urUSMGetMemAllocInfo_id=111,
-    urUSMPoolCreate_id=112,
-    urCommandBufferCreateExp_id=113,
-    urPlatformGetBackendOption_id=114,
-    urMemBufferCreateWithNativeHandle_id=115,
-    urMemImageCreateWithNativeHandle_id=116,
-    urEnqueueWriteHostPipe_id=117,
-    urUSMPoolRetain_id=118,
-    urUSMPoolRelease_id=119,
-    urUSMPoolGetInfo_id=120,
-    urCommandBufferRetainExp_id=121,
-    urCommandBufferReleaseExp_id=122,
-    urCommandBufferFinalizeExp_id=123,
-    urCommandBufferAppendKernelLaunchExp_id=125,
-    urCommandBufferEnqueueExp_id=128,
-    urUSMPitchedAllocExp_id=132,
-    urBindlessImagesUnsampledImageHandleDestroyExp_id=133,
-    urBindlessImagesSampledImageHandleDestroyExp_id=134,
-    urBindlessImagesImageAllocateExp_id=135,
-    urBindlessImagesImageFreeExp_id=136,
-    urBindlessImagesUnsampledImageCreateExp_id=137,
-    urBindlessImagesSampledImageCreateExp_id=138,
-    urBindlessImagesImageCopyExp_id=139,
-    urBindlessImagesImageGetInfoExp_id=140,
-    urBindlessImagesMipmapGetLevelExp_id=141,
-    urBindlessImagesMipmapFreeExp_id=142,
-    urBindlessImagesMapExternalArrayExp_id=144,
-    urBindlessImagesReleaseExternalSemaphoreExp_id=147,
-    urBindlessImagesWaitExternalSemaphoreExp_id=148,
-    urBindlessImagesSignalExternalSemaphoreExp_id=149,
-    urEnqueueUSMFill2D_id=151,
-    urEnqueueUSMMemcpy2D_id=152,
-    urVirtualMemGranularityGetInfo_id=153,
-    urVirtualMemReserve_id=154,
-    urVirtualMemFree_id=155,
-    urVirtualMemMap_id=156,
-    urVirtualMemUnmap_id=157,
-    urVirtualMemSetAccess_id=158,
-    urVirtualMemGetInfo_id=159,
-    urPhysicalMemCreate_id=160,
-    urPhysicalMemRetain_id=161,
-    urPhysicalMemRelease_id=162,
-    urUSMImportExp_id=163,
-    urUSMReleaseExp_id=164,
-    urUsmP2PEnablePeerAccessExp_id=165,
-    urUsmP2PDisablePeerAccessExp_id=166,
-    urUsmP2PPeerAccessGetInfoExp_id=167,
-    urLoaderConfigCreate_id=172,
-    urLoaderConfigRelease_id=173,
-    urLoaderConfigRetain_id=174,
-    urLoaderConfigGetInfo_id=175,
-    urLoaderConfigEnableLayer_id=176,
-    urAdapterRelease_id=177,
-    urAdapterGet_id=178,
-    urAdapterRetain_id=179,
-    urAdapterGetLastError_id=180,
-    urAdapterGetInfo_id=181,
-    urProgramBuildExp_id=197,
-    urProgramCompileExp_id=198,
-    urProgramLinkExp_id=199,
-    urLoaderConfigSetCodeLocationCallback_id=200,
-    urLoaderInit_id=201,
-    urLoaderTearDown_id=202,
-    urCommandBufferAppendUSMMemcpyExp_id=203,
-    urCommandBufferAppendUSMFillExp_id=204,
-    urCommandBufferAppendMemBufferCopyExp_id=205,
-    urCommandBufferAppendMemBufferWriteExp_id=206,
-    urCommandBufferAppendMemBufferReadExp_id=207,
-    urCommandBufferAppendMemBufferCopyRectExp_id=208,
-    urCommandBufferAppendMemBufferWriteRectExp_id=209,
-    urCommandBufferAppendMemBufferReadRectExp_id=210,
-    urCommandBufferAppendMemBufferFillExp_id=211,
-    urCommandBufferAppendUSMPrefetchExp_id=212,
-    urCommandBufferAppendUSMAdviseExp_id=213,
-    urEnqueueCooperativeKernelLaunchExp_id=214,
-    urKernelSuggestMaxCooperativeGroupCountExp_id=215,
-    urProgramGetGlobalVariablePointer_id=216,
-    urDeviceGetSelected_id=217,
-    urCommandBufferRetainCommandExp_id=218,
-    urCommandBufferReleaseCommandExp_id=219,
-    urCommandBufferUpdateKernelLaunchExp_id=220,
-    urCommandBufferGetInfoExp_id=221,
-    urCommandBufferCommandGetInfoExp_id=222,
-    urEnqueueTimestampRecordingExp_id=223,
-    urEnqueueKernelLaunchCustomExp_id=224,
-    urKernelGetSuggestedLocalWorkSize_id=225,
-    urBindlessImagesImportExternalMemoryExp_id=226,
-    urBindlessImagesImportExternalSemaphoreExp_id=227,
-    urEnqueueNativeCommandExp_id=228,
-    urLoaderConfigSetMockingEnabled_id=229,
-    urBindlessImagesReleaseExternalMemoryExp_id=230,
-    urCommandBufferAppendUSMMemcpyExp_v2_id=231,
-    urCommandBufferAppendUSMFillExp_v2_id=232,
-    urCommandBufferAppendMemBufferCopyExp_v2_id=233,
-    urCommandBufferAppendMemBufferWriteExp_v2_id=234,
-    urCommandBufferAppendMemBufferReadExp_v2_id=235,
-    urCommandBufferAppendMemBufferCopyRectExp_v2_id=236,
-    urCommandBufferAppendMemBufferWriteRectExp_v2_id=237,
-    urCommandBufferAppendMemBufferReadRectExp_v2_id=238,
-    urCommandBufferAppendMemBufferFillExp_v2_id=239,
-    urCommandBufferAppendUSMPrefetchExp_v2_id=240,
-    urCommandBufferAppendUSMAdviseExp_v2_id=241,
-    urEnqueueCommandBufferExp_id=242,
-    urCommandBufferUpdateSignalEventExp_id=243,
-    urCommandBufferUpdateWaitEventsExp_id=244,
-    urBindlessImagesMapExternalLinearMemoryExp_id=245,
-    urEnqueueEventsWaitWithBarrierExt_id=246,
-    urTensorMapEncodeIm2ColExp_id=247,
-    urTensorMapEncodeTiledExp_id=248,
-    urPhysicalMemGetInfo_id=249,
-    urEnqueueUSMDeviceAllocExp_id=250,
-    urEnqueueUSMSharedAllocExp_id=251,
-    urEnqueueUSMHostAllocExp_id=252,
-    urEnqueueUSMFreeExp_id=253,
-    urUSMPoolCreateExp_id=254,
-    urUSMPoolDestroyExp_id=255,
-    urUSMPoolSetThresholdExp_id=256,
-    urUSMPoolGetDefaultDevicePoolExp_id=257,
-    urUSMPoolSetDevicePoolExp_id=259,
-    urUSMPoolGetDevicePoolExp_id=260,
-    urUSMPoolTrimToExp_id=261,
-    urUSMPoolGetInfoExp_id=262,
-    urCommandBufferAppendNativeCommandExp_id=263,
-    urCommandBufferGetNativeHandleExp_id=264,
-    urUSMPoolSetInfoExp_id=265,
-    urAdapterSetLoggerCallback_id=266,
-    urAdapterSetLoggerCallbackLevel_id=267,
-    urBindlessImagesGetImageUnsampledHandleSupportExp_id=268,
-    urBindlessImagesGetImageSampledHandleSupportExp_id=269,
-    urBindlessImagesGetImageMemoryHandleTypeSupportExp_id=270,
-    urBindlessImagesFreeMappedLinearMemoryExp_id=271,
-    urKernelSuggestMaxCooperativeGroupCount_id=272,
-    urUSMContextMemcpyExp_id=273,
-    urMemoryExportAllocExportableMemoryExp_id=285,
-    urMemoryExportFreeExportableMemoryExp_id=286,
-    urMemoryExportExportMemoryHandleExp_id=287,
-    urBindlessImagesSupportsImportingHandleTypeExp_id=288,
-    urIPCGetMemHandleExp_id=289,
-    urIPCPutMemHandleExp_id=290,
-    urIPCOpenMemHandleExp_id=291,
-    urIPCCloseMemHandleExp_id=292,
-    urDeviceWaitExp_id=293,
-    urProgramDynamicLinkExp_id=294,
-    urEnqueueKernelLaunchWithArgsExp_id=295,
-    urGraphCreateExp_id=296,
-    urQueueBeginGraphCaptureExp_id=297,
-    urQueueBeginCaptureIntoGraphExp_id=298,
-    urQueueEndGraphCaptureExp_id=299,
-    urGraphDestroyExp_id=302,
-    urGraphExecutableGraphDestroyExp_id=303,
-    urQueueIsGraphCaptureEnabledExp_id=304,
-    urGraphIsEmptyExp_id=305,
-    urGraphDumpContentsExp_id=306,
-    urGraphInstantiateGraphExp_id=307,
-    urEnqueueGraphExp_id=308,
-    urEnqueueHostTaskExp_id=309,
-    urCommandBufferAppendKernelLaunchWithArgsExp_id=310,
-    urKernelGetSuggestedLocalWorkSizeWithArgs_id=311,
-    urUSMHostAllocRegisterExp_id=312,
-    urUSMHostAllocUnregisterExp_id=313,
-    urQueueGetGraphExp_id=314,
-    urGraphSetDestructionCallbackExp_id=315,
-    urIPCGetPhysMemHandleExp_id=316,
-    urIPCPutPhysMemHandleExp_id=317,
-    urIPCOpenPhysMemHandleExp_id=318,
-    urIPCClosePhysMemHandleExp_id=319,
-    urGraphGetNativeHandleExp_id=320,
-    urGraphExecutableGraphGetNativeHandleExp_id=321,
-    urEventCreateExp_id=322,
-    urIPCGetEventHandleExp_id=323,
-    urIPCPutEventHandleExp_id=324,
-    urIPCOpenEventHandleExp_id=325,
- } pti_api_id_runtime_sycl;
-
-#endif
diff --git a/sdk/include/pti/pti_version.h.in b/sdk/include/pti/pti_version.h.in
deleted file mode 100644
index c3f7075a..00000000
--- a/sdk/include/pti/pti_version.h.in
+++ /dev/null
@@ -1,53 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef INCLUDE_PTI_VERSION_H_
-#define INCLUDE_PTI_VERSION_H_
-
-#include <stdint.h>
-
-#include "pti/pti_export.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#if !defined(PTI_VERSION)
-#define PTI_VERSION @PTI_VERSION@
-#endif
-
-#define PTI_VERSION_STRING "@PTI_VERSION@"
-#define PTI_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
-#define PTI_VERSION_MINOR @PROJECT_VERSION_MINOR@
-#define PTI_VERSION_PATCH @PROJECT_VERSION_PATCH@
-
-#define PTI_COMMIT_HASH_STRING "@PTI_COMMIT_HASH@"
-
-typedef struct pti_version {
-  uint32_t _major;
-  uint32_t _minor;
-  uint32_t _patch;
-} pti_version;
-
-/**
- * @brief Returns the compiled version of Intel(R) PTI
- *
- * @return c-string with compiled version of Intel(R) PTI
- */
-PTI_EXPORT const char* ptiVersionString(void);
-
-/**
- * @brief Returns the compiled version of Intel(R) PTI
- *
- * @return pti_version struct with compiled version of Intel(R) PTI
- */
-pti_version PTI_EXPORT ptiVersion(void);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // INCLUDE_PTI_VERSION_H_
diff --git a/sdk/include/pti/pti_view.h b/sdk/include/pti/pti_view.h
deleted file mode 100644
index 3346a128..00000000
--- a/sdk/include/pti/pti_view.h
+++ /dev/null
@@ -1,742 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef INCLUDE_PTI_VIEW_H_
-#define INCLUDE_PTI_VIEW_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "pti/pti.h"
-#include "pti/pti_driver_levelzero_api_ids.h"
-#include "pti/pti_export.h"
-#include "pti/pti_runtime_sycl_api_ids.h"
-
-/* clang-format off */
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/**
- * @brief const defines.
- */
-#define PTI_MAX_PCI_ADDRESS_SIZE 16                         //!< Size of pci address array.
-#define PTI_INVALID_QUEUE_ID (0xFFFFFFFFFFFFFFFF-1)         //!< Indicates a missing sycl queue id. UINT64_MAX-1
-
-/**
- * @brief Kinds of software and hardware operations to be tracked and viewed,
- * passed to ptiViewEnable/ptiViewDisable
- */
-typedef enum _pti_view_kind {
-  PTI_VIEW_INVALID = 0,                      //!< Invalid
-  PTI_VIEW_DEVICE_GPU_KERNEL = 1,            //!< Device kernels
-  PTI_VIEW_DEVICE_CPU_KERNEL = 2,            //!< Host (CPU) kernels; not implemented,
-                                             //!< ptiViewEnable returns PTI_ERROR_NOT_IMPLEMENTED
-  PTI_VIEW_DRIVER_API = 3,                   //!< Driver (aka back-end) API tracing
-  PTI_VIEW_RESERVED = 4,                     //!< For future use
-  PTI_VIEW_COLLECTION_OVERHEAD = 5,          //!< Collection overhead
-  PTI_VIEW_RUNTIME_API = 6,                  //!< Runtime(Sycl, other) API tracing
-  PTI_VIEW_EXTERNAL_CORRELATION = 7,         //!< Correlation of external operations
-  PTI_VIEW_DEVICE_GPU_MEM_COPY = 8,          //!< Memory copies between Host and Device
-  PTI_VIEW_DEVICE_GPU_MEM_FILL = 9,          //!< Device memory fills
-  PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P = 10,     //!< Peer to Peer Memory copies between Devices.
-  PTI_VIEW_DEVICE_SYNCHRONIZATION = 11,      //!< Synchronization operations on host and GPU.
-  PTI_VIEW_COMMUNICATION = 12,               //!< Communication records via oneCCL. Only for Linux.
-  PTI_VIEW_KIND_FORCE_UINT32 = 0x7fffffff
-} pti_view_kind;
-
-PTI_STATIC_ASSERT(sizeof(pti_view_kind) == sizeof(uint32_t), "pti_view_kind enum should be equal to size of uint32_t");
-
-/**
- * @brief Synchronization types:
- *                             Type marked as *_GPU_* note the synchronization start/complete on device (e.g Barriers).
- *                             Type marked as *_HOST_* note the synchronization start/end on host (e.g. Fence).
- */
-typedef enum _pti_view_synchronization_type {
-  PTI_VIEW_SYNCHRONIZATION_TYPE_UNKNOWN = 0,                  //!< Unknown synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_EXECUTION = 1,    //!< Barrier execution and global memory synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_MEMORY = 2,       //!< Barrier memory range coherency synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_FENCE = 3,               //!< Fence coarse grain execution synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_EVENT = 4,               //!< Event host synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_LIST = 5,        //!< Commandlist host synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_QUEUE = 6,       //!< CommandQueue host synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_DEVICE = 7,              //!< Device host synchronization type
-  PTI_VIEW_SYNCHRONIZATION_TYPE_FORCE_UINT32 = 0x7fffffff
-} pti_view_synchronization_type;
-PTI_STATIC_ASSERT(sizeof(pti_view_synchronization_type) == sizeof(uint32_t), "pti_view_synchronization_type enum should be equal to size of uint32_t");
-
-/**
- * @brief Memory types
- */
-typedef enum _pti_view_memory_type {
-  PTI_VIEW_MEMORY_TYPE_MEMORY = 0,  //!< Unknown or host memory (user allocated)
-  PTI_VIEW_MEMORY_TYPE_HOST = 1,    //!< Host memory (driver allocated)
-  PTI_VIEW_MEMORY_TYPE_DEVICE = 2,  //!< Device memory
-  PTI_VIEW_MEMORY_TYPE_SHARED = 3,  //!< Shared memory
-  PTI_VIEW_MEMORY_TYPE_FORCE_UINT32 = 0x7fffffff
-} pti_view_memory_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_view_memory_type) == sizeof(uint32_t), "pti_view_memory_type enum should be equal to size of uint32_t");
-
-/**
- * @brief Memory copy types
- * where M=Memory, D=Device, H=Host, S=Shared
- */
-typedef enum _pti_view_memcpy_type {
-  PTI_VIEW_MEMCPY_TYPE_M2M = 0,     //!< Memory to Memory type
-  PTI_VIEW_MEMCPY_TYPE_M2H = 1,     //!< Memory to Host type
-  PTI_VIEW_MEMCPY_TYPE_M2D = 2,     //!< Memory to Device type
-  PTI_VIEW_MEMCPY_TYPE_M2S = 3,     //!< Memory to Shared type
-
-  PTI_VIEW_MEMCPY_TYPE_H2M = 4,     //!< Host to Memory type
-  PTI_VIEW_MEMCPY_TYPE_H2H = 5,     //!< Host to Host type
-  PTI_VIEW_MEMCPY_TYPE_H2D = 6,     //!< Host to Device type
-  PTI_VIEW_MEMCPY_TYPE_H2S = 7,     //!< Host to Shared type
-
-  PTI_VIEW_MEMCPY_TYPE_D2M = 8,     //!< Device to Memory type
-  PTI_VIEW_MEMCPY_TYPE_D2H = 9,     //!< Device to Host type
-  PTI_VIEW_MEMCPY_TYPE_D2D = 10,    //!< Device to Device type
-  PTI_VIEW_MEMCPY_TYPE_D2S = 11,    //!< Device to Shared type
-
-  PTI_VIEW_MEMCPY_TYPE_S2M = 12,    //!< Shared to Memory type
-  PTI_VIEW_MEMCPY_TYPE_S2H = 13,    //!< Shared to Host type
-  PTI_VIEW_MEMCPY_TYPE_S2D = 14,    //!< Shared to Device type
-  PTI_VIEW_MEMCPY_TYPE_S2S = 15,    //!< Shared to Shared type
-
-  PTI_VIEW_MEMCPY_TYPE_FORCE_UINT32 = 0x7fffffff
-} pti_view_memcpy_type;
-
-PTI_STATIC_ASSERT(sizeof(pti_view_memcpy_type) == sizeof(uint32_t), "pti_view_memcpy_type enum should be equal to size of uint32_t");
-
-/**
- *  @brief External correlation kinds
- */
-typedef enum _pti_view_external_kind {
-  PTI_VIEW_EXTERNAL_KIND_INVALID = 0,   //!< Invalid external kind
-  PTI_VIEW_EXTERNAL_KIND_UNKNOWN = 1,   //!< Unknown external kind
-  PTI_VIEW_EXTERNAL_KIND_CUSTOM_0 = 2,  //!< Custom external kind
-  PTI_VIEW_EXTERNAL_KIND_CUSTOM_1 = 3,  //!< Custom external kind
-  PTI_VIEW_EXTERNAL_KIND_CUSTOM_2 = 4,  //!< Custom external kind
-  PTI_VIEW_EXTERNAL_KIND_CUSTOM_3 = 5,  //!< Custom external kind
-  PTI_VIEW_EXTERNAL_KIND_FORCE_UINT32 = 0x7fffffff
-} pti_view_external_kind;
-
-PTI_STATIC_ASSERT(sizeof(pti_view_external_kind) == sizeof(uint32_t), "pti_view_external_kind enum should be equal to size of uint32_t");
-
-/**
- *  @brief Collection Overhead kinds; currently only PTI_VIEW_OVERHEAD_KIND_TIME is reported
- */
-typedef enum _pti_view_overhead_kind {
-  PTI_VIEW_OVERHEAD_KIND_INVALID = 0,        //!< Invalid overhead kind
-  PTI_VIEW_OVERHEAD_KIND_UNKNOWN = 1,        //!< Unknown overhead kind
-  PTI_VIEW_OVERHEAD_KIND_RESOURCE = 2,       //!< Overhead due to a resource
-  PTI_VIEW_OVERHEAD_KIND_BUFFER_FLUSH = 3,   //!< Overhead due to a buffer flush
-  PTI_VIEW_OVERHEAD_KIND_DRIVER = 4,         //!< Overhead due to driver
-  PTI_VIEW_OVERHEAD_KIND_TIME = 5,           //!< Overhead due to instrumentation: time spent
-                                             //!< in PTI tracing code around Level Zero API calls
-  PTI_VIEW_OVERHEAD_KIND_FORCE_UINT32 = 0x7fffffff
-} pti_view_overhead_kind;
-
-PTI_STATIC_ASSERT(sizeof(pti_view_overhead_kind) == sizeof(uint32_t), "pti_view_overhead_kind enum should be equal to size of uint32_t");
-
-/**
- * @brief api_group types
- */
-typedef enum _pti_api_group_id {
-  PTI_API_GROUP_RESERVED              = 0,
-  PTI_API_GROUP_LEVELZERO             = 1,   // Belongs to Driver super-group
-  PTI_API_GROUP_OPENCL                = 2,   // Belongs to Driver super-group
-  PTI_API_GROUP_SYCL                  = 3,   // Belongs to Runtime super-group
-  PTI_API_GROUP_HYBRID_SYCL_LEVELZERO = 4,   // Sycl api_group, L0 api_id, only for output
-  PTI_API_GROUP_HYBRID_SYCL_OPENCL    = 5,   // Sycl api_group, OCL api_id, only for output
-  PTI_API_GROUP_ALL                   = 0x7fffffff // all groups, used as input only
-                                                   // Be careful using GROUP_ALL in api calls
-                                                   // -- you will get all *groups* now and in the *future*!
-} pti_api_group_id;
-
-PTI_STATIC_ASSERT(sizeof(pti_api_group_id) == sizeof(uint32_t), "pti_api_group_id enum should be equal to size of uint32_t");
-
-/**
- * @brief API Classes across API groups, used for coarse-grain filtering of traced APIs,
- *                   serve only as input to PTI functions
- */
- typedef enum _pti_api_class {
-  PTI_API_CLASS_RESERVED = 0,
-  PTI_API_CLASS_GPU_OPERATION_CORE = 1,                    //!< any memory or kernel APIs submitting some work to GPU:
-                                                           //!< SYCL runtime mem/kernel APIs, and Level Zero append APIs,
-                                                           //!< zeCommandListImmediateAppendCommandListsExp and
-                                                           //!< zeCommandQueueExecuteCommandLists
-  PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION = 2,        //!< Host synchronization APIs (no barriers)
-                                                           //!< -- only LZ synch apis covered for now.
-  PTI_API_CLASS_ALL = 0x7fffffff,                          //!< all APIs, makes all valid values positive numbers
-                                                           //!< Be careful using CLASS_ALL in api calls
-                                                           //!< -- you will get all classes *now* and in the *future*!
- } pti_api_class;
-
- PTI_STATIC_ASSERT(sizeof(pti_api_class) == sizeof(uint32_t), "pti_api_class enum should be equal to size of uint32_t");
-
-/**
- * @brief Base View record type
- */
-typedef struct pti_view_record_base {
-  pti_view_kind _view_kind;                   //!< Record View kind
-} pti_view_record_base;
-
-/**
- * @note about the timestamps in the all records below:
- * in case PTI collection was not able to determine the timestamp
- * for a particular event in the life of a kernel, data transfer, a call, etc.,
- * the timestamp value will be zero
- */
-
-/**
- * @brief Device Compute kernel View record type
- */
-typedef struct pti_view_record_kernel {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Kernel name
-  const char* _source_file_name;                    //!< Kernel source file,
-                                                    //!< empty string if no information
-  uint64_t _source_line_number;                     //!< Kernel beginning source line number,
-                                                    //!< 0 if no information
-  uint64_t _kernel_id;                              //!< Kernel instance ID,
-                                                    //!< unique among all device kernel instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID of Function call
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Device pci_address
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Device uuid
-  uint64_t _append_timestamp;                       //!< Timestamp of kernel appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of kernel start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of kernel completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of kernel command list submission
-                                                    //!< of device, ns
-  uint64_t _sycl_task_begin_timestamp;              //!< Timestamp of kernel submission from SYCL layer,
-                                                    //!< ns
-  uint64_t _sycl_enqk_begin_timestamp;              //!< Timestamp of enqueue kernel from SYCL layer, ns
-  uint64_t _sycl_node_id;                           //!< SYCL Node ID
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-  uint32_t _sycl_invocation_id;                     //!< SYCL Invocation ID
-} pti_view_record_kernel;
-
-typedef struct pti_view_record_kernel_v2 {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Kernel name
-  const char* _source_file_name;                    //!< Kernel source file,
-                                                    //!< empty string if no information
-  uint64_t _source_line_number;                     //!< Kernel beginning source line number,
-                                                    //!< 0 if no information
-  uint64_t _kernel_id;                              //!< Kernel instance ID,
-                                                    //!< unique among all device kernel instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID of Function call
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Device pci_address
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Device uuid
-  uint64_t _append_timestamp;                       //!< Timestamp of kernel appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of kernel start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of kernel completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of kernel command list submission
-                                                    //!< of device, ns
-  uint64_t _sycl_task_begin_timestamp;              //!< Timestamp of kernel submission from SYCL layer,
-                                                    //!< ns
-  uint64_t _sycl_enqk_begin_timestamp;              //!< Timestamp of enqueue kernel from SYCL layer, ns
-  uint64_t _sycl_node_id;                           //!< SYCL Node ID
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-  uint32_t _sycl_invocation_id;                     //!< SYCL Invocation ID
-  pti_device_handle_t _device_handle;               //!< Device handle on which kernel was executed
-  uint32_t _engine_ordinal;                         //!< Device engine ordinal on which kernel was executed
-  uint32_t _engine_index;                           //!< Device engine index on which kernel was executed
-} pti_view_record_kernel_v2;
-
-PTI_STATIC_ASSERT(offsetof(pti_view_record_kernel_v2, _device_handle) == sizeof(pti_view_record_kernel),
-     "pti_view_record_kernel_v2 must be an extension of pti_view_record_kernel");
-
-/**
- * @brief Synchronization View record type
- */
-typedef struct pti_view_record_synchronization {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_synchronization_type _synch_type;        //!< Synchronization type
-  pti_backend_ctx_t _context_handle;                //!< Context handle, null if not applicable or not available.
-  pti_backend_queue_t _queue_handle;                //!< Queue handle, null if not applicable or not
-                                                    //!< available.
-  pti_backend_evt_t _event_handle;                  //!< Event handle the synchronization API is called with;
-                                                    //!< null if not applicable or not available.
-  uint64_t _start_timestamp;                        //!< For host synchronization types: function enter timestamp
-                                                    //!< For gpu synchronization types: synch start timestamp on device
-  uint64_t _end_timestamp;                          //!< For host synchronization types: function exit timestamp
-                                                    //!< For gpu synchronization types: synch complete timestamp on device
-  uint32_t _thread_id;                              //!< Thread ID of function call
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records of other Views
-  uint32_t _number_wait_events;                     //!< For relevant event synch types (eg. Barriers)
-  uint32_t _return_code;                            //!< L0/OCL synch api onexit return type - cast to specific driver code type
-  uint32_t _api_id;                                 //!< Id of this synch api call
-  pti_api_group_id _api_group;                      //!< Defines api api_group this record was collected in (L0,Sycl,OCL, etc).
-} pti_view_record_synchronization;
-
-/**
- * @brief Memory Copy Operation View record type
- */
-typedef struct pti_view_record_memory_copy {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memcpy_type _memcpy_type;                //!< Memory copy type
-  pti_view_memory_type _mem_src;                    //!< Memory type
-  pti_view_memory_type _mem_dst;                    //!< Memory type
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory copy
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Source or Destination Device pci_address
-                                                    //!< Only a single device is represented by
-                                                    //!< this record
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Source or Destination Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID, unique among
-                                                    //!< all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory copy appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory copy start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory copy completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory copy command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< number of bytes copied
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-} pti_view_record_memory_copy;
-
-/**
- * @brief Memory Copy Operation View version2 record type
- */
-typedef struct pti_view_record_memory_copy_v2 {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memcpy_type _memcpy_type;                //!< Memory copy type
-  pti_view_memory_type _mem_src;                    //!< Memory type
-  pti_view_memory_type _mem_dst;                    //!< Memory type
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory copy
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Source or Destination Device pci_address
-                                                    //!< Only a single device is represented by
-                                                    //!< this record
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Source or Destination Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID, unique among
-                                                    //!< all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory copy appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory copy start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory copy completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory copy command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< number of bytes copied
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-  pti_device_handle_t _device_handle;               //!< Device handle on which copy was executed
-  uint32_t _engine_ordinal;                         //!< Device engine ordinal on which copy was executed
-  uint32_t _engine_index;                           //!< Device engine index on which copy was executed
-} pti_view_record_memory_copy_v2;
-
-PTI_STATIC_ASSERT(offsetof(pti_view_record_memory_copy_v2, _device_handle) == sizeof(pti_view_record_memory_copy),
-     "pti_view_record_memory_copy_v2 must be an extension of pti_view_record_memory_copy");
-
-/**
- * @brief Peer to Peer Memory Copy Operation View record type
- */
-typedef struct pti_view_record_memory_copy_p2p {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memcpy_type _memcpy_type;                //!< Memory copy type
-  pti_view_memory_type _mem_src;                    //!< Memory type
-  pti_view_memory_type _mem_dst;                    //!< Memory type
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory copy
-  char _src_pci_address[PTI_MAX_PCI_ADDRESS_SIZE];  //!< Source Device pci_address
-  char _dst_pci_address[PTI_MAX_PCI_ADDRESS_SIZE];  //!< Destination Device pci_address
-  uint8_t _src_uuid[PTI_MAX_DEVICE_UUID_SIZE];      //!< Source Device uuid
-  uint8_t _dst_uuid[PTI_MAX_DEVICE_UUID_SIZE];      //!< Destination Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID, unique among
-                                                    //!< all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory copy appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory copy start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory copy completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory copy command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< number of bytes copied
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-} pti_view_record_memory_copy_p2p;
-
-/**
- * @brief Peer to Peer Memory Copy Operation View version2 record type
- */
-typedef struct pti_view_record_memory_copy_p2p_v2 {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memcpy_type _memcpy_type;                //!< Memory copy type
-  pti_view_memory_type _mem_src;                    //!< Memory type
-  pti_view_memory_type _mem_dst;                    //!< Memory type
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory copy
-  char _src_pci_address[PTI_MAX_PCI_ADDRESS_SIZE];  //!< Source Device pci_address
-  char _dst_pci_address[PTI_MAX_PCI_ADDRESS_SIZE];  //!< Destination Device pci_address
-  uint8_t _src_uuid[PTI_MAX_DEVICE_UUID_SIZE];      //!< Source Device uuid
-  uint8_t _dst_uuid[PTI_MAX_DEVICE_UUID_SIZE];      //!< Destination Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID, unique among
-                                                    //!< all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records
-                                                    //!< of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory copy appending to
-                                                    //!< back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory copy start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory copy completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory copy command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< number of bytes copied
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-  pti_device_handle_t _src_device_handle;           //!< Device handle of source memory
-  pti_device_handle_t _dst_device_handle;           //!< Device handle of destination memory
-  uint32_t _engine_ordinal;                         //!< Source device engine ordinal on which copy was executed
-  uint32_t _engine_index;                           //!< Source device engine index on which copy was executed
-} pti_view_record_memory_copy_p2p_v2;
-
-PTI_STATIC_ASSERT(offsetof(pti_view_record_memory_copy_p2p_v2, _src_device_handle) == sizeof(pti_view_record_memory_copy_p2p),
-     "pti_view_record_memory_copy_p2p_v2 must be an extension of pti_view_record_memory_copy_p2p");
-
-/**
- * @brief Device Memory Fill operation View record type
- */
-typedef struct pti_view_record_memory_fill {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memory_type _mem_type;                   //!< Type of memory filled
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory fill
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Device pci_address
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID,
-                                                    //!< unique among all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory fill appending
-                                                    //!< to back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory fill start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory fill completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory fill command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< Number of bytes filled
-  uint64_t _value_for_set;                          //!< Value filled
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-} pti_view_record_memory_fill;
-
-/**
- * @brief Device Memory Fill operation View version2 record type
- */
-typedef struct pti_view_record_memory_fill_v2 {
-  pti_view_record_base _view_kind;                  //!< Base record
-  pti_view_memory_type _mem_type;                   //!< Type of memory filled
-  pti_backend_queue_t _queue_handle;                //!< Device back-end queue handle
-  pti_backend_ctx_t _context_handle;                //!< Context handle
-  const char* _name;                                //!< Back-end API name making a memory fill
-  char _pci_address[PTI_MAX_PCI_ADDRESS_SIZE];      //!< Device pci_address
-  uint8_t _device_uuid[PTI_MAX_DEVICE_UUID_SIZE];   //!< Device uuid
-  uint64_t _mem_op_id;                              //!< Memory operation ID,
-                                                    //!< unique among all memory operations instances
-  uint32_t _correlation_id;                         //!< ID that correlates this record with records of other Views
-  uint32_t _thread_id;                              //!< Thread ID from which operation submitted
-  uint64_t _append_timestamp;                       //!< Timestamp of memory fill appending
-                                                    //!< to back-end command list, ns
-  uint64_t _start_timestamp;                        //!< Timestamp of memory fill start on device, ns
-  uint64_t _end_timestamp;                          //!< Timestamp of memory fill completion on device, ns
-  uint64_t _submit_timestamp;                       //!< Timestamp of memory fill command list submission
-                                                    //!< to device, ns
-  uint64_t _bytes;                                  //!< Number of bytes filled
-  uint64_t _value_for_set;                          //!< Value filled
-  uint64_t _sycl_queue_id;                          //!< Device front-end queue id
-  pti_device_handle_t _device_handle;               //!< Device handle on which fill was executed
-  uint32_t _engine_ordinal;                         //!< Device engine ordinal on which fill was performed
-  uint32_t _engine_index;                           //!< Device engine index on which fill was performed
-} pti_view_record_memory_fill_v2;
-
-PTI_STATIC_ASSERT(offsetof(pti_view_record_memory_fill_v2, _device_handle) == sizeof(pti_view_record_memory_fill),
-     "pti_view_record_memory_fill_v2 must be an extension of pti_view_record_memory_fill");
-
-/**
- * @brief External Correlation View record type
- */
-typedef struct pti_view_record_external_correlation {
-  pti_view_record_base _view_kind;          //!< Base record
-  uint32_t _correlation_id;                 //!< ID that correlates this record with records
-                                            //!< of other Views
-  uint64_t _external_id;                    //!< ID provided by user, marking an external
-                                            //!< to PTI operation
-  pti_view_external_kind _external_kind;    //!< External correlation kind
-} pti_view_record_external_correlation;
-
-
-/**
- * @brief Overhead View record type
- */
-typedef struct pti_view_record_overhead {
-  pti_view_record_base _view_kind;          //!< Base record
-  uint64_t _overhead_start_timestamp_ns;    //!< Overhead observation start timestamp, ns
-  uint64_t _overhead_end_timestamp_ns;      //!< Overhead observation end timestamp, ns
-  uint32_t _overhead_thread_id;             //!< Thread ID of where the overhead observed
-  uint32_t _api_id;                         //!< API id of the overhead
-  uint64_t _overhead_count;                 //!< number of views in the overhead region
-  uint64_t _overhead_duration_ns;           //!< Cumulative duration of the overhead over
-                                            //!< the observation region, could be less than
-                                            //!< interval between the observation region
-                                            //!< start and the end
-  pti_view_overhead_kind  _overhead_kind;   //!< Type of overhead
-} pti_view_record_overhead;
-
-/**
- * @brief API Calls View record type
- */
-typedef struct pti_view_record_api {
-  pti_view_record_base _view_kind; //!< Base record
-  uint64_t _start_timestamp;       //!< Function call start timestamp, ns
-  uint64_t _end_timestamp;         //!< Function call end timestamp, ns
-  pti_api_group_id _api_group;     //!< Defines the API group this record was collected in (L0, SYCL, OCL, etc).
-  uint32_t _api_id;                //!< Id of this api call
-  uint32_t _process_id;            //!< Process ID of where the API call observed
-  uint32_t _thread_id;             //!< Thread ID of where the API call observed
-  uint32_t _correlation_id;        //!< Id correlating this call with other views, eg: memfill, memcpy and kernel GPU activity
-  uint32_t _return_code;           //!< Applicable only for PTI_VIEW_DRIVER_API, type cast to specific driver code type
-} pti_view_record_api;
-
-/**
- * @brief Communication View record type,
- *        communication provided by oneCCL, supported only for Linux
- */
-typedef struct pti_view_record_comms {
-  pti_view_record_base _view_kind; //!< Base record
-  uint64_t _start_timestamp;       //!< Operation start timestamp, ns
-  uint64_t _end_timestamp;         //!< Operation end timestamp, ns
-  uint32_t _process_id;            //!< Process ID of where the operation observed
-  uint32_t _thread_id;             //!< Thread ID of where the operation observed
-  uint64_t _send_size;             //!< Send buffer size of the communication operation
-  uint64_t _recv_size;             //!< Receive buffer size of the communication operation
-  uint64_t _communicator_id;       //!< Communicator ID of the operation
-  const char *_name;               //!< Operation name
-} pti_view_record_comms;
-
-/**
- * @brief Function pointer for buffer completed
- *
- * @param buffer
- * @param buffer_size_in_bytes
- * @param used_bytes
- * @return void
- */
-
-typedef void (*pti_fptr_buffer_completed)(unsigned char* buffer,
-                                             size_t buffer_size_in_bytes,
-                                             size_t used_bytes);
-
-
-/**
- * @brief Function pointer for buffer requested
- *
- * @param buffer_ptr
- * @param buffer_size_in_bytes
- * @return void
- */
-typedef void (*pti_fptr_buffer_requested)(unsigned char** buffer_ptr,
-                                             size_t* buffer_size_in_bytes);
-
-
-/**
- * @brief Sets callback to user buffer management functions implemented
- * by a user
- *
- * @param fptr_bufferRequested
- * @param fptr_bufferCompleted
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewSetCallbacks(pti_fptr_buffer_requested fptr_bufferRequested,
-                       pti_fptr_buffer_completed fptr_bufferCompleted);
-
-/**
- * @brief Enables View of specific group of operations
- *
- * Communication tracing requires PTI to be selected as the ITT collector when
- * the PTI interface library loads. If another collector is selected, its path
- * does not exist, a bare collector name cannot be identified among loaded
- * modules, or configuration fails, enabling PTI_VIEW_COMMUNICATION returns
- * PTI_ERROR_COLLECTOR_UNAVAILABLE.
- *
- * @param view_kind
- * @return pti_result
- */
-pti_result PTI_EXPORT ptiViewEnable(pti_view_kind view_kind);
-
-/**
- * @brief Disables View of specific group of operations
- *
- * @param view_kind
- * @return pti_result
- */
-pti_result PTI_EXPORT ptiViewDisable(pti_view_kind view_kind);
-
-/**
- * @brief Returns if GPU Local view is supported by the installed driver
- *
- * @return pti_result
-*/
-pti_result PTI_EXPORT ptiViewGPULocalAvailable(void);
-
-/**
- * @brief Flushes all view records by calling bufferCompleted callback
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT ptiFlushAllViews(void);
-
-/**
- * @brief Gets next view record in buffer.
- *
- * @param buffer The buffer initially provided by pti_fptr_buffer_requested
- * user function and now passed to pti_fptr_buffer_completed
- * @param valid_bytes Size of portion of the buffer filled with view records
- * @param record Current view record
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewGetNextRecord(uint8_t* buffer, size_t valid_bytes,
-                       pti_view_record_base** record);
-
-/**
- * @brief Pushes ExternalCorrelationId kind and id for generation of external correlation records
- *
- * @param external_kind
- * @param external_id
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewPushExternalCorrelationId(pti_view_external_kind external_kind, uint64_t external_id);
-
-/**
- * @brief Pops ExternalCorrelationId kind and id for generation of external correlation records
- *
- * @param external_kind
- * @param p_external_id
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewPopExternalCorrelationId(pti_view_external_kind external_kind, uint64_t* p_external_id);
-
-/**
- * @brief Helper function to return stringified enum types for pti_view_overhead_kind.
- *
- * @return const char*
- */
-PTI_EXPORT const char*
-ptiViewOverheadKindToString( pti_view_overhead_kind type );
-
-/**
- * @brief Helper function to return stringified enum types for pti_view_memory_type.
- *
- * @return const char*
- */
-PTI_EXPORT const char*
-ptiViewMemoryTypeToString( pti_view_memory_type type );
-
-/**
- * @brief Helper function to return stringified enum types for pti_view_memcpy_type.
- *
- * @return const char*
- */
-PTI_EXPORT const char*
-ptiViewMemcpyTypeToString( pti_view_memcpy_type type );
-
-/**
- * @brief Returns current Intel(R) PTI host timestamp in nanoseconds. The timestamp is in the same time domain as view records timestamps.
- *
- * @return uint64_t
- */
-PTI_EXPORT uint64_t
-ptiViewGetTimestamp(void);
-
-
-/**
- * @brief User provided timestamping function.
- *        This will be used to obtain host timestamps when user registers using the ptiViewSetTimestampCallback.
- *        It is expected that this function will return timestamps in nano seconds.
- */
-typedef uint64_t (*pti_fptr_get_timestamp)( void );
-
-/**
- * @brief Sets callback to user provided timestamping function.  This will replace the default Intel(R) PTI host timestamper.
- *        Multiple callbacks that set differing timestamp function, through the session; will result in differing
- *        time domains in the view record buffer.
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewSetTimestampCallback(pti_fptr_get_timestamp fptr_timestampRequested);
-
-/**
- * @brief Gets api name for api id to user -- the api is embedded in the pti_view_record_api.
- * Sample usage -  const char* pName = nullptr;
- *              -  pti_result status = ptiViewGetApiIdName(PTI_API_GROUP_LEVELZERO, rec._api_id, &pName);
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewGetApiIdName(pti_api_group_id type, uint32_t unique_id, const char** name);
-
-/**
- * @brief Enable/Disable driver specific API specified by api_id within the api_group_id.
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewEnableDriverApi(uint32_t enable, pti_api_group_id api_group_id, uint32_t api_id);
-
-/**
- * @brief Enable/Disable runtime specific API specified by api_id within the api_group_id.
- *
- * @return pti_result
- */
-pti_result PTI_EXPORT
-ptiViewEnableRuntimeApi(uint32_t enable, pti_api_group_id api_group_id, uint32_t api_id);
-
-/**
- * @brief Enable/Disable driver APIs tracing specified by api_class across specified api group(s).
- *        Use for the coarse-grain control of the Driver APIs tracing.
- *
- * @return pti_result
- */
-pti_result  PTI_EXPORT
-ptiViewEnableDriverApiClass(uint32_t enable, pti_api_class api_class, pti_api_group_id group);
-
-/**
- * @brief Enable/Disable runtime APIs tracing specified by api_class across specified api group(s).
- *        Use for the coarse-grain control of the Runtime APIs tracing.
- *
- * @return pti_result
- */
-pti_result  PTI_EXPORT
-ptiViewEnableRuntimeApiClass(uint32_t enable, pti_api_class api_class, pti_api_group_id group);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif  // INCLUDE_PTI_VIEW_H_
diff --git a/sdk/pyproject.toml b/sdk/pyproject.toml
deleted file mode 100644
index 10ab22b7..00000000
--- a/sdk/pyproject.toml
+++ /dev/null
@@ -1,92 +0,0 @@
-[project]
-name = "intel-pti"
-dynamic = ["version"]
-description = "Intel Profiling Tools Interface"
-readme = "README.md"
-license = { text = "MIT" }
-authors = [{ name = "Intel Corporation" }]
-requires-python = ">=3.7"
-
-dependencies = []
-classifiers = [
-  "Development Status :: 5 - Production/Stable",
-
-  "Intended Audience :: Developers",
-  "Intended Audience :: Education",
-  "Intended Audience :: Science/Research",
-  "Intended Audience :: System Administrators",
-  "Intended Audience :: Other Audience",
-
-  "Topic :: Software Development :: Libraries",
-  "Topic :: System :: Hardware",
-
-  "Operating System :: Microsoft :: Windows",
-  "Operating System :: POSIX :: Linux",
-
-  "Programming Language :: C++",
-]
-
-[tool.scikit-build]
-build.verbose = true
-logging.level = "INFO"
-cmake.version = ">=3.14"
-cmake.build-type = "RelWithDebInfo"
-ninja.version = ">=1.10.1"
-minimum-version = "build-system.requires"
-wheel.py-api = "py3"
-wheel.platlib = true
-cmake.define.CMAKE_TOOLCHAIN_FILE = "cmake/toolchains/scikit-build.cmake"
-
-[tool.scikit-build.metadata.version]
-provider = "scikit_build_core.metadata.regex"
-input = "VERSION"
-regex = '''
-^(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)$
-'''
-result = "{major}.{minor}.{patch}dev1"
-
-[tool.uv]
-cache-keys = [{ file = "pyproject.toml" }, { file = "CMakeLists.txt" }, { file = "VERSION" }]
-
-[build-system]
-requires = ["scikit-build-core>=0.10"]
-build-backend = "scikit_build_core.build"
-
-[project.urls]
-Homepage = "https://github.com/intel/pti-gpu/tree/master/sdk"
-Documentation = "https://intel.github.io/pti-gpu/"
-Repository = "https://github.com/intel/pti-gpu"
-Issues = "https://github.com/intel/pti-gpu/issues"
-
-[[tool.scikit-build.overrides]]
-if.env.PTI_RELEASE_WHL = "1"
-if.platform_system = "linux"
-metadata.version.provider = "scikit_build_core.metadata.regex"
-metadata.version.input = "VERSION"
-metadata.version.regex = '''
-^(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)$
-'''
-metadata.version.result = "{major}.{minor}.{patch}"
-cmake.build-type = "Release"
-cmake.define.CMAKE_CXX_FLAGS = "-Wall -Wextra -Wextra-semi -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -D_FORTIFY_SOURCE=2"
-cmake.define.CMAKE_C_FLAGS = "-Wall -Wextra -pedantic -Wformat -Werror -Wformat-security -Werror=format-security -fstack-protector-strong -D_FORTIFY_SOURCE=2"
-cmake.define.CMAKE_SHARED_LINKER_FLAGS = "-Wl,-z,relro,-z,now,-z,noexecstack"
-cmake.define.CMAKE_MODULE_LINKER_FLAGS = "-Wl,-z,relro,-z,now,-z,noexecstack"
-cmake.define.CMAKE_EXE_LINKER_FLAGS = "-Wl,-z,relro,-z,now,-z,noexecstack"
-
-[[tool.scikit-build.overrides]]
-if.env.PTI_RELEASE_WHL = "1"
-if.platform_system = "win32"
-metadata.version.provider = "scikit_build_core.metadata.regex"
-metadata.version.input = "VERSION"
-metadata.version.regex = '''
-^(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)$
-'''
-metadata.version.result = "{major}.{minor}.{patch}"
-cmake.build-type = "Release"
-cmake.define.CMAKE_CXX_FLAGS = "/W4 /WX /MD /EHcs /fp:precise /sdl /GS /Gy /DYNAMICBASE /guard:cf"
-cmake.define.CMAKE_C_FLAGS = "/W4 /WX /MD /fp:precise /sdl /GS /Gy /guard:cf"
-cmake.define.CMAKE_SHARED_LINKER_FLAGS = "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf"
-cmake.define.CMAKE_MODULE_LINKER_FLAGS = "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf"
-cmake.define.CMAKE_EXE_LINKER_FLAGS = "/DEPENDENTLOADFLAG:0x2000 /DYNAMICBASE /NXCOMPAT /guard:cf"
-
diff --git a/sdk/samples/callback/CMakeLists.txt b/sdk/samples/callback/CMakeLists.txt
deleted file mode 100644
index 880e5e07..00000000
--- a/sdk/samples/callback/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_CALLBACK CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-# TODO: find_package(IntelSYCL)?
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if (NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(callback main.cc client.cc)
-
-target_link_options(callback PUBLIC -fsycl)
-target_compile_options(callback PUBLIC -fsycl)
-
-target_include_directories(callback PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-target_link_libraries(callback PRIVATE LevelZero::level-zero)
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(callback PUBLIC Pti::pti_view)
diff --git a/sdk/samples/callback/client.cc b/sdk/samples/callback/client.cc
deleted file mode 100644
index e7810f14..00000000
--- a/sdk/samples/callback/client.cc
+++ /dev/null
@@ -1,266 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "client.h"
-
-#include <level_zero/ze_api.h>
-
-#include <atomic>
-#include <cstdlib>
-#include <iostream>
-#include <sycl/sycl.hpp>
-
-#include "pti/pti_callback.h"
-#include "samples_utils.h"
-
-/**
- * This file demonstrate usage of PTI Callback Subscriber and
- * External Correlation called from within Append callbacks
- * The sample workload uses a single thread.
- */
-
-namespace {
-
-pti_callback_subscriber_handle subscriber = nullptr;
-
-std::atomic<uint64_t> external_correlation_id = 0;
-
-}  // namespace
-
-//
-// Forward declaration of tool functions required for PTI initialization
-//
-void CallbackCommon(pti_callback_domain domain, pti_api_group_id driver_group_id,
-                    uint32_t driver_api_id, pti_backend_ctx_t backend_context, void *cb_data,
-                    void *user_data, void **instance_user_data);
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size);
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size);
-
-//
-// Start and Stop profiling
-//
-void StartProfiling() {
-  // At the moment when subscribe for ptiCallback-s -
-  // need to enable at least one ptiView for GPU operations
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-
-  // Demonstrating here how to use External Correlation in Subscriber Callbacks
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DRIVER_API));
-  PTI_CHECK_SUCCESS(ptiViewEnableDriverApiClass(1, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                                                pti_api_group_id::PTI_API_GROUP_LEVELZERO));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION));
-
-  // Initializing Subscriber and setting the callback function
-  // As user data we pass to subscriber its own address
-  PTI_CHECK_SUCCESS(ptiCallbackSubscribe(&subscriber, CallbackCommon, &subscriber));
-  std::cout << "Initialized Subscriber: " << subscriber << std::endl;
-
-  // Enabling for each subscriber domains of interest
-  PTI_CHECK_SUCCESS(
-      ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1));
-  PTI_CHECK_SUCCESS(
-      ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1));
-}
-
-void StopProfiling() {
-  PTI_CHECK_SUCCESS(ptiCallbackUnsubscribe(subscriber));
-
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DRIVER_API));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION));
-
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-}
-
-//
-// Functions used in Callbacks
-//
-void CallbackGPUOperationAppend([[maybe_unused]] pti_callback_domain domain,
-                                pti_api_group_id driver_group_id, uint32_t driver_api_id,
-                                [[maybe_unused]] pti_backend_ctx_t backend_context, void *cb_data,
-                                void *user_data, void **instance_user_data) {
-  std::cout << "In " << __func__
-            << " Subscriber: " << *(reinterpret_cast<pti_callback_subscriber_handle *>(user_data))
-            << std::endl;
-
-  samples_utils::DumpCallbackData(domain, driver_group_id, driver_api_id, backend_context, cb_data,
-                                  user_data, instance_user_data);
-
-  if (cb_data == nullptr) {
-    std::cerr << "CallbackGPUOperationAppend: callback_data is null. Unexpected" << std::endl;
-    return;
-  }
-  pti_callback_gpu_op_data *gpu_op_data = static_cast<pti_callback_gpu_op_data *>(cb_data);
-  if (gpu_op_data->_operation_details == nullptr) {
-    std::cerr << "CallbackGPUOperationAppend: pti_gpu_op_details is null. Unexpected" << std::endl;
-    return;
-  }
-
-  if (gpu_op_data->_operation_count != 1) {
-    std::cout << "WARNING: Operation count is not 1, it is: " << gpu_op_data->_operation_count
-              << " . Unexpected for this sample! Will not proceed with Push/Pop "
-              << "of External Correlation " << std::endl;
-    return;
-  }
-
-  if (gpu_op_data->_phase == PTI_CB_PHASE_API_ENTER) {
-    *instance_user_data = static_cast<void *>(nullptr);
-    external_correlation_id.fetch_add(1);
-    auto result = ptiViewPushExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, external_correlation_id);
-    std::cout << "Pushing External Correlation Id: " << external_correlation_id
-              << ", Result: " << result << std::endl;
-  } else if (gpu_op_data->_phase == PTI_CB_PHASE_API_EXIT) {
-    uint64_t local_external_correlation_id = 0ULL;
-    auto result = ptiViewPopExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &local_external_correlation_id);
-    std::cout << "Popped External Correlation Id: " << local_external_correlation_id
-              << ", Result: " << result << std::endl;
-  } else {
-    std::cout << "Unexpected phase: " << gpu_op_data->_phase << std::endl;
-  }
-}
-
-void CallbackGPUOperationCompletion([[maybe_unused]] pti_callback_domain domain,
-                                    pti_api_group_id driver_group_id, uint32_t driver_api_id,
-                                    [[maybe_unused]] pti_backend_ctx_t backend_context,
-                                    void *cb_data, void *user_data,
-                                    [[maybe_unused]] void **instance_user_data) {
-  std::cout << "In " << __func__
-            << " Subscriber: " << *(reinterpret_cast<pti_callback_subscriber_handle *>(user_data))
-            << std::endl;
-
-  samples_utils::DumpCallbackData(domain, driver_group_id, driver_api_id, backend_context, cb_data,
-                                  user_data, instance_user_data);
-}
-
-void CallbackCommon(pti_callback_domain domain, pti_api_group_id driver_group_id,
-                    uint32_t driver_api_id, pti_backend_ctx_t backend_context, void *cb_data,
-                    void *user_data, void **instance_user_data) {
-  switch (domain) {
-    case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED:
-      CallbackGPUOperationAppend(domain, driver_group_id, driver_api_id, backend_context, cb_data,
-                                 user_data, instance_user_data);
-      break;
-    case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED:
-      CallbackGPUOperationCompletion(domain, driver_group_id, driver_api_id, backend_context,
-                                     cb_data, user_data, instance_user_data);
-      break;
-    default: {
-      std::cout << "In " << __func__ << " (default case)" << std::endl;
-      samples_utils::DumpCallbackData(domain, driver_group_id, driver_api_id, backend_context,
-                                      cb_data, user_data, instance_user_data);
-      break;
-    }
-  }
-  std::cout << std::endl;
-}
-
-//
-// PTI Reports Buffer functions
-//
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  constexpr auto kRequestedRecordCount = 5'000'000ULL;
-  constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (valid_buf_size) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      std::cout << "Reached End of buffer" << '\n';
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        auto *rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        std::cout << "Found Kernel Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        auto *rec = reinterpret_cast<pti_view_record_memory_copy *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        std::cout << "Found Memory Copy Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        auto *rec = reinterpret_cast<pti_view_record_memory_fill *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        std::cout << "Found Memory Fill Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        std::cout << "Found Driver API Record" << '\n';
-        auto *rec = reinterpret_cast<pti_view_record_api *>(ptr);
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        std::cout << "Found External Correlation Record" << '\n';
-        auto *rec = reinterpret_cast<pti_view_record_external_correlation *>(ptr);
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------\n";
-        break;
-      }
-      default: {
-        std::cerr << "We don't expect this kind of record in this sample. Kind: "
-                  << static_cast<int>(ptr->_view_kind) << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
diff --git a/sdk/samples/callback/client.h b/sdk/samples/callback/client.h
deleted file mode 100644
index 34b94959..00000000
--- a/sdk/samples/callback/client.h
+++ /dev/null
@@ -1,13 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef CLIENT_H_
-#define CLIENT_H_
-
-void StartProfiling();
-
-void StopProfiling();
-
-#endif  // CLIENT_H_
diff --git a/sdk/samples/callback/main.cc b/sdk/samples/callback/main.cc
deleted file mode 100644
index 35ebfc47..00000000
--- a/sdk/samples/callback/main.cc
+++ /dev/null
@@ -1,161 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <stdexcept>
-#include <sycl/sycl.hpp>
-
-#include "client.h"
-
-#define NSEC_IN_SEC 1'000'000'000
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-constexpr unsigned kMaxSize = 8192;
-constexpr unsigned kMinSize = 32;
-
-static float Check(const std::vector<float> &a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float *a, const float *b, float *c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static void Run(sycl::queue &queue, const std::vector<float> &a, const std::vector<float> &b,
-                std::vector<float> &c, unsigned size) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  sycl::buffer<float, 1> a_buf(a.data(), a.size());
-  sycl::buffer<float, 1> b_buf(b.data(), b.size());
-  sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-  [[maybe_unused]] sycl::event event = queue.submit([&](sycl::handler &cgh) {
-    auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-    auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-    auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-    cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-      auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-      auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-      auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-      GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-    });
-  });
-}
-
-static void Compute(sycl::queue &queue, const std::vector<float> &a, const std::vector<float> &b,
-                    std::vector<float> &c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  try {
-    for (unsigned i = 0; i < repeat_count; ++i) {
-      Run(queue, a, b, c, size);
-    }
-    queue.wait_and_throw();
-    float eps = Check(c, expected_result);
-    std::cout << "Matrix multiplication done. Checking result.." << std::endl;
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  } catch (const sycl::exception &e) {
-    std::cerr << "[ERROR] Exception during Compute: " << e.what() << std::endl;
-    throw;
-  }
-}
-
-void Usage(const char *name) {
-  std::cout << " Calculating floating point matrix multiply on gpu. Usage:\n";
-  std::cout << name << " [matrix size] [repetition count]\n"
-            << "\t - matrix size, default=1024, max=" << kMaxSize << "\n"
-            << "\t - repetition count, default=1 \n";
-}
-
-int main(int argc, char *argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  StartProfiling();
-  unsigned repeat_count = 1;
-  unsigned size = 1024;
-  try {
-    if (argc > 1) {
-      unsigned temp = std::stoul(argv[1]);
-      size = (temp < kMinSize) ? kMinSize : (temp > kMaxSize) ? kMaxSize : temp;
-    }
-    if (argc > 2) {
-      repeat_count = std::stoul(argv[2]);
-    }
-  } catch (std::invalid_argument const &e) {
-    std::cerr << "Error: Invalid argument when processing command line " << e.what() << '\n';
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  } catch (std::out_of_range const &e) {
-    std::cerr << "Error: Out-of-range when processing command line " << e.what() << '\n';
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  sycl::device dev(sycl::gpu_selector_v);
-  sycl::queue queue(dev, sycl::async_handler{}, {sycl::property::queue::in_order()});
-
-  // Main run and check kernel
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size << " x " << size << ", repeats "
-            << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: "
-            << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-            << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  try {
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    Compute(queue, a, b, c, size, repeat_count, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-
-  StopProfiling();
-
-  return exit_code;
-}
diff --git a/sdk/samples/dlworkloads/CMakeLists.txt b/sdk/samples/dlworkloads/CMakeLists.txt
deleted file mode 100644
index d4420b18..00000000
--- a/sdk/samples/dlworkloads/CMakeLists.txt
+++ /dev/null
@@ -1,91 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-if(WIN32)
-  if(CMAKE_VERSION VERSION_LESS "3.20")
-    message(WARNING "sample requires CMake version 3.20 or greater.")
-    return()
-  endif()
-  cmake_minimum_required(VERSION 3.20)
-  find_package(oneDPLWindowsIntelLLVM)
-else()
-  cmake_minimum_required(VERSION 3.14)
-endif()
-
-
-project(dlworkload_demo_with_syclgraph_capture)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Debug")
-endif()
-
-option(USE_HOST_MEMORY "Use USE_HOST_MEMORY" OFF)
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler.")
-  return()
-endif()
-
-if (NOT TARGET oneDPL)
-  find_package(oneDPL)
-endif()
-
-if (NOT TARGET oneDPL)
-  message(WARNING "${PROJECT_NAME} requires a oneDPL installation.")
-  return ()
-endif()
-
-if (NOT TARGET TBB::tbb)
-  find_package(TBB)
-endif()
-
-if (NOT TARGET TBB::tbb)
-  message(WARNING "${PROJECT_NAME} requires a Intel TBB installation.")
-  return ()
-endif()
-
-if (NOT TARGET DNNL::dnnl)
-  find_package(dnnl)
-endif()
-
-if (NOT TARGET DNNL::dnnl)
-  message(WARNING "${PROJECT_NAME} requires a DNNL installation.")
-  return ()
-endif()
-
-if (NOT TARGET MKL::MKL)
-  find_package(MKL CONFIG PATHS $ENV{MKLROOT} NO_DEFAULT_PATH)
-  message(STATUS "Imported oneMKL targets: ${MKL_IMPORTED_TARGETS}")
-endif()
-
-if (NOT TARGET MKL::MKL)
-  message(WARNING "${PROJECT_NAME} requires a oneMKL installation.")
-  return ()
-endif()
-
-FILE(GLOB SOURCES "*.cpp")
-add_executable(dlworkload ${SOURCES})
-
-target_compile_options(dlworkload PUBLIC -fsycl)
-
-target_link_options(dlworkload PUBLIC -fsycl)
-
-if(USE_HOST_MEMORY)
-  target_compile_definitions(dlworkload PUBLIC USE_HOST_MEMORY)
-endif()
-
-target_include_directories(dlworkload PRIVATE ${PROJECT_SOURCE_DIR}/../samples_utilities)
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_include_directories(dlworkload SYSTEM PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_INCLUDE_DIRECTORIES>)
-target_link_libraries(dlworkload DNNL::dnnl MKL::MKL MKL::MKL_SYCL oneDPL Pti::pti_view)
diff --git a/sdk/samples/dlworkloads/CMakeLists_bkup.txt b/sdk/samples/dlworkloads/CMakeLists_bkup.txt
deleted file mode 100644
index 03440e6d..00000000
--- a/sdk/samples/dlworkloads/CMakeLists_bkup.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.5)
-project(dlworkload_demo_with_syclgraph_capture)
-
-option(USE_HOST_MEMORY "Use USE_HOST_MEMORY" OFF)
-if(USE_HOST_MEMORY)
-    add_definitions(-DUSE_HOST_MEMORY)
-endif()
-
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
-
-add_definitions(-Wall)
-set (CMAKE_CXX_COMPILER "dpcpp")
-FILE(GLOB SOURCES "*.cpp")
-
-add_executable(dlworkload ${SOURCES})
-target_include_directories(dlworkload PUBLIC "${CMAKE_INCLUDE_PATH}")
-
-target_link_libraries(dlworkload -ldnnl -lmkl_sycl -lmkl_intel_ilp64 -lmkl_core -lmkl_tbb_thread)
diff --git a/sdk/samples/dlworkloads/README.md b/sdk/samples/dlworkloads/README.md
deleted file mode 100644
index 35b159d2..00000000
--- a/sdk/samples/dlworkloads/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# personal.guoyejun.syclgraph_capture_dlworkloads
\ No newline at end of file
diff --git a/sdk/samples/dlworkloads/device_memory.cpp b/sdk/samples/dlworkloads/device_memory.cpp
deleted file mode 100644
index 06eae3a2..00000000
--- a/sdk/samples/dlworkloads/device_memory.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "device_memory.h"
-
-void DeviceMemoryManager::deinit()
-{
-    for(auto& info : memInfos) {
-        sycl::free(info.data, *q);
-    }
-}
-
-float * DeviceMemoryManager::alloc(size_t count)
-{
-    if (count == 0) {
-        return nullptr;
-    }
-
-    if (q == nullptr) {
-        return nullptr;
-    }
-
-    for(auto& info : memInfos) {
-        if (info.count >= count && !info.used) {
-            info.used = true;
-#ifdef USE_HOST_MEMORY
-            memset(info.data, 0xAB, info.count*sizeof(float));
-#endif
-            return info.data;
-        }
-    }
-
-#ifdef USE_HOST_MEMORY
-    float *p = sycl::malloc_host<float>(count, *q);
-    memset(p, 0xCD, count*sizeof(float));
-#else
-    float *p = sycl::malloc_device<float>(count, *q);
-#endif
-    DeviceMemoryInfo info;
-    info.data = p;
-    info.count = count;
-    info.used = true;
-    memInfos.push_back(info);
-
-    return p;
-}
-
-void DeviceMemoryManager::free(float *data)
-{
-    for(auto& info : memInfos) {
-        if (info.data == data) {
-            info.used = false;
-            return;
-        }
-    }
-
-    assert(!"should not reach here");
-}
diff --git a/sdk/samples/dlworkloads/device_memory.h b/sdk/samples/dlworkloads/device_memory.h
deleted file mode 100644
index 34bc7db2..00000000
--- a/sdk/samples/dlworkloads/device_memory.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef DEVICE_MEMORY_H_
-#define DEVICE_MEMORY_H_
-
-#include <vector>
-#include <sycl/sycl.hpp>
-
-// In IPEX/ITEX, device memory are allocated and reused, and released at last.
-// here is a very simple mock for this behavior.
-
-struct DeviceMemoryInfo {
-    float *data = nullptr;  // float is enough for the demo
-    size_t count = 0;
-    bool used = 0;
-};
-
-class DeviceMemoryManager {
-public:
-    DeviceMemoryManager() {}
-    void init(sycl::queue *q) { this->q = q;}
-    void deinit();
-    float * alloc(size_t count);
-    void free(float *data);
-private:
-    std::vector<DeviceMemoryInfo> memInfos = {};
-    sycl::queue *q = nullptr;
-};
-
-inline auto& GlobalDeviceMemoryManager() {
-    static DeviceMemoryManager g_devMemMgr = {};
-    return g_devMemMgr;
-}
-
-//extern DeviceMemoryManager g_devMemMgr;
-
-#endif
diff --git a/sdk/samples/dlworkloads/main.cpp b/sdk/samples/dlworkloads/main.cpp
deleted file mode 100644
index b1c88114..00000000
--- a/sdk/samples/dlworkloads/main.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <iostream>
-#include <vector>
-#include <atomic>
-#include <sycl/sycl.hpp>
-
-#include "queue.h"
-#include "device_memory.h"
-#include "tiny_tensor.h"
-#include "model_mixedprogramming.h"
-#include "utils.h"
-#include "operation_onednn.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-// Global counter for GPU kernel records
-std::atomic<uint64_t> g_gpu_kernel_count{0};
-
-void PrintUsage()
-{
-  std::cout << "It is a largely simpilified application to demo mixed programming ";
-  std::cout << "on Intel GPU for deep learning (PyTorch&TensorFlow) workloads (ITEX&IPEX) ";
-  std::cout << "with direct dpcpp kernel, onednn, onemkl, onedpl, onemkl, eigen, etc." << std::endl;
-  std::cout << "IPEX: https://github.com/intel/intel-extension-for-pytorch" << std::endl;
-  std::cout << std::endl;
-  std::cout << "The purpose of this application is to provide a basic rough requirement for sycl graph capture mode." << std::endl;
-  std::cout << std::endl;
-  std::cout << "opens:" << std::endl;
-  std::cout << "-) out of order queue" << std::endl;
-  std::cout << "-) multiple threads" << std::endl;
-  std::cout << "-) multiple queues" << std::endl;
-  std::cout << "-) distributed traing with multiple instances (oneccl workload captured in the graph)" << std::endl;
-  std::cout << "-) share device memory between sycl graphs" << std::endl;
-  std::cout << "-) lock device memory used within graph internals" << std::endl;
-  std::cout << "-) oneDNN, oneMKL etc might create USM internally" << std::endl;
-  std::cout << "-) integrate into deep learning framework (python code)" << std::endl;
-  std::cout << "-) ITEX uses eigen instead of oneDPL for functions such as cos." << std::endl;
-  std::cout << std::endl;
-  std::cout << "It is supposed that this application will be updated frequently, so this might be not the latest one." << std::endl;
-  std::cout << std::endl;
-}
-
-void run(sycl::queue *q, size_t iterations)
-{
-  // shape of model input (NCHW)
-  size_t n = 1, c = 3, h = 224, w = 224;
-
-  // prepare host data for model input
-  float *inp_h = new float[n*c*h*w];
-  for (size_t i = 0; i < n*c*h*w; ++i) {
-    inp_h[i] = random_float();
-  }
-
-  // prepare model weights
-  size_t oc = 5, ks = 3;
-  onednn_prepare_weights(oc, c, ks, q);
-
-  // current usage without sycl graph
-  for (size_t i = 0; i < iterations; ++i) {
-    // Host2Device for model input
-    TinyTensor inp(n, c, h, w);
-    q->memcpy(inp.data, inp_h, inp.count() * sizeof(float));
-
-    // we may add more special models such as run_model_dlrm for the demo purpose
-    TinyTensor outp = run_model_mixedprogramming(inp, q);
-
-    // for model training iterations (one instance), the final step is update
-    // the model parameters buffer which is in device memory.
-    // for inference, the final step is Device2Host for CPU access.
-    // let's mock with wait to reuse outp.
-    q->wait();
-    GlobalDeviceMemoryManager().free(outp.data);
-  }
-
-  // it's not easy to get golden reference to verify the correctness,
-  // currently we need to manually check it when add new operations.
-  // we can at least compare the results with/without the sycl graph.
-
-  {
-    // in sycl graph capture mode, the very rough expectation looks like below.
-    // how the input, output device memory are managed are still opens.
-
-    // 1. warmup, there's some one-time workloads that we don't want to capture
-    // for (int i = 0; i < 3; ++i) {
-    //   run_model_mixedprogramming(inp, q);
-    // }
-
-    // 2. capture, no GPU kernel execution at this stage
-    // auto graph = sycl::start_capture();
-    // outp = run_model_mixedprogramming(inp, q);
-    // sycl::end_capture(graph);
-
-    // 3. replay
-    // for (int i = 0; i < 100; ++i) {
-    //   fill(inp);
-    //   outp = graph.replay(inp);
-    //   use(outp);
-    // }
-  }
-
-  delete[] inp_h;
-}
-
-void StartTracing() {
-  ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL);
-  ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-  ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL);
-  ptiViewEnable(PTI_VIEW_RUNTIME_API);
-  ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION);
-  ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD);
-}
-
-void StopTracing() {
-  ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL);
-  ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-  ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL);
-  ptiViewDisable(PTI_VIEW_RUNTIME_API);
-  ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION);
-  ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD);
-}
-
-
-int main()
-{
-  int exit_code = EXIT_SUCCESS;
-  uint64_t eid = 21;
-
-  PrintUsage();
-
-  pti_result result = ptiViewSetCallbacks(
-      [](auto **buf, auto *buf_size) {
-        static constexpr size_t kBufferSize = 1000;
-        *buf_size = kBufferSize;
-        *buf = reinterpret_cast<unsigned char *>(::operator new(*buf_size));
-        if (!*buf) {
-          std::abort();
-        }
-        return;
-      },
-      [](auto *buf, auto buf_size, auto valid_buf_size) {
-        if (!buf || !valid_buf_size || !buf_size) {
-          std::cerr << "Received empty buffer" << '\n';
-          if (buf) {
-            ::operator delete(buf);
-          }
-          return;
-        }
-        pti_view_record_base *ptr = nullptr;
-        while (true) {
-          auto buf_status =
-              ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-
-          if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-            // std::cout << "Reached End of buffer" << '\n';
-            break;
-          }
-          if (buf_status != pti_result::PTI_SUCCESS) {
-            // std::cerr << "Found Error Parsing Records from PTI" << '\n';
-            break;
-          }
-          switch (ptr->_view_kind) {
-            case pti_view_kind::PTI_VIEW_INVALID: {
-              // std::cout << "Found Invalid Record" << '\n';
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              samples_utils::DumpRecord(
-                  reinterpret_cast<pti_view_record_overhead *>(ptr));
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              samples_utils::DumpRecord(
-                  reinterpret_cast<pti_view_record_external_correlation *>(
-                      ptr));
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Sycl Runtime Record" << '\n';
-              samples_utils::DumpRecord(
-                  reinterpret_cast<pti_view_record_api *>(ptr));
-              break;
-            }
-            case pti_view_kind:: PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Memory Record" << '\n';
-              samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy *>(ptr));
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              break;
-            }
-            case pti_view_kind:: PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Memory Record" << '\n';
-              samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill *>(ptr));
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-              pti_view_record_kernel* rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
-              g_gpu_kernel_count++;
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Kernel Record" << '\n';
-              samples_utils::DumpRecord(rec);
-              if (samples_utils::IsMonotonic(
-                                  {
-                                    rec->_sycl_task_begin_timestamp ,
-                                    rec->_sycl_enqk_begin_timestamp ,
-                                    rec->_append_timestamp ,
-                                    rec->_submit_timestamp ,
-                                    rec->_start_timestamp ,
-                                    rec->_end_timestamp
-                                  }
-                                )) {
-                std::cout << "------------>     All Monotonic" << std::endl;
-              } else {
-                std::cerr
-                    << "------------>     Something wrong: NOT All monotonic"
-                    << std::endl;
-              };
-              if (rec->_sycl_task_begin_timestamp == 0)
-                std::cerr << "------------>     Something wrong: Sycl Task "
-                             "Begin Time is 0"
-                          << std::endl;
-              if (rec->_sycl_enqk_begin_timestamp == 0)
-                std::cerr << "------------>     Something wrong: Sycl Enq "
-                             "Launch Kernel Time is 0"
-                          << std::endl;
-
-              break;
-            }
-            default: {
-              std::cerr << "This shouldn't happen" << '\n';
-              break;
-            }
-          }
-        }
-        ::operator delete(buf);
-      });
-  if (result != pti_result::PTI_SUCCESS) {
-    std::cerr << "Failed to set PTI View callbacks" << '\n';
-    return EXIT_FAILURE;
-  }
-  StartTracing();
-  ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, eid);
-
-  auto q = CreateQueue();
-  if (q == NULL) {
-    std::cout << "failed to create sycl queue." << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  GlobalDeviceMemoryManager().init(q.get());
-
-  // execute the model (we are now focus on training)
-  const size_t iterations = 100;
-  try {
-    run(q.get(), iterations);
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value()
-              << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-
-  // make sure all the GPU tasks are done when cleanup
-  q->wait();
-
-  StopTracing();
-
-  GlobalDeviceMemoryManager().deinit();
-  // Xunsong: Disable PTI at here
-
-  std::cout  << std::endl << "program finished." << std::endl;
-
-  if (ptiFlushAllViews() != pti_result::PTI_SUCCESS) {
-    std::cerr << "Failed to flush views" << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-
-  ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &eid);
-
-  // Validate that "many" GPU_KERNEL records were captured,
-  // the exact count depends on the number of iterations in run() and
-  // the number of kernels in run_model_mixedprogramming(), which depends on runtime and platform,
-  // so just check if the actual count is greater than number of iterations
-  uint64_t min_kernel_count = iterations;
-  uint64_t actual_kernel_count = g_gpu_kernel_count.load();
-
-  std::cout << std::endl;
-  std::cout << "================================================" << std::endl;
-  std::cout << "GPU Kernel Record Validation:" << std::endl;
-  std::cout << "  Expected > " << min_kernel_count << std::endl;
-  std::cout << "  Actual:     " << actual_kernel_count << std::endl;
-
-  if (actual_kernel_count > min_kernel_count) {
-    std::cout << "  Status:     PASS" << std::endl;
-    std::cout << "================================================" << std::endl;
-  } else {
-    std::cout << "  Status:     FAIL" << std::endl;
-    std::cout << "================================================" << std::endl;
-    std::cerr << "ERROR: Expected more than " << min_kernel_count
-              << " GPU kernel records but got " << actual_kernel_count << std::endl;
-    exit_code = EXIT_FAILURE;
-  }
-
-  return exit_code;
-}
diff --git a/sdk/samples/dlworkloads/model_mixedprogramming.cpp b/sdk/samples/dlworkloads/model_mixedprogramming.cpp
deleted file mode 100644
index bb5e4c08..00000000
--- a/sdk/samples/dlworkloads/model_mixedprogramming.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "model_mixedprogramming.h"
-#include "operation_syclkernel.h"
-#include "operation_onednn.h"
-#include "operation_onemkl.h"
-#include "operation_onedpl.h"
-
-TinyTensor run_model_mixedprogramming(TinyTensor inp, sycl::queue *q)
-{
-  // the first operation is written with sycl kernel for scale down
-  TinyTensor outp = run_syclkernel_operation_scaledown(inp, q);
-  GlobalDeviceMemoryManager().free(inp.data);
-
-  inp = outp;
-  outp = run_onednn_operation_conv2d(inp, q);
-  GlobalDeviceMemoryManager().free(inp.data);
-
-  // next operation uses oneMKL
-  inp = outp;
-  outp = run_onemkl_operation_fft(inp, q);
-  GlobalDeviceMemoryManager().free(inp.data);
-
-  // next operation uses oneDPL
-  inp = outp;
-  outp = run_onedpl_operation_cos(inp, q);
-  GlobalDeviceMemoryManager().free(inp.data);
-
-  return outp;
-}
diff --git a/sdk/samples/dlworkloads/model_mixedprogramming.h b/sdk/samples/dlworkloads/model_mixedprogramming.h
deleted file mode 100644
index 495e990a..00000000
--- a/sdk/samples/dlworkloads/model_mixedprogramming.h
+++ /dev/null
@@ -1,14 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef MODEL_MIXEDPROGRAMMING_H_
-#define MODEL_MIXEDPROGRAMMING_H_
-
-#include <sycl/sycl.hpp>
-#include "tiny_tensor.h"
-
-TinyTensor run_model_mixedprogramming(TinyTensor inp, sycl::queue *q);
-
-#endif
diff --git a/sdk/samples/dlworkloads/operation_onednn.cpp b/sdk/samples/dlworkloads/operation_onednn.cpp
deleted file mode 100644
index 49b7c26e..00000000
--- a/sdk/samples/dlworkloads/operation_onednn.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <oneapi/dnnl/dnnl.hpp>
-#include <oneapi/dnnl/dnnl_sycl.hpp>
-
-#include "operation_onednn.h"
-#include "utils.h"
-#include "device_memory.h"
-
-// code as simple as possible for the demo
-namespace {
-inline auto& Conv2dWeightsInstance() {
-    static TinyTensor conv2d_weights(0, 0, 0, 0);
-    return conv2d_weights;
-}
-} // namespace
-
-void onednn_prepare_weights(int oc, int ic, int ks, sycl::queue *q)
-{
-    TinyTensor tt(oc, ic, ks, ks);
-    Conv2dWeightsInstance() = tt;
-
-    float *weights_h = new float[Conv2dWeightsInstance().count()];
-    for (size_t i = 0; i < Conv2dWeightsInstance().count(); ++i) {
-        weights_h[i] = random_float();
-    }
-
-    q->memcpy(Conv2dWeightsInstance().data, weights_h, Conv2dWeightsInstance().count() * sizeof(float)).wait();
-    delete [] weights_h;
-}
-
-dnnl::engine& get_engine(sycl::queue *q)
-{
-    // static for dev and ctx?
-    sycl::device dev = q->get_device();
-    sycl::context ctx(dev);
-    // is it safe when q is released at the end of the process?
-    static dnnl::engine eng = dnnl::sycl_interop::make_engine(dev, ctx);
-    return eng;
-}
-
-dnnl::stream& get_stream(dnnl::engine& eng, sycl::queue *q)
-{
-    // is it safe when q is released at the end of the process?
-    static dnnl::stream s = dnnl::sycl_interop::make_stream(eng, *q);
-    return s;
-}
-
-TinyTensor run_onednn_operation_conv2d(const TinyTensor& inp, sycl::queue *q)
-{
-    dnnl::engine eng;
-    dnnl::stream s;
-    try {
-        eng = get_engine(q);
-        s = get_stream(eng, q);
-    } catch(const dnnl::error& e) {
-        std::cerr << "Unable to get dnnl resources, failed with status: " << e.status << '\n';
-        throw;
-    }
-
-    TinyTensor outp(inp.N, Conv2dWeightsInstance().N, inp.H, inp.W);
-
-    // for the simple case, don't use reorder
-    auto src_md = dnnl::memory::desc(
-            {inp.N, inp.C, inp.H, inp.W},
-            dnnl::memory::data_type::f32,
-            dnnl::memory::format_tag::nchw
-    );
-
-    auto weights_md = dnnl::memory::desc(
-            {outp.C, inp.C, Conv2dWeightsInstance().H, Conv2dWeightsInstance().W},
-            dnnl::memory::data_type::f32,
-            dnnl::memory::format_tag::nchw
-    );
-
-    auto bias_md = dnnl::memory::desc();
-
-    auto dst_md = dnnl::memory::desc(
-            {outp.N, outp.C, outp.H, outp.W},
-            dnnl::memory::data_type::f32,
-            dnnl::memory::format_tag::nchw
-    );
-
-    dnnl::primitive_attr pattr;
-    pattr.set_scratchpad_mode(dnnl::scratchpad_mode::user);
-    auto conv_pd = dnnl::convolution_forward::primitive_desc(
-                eng,
-                dnnl::prop_kind::forward_inference,
-                dnnl::algorithm::convolution_auto,
-                src_md,
-                weights_md,
-                bias_md,
-                dst_md,
-                {1, 1}, // strides
-                {0, 0}, // dilations
-                {1, 1}, {1, 1}, // left and right padding
-                pattr);
-
-    auto src_mem = dnnl::sycl_interop::make_memory(
-            src_md,
-            eng,
-            dnnl::sycl_interop::memory_kind::usm,
-            inp.data);
-
-    auto weights_mem = dnnl::sycl_interop::make_memory(
-            weights_md,
-            eng,
-            dnnl::sycl_interop::memory_kind::usm,
-            Conv2dWeightsInstance().data);
-
-    auto dst_mem = dnnl::sycl_interop::make_memory(
-            dst_md,
-            eng,
-            dnnl::sycl_interop::memory_kind::usm,
-            outp.data);
-
-    assert(conv_pd.src_desc() == src_mem.get_desc());
-    assert(conv_pd.dst_desc() == dst_mem.get_desc());
-    assert(conv_pd.weights_desc() == weights_mem.get_desc());
-
-    dnnl::memory::desc scratchpad_md = conv_pd.scratchpad_desc();
-    auto scratchpad_size = scratchpad_md.get_size();
-    auto* scratchpad_ptr = GlobalDeviceMemoryManager().alloc(scratchpad_size/sizeof(float)+1);
-    dnnl::memory scratchpad(scratchpad_md, eng, scratchpad_ptr);
-
-    auto conv = dnnl::convolution_forward(conv_pd);
-    conv.execute(s,
-                {{DNNL_ARG_SRC, src_mem},
-                 {DNNL_ARG_WEIGHTS, weights_mem},
-                 {DNNL_ARG_DST, dst_mem},
-                 {DNNL_ARG_SCRATCHPAD, scratchpad}});
-
-    GlobalDeviceMemoryManager().free(scratchpad_ptr);
-    return outp;
-}
diff --git a/sdk/samples/dlworkloads/operation_onednn.h b/sdk/samples/dlworkloads/operation_onednn.h
deleted file mode 100644
index 74f10e28..00000000
--- a/sdk/samples/dlworkloads/operation_onednn.h
+++ /dev/null
@@ -1,15 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef OPERATION_ONEDNN_H_
-#define OPERATION_ONEDNN_H_
-
-#include <sycl/sycl.hpp>
-#include "tiny_tensor.h"
-
-void onednn_prepare_weights(int oc, int ic, int ks, sycl::queue *q);
-TinyTensor run_onednn_operation_conv2d(const TinyTensor& inp, sycl::queue *q);
-
-#endif
diff --git a/sdk/samples/dlworkloads/operation_onedpl.cpp b/sdk/samples/dlworkloads/operation_onedpl.cpp
deleted file mode 100644
index 3b2f22e0..00000000
--- a/sdk/samples/dlworkloads/operation_onedpl.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "operation_onedpl.h"
-#include <oneapi/dpl/cmath>
-
-// onedpl is only used by IPEX as code piece in kernel, while ITEX uses eigen
-TinyTensor run_onedpl_operation_cos(const TinyTensor& inp, sycl::queue *q)
-{
-    TinyTensor outp(inp.N, inp.C, inp.H, inp.W);
-
-    float *src = inp.data;
-    float *dst = outp.data;
-
-    q->submit([&](sycl::handler &h) {
-        h.parallel_for(outp.count(), [=](sycl::item<1> item) {
-            int idx = item.get_id(0);
-            dst[idx] = oneapi::dpl::cos(src[idx]);
-        });
-    });
-
-    return outp;
-}
diff --git a/sdk/samples/dlworkloads/operation_onedpl.h b/sdk/samples/dlworkloads/operation_onedpl.h
deleted file mode 100644
index 10fbb653..00000000
--- a/sdk/samples/dlworkloads/operation_onedpl.h
+++ /dev/null
@@ -1,14 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef OPERATION_ONEDPL_H_
-#define OPERATION_ONEDPL_H_
-
-#include <sycl/sycl.hpp>
-#include "tiny_tensor.h"
-
-TinyTensor run_onedpl_operation_cos(const TinyTensor& inp, sycl::queue *q);
-
-#endif
diff --git a/sdk/samples/dlworkloads/operation_onemkl.cpp b/sdk/samples/dlworkloads/operation_onemkl.cpp
deleted file mode 100644
index 80ffdc1e..00000000
--- a/sdk/samples/dlworkloads/operation_onemkl.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <mkl_version.h>
-
-#if (__INTEL_MKL_BUILD_DATE == 20240401)
-
-//
-// This branch accommodates oneAPI 2024.1.1 plus
-// the special version of mkl used for this release
-// identified as l_onemkl_2025.0.0-intel-for-pytorch-gpu-dev-19
-//
-#undef __INTEL_MKL__
-#define __INTEL_MKL__ 2024
-#include <oneapi/mkl/dfti.hpp>
-
-#elif (__INTEL_MKL__ < 2025) 
-#include <oneapi/mkl/dfti.hpp>
-#else
-#include <oneapi/mkl/dft.hpp>
-#endif
-#include "operation_onemkl.h"
-
-// code to just call onemkl function
-TinyTensor run_onemkl_operation_fft(const TinyTensor& inp, sycl::queue *q)
-{
-    TinyTensor outp(inp.N, inp.C, inp.H, inp.W*2);
-
-    int batch = inp.N * inp.C * inp.H;
-
-    std::vector<int64_t> mkl_signal_sizes{inp.W};
-    oneapi::mkl::dft::descriptor<oneapi::mkl::dft::precision::SINGLE, oneapi::mkl::dft::domain::REAL> desc(std::move(mkl_signal_sizes));
-#if __INTEL_MKL__ < 2025
-    desc.set_value(oneapi::mkl::dft::config_param::PLACEMENT, DFTI_NOT_INPLACE);
-    desc.set_value(oneapi::mkl::dft::config_param::NUMBER_OF_TRANSFORMS, batch);
-
-    int64_t idist = inp.W;
-    int64_t odist = inp.W;
-    desc.set_value(oneapi::mkl::dft::config_param::FWD_DISTANCE, idist);
-    desc.set_value(oneapi::mkl::dft::config_param::BWD_DISTANCE, odist);
-
-    int64_t signal_ndim = 1;
-    std::vector<int64_t> mkl_istrides(1 + signal_ndim, 0);
-    std::vector<int64_t> mkl_ostrides(1 + signal_ndim, 0);
-    mkl_istrides[1] = 1;
-    mkl_ostrides[1] = 1;
-    desc.set_value(
-        oneapi::mkl::dft::config_param::INPUT_STRIDES, mkl_istrides.data());
-    desc.set_value(
-        oneapi::mkl::dft::config_param::OUTPUT_STRIDES, mkl_ostrides.data());
-
-    desc.set_value(
-        oneapi::mkl::dft::config_param::CONJUGATE_EVEN_STORAGE,
-        DFTI_COMPLEX_COMPLEX);
-#else
-    desc.set_value(oneapi::mkl::dft::config_param::PLACEMENT, oneapi::mkl::dft::config_value::NOT_INPLACE);
-    desc.set_value(oneapi::mkl::dft::config_param::NUMBER_OF_TRANSFORMS, batch);
-
-    int64_t idist = inp.W;
-    int64_t odist = inp.W;
-    desc.set_value(oneapi::mkl::dft::config_param::FWD_DISTANCE, idist);
-    desc.set_value(oneapi::mkl::dft::config_param::BWD_DISTANCE, odist);
-
-    int64_t signal_ndim = 1;
-    std::vector<int64_t> mkl_istrides(1 + signal_ndim, 0);
-    std::vector<int64_t> mkl_ostrides(1 + signal_ndim, 0);
-    mkl_istrides[1] = 1;
-    mkl_ostrides[1] = 1;
-    desc.set_value(
-        oneapi::mkl::dft::config_param::FWD_STRIDES, mkl_istrides);
-    desc.set_value(
-        oneapi::mkl::dft::config_param::BWD_STRIDES, mkl_ostrides);
-    desc.set_value(
-        oneapi::mkl::dft::config_param::COMPLEX_STORAGE,
-    oneapi::mkl::dft::config_value::COMPLEX_COMPLEX);
-#endif
-
-    desc.commit(*q);
-    static bool warning_shown = false;
-    if (!warning_shown) {
-        warning_shown = true;
-        // Bollapragada, Datta is working on new API to support allocated external device memory
-        std::cout << __FILE__ << ":" << __LINE__;
-        std::cout << " internal device memory created in function desc.commit within oneMKL." << std::endl;
-    }
-
-    // the conjugate part of the result is not written into outp.data
-    oneapi::mkl::dft::compute_forward(desc, inp.data, outp.data);
-
-    return outp;
-}
diff --git a/sdk/samples/dlworkloads/operation_onemkl.h b/sdk/samples/dlworkloads/operation_onemkl.h
deleted file mode 100644
index b22e4f22..00000000
--- a/sdk/samples/dlworkloads/operation_onemkl.h
+++ /dev/null
@@ -1,14 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef OPERATION_ONEMKL_H_
-#define OPERATION_ONEMKL_H_
-
-#include <sycl/sycl.hpp>
-#include "tiny_tensor.h"
-
-TinyTensor run_onemkl_operation_fft(const TinyTensor& inp, sycl::queue *q);
-
-#endif
diff --git a/sdk/samples/dlworkloads/operation_syclkernel.cpp b/sdk/samples/dlworkloads/operation_syclkernel.cpp
deleted file mode 100644
index 006ccbef..00000000
--- a/sdk/samples/dlworkloads/operation_syclkernel.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <iostream>
-#include "operation_syclkernel.h"
-
-TinyTensor run_syclkernel_operation_scaledown(const TinyTensor& inp, sycl::queue *q)
-{
-    TinyTensor outp(inp.N, inp.C, inp.H / 2, inp.W / 2);
-
-    float *src = inp.data;
-    float *dst = outp.data;
-
-    q->submit([&](sycl::handler &h) {
-        h.parallel_for(outp.count(), [=](sycl::item<1> item) {
-            int idx = item.get_id(0);
-            dst[idx] = src[idx*4];
-        });
-    });
-
-    return outp;
-}
diff --git a/sdk/samples/dlworkloads/operation_syclkernel.h b/sdk/samples/dlworkloads/operation_syclkernel.h
deleted file mode 100644
index 9dba190f..00000000
--- a/sdk/samples/dlworkloads/operation_syclkernel.h
+++ /dev/null
@@ -1,14 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef OPERATION_SYCLKERNEL_H_
-#define OPERATION_SYCLKERNEL_H_
-
-#include <sycl/sycl.hpp>
-#include "tiny_tensor.h"
-
-TinyTensor run_syclkernel_operation_scaledown(const TinyTensor& inp, sycl::queue *q);
-
-#endif
diff --git a/sdk/samples/dlworkloads/queue.cpp b/sdk/samples/dlworkloads/queue.cpp
deleted file mode 100644
index 53b06c38..00000000
--- a/sdk/samples/dlworkloads/queue.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "queue.h"
-
-std::unique_ptr<sycl::queue> CreateQueue()
-{
-  auto plaform_list = sycl::platform::get_platforms();
-  std::vector<sycl::device> root_devices;
-  // Enumerated root devices(GPU cards) from GPU Platform firstly.
-  for (const auto& platform : plaform_list) {
-    if (platform.get_backend() != sycl::backend::ext_oneapi_level_zero)
-      continue;
-    auto device_list = platform.get_devices();
-    for (const auto& device : device_list) {
-      if (device.is_gpu()) {
-        root_devices.push_back(device);
-      }
-    }
-  }
-
-  std::cout << root_devices.size() << " GPU root devices (cards) are found." << std::endl;
-  std::cout << "//export EnableImplicitScaling=1 to show the full device memory capability of the root device." << std::endl;
-  if (root_devices.size() == 0) {
-    return NULL;
-  }
-  for (std::size_t i = 0; i < root_devices.size(); ++i) {
-    const auto& root_device = root_devices[i];
-    std::cout << "  " << i << ") ";
-    std::cout << "root device: " << root_device.get_info<sycl::info::device::name>();
-    std::cout << " (" << root_device.get_info<sycl::info::device::global_mem_size>()/1024./1024./1024. << "GiB)";
-    std::cout << " in platform: " << root_device.get_platform().get_info<sycl::info::platform::name>() << std::endl;
-  }
-  std::cout << std::endl;
-
-  auto& root_device = root_devices[0];
-  sycl::device dev = root_device;
-  try {
-    // the default behavior of IPEX is to consider one tile as a card
-    constexpr sycl::info::partition_property partition_by_affinity = sycl::info::partition_property::partition_by_affinity_domain;
-    constexpr sycl::info::partition_affinity_domain next_partitionable = sycl::info::partition_affinity_domain::next_partitionable;
-    std::vector<sycl::device> sub_devices = root_device.create_sub_devices<partition_by_affinity>(next_partitionable);
-    dev = sub_devices[0];
-    std::cout << sub_devices.size() << " sub devices found in the first root device, try the first sub device: " << dev.get_info<sycl::info::device::name>();
-    std::cout << " (" << dev.get_info<sycl::info::device::global_mem_size>()/1024./1024./1024. << "GiB)" << std::endl;
-  } catch (...) {
-    std::cout << "no sub device found in the first root device, continue to use the first root device." << std::endl;
-  }
-
-  std::cout << "Driver: "
-            << dev.get_info<sycl::info::device::driver_version>()
-            << std::endl;
-
-  // both IPEX and ITEX use in order sycl queue
-  auto q = std::make_unique<sycl::queue>(sycl::queue{dev, {sycl::property::queue::in_order(),
-                                          sycl::property::queue::enable_profiling()}});
-
-  return q;
-}
diff --git a/sdk/samples/dlworkloads/queue.h b/sdk/samples/dlworkloads/queue.h
deleted file mode 100644
index b57e94d2..00000000
--- a/sdk/samples/dlworkloads/queue.h
+++ /dev/null
@@ -1,14 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef QUEUE_H_
-#define QUEUE_H_
-
-#include <sycl/sycl.hpp>
-#include <memory>
-
-std::unique_ptr<sycl::queue> CreateQueue();
-
-#endif
diff --git a/sdk/samples/dlworkloads/tiny_tensor.h b/sdk/samples/dlworkloads/tiny_tensor.h
deleted file mode 100644
index 12455489..00000000
--- a/sdk/samples/dlworkloads/tiny_tensor.h
+++ /dev/null
@@ -1,52 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TINY_TENSOR_H_
-#define TINY_TENSOR_H_
-
-#include <stddef.h>
-#include <iostream>
-#include "device_memory.h"
-
-class TinyTensor {
-public:
-    TinyTensor(int n, int c, int h, int w) {
-        this->N = n;
-        this->C = c;
-        this->H = h;
-        this->W = w;
-        this->data = GlobalDeviceMemoryManager().alloc(count());
-    }
-    size_t count() const {
-        return N*C*H*W;
-    }
-    void print(bool showdata) const {
-        std::cout << "NCHW: (" << N << ", "  << C << ", "  << H << ", " << W << ")" << std::endl;
-        if (!showdata) {
-            return;
-        }
-        #ifdef USE_HOST_MEMORY
-        for (int ni = 0; ni < N; ++ni) {
-            for (int ci = 0; ci < C; ++ci) {
-                std::cout << "n: " << ni << ",  c: " << ci << std::endl;
-                for (int hi = 0; hi < H; ++hi) {
-                    for (int wi = 0; wi < W; ++wi) {
-                        std::cout << data[wi + hi * W + ci * H * W + ni * C * H * W] << ", ";
-                    }
-                    std::cout << std::endl << std::endl;
-                }
-            }
-        }
-        #endif
-    }
-    // NCHW for the demo
-    int N;
-    int C;
-    int H;
-    int W;
-    float *data;
-};
-
-#endif
diff --git a/sdk/samples/dlworkloads/utils.h b/sdk/samples/dlworkloads/utils.h
deleted file mode 100644
index 4ce8fadd..00000000
--- a/sdk/samples/dlworkloads/utils.h
+++ /dev/null
@@ -1,42 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef UTILS_H_
-#define UTILS_H_
-
-#include <random>
-
-class RandomFloatGen {
-public:
-  inline static constexpr float kUpperBound = 10.0;
-  inline static constexpr float kLowerBound = -1 * kUpperBound;
-
-  RandomFloatGen() : mt_engine_(rand_num_dev_()) {
-  }
-
-  inline float Get() {
-    return distribution_(mt_engine_);
-  }
-
-private:
-  std::random_device rand_num_dev_{}; // defaults to /dev/urandom libstdc++
-  std::uniform_real_distribution<float> distribution_{kLowerBound, kUpperBound};
-  std::mt19937 mt_engine_;
-};
-
-// Don't want to change the sample too much, so just use std C++ random number
-// generator because C's rand() is flagged by static code analysis.
-// (https://en.cppreference.com/w/cpp/numeric/random)
-inline auto& RandomFloatGenInstance() {
-  static RandomFloatGen rand_float_gen = {};
-  return rand_float_gen;
-}
-
-// generate rand float [-10.0, 10.0]
-inline auto random_float() {
-  return RandomFloatGenInstance().Get();
-}
-
-#endif
diff --git a/sdk/samples/dpc_gemm/CMakeLists.txt b/sdk/samples/dpc_gemm/CMakeLists.txt
deleted file mode 100644
index c772e691..00000000
--- a/sdk/samples/dpc_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_DPC_GEMM CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-# TODO: find_package(IntelSYCL)?
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if (NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(dpc_gemm main.cc)
-
-target_link_options(dpc_gemm PUBLIC -fsycl)
-target_compile_options(dpc_gemm PUBLIC -fsycl)
-
-target_include_directories(dpc_gemm PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(dpc_gemm PUBLIC Pti::pti_view)
diff --git a/sdk/samples/dpc_gemm/main.cc b/sdk/samples/dpc_gemm/main.cc
deleted file mode 100644
index d3a1eee4..00000000
--- a/sdk/samples/dpc_gemm/main.cc
+++ /dev/null
@@ -1,378 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <string.h>
-
-#include <cmath>
-#include <cstdlib>
-#include <memory>
-#include <sycl/sycl.hpp>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-#define NSEC_IN_SEC 1'000'000'000
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-constexpr auto kRequestedRecordCount = 5'000'000ULL;
-constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-void EnableIndividualDriverApis() {
-  PTI_CHECK_SUCCESS(
-      ptiViewEnableDriverApi(1, pti_api_group_id::PTI_API_GROUP_LEVELZERO,
-                             pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernel_id));
-}
-
-void StartTracing() {
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DRIVER_API));
-  EnableIndividualDriverApis();
-}
-
-void StopTracing() {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DRIVER_API));
-}
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (valid_buf_size) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      std::cout << "Reached End of buffer" << '\n';
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_overhead *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_external_correlation *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Driver Api Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        pti_view_record_kernel *rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        if (samples_utils::IsMonotonic({rec->_sycl_task_begin_timestamp,
-                                        rec->_sycl_enqk_begin_timestamp, rec->_append_timestamp,
-                                        rec->_submit_timestamp, rec->_start_timestamp,
-                                        rec->_end_timestamp})) {
-          std::cout << "------------>     All Monotonic" << std::endl;
-        } else {
-          std::cerr << "------------>     Something wrong: NOT All monotonic" << std::endl;
-        }
-        if (rec->_sycl_task_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Task "
-                       "Begin Time is 0"
-                    << std::endl;
-        }
-        if (rec->_sycl_enqk_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Enq "
-                       "Launch Kernel Time is 0"
-                    << std::endl;
-        }
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-static float Check(const std::vector<float> &a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float *a, const float *b, float *c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue, const std::vector<float> &a,
-                         const std::vector<float> &b, std::vector<float> &c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  double time = 0.0;
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-
-    auto start = event.get_profiling_info<sycl::info::event_profiling::command_start>();
-    auto end = event.get_profiling_info<sycl::info::event_profiling::command_end>();
-    time = static_cast<double>(end - start) / NSEC_IN_SEC;
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  std::cout << "Matrix multiplication time: " << time << " sec" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue, const std::vector<float> &a, const std::vector<float> &b,
-                    std::vector<float> &c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-}
-
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-void Usage(const char *name) {
-  std::cout << " Calculating floating point matrix multiply on gpu\n";
-  std::cout << name
-            << " [ [gpu|cpu|host, default=gpu],  [matrix size, default=1024, max=" << max_size
-            << "], [repetition count, default=4]] \n";
-}
-
-int main(int argc, char *argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  uint64_t eid = 11;  // external correlation id base.
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-  StartTracing();
-  // start tracing early enables to capture nodes creation at piProgramCreate
-  //  and Kernel Task sycl file/line info is captured, as example shows at a Node Creation
-  // Emit external correlation id records by marking section of code by
-  // ptiViewPushExternalCorrelationId / ptiViewPopExternalCorrelationId
-  //   Each of the enabled activity view records (sycl runtime, kernel launches) will be *preceded*
-  //   by 1 external correlation id record per kind.
-  PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid));
-  PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid + 50));
-  PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, eid + 30));
-  PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_2, eid + 40));
-  unsigned repeat_count = 1;
-  unsigned size = 1024;
-  sycl::device dev;
-  try {
-    dev = sycl::device(sycl::gpu_selector_v);
-    if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-      dev = sycl::device(sycl::cpu_selector_v);
-      std::cerr << "PTI doesn't support cpu profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
-      std::cerr << "PTI doesn't support host profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    }
-
-    unsigned temp = size;
-    if (argc > 2) {
-      temp = std::stoul(argv[2]);
-      size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-    }
-
-    if (argc > 3) {
-      temp = std::stoul(argv[3]);
-      repeat_count = (temp < 1) ? 1 : temp;
-    }
-  } catch (const sycl::exception &e) {
-    Usage(argv[0]);
-    std::cerr << "Error: Exception caught while executing SYCL " << e.what() << '\n';
-    std::cerr << "Unable to select valid sycl device" << '\n';
-    return EXIT_FAILURE;
-  } catch (...) {
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::enable_profiling(),
-                                sycl::property::queue::in_order()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);   // Main runandcheck kernel
-  sycl::queue queue1(dev, sycl::async_handler{}, prop_list);  // Main runandcheck kernel
-
-  PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, &eid));
-  PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, &eid));
-  PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &eid));
-  PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_2, &eid));
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size << " x " << size << ", repeats "
-            << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: "
-            << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-            << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-      pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1, eid + 50));
-
-  try {
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    Compute(queue1, a, b, c, size, repeat_count, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    std::cout << "Total execution time with tracing: " << time.count() << " sec" << std::endl;
-
-    start = std::chrono::steady_clock::now();
-    expected_result = A_VALUE * B_VALUE * size;
-
-    PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1, &eid));
-
-    Compute(std::move(queue), a, b, c, size, repeat_count, expected_result);
-    end = std::chrono::steady_clock::now();
-    time = end - start;
-
-    std::cout << "Total execution time without tracing: " << time.count() << " sec" << std::endl;
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  StopTracing();
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-
-  return exit_code;
-}
diff --git a/sdk/samples/dpc_gemm_threaded/CMakeLists.txt b/sdk/samples/dpc_gemm_threaded/CMakeLists.txt
deleted file mode 100644
index d087acdf..00000000
--- a/sdk/samples/dpc_gemm_threaded/CMakeLists.txt
+++ /dev/null
@@ -1,38 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_DPC_GEMM_THREADED CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(dpc_gemm_threaded main.cc)
-
-target_compile_options(dpc_gemm_threaded PRIVATE -fsycl)
-target_link_options(dpc_gemm_threaded PRIVATE -fsycl)
-target_include_directories(dpc_gemm_threaded PRIVATE
-                           "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-if (NOT TARGET Threads::Threads)
-  find_package(Threads REQUIRED)
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(dpc_gemm_threaded PUBLIC Threads::Threads Pti::pti_view)
diff --git a/sdk/samples/dpc_gemm_threaded/main.cc b/sdk/samples/dpc_gemm_threaded/main.cc
deleted file mode 100644
index b1702641..00000000
--- a/sdk/samples/dpc_gemm_threaded/main.cc
+++ /dev/null
@@ -1,389 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-//
-// Based on dpc_gemm sample. Added multithreading
-//
-
-#include <stdarg.h>
-#include <string.h>
-
-#include <cmath>
-#include <cstdlib>
-#include <memory>
-#include <sycl/sycl.hpp>
-#include <thread>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-#define NSEC_IN_SEC 1'000'000'000
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static bool verbose = false;
-
-static float Check(const std::vector<float>& a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  double time = 0.0;
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-
-    auto start = event.get_profiling_info<sycl::info::event_profiling::command_start>();
-    auto end = event.get_profiling_info<sycl::info::event_profiling::command_end>();
-    time = static_cast<double>(end - start) / NSEC_IN_SEC;
-  } catch (const sycl::exception& e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  if (verbose) {
-    std::cout << "\tMatrix multiplication time: " << time << " sec" << std::endl;
-  }
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    if (verbose) {
-      std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN")
-                << "CORRECT with accuracy: " << eps << std::endl;
-    }
-  }
-}
-
-constexpr auto kRequestedRecordCount = 1'000ULL;
-constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-void StartTracing() {
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DRIVER_API));
-}
-
-void StopTracing() {
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DRIVER_API));
-}
-
-void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-void ParseBuffer(unsigned char* buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    samples_utils::AlignedDealloc(buf);
-    return;
-  }
-  pti_view_record_base* ptr = nullptr;
-
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      std::cout << "Reached End of buffer" << '\n';
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Zecalls Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_overhead*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_external_correlation*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-
-        pti_view_record_memory_copy* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_copy*>(ptr);
-        samples_utils::DumpRecord(p_memory_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Memcopy Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-
-        pti_view_record_memory_fill* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_fill*>(ptr);
-        samples_utils::DumpRecord(p_memory_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Memfill Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-
-        pti_view_record_kernel* p_kernel_rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
-        samples_utils::DumpRecord(p_kernel_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_kernel_rec->_sycl_task_begin_timestamp, p_kernel_rec->_sycl_enqk_begin_timestamp,
-            p_kernel_rec->_append_timestamp, p_kernel_rec->_submit_timestamp,
-            p_kernel_rec->_start_timestamp, p_kernel_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Kernel Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-const unsigned max_thread_count = 64;
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-const unsigned default_size = 1024;
-const unsigned default_thread_count = 2;
-const unsigned default_repetition_per_thread = 4;
-
-void Usage(const char* name) {
-  std::cout << " Calculating floating point matrix multiply on gpu, submitting the work from many "
-               "CPU threads\n"
-            << "  Usage " << name << "  [ options ]" << std::endl;
-  std::cout << "--threads [-t]  integer         "
-            << "Threads number, default: " << default_thread_count << std::endl;
-  std::cout << "--size [-s]     integer        " << "Matrix size, default: " << default_size
-            << std::endl;
-  std::cout << "--repeat [-r]   integer         "
-            << "Repetition number per thread, default: " << default_repetition_per_thread
-            << std::endl;
-  std::cout << "--verbose [-v]                 "
-            << "Enable verbose mode to report the app progress, default: off" << std::endl;
-}
-
-int main(int argc, char* argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  unsigned thread_count = default_thread_count;
-  unsigned repeat_count = default_repetition_per_thread;
-  unsigned size = default_size;
-
-  try {
-    for (int i = 1; i < argc; i++) {
-      if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--size") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-      } else if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--threads") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        thread_count = (temp < 1) ? 1 : (temp > max_thread_count) ? max_thread_count : temp;
-      } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--repeat") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        repeat_count = (temp < 1) ? 1 : temp;
-      } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
-        // verbosity off makes minimal the sample self output -
-        // so profiling output won't be intermixed with the sample output
-        // and could be analyzed by tests
-        verbose = true;
-      } else {
-        Usage(argv[0]);
-        return EXIT_SUCCESS;
-      }
-    }
-  } catch (...) {
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  try {
-    PTI_THROW(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-
-    StartTracing();
-    sycl::device dev;
-    dev = sycl::device(sycl::gpu_selector_v);
-    sycl::property_list prop_list{sycl::property::queue::in_order(),
-                                  sycl::property::queue::enable_profiling()};
-    sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-    if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-      dev = sycl::device(sycl::cpu_selector_v);
-      std::cerr << "PTI doesn't support cpu profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
-      std::cerr << "PTI doesn't support host profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    }
-
-    float expected_result = A_VALUE * B_VALUE * size;
-
-    auto threadFunction = [&queue](unsigned _size, unsigned _repeat_count, float _expected_result) {
-      std::vector<float> a(_size * _size, A_VALUE);
-      std::vector<float> b(_size * _size, B_VALUE);
-      std::vector<float> c(_size * _size, 0.0f);
-
-      auto start = std::chrono::steady_clock::now();
-      Compute(queue, a, b, c, _size, _repeat_count, _expected_result);
-      auto end = std::chrono::steady_clock::now();
-      std::chrono::duration<float> time = end - start;
-
-      if (verbose) {
-        std::cout << "\t-- Total execution time: " << time.count() << " sec" << std::endl;
-      }
-    };
-
-    std::cout << "DPC++ Matrix Multiplication (CPU threads: " << thread_count
-              << ", matrix size: " << size << " x " << size << ", repeats: " << repeat_count
-              << " times)" << std::endl;
-    std::cout << "Target device: "
-              << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-              << std::endl
-              << std::flush;
-
-    std::vector<std::thread> the_threads;
-    for (unsigned i = 0; i < thread_count; i++) {
-      std::thread t = std::thread(threadFunction, size, repeat_count, expected_result);
-      the_threads.push_back(std::move(t));
-    }
-
-    for (auto& th : the_threads) {
-      if (th.joinable()) {
-        th.join();
-      }
-    }
-    StopTracing();
-    PTI_THROW(ptiFlushAllViews());
-  } catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  return exit_code;
-}
diff --git a/sdk/samples/iso3dfd_dpcpp/CMakeLists.txt b/sdk/samples/iso3dfd_dpcpp/CMakeLists.txt
deleted file mode 100644
index c6d28863..00000000
--- a/sdk/samples/iso3dfd_dpcpp/CMakeLists.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-                      "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules/")
-include(macros)
-
-cmake_minimum_required(VERSION 3.14)
-
-project (ISO3DFD)
-
-if (NOT CMAKE_BUILD_TYPE)
-    message (STATUS "Default CMAKE_BUILD_TYPE not set using Release with Debug Info")
-    set (CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE
-        STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel"
-        FORCE)
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler.")
-  return()
-endif()
-
-if (NOT TARGET DevUtilities::utils)
-  find_package(DevUtilities)
-endif()
-
-if (NOT TARGET DevUtilities::utils)
-  message(WARNING "${PROJECT_NAME} requires dev-utilities installed.")
-  return()
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-add_subdirectory (src)
diff --git a/sdk/samples/iso3dfd_dpcpp/License.txt b/sdk/samples/iso3dfd_dpcpp/License.txt
deleted file mode 100644
index e63c6e13..00000000
--- a/sdk/samples/iso3dfd_dpcpp/License.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-Copyright Intel Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/sdk/samples/iso3dfd_dpcpp/include/device_selector.hpp b/sdk/samples/iso3dfd_dpcpp/include/device_selector.hpp
deleted file mode 100644
index 6b8749d4..00000000
--- a/sdk/samples/iso3dfd_dpcpp/include/device_selector.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef DEVICESELECTOR_HPP
-#define DEVICESELECTOR_HPP
-
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <sycl/sycl.hpp>
-
-// This is the class provided to SYCL runtime by the application to decide
-// on which device to run, or whether to run at all.
-// When selecting a device, SYCL runtime first takes (1) a selector provided by
-// the program or a default one and (2) the set of all available devices. Then
-// it passes each device to the '()' operator of the selector. Device, for
-// which '()' returned the highest number, is selected. If a negative number
-// was returned for all devices, then the selection process will cause an
-// exception.
-class MyDeviceSelector {
- public:
-  MyDeviceSelector(const std::string &p) : pattern(p) {
-    // std::cout << "Looking for \"" << p << "\" devices" << std::endl;
-  }
-
-  // This is the function which gives a "rating" to devices.
-  int operator()(const sycl::device &device) const {
-    // The template parameter to device.get_info can be a variety of properties
-    // defined by the SYCL spec's sycl::info:: enum. Properties may have
-    // different types. Here we query name which is a string.
-    const std::string name = device.get_info<sycl::info::device::name>();
-    // std::cout << "Trying device: " << name << "..." << std::endl;
-    // std::cout << "  Vendor: " <<
-    // device.get_info<sycl::info::device::vendor>() << std::endl;
-
-    // Device with pattern in the name is prioritized:
-    return (name.find(pattern) != std::string::npos) ? 100 : 1;
-  }
-
- private:
-  std::string pattern;
-};
-
-#endif
diff --git a/sdk/samples/iso3dfd_dpcpp/include/iso3dfd.h b/sdk/samples/iso3dfd_dpcpp/include/iso3dfd.h
deleted file mode 100644
index 66116301..00000000
--- a/sdk/samples/iso3dfd_dpcpp/include/iso3dfd.h
+++ /dev/null
@@ -1,55 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <sycl/sycl.hpp>
-using namespace sycl;
-
-#include <mutex>
-#include <chrono>
-#include <cmath>
-#include <cstring>
-#include <ctime>
-#include <fstream>
-#include <algorithm>
-/*
- * Parameters to define coefficients
- * kHalfLength: Radius of the stencil
- * Sample source code is tested for kHalfLength=8 resulting in
- * 16th order Stencil finite difference kernel
- */
-constexpr float dt = 0.002f;
-constexpr float dxyz = 50.0f;
-constexpr unsigned int kHalfLength = 8;
-
-extern std::mutex global_cout_mtx;
-
-/*
- * Padding to test and eliminate shared local memory bank conflicts for
- * the shared local memory(slm) version of the kernel executing on GPU
- */
-constexpr unsigned int kPad = 0;
-
-bool Iso3dfdDevice(sycl::queue &q, float *ptr_next, float *ptr_prev,
-                     float *ptr_vel, float *ptr_coeff, size_t n1, size_t n2,
-                     size_t n3, size_t n1_block, size_t n2_block,
-                     size_t n3_block, size_t end_z, unsigned int num_iterations);
-
-void PrintTargetInfo(sycl::queue &q, unsigned int dim_x, unsigned int dim_y);
-
-void Usage(const std::string &program_name);
-
-void PrintStats(double time, size_t n1, size_t n2, size_t n3,
-                unsigned int num_iterations);
-
-bool WithinEpsilon(float *output, float *reference, const size_t dim_x,
-                    const size_t dim_y, const size_t dim_z,
-                    const unsigned int radius, const int zadjust,
-                    const float delta);
-
-bool CheckGridDimension(size_t n1, size_t n2, size_t n3, unsigned int dim_x,
-                        unsigned int dim_y, unsigned int block_z);
-
-bool CheckBlockDimension(sycl::queue &q, unsigned int dim_x, unsigned int dim_y);
diff --git a/sdk/samples/iso3dfd_dpcpp/sample.json b/sdk/samples/iso3dfd_dpcpp/sample.json
deleted file mode 100755
index a8ad0e57..00000000
--- a/sdk/samples/iso3dfd_dpcpp/sample.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-  "guid": "3A7DA713-6083-4CA3-B66E-A3DF21744EB4",
-  "name": "ISO3DFD",
-  "categories": ["Toolkit/oneAPI Direct Programming/C++SYCL/Structured Grids"],
-  "description": "The ISO3DFD Sample illustrates SYCL using Finite Difference Stencil Kernel for solving 3D Acoustic Isotropic Wave Equation",
-  "toolchain": [ "dpcpp" ],
-  "targetDevice": [ "CPU", "GPU" ],
-  "languages": [ { "cpp": {} } ],
-  "os": [ "linux", "windows" ],
-  "builder": [ "ide", "cmake" ],
-  "targetDevice": [ "CPU" ],
-  "ciTests": {
-	"linux": [{
-            "steps": [
-                        "mkdir build",
-                        "cd build",
-                        "cmake ..",
-                        "make",
-                        "make run"
-                 ]
-        }],
-        "windows": [{
-                "steps": [
-                        "MSBuild iso3dfd.sln /t:Rebuild /p:Configuration=\"Release\"",
-                        "cd x64/Release",
-                        "iso3dfd.exe 256 256 256 32 8 64 10 gpu"
-                ]
-        }]
-
-  },
-  "expertise": "Concepts and Functionality"
-}
diff --git a/sdk/samples/iso3dfd_dpcpp/src/CMakeLists.txt b/sdk/samples/iso3dfd_dpcpp/src/CMakeLists.txt
deleted file mode 100644
index b0e0264e..00000000
--- a/sdk/samples/iso3dfd_dpcpp/src/CMakeLists.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-option(SHARED_KERNEL "Use SLM Kernel Version - Only for GPU" OFF)
-
-# Set default build type to RelWithDebInfo if not specified
-if(NOT CMAKE_BUILD_TYPE)
-  message(
-    STATUS "Default CMAKE_BUILD_TYPE not set using Release with Debug Info")
-  set(CMAKE_BUILD_TYPE
-      "RelWithDebInfo"
-      CACHE
-        STRING
-        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel"
-        FORCE)
-endif()
-
-add_executable(iso3dfd iso3dfd.cpp iso3dfd_kernels.cpp utils.cpp)
-target_compile_options(iso3dfd PUBLIC -O3 -fsycl)
-target_link_options(iso3dfd PUBLIC -O3 -fsycl)
-target_include_directories(
-  iso3dfd PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../samples_utilities
-                      ${CMAKE_CURRENT_SOURCE_DIR}/../include)
-
-target_link_libraries(iso3dfd PUBLIC Pti::pti_view DevUtilities::utils)
-
-if(SHARED_KERNEL)
-  target_compile_definitions(iso3dfd PUBLIC USED_SHARED)
-endif()
-
-if(WIN32)
-  add_custom_target(runiso iso3dfd.exe 256 256 256 32 8 64 10 gpu)
-  add_custom_target(runiso_cpu iso3dfd.exe 256 256 256 256 1 1 10 cpu)
-else()
-  add_custom_target(runiso iso3dfd 256 256 256 32 8 64 10 gpu)
-  add_custom_target(runiso_cpu iso3dfd 256 256 256 256 1 1 10 cpu)
-endif()
diff --git a/sdk/samples/iso3dfd_dpcpp/src/iso3dfd.cpp b/sdk/samples/iso3dfd_dpcpp/src/iso3dfd.cpp
deleted file mode 100644
index 1e45e830..00000000
--- a/sdk/samples/iso3dfd_dpcpp/src/iso3dfd.cpp
+++ /dev/null
@@ -1,511 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// ISO3DFD: Data Parallel C++ Language Basics Using 3D-Finite-Difference-Wave
-// Propagation
-//
-// ISO3DFD is a finite difference stencil kernel for solving the 3D acoustic
-// isotropic wave equation. Kernels in this sample are implemented as 16th order
-// in space, 2nd order in time scheme without boundary conditions. Using Data
-// Parallel C++, the sample can explicitly run on the GPU and/or CPU to
-// calculate a result.  If successful, the output will print the device name
-// where the SYCL code ran along with the grid computation metrics - flops
-// and effective throughput
-//
-// For comprehensive instructions regarding SYCL Programming, go to
-// https://software.intel.com/en-us/oneapi-programming-guide
-// and search based on relevant terms noted in the comments.
-//
-// SYCL material used in this code sample:
-//
-// SYCL Queues (including device selectors and exception handlers)
-// SYCL Custom device selector
-// SYCL Buffers and accessors (communicate data between the host and the
-// device)
-// SYCL Kernels (including parallel_for function and nd-range<3>
-// objects)
-// Shared Local Memory (SLM) optimizations (SYCL)
-// SYCL Basic synchronization (barrier function)
-//
-#include "iso3dfd.h"
-#include <iostream>
-#include <string>
-#include <mutex>
-#include "device_selector.hpp"
-#include <dpc_common.hpp>
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-std::mutex global_cout_mtx;
-
-namespace oneapi {}
-using namespace oneapi;
-
-void StartTracing() {
-  assert(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL) == pti_result::PTI_SUCCESS);
-  assert(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY) == pti_result::PTI_SUCCESS);
-  assert(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL) == pti_result::PTI_SUCCESS);
-  assert(ptiViewEnable(PTI_VIEW_RUNTIME_API) == pti_result::PTI_SUCCESS);
-}
-
-void StopTracing() {
-  assert(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL) == pti_result::PTI_SUCCESS);
-  assert(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY) == pti_result::PTI_SUCCESS);
-  assert(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL) == pti_result::PTI_SUCCESS);
-  assert(ptiViewDisable(PTI_VIEW_RUNTIME_API) == pti_result::PTI_SUCCESS);
-}
-
-/*
- * Host-Code
- * Function used for initialization
- */
-void Initialize(float* ptr_prev, float* ptr_next, float* ptr_vel, size_t n1,
-                size_t n2, size_t n3) {
-  {
-    const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-    std::cout << "Initializing ... \n";
-  }
-  size_t dim2 = n2 * n1;
-
-  for (size_t i = 0; i < n3; i++) {
-    for (size_t j = 0; j < n2; j++) {
-      size_t offset = i * dim2 + j * n1;
-#pragma omp simd
-      for (size_t k = 0; k < n1; k++) {
-        ptr_prev[offset + k] = 0.0f;
-        ptr_next[offset + k] = 0.0f;
-        ptr_vel[offset + k] =
-            2250000.0f * dt * dt;  // Integration of the v*v and dt*dt
-      }
-    }
-  }
-  // Add a source to initial wavefield as an initial condition
-  float val = 1.f;
-  for (int s = 5; s >= 0; s--) {
-    for (size_t i = n3 / 2 - s; i < n3 / 2 + s; i++) {
-      for (size_t j = n2 / 4 - s; j < n2 / 4 + s; j++) {
-        size_t offset = i * dim2 + j * n1;
-        for (size_t k = n1 / 4 - s; k < n1 / 4 + s; k++) {
-          ptr_prev[offset + k] = val;
-        }
-      }
-    }
-    val *= 10;
-  }
-}
-
-/*
- * Host-Code
- * OpenMP implementation for single iteration of iso3dfd kernel.
- * This function is used as reference implementation for verification and
- * also to compare performance of OpenMP and SYCL on CPU
- * Additional Details:
- * https://software.intel.com/en-us/articles/eight-optimizations-for-3-dimensional-finite-difference-3dfd-code-with-an-isotropic-iso
- */
-void Iso3dfdIteration(float* ptr_next_base, float* ptr_prev_base,
-                      float* ptr_vel_base, float* coeff, const size_t n1,
-                      const size_t n2, const size_t n3, const size_t n1_block,
-                      const size_t n2_block, const size_t n3_block) {
-  size_t dimn1n2 = n1 * n2;
-  size_t n3End = n3 - kHalfLength;
-  size_t n2End = n2 - kHalfLength;
-  size_t n1End = n1 - kHalfLength;
-
-#pragma omp parallel default(shared)
-#pragma omp for schedule(static) collapse(3)
-  for (size_t bz = kHalfLength; bz < n3End;
-       bz += n3_block) {  // start of cache blocking
-    for (size_t by = kHalfLength; by < n2End; by += n2_block) {
-      for (size_t bx = kHalfLength; bx < n1End; bx += n1_block) {
-        size_t izEnd = std::min(bz + n3_block, n3End);
-        size_t iyEnd = std::min(by + n2_block, n2End);
-        size_t ixEnd = std::min(n1_block, n1End - bx);
-        for (size_t iz = bz; iz < izEnd; iz++) {  // start of inner iterations
-          for (size_t iy = by; iy < iyEnd; iy++) {
-            float* ptr_next = ptr_next_base + iz * dimn1n2 + iy * n1 + bx;
-            float* ptr_prev = ptr_prev_base + iz * dimn1n2 + iy * n1 + bx;
-            float* ptr_vel = ptr_vel_base + iz * dimn1n2 + iy * n1 + bx;
-#pragma omp simd
-            for (size_t ix = 0; ix < ixEnd; ix++) {
-              float value = 0.0;
-              value += ptr_prev[ix] * coeff[0];
-#pragma unroll(kHalfLength)
-              for (unsigned int ir = 1; ir <= kHalfLength; ir++) {
-                value += coeff[ir] *
-                         ((ptr_prev[ix + ir] + ptr_prev[ix - ir]) +
-                          (ptr_prev[ix + ir * n1] + ptr_prev[ix - ir * n1]) +
-                          (ptr_prev[ix + ir * dimn1n2] +
-                           ptr_prev[ix - ir * dimn1n2]));
-              }
-              ptr_next[ix] =
-                  2.0f * ptr_prev[ix] - ptr_next[ix] + value * ptr_vel[ix];
-            }
-          }
-        }  // end of inner iterations
-      }
-    }
-  }  // end of cache blocking
-}
-
-/*
- * Host-Code
- * Driver function for ISO3DFD OpenMP code
- * Uses ptr_next and ptr_prev as ping-pong buffers to achieve
- * accelerated wave propagation
- */
-void Iso3dfd(float* ptr_next, float* ptr_prev, float* ptr_vel, float* coeff,
-             const size_t n1, const size_t n2, const size_t n3,
-             const unsigned int nreps, const size_t n1_block,
-             const size_t n2_block, const size_t n3_block) {
-  for (unsigned int it = 0; it < nreps; it += 1) {
-    Iso3dfdIteration(ptr_next, ptr_prev, ptr_vel, coeff, n1, n2, n3, n1_block,
-                     n2_block, n3_block);
-
-    // here's where boundary conditions and halo exchanges happen
-    // Swap previous & next between iterations
-    it++;
-    if (it < nreps)
-      Iso3dfdIteration(ptr_prev, ptr_next, ptr_vel, coeff, n1, n2, n3, n1_block,
-                       n2_block, n3_block);
-  }  // time loop
-}
-
-/*
- * Host-Code
- * Main function to drive the sample application
- */
-int main(int argc, char* argv[]) {
-  // Arrays used to update the wavefield
-  float* prev_base;
-  float* next_base;
-  // Array to store wave velocity
-  float* vel_base;
-  // Array to store results for comparison
-  float* temp;
-
-  bool sycl = true;
-  bool omp = true;
-  bool error = false;
-  bool is_gpu = true;
-
-  size_t n1, n2, n3;
-  size_t n1_block, n2_block, n3_block;
-  unsigned int num_iterations;
-
-  ptiViewSetCallbacks(
-      [](auto **buf, auto *buf_size) {
-        *buf_size = sizeof(pti_view_record_kernel) * 100;
-        void *ptr = ::operator new(*buf_size);
-        ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-        *buf = reinterpret_cast<unsigned char *>(ptr);
-        if (!*buf) {
-          std::abort();
-        }
-        return;
-      },
-      [](auto *buf, auto buf_size, auto valid_buf_size) {
-        if (!buf_size || !valid_buf_size || !buf_size) {
-          std::cerr << "Received empty buffer" << '\n';
-          if (valid_buf_size) {
-            ::operator delete(buf);
-          }
-          return;
-        }
-        pti_view_record_base *ptr = nullptr;
-        while (true) {
-          auto buf_status =
-              ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-          const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-          if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-            std::cout << "Reached End of buffer" << '\n';
-            break;
-          }
-          if (buf_status != pti_result::PTI_SUCCESS) {
-            std::cerr << "Found Error Parsing Records from PTI" << '\n';
-            break;
-          }
-          switch (ptr->_view_kind) {
-            case pti_view_kind::PTI_VIEW_INVALID: {
-              std::cout << "Found Invalid Record" << '\n';
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Sycl Runtime Record" << '\n';
-              samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-              break;
-            }
-            case pti_view_kind:: PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Memory Record" << '\n';
-              samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy *>(ptr));
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              break;
-            }
-            case pti_view_kind:: PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Memory Record" << '\n';
-              samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill *>(ptr));
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              break;
-            }
-            case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-              pti_view_record_kernel* rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              std::cout << "Found Kernel Record" << '\n';
-              samples_utils::DumpRecord(rec);
-              std::cout << "---------------------------------------------------"
-                           "-----------------------------"
-                        << '\n';
-              if (samples_utils::IsMonotonic(
-                                  {
-                                    rec->_sycl_task_begin_timestamp ,
-                                    rec->_sycl_enqk_begin_timestamp ,
-                                    rec->_append_timestamp ,
-                                    rec->_submit_timestamp ,
-                                    rec->_start_timestamp ,
-                                    rec->_end_timestamp
-                                  }
-                                )) {
-                  std::cout << "------------>     All Monotonic" << std::endl;
-                } else {
-                  std::cout << "------------>     Something wrong: NOT All monotonic" << std::endl;
-                }
-                if (rec->_sycl_task_begin_timestamp == 0) {
-                  std::cout << "------------>     Something wrong: Sycl Task Begin Time is 0" << std::endl;
-                }
-                if ( rec->_sycl_enqk_begin_timestamp == 0) {
-                 std::cout << "------------>     Something wrong: Sycl Enq Launch Kernel Time is 0" << std::endl;
-                }
-              break;
-            }
-            default: {
-              std::cerr << "This shouldn't happen: " << ptr->_view_kind << '\n';
-              break;
-            }
-          }
-        }
-        ::operator delete(buf);
-      });
-
-  StartTracing();
-
-  // Read Input Parameters
-  try {
-    n1 = std::stoi(argv[1]) + (2 * kHalfLength);
-    n2 = std::stoi(argv[2]) + (2 * kHalfLength);
-    n3 = std::stoi(argv[3]) + (2 * kHalfLength);
-    n1_block = std::stoi(argv[4]);
-    n2_block = std::stoi(argv[5]);
-    n3_block = std::stoi(argv[6]);
-    num_iterations = std::stoi(argv[7]);
-  }
-
-  catch (...) {
-    Usage(argv[0]);
-    return 1;
-  }
-
-  // Read optional arguments to select version and device
-  for (auto arg = 8; arg < argc; arg++) {
-    std::string arg_value = argv[arg];
-    std::transform(arg_value.begin(), arg_value.end(), arg_value.begin(), ::tolower);
-
-    if (arg_value == "omp") {
-      omp = true;
-      sycl = false;
-    } else if (arg_value == "sycl") {
-      omp = false;
-      sycl = true;
-    } else if (arg_value == "gpu") {
-      is_gpu = true;
-    } else if (arg_value == "cpu") {
-      is_gpu = false;
-    } else {
-      Usage(argv[0]);
-      return 1;
-    }
-  }
-
-  // Validate input sizes for the grid and block dimensions
-  if (CheckGridDimension(n1 - 2 * kHalfLength, n2 - 2 * kHalfLength,
-                         n3 - 2 * kHalfLength, n1_block, n2_block, n3_block)) {
-    Usage(argv[0]);
-    return 1;
-  }
-
-  // Compute the total size of grid
-  size_t nsize = n1 * n2 * n3;
-
-  try {
-    prev_base = new float[nsize];
-    next_base = new float[nsize];
-    vel_base = new float[nsize];
-  } catch (const std::bad_alloc& e) {
-    std::cerr << "Error: While attempting to allocate space for grid, caught exception: " << e.what() <<"."  <<  '\n';
-    return 1;
-  }
-
-  // Compute coefficients to be used in wavefield update
-  float coeff[kHalfLength + 1] = {-3.0548446,   +1.7777778,     -3.1111111e-1,
-                                  +7.572087e-2, -1.76767677e-2, +3.480962e-3,
-                                  -5.180005e-4, +5.074287e-5,   -2.42812e-6};
-
-  // Apply the DX DY and DZ to coefficients
-  coeff[0] = (3.0f * coeff[0]) / (dxyz * dxyz);
-  for (unsigned int i = 1; i <= kHalfLength; i++) {
-    coeff[i] = coeff[i] / (dxyz * dxyz);
-  }
-
-  {
-    const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-    std::cout << "Grid Sizes: " << n1 - 2 * kHalfLength << " "
-              << n2 - 2 * kHalfLength << " " << n3 - 2 * kHalfLength << "\n";
-    std::cout << "Memory Usage: " << ((3 * nsize * sizeof(float)) / (1024 * 1024))
-              << " MB\n";
-  }
-
-  // Check if running OpenMP OR Serial version on CPU
-  if (omp) {
-    {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-#if defined(_OPENMP)
-      std::cout << " ***** Running OpenMP variant *****\n";
-#else
-      std::cout << " ***** Running C++ Serial variant *****\n";
-#endif
-    }
-
-    // Initialize arrays and introduce initial conditions (source)
-    Initialize(prev_base, next_base, vel_base, n1, n2, n3);
-
-    // Start timer
-    dpc_common::TimeInterval t_ser;
-    // Invoke the driver function to perform 3D wave propagation
-    // using OpenMP/Serial version
-    Iso3dfd(next_base, prev_base, vel_base, coeff, n1, n2, n3, num_iterations,
-            n1_block, n2_block, n3_block);
-
-    // End timer
-    PrintStats(t_ser.Elapsed() * 1e3, n1, n2, n3, num_iterations);
-  }
-
-  // Check if running both OpenMP/Serial and SYCL version
-  // Keeping a copy of output buffer from OpenMP version
-  // for comparison
-  if (omp && sycl) {
-    temp = new float[nsize];
-    if (num_iterations % 2)
-      memcpy(temp, next_base, nsize * sizeof(float));
-    else
-      memcpy(temp, prev_base, nsize * sizeof(float));
-  }
-
-  // Check if running SYCL version
-  if (sycl) {
-    try {
-      {
-        const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-        std::cout << " ***** Running SYCL variant *****\n";
-      }
-      // Initialize arrays and introduce initial conditions (source)
-      Initialize(prev_base, next_base, vel_base, n1, n2, n3);
-
-      // Initializing a string pattern to allow a custom device selector
-      // pick a SYCL device as per user's preference and available devices
-      // Default value of pattern is set to CPU
-      std::string pattern("CPU");
-      std::string pattern_gpu("Gen");
-
-      // Replacing the pattern string to Gen if running on a GPU
-      if (is_gpu) {
-        pattern.replace(0, 3, pattern_gpu);
-      }
-
-      // Create a custom device selector using SYCL device selector class
-      MyDeviceSelector device_sel(pattern);
-
-      // Create a device queue using SYCL class queue with a custom
-      // device selector
-      queue q(device_sel);
-
-      // Validate if the block sizes selected are
-      // within range for the selected SYCL device
-      if (CheckBlockDimension(q, n1_block, n2_block)) {
-        Usage(argv[0]);
-        return 1;
-      }
-
-      // Start timer
-      dpc_common::TimeInterval t_dpc;
-
-      // Invoke the driver function to perform 3D wave propagation
-      // using SYCL version on the selected device
-      Iso3dfdDevice(q, next_base, prev_base, vel_base, coeff, n1, n2, n3,
-                    n1_block, n2_block, n3_block, n3 - kHalfLength,
-                    num_iterations);
-      // Wait for the commands to complete. Enforce synchronization on the command
-      // queue
-      q.wait_and_throw();
-
-      // End timer
-      PrintStats(t_dpc.Elapsed() * 1e3, n1, n2, n3, num_iterations);
-    } catch (const sycl::exception &e) {
-      std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-      std::cerr << "\tError code: " << e.code().value()
-                << "\n\tCategory: " << e.category().name()
-                << "\n\tMessage: " << e.code().message() << '\n';
-    } catch (const std::exception &e) {
-      std::cerr << "Error: Exception caught " << e.what() << '\n';
-    } catch (...) {
-      std::cerr << "Error: Unknown exception caught." << '\n';
-    }
-  }
-
-  // If running both OpenMP/Serial and SYCL version
-  // Comparing results
-  if (omp && sycl) {
-    if (num_iterations % 2) {
-      error = WithinEpsilon(next_base, temp, n1, n2, n3, kHalfLength, 0, 0.1f);
-    } else {
-      error = WithinEpsilon(prev_base, temp, n1, n2, n3, kHalfLength, 0, 0.1f);
-    }
-    if (error) {
-      std::cerr << "Final wavefields from SYCL device and CPU are not "
-                << "equivalent: Fail\n";
-    } else {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-      std::cout << "Final wavefields from SYCL device and CPU are equivalent:"
-                << " Success\n";
-    }
-    {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-      std::cout << "--------------------------------------\n";
-    }
-    delete[] temp;
-  }
-
-  delete[] prev_base;
-  delete[] next_base;
-  delete[] vel_base;
-
-  StopTracing();
-  assert(ptiFlushAllViews() == pti_result::PTI_SUCCESS);
-
-  return error ? 1 : 0;
-}
diff --git a/sdk/samples/iso3dfd_dpcpp/src/iso3dfd_kernels.cpp b/sdk/samples/iso3dfd_dpcpp/src/iso3dfd_kernels.cpp
deleted file mode 100644
index 96f12aac..00000000
--- a/sdk/samples/iso3dfd_dpcpp/src/iso3dfd_kernels.cpp
+++ /dev/null
@@ -1,472 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-// ISO3DFD: Data Parallel C++ Language Basics Using 3D-Finite-Difference-Wave
-// Propagation
-//
-// ISO3DFD is a finite difference stencil kernel for solving the 3D acoustic
-// isotropic wave equation which can be used as a proxy for propagating a
-// seismic wave. Kernels in this sample are implemented as 16th order in space,
-// with symmetric coefficients, and 2nd order in time scheme without boundary
-// conditions.. Using Data Parallel C++, the sample can explicitly run on the
-// GPU and/or CPU to propagate a seismic wave which is a compute intensive task.
-// If successful, the output will print the device name
-// where the SYCL code ran along with the grid computation metrics - flops
-// and effective throughput.
-//
-// For comprehensive instructions regarding SYCL Programming, go to
-// https://software.intel.com/en-us/oneapi-programming-guide
-// and search based on relevant terms noted in the comments.
-//
-// SYCL material used in this code sample:
-//
-// SYCL Queues (including device selectors and exception handlers)
-// SYCL Custom device selector
-// SYCL Buffers and accessors (communicate data between the host and the
-// device)
-// SYCL Kernels (including parallel_for function and nd-range<3>
-// objects)
-// Shared Local Memory (SLM) optimizations (SYCL)
-// SYCL Basic synchronization (barrier function)
-//
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-
-#include "iso3dfd.h"
-
-#define NSEC_IN_USEC 1000
-#define MSEC_IN_SEC  1000
-#define NSEC_IN_MSEC 1000000
-#define NSEC_IN_SEC  1000000000
-
-inline uint64_t GetTime() {
-#if defined(_WIN32)
-  LARGE_INTEGER ticks{ {0, 0} };
-  LARGE_INTEGER frequency{ {0, 0} };
-  BOOL status = QueryPerformanceFrequency(&frequency);
-
-  if (!status) {
-    std::cerr << "Could not query performance frequency" << '\n';
-    std::abort();
-  }
-
-  status = QueryPerformanceCounter(&ticks);
-
-  if (!status) {
-    std::cerr << "Could not query performance counter" << '\n';
-    std::abort();
-  }
-
-  return ticks.QuadPart * (NSEC_IN_SEC / frequency.QuadPart);
-#else
- timespec ts{0, 0};
- int status = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
- if(status) {
-   std::cerr << "Error while getting time: " << std::strerror(errno) << '\n';
-   std::abort();
- }
- return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-#endif
-  }
-/*
- * Device-Code - Optimized for GPU
- * SYCL implementation for single iteration of iso3dfd kernel
- * using shared local memory optimizations
- *
- * ND-Range kernel is used to spawn work-items in x, y dimension
- * Each work-item then traverses in the z-dimension
- *
- * z-dimension slicing can be used to vary the total number
- * global work-items.
- *
- * SLM Padding can be used to eliminate SLM bank conflicts if
- * there are any
- */
-void Iso3dfdIterationSLM(sycl::nd_item<3> &it, float *next, float *prev,
-                         float *vel, const float *coeff, float *tab, size_t nx,
-                         size_t nxy, size_t bx, size_t by, size_t z_offset,
-                         size_t full_end_z) {
-  // Compute local-id for each work-item
-  auto id0 = it.get_local_id(2);
-  auto id1 = it.get_local_id(1);
-
-  // Compute the position in local memory each work-item
-  // will fetch data from global memory into shared
-  // local memory
-  auto stride = it.get_local_range(2) + 2 * kHalfLength + kPad;
-  auto identifiant = (id0 + kHalfLength) + (id1 + kHalfLength) * stride;
-
-  // We compute the start and the end position in the grid
-  // for each work-item.
-  // Each work-items local value gid is updated to track the
-  // current cell/grid point it is working with.
-  // This position is calculated with the help of slice-ID and number of
-  // grid points each work-item will process.
-  // Offset of kHalfLength is also used to account for HALO
-  auto begin_z = it.get_global_id(0) * z_offset + kHalfLength;
-  auto end_z = begin_z + z_offset;
-  if (end_z > full_end_z) end_z = full_end_z;
-
-  auto gid = (it.get_global_id(2) + bx) + ((it.get_global_id(1) + by) * nx) +
-             (begin_z * nxy);
-
-  // front and back temporary arrays are used to ensure
-  // the grid values in z-dimension are read once, shifted in
-  // these array and reused multiple times before being discarded
-  //
-  // This is an optimization technique to enable data-reuse and
-  // improve overall FLOPS to BYTES read ratio
-  float front[kHalfLength + 1];
-  float back[kHalfLength];
-  float c[kHalfLength + 1];
-
-  for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-    front[iter] = prev[gid + iter * nxy];
-  }
-  c[0] = coeff[0];
-
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    back[iter - 1] = prev[gid - iter * nxy];
-    c[iter] = coeff[iter];
-  }
-
-  // Shared Local Memory (SLM) optimizations (SYCL)
-  // Set some flags to indicate if the current work-item
-  // should read from global memory to shared local memory buffer
-  // or not
-  auto items_x = it.get_local_range(2);
-  auto items_y = it.get_local_range(1);
-
-  bool copy_halo_y = false, copy_halo_x = false;
-  if (id1 < kHalfLength) copy_halo_y = true;
-  if (id0 < kHalfLength) copy_halo_x = true;
-
-  for (auto i = begin_z; i < end_z; i++) {
-    // Shared Local Memory (SLM) optimizations (SYCL)
-    // If work-item is flagged to read into SLM buffer
-    if (copy_halo_y) {
-      tab[identifiant - kHalfLength * stride] = prev[gid - kHalfLength * nx];
-      tab[identifiant + items_y * stride] = prev[gid + items_y * nx];
-    }
-    if (copy_halo_x) {
-      tab[identifiant - kHalfLength] = prev[gid - kHalfLength];
-      tab[identifiant + items_x] = prev[gid + items_x];
-    }
-    tab[identifiant] = front[0];
-
-    // SYCL Basic synchronization (barrier function)
-    // Force synchronization within a work-group
-    // using barrier function to ensure
-    // all the work-items have completed reading into the SLM buffer
-    sycl::group_barrier(it.get_group());
-
-    // Only one new data-point read from global memory
-    // in z-dimension (depth)
-    front[kHalfLength] = prev[gid + kHalfLength * nxy];
-
-    // Stencil code to update grid point at position given by global id (gid)
-    // New time step for grid point is computed based on the values of the
-    // the immediate neighbors - horizontal, vertical and depth
-    // directions(kHalfLength number of points in each direction),
-    // as well as the value of grid point at a previous time step
-    //
-    // Neighbors in the depth (z-dimension) are read out of
-    // front and back arrays
-    // Neighbors in the horizontal and vertical (x, y dimension) are
-    // read from the SLM buffers
-    float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-    for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-      value += c[iter] *
-               (front[iter] + back[iter - 1] + tab[identifiant + iter] +
-                tab[identifiant - iter] + tab[identifiant + iter * stride] +
-                tab[identifiant - iter * stride]);
-    }
-    next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-    // Update the gid to advance in the z-dimension
-    gid += nxy;
-
-    // Input data in front and back are shifted to discard the
-    // oldest value and read one new value.
-    for (unsigned int iter = kHalfLength - 1; iter > 0; iter--) {
-      back[iter] = back[iter - 1];
-    }
-    back[0] = front[0];
-
-    for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-      front[iter] = front[iter + 1];
-    }
-
-    // SYCL Basic synchronization (barrier function)
-    // Force synchronization within a work-group
-    // using barrier function to ensure that SLM buffers
-    // are not overwritten by next set of work-items
-    // (highly unlikely but not impossible)
-    sycl::group_barrier(it.get_group());
-  }
-}
-
-/*
- * Device-Code - Optimized for GPU, CPU
- * SYCL implementation for single iteration of iso3dfd kernel
- * without using any shared local memory optimizations
- *
- *
- * ND-Range kernel is used to spawn work-items in x, y dimension
- * Each work-item can then traverse in the z-dimension
- *
- * z-dimension slicing can be used to vary the total number
- * global work-items.
- *
- */
-void Iso3dfdIterationGlobal(sycl::nd_item<3> &it, float *next, float *prev,
-                            const float *vel, const float *coeff, int nx, int nxy,
-                            int bx, int by, int z_offset, size_t full_end_z) {
-  // We compute the start and the end position in the grid
-  // for each work-item.
-  // Each work-items local value gid is updated to track the
-  // current cell/grid point it is working with.
-  // This position is calculated with the help of slice-ID and number of
-  // grid points each work-item will process.
-  // Offset of kHalfLength is also used to account for HALO
-  auto begin_z = it.get_global_id(0) * z_offset + kHalfLength;
-  auto end_z = begin_z + z_offset;
-  if (end_z > full_end_z) end_z = full_end_z;
-
-  auto gid = (it.get_global_id(2) + bx) + ((it.get_global_id(1) + by) * nx) +
-             (begin_z * nxy);
-
-  // front and back temporary arrays are used to ensure
-  // the grid values in z-dimension are read once, shifted in
-  // these array and reused multiple times before being discarded
-  //
-  // This is an optimization technique to enable data-reuse and
-  // improve overall FLOPS to BYTES read ratio
-  float front[kHalfLength + 1];
-  float back[kHalfLength];
-  float c[kHalfLength + 1];
-
-  for (unsigned int iter = 0; iter <= kHalfLength; iter++) {
-    front[iter] = prev[gid + iter * nxy];
-  }
-  c[0] = coeff[0];
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    c[iter] = coeff[iter];
-    back[iter - 1] = prev[gid - iter * nxy];
-  }
-
-  // Stencil code to update grid point at position given by global id (gid)
-  // New time step for grid point is computed based on the values of the
-  // the immediate neighbors - horizontal, vertical and depth
-  // directions(kHalfLength number of points in each direction),
-  // as well as the value of grid point at a previous time step
-
-  float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    value += c[iter] *
-             (front[iter] + back[iter - 1] + prev[gid + iter] +
-              prev[gid - iter] + prev[gid + iter * nx] + prev[gid - iter * nx]);
-  }
-  next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-  // Update the gid and position in z-dimension and check if there
-  // is more work to do
-  gid += nxy;
-  begin_z++;
-
-  while (begin_z < end_z) {
-    // Input data in front and back are shifted to discard the
-    // oldest value and read one new value.
-    for (auto iter = kHalfLength - 1; iter > 0; iter--) {
-      back[iter] = back[iter - 1];
-    }
-    back[0] = front[0];
-
-    for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-      front[iter] = front[iter + 1];
-    }
-
-    // Only one new data-point read from global memory
-    // in z-dimension (depth)
-    front[kHalfLength] = prev[gid + kHalfLength * nxy];
-
-    // Stencil code to update grid point at position given by global id (gid)
-    float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-    for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-      value += c[iter] * (front[iter] + back[iter - 1] + prev[gid + iter] +
-                          prev[gid - iter] + prev[gid + iter * nx] +
-                          prev[gid - iter * nx]);
-    }
-
-    next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-    gid += nxy;
-    begin_z++;
-  }
-}
-
-/*
- * Host-side SYCL Code
- *
- * Driver function for ISO3DFD SYCL code
- * Uses ptr_next and ptr_prev as ping-pong buffers to achieve
- * accelerated wave propagation
- *
- * This function uses SYCL buffers to facilitate host to device
- * buffer copies
- *
- */
-
-bool Iso3dfdDevice(sycl::queue &q, float *ptr_next, float *ptr_prev,
-                   float *ptr_vel, float *ptr_coeff, size_t n1, size_t n2,
-                   size_t n3, size_t n1_block, size_t n2_block, size_t n3_block,
-                   size_t end_z, unsigned int nIterations) {
-  auto nx = n1;
-  auto nxy = n1 * n2;
-
-  auto bx = kHalfLength;
-  auto by = kHalfLength;
-
-  // Display information about the selected device
-  PrintTargetInfo(q, n1_block, n2_block);
-
-  auto grid_size = nxy * n3;
-
-  {  // Begin buffer scope
-    // Create buffers using SYCL class buffer
-    buffer b_ptr_next(ptr_next, range(grid_size));
-    buffer b_ptr_prev(ptr_prev, range(grid_size));
-    buffer b_ptr_vel(ptr_vel, range(grid_size));
-    buffer b_ptr_coeff(ptr_coeff, range(kHalfLength + 1));
-
-    // Iterate over time steps
-    for (unsigned int i = 0; i < nIterations; i += 1) {
-      // Submit command group for execution
-      {
-        const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-        std::cout << "Q Submitting at: " << i << ": " << std::dec << GetTime() << std::endl;
-      }
-      q.submit([&](auto &h) {
-        // Create accessors
-        accessor next(b_ptr_next, h);
-        accessor prev(b_ptr_prev, h);
-        accessor vel(b_ptr_vel, h, read_only);
-        accessor coeff(b_ptr_coeff, h, read_only);
-
-        // Define local and global range
-
-        // Define local ND range of work-items
-        // Size of each SYCL work-group selected here is a product of
-        // n2_block and n1_block which can be controlled by the input
-        // command line arguments
-        auto local_nd_range = range(1, n2_block, n1_block);
-
-        // Define global ND range of work-items
-        // Size of total number of work-items is selected based on the
-        // total grid size in first and second dimensions (XY-plane)
-        //
-        // Each of the work-item then works on computing
-        // one or more grid points. This value can be controlled by the
-        // input command line argument n3_block
-        //
-        // Effectively this implementation enables slicing of the full
-        // grid into smaller grid slices which can be computed in parallel
-        // to allow auto-scaling of the total number of work-items
-        // spawned to achieve full occupancy for small or larger accelerator
-        // devices
-        auto global_nd_range =
-            range((n3 - 2 * kHalfLength) / n3_block, (n2 - 2 * kHalfLength),
-                  (n1 - 2 * kHalfLength));
-
-#ifdef USE_SHARED
-        // Using 3D-stencil kernel with Shared Local Memory (SLM)
-        // optimizations (SYCL) to improve effective FLOPS to BYTES
-        // ratio. By default, SLM code path is disabled in this
-        // code sample.
-        // SLM code path can be enabled by recompiling the SYCL source
-        // as follows:
-        // cmake -DSHARED_KERNEL=1 ..
-        // make -j`nproc`
-
-        // Define a range for SLM Buffer
-        // Padding can be used to avoid SLM bank conflicts
-        // By default padding is disabled in the sample code
-        auto local_range = range((n1_block + (2 * kHalfLength) + kPad) *
-                                 (n2_block + (2 * kHalfLength)));
-
-        //  Create an accessor for SLM buffer
-        accessor<float, 1, access::mode::read_write, access::target::local> tab(
-            local_range, h);
-
-        // Send a SYCL kernel (lambda) for parallel execution
-        // The function that executes a single iteration is called
-        // "Iso3dfdIterationSLM"
-        // alternating the 'next' and 'prev' parameters which effectively
-        // swaps their content at every iteration.
-        if (i % 2 == 0)
-          h.parallel_for(
-              nd_range(global_nd_range, local_nd_range), [=](auto it) {
-                Iso3dfdIterationSLM(it, next.get(), prev.get(),
-                                    vel.get(), coeff.get(),
-                                    tab.get(), nx, nxy, bx, by,
-                                    n3_block, end_z);
-              });
-        else
-          h.parallel_for(
-              nd_range(global_nd_range, local_nd_range), [=](auto it) {
-                Iso3dfdIterationSLM(it, prev.get(), next.get(),
-                                    vel.get(), coeff.get(),
-                                    tab.get(), nx, nxy, bx, by,
-                                    n3_block, end_z);
-              });
-
-#else
-
-        // Use Global Memory version of the 3D-Stencil kernel.
-        // This code path is enabled by default
-
-        // Send a SYCL kernel (lambda) for parallel execution
-        // The function that executes a single iteration is called
-        // "Iso3dfdIterationGlobal"
-        // alternating the 'next' and 'prev' parameters which effectively
-        // swaps their content at every iteration.
-        if (i % 2 == 0)
-          h.parallel_for(
-              nd_range(global_nd_range, local_nd_range), [=](auto it) {
-                auto next_ptr = next.template get_multi_ptr<sycl::access::decorated::no>();
-                auto prev_ptr = prev.template get_multi_ptr<sycl::access::decorated::no>();
-                auto vel_ptr = vel.template get_multi_ptr<sycl::access::decorated::no>();
-                auto coeff_ptr = coeff.template get_multi_ptr<sycl::access::decorated::no>();
-                Iso3dfdIterationGlobal(it, next_ptr.get(),
-                                       prev_ptr.get(), vel_ptr.get(),
-                                       coeff_ptr.get(), nx, nxy, bx, by,
-                                       n3_block, end_z);
-              });
-        else
-          h.parallel_for(
-              nd_range(global_nd_range, local_nd_range), [=](auto it) {
-                auto next_ptr = next.template get_multi_ptr<sycl::access::decorated::no>();
-                auto prev_ptr = prev.template get_multi_ptr<sycl::access::decorated::no>();
-                auto vel_ptr = vel.template get_multi_ptr<sycl::access::decorated::no>();
-                auto coeff_ptr = coeff.template get_multi_ptr<sycl::access::decorated::no>();
-                Iso3dfdIterationGlobal(it, prev_ptr.get(),
-                                       next_ptr.get(), vel_ptr.get(),
-                                       coeff_ptr.get(), nx, nxy, bx, by,
-                                       n3_block, end_z);
-              });
-#endif
-      });
-    }
-  }  // end buffer scope
-  return true;
-}
diff --git a/sdk/samples/iso3dfd_dpcpp/src/utils.cpp b/sdk/samples/iso3dfd_dpcpp/src/utils.cpp
deleted file mode 100644
index 32150a53..00000000
--- a/sdk/samples/iso3dfd_dpcpp/src/utils.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <cmath>
-#include "iso3dfd.h"
-
-/*
- * Host-Code
- * Utility function to validate grid and block dimensions
- */
-bool CheckGridDimension(size_t n1, size_t n2, size_t n3, unsigned int dim_x,
-                        unsigned int dim_y, unsigned int block_z) {
-
-  if (0 == dim_x) {
-    std::cout << " ERROR: Invalid Grid Size: DIMX cannot be Zero\n";
-    return true;
-  }
-  if (0 == dim_y) {
-    std::cout << " ERROR: Invalid Grid Size: DIMY cannot be Zero\n";
-    return true;
-  }
-  if (0 == block_z) {
-    std::cout << " ERROR: Invalid Grid Size: BLOCKZ cannot be Zero\n";
-    return true;
-  }
-
-  if (n1 % dim_x) {
-    std::cout << " ERROR: Invalid Grid Size: n1 should be multiple of DIMX - "
-              << dim_x << "\n";
-    return true;
-  }
-  if (n2 % dim_y) {
-    std::cout << " ERROR: Invalid Grid Size: n2 should be multiple of DIMY - "
-              << dim_y << "\n";
-    return true;
-  }
-  if (n3 % block_z) {
-    std::cout << " ERROR: Invalid Grid Size: n3 should be multiple of BLOCKZ - "
-              << block_z << "\n";
-    return true;
-  }
-
-  return false;
-}
-
-/*
- * Host-Code
- * Utility function to validate block sizes
- */
-bool CheckBlockDimension(sycl::queue& q, unsigned int dim_x,
-                         unsigned int dim_y) {
-  auto device = q.get_device();
-  auto max_block_size =
-      device.get_info<sycl::info::device::max_work_group_size>();
-
-  if ((max_block_size > 1) && (static_cast<std::size_t>(dim_x) * dim_y > max_block_size)) {
-    std::cout << "ERROR: Invalid block sizes: n1_Tblock * n2_Tblock should be "
-                 "less than or equal to "
-              << max_block_size << "\n";
-    return true;
-  }
-
-  return false;
-}
-
-/*
- * Host-Code
- * Utility function to print device info
- */
-void PrintTargetInfo(sycl::queue& q, unsigned int dim_x, unsigned int dim_y) {
-  auto device = q.get_device();
-  auto max_block_size =
-      device.get_info<sycl::info::device::max_work_group_size>();
-
-  auto max_exec_unit_count =
-      device.get_info<sycl::info::device::max_compute_units>();
-
-  std::cout << " Running on " << device.get_info<sycl::info::device::name>()
-            << "\n";
-  std::cout << " The Device Max Work Group Size is : " << max_block_size
-            << "\n";
-  std::cout << " The Device Max EUCount is : " << max_exec_unit_count << "\n";
-  std::cout << " The blockSize x is : " << dim_x << "\n";
-  std::cout << " The blockSize y is : " << dim_y << "\n";
-#ifdef USE_SHARED
-  std::cout << " Using Shared Local Memory Kernel\n";
-#else
-  std::cout << " Using Global Memory Kernel\n";
-
-#endif
-}
-
-/*
- * Host-Code
- * Utility function to get input arguments
- */
-void Usage(const std::string& programName) {
-  std::cout << " Incorrect parameters \n";
-  std::cout << " Usage: ";
-  std::cout << programName
-            << " n1 n2 n3 b1 b2 b3 Iterations [omp|sycl] [gpu|cpu] \n\n";
-  std::cout << " n1 n2 n3      : Grid sizes for the stencil \n";
-  std::cout << " b1 b2 b3      : cache block sizes for cpu openmp version.\n";
-  std::cout << " Iterations    : No. of timesteps. \n";
-  std::cout << " [omp|sycl]    : Optional: Run the OpenMP or the SYCL variant."
-            << " Default is to use both for validation \n";
-  std::cout
-      << " [gpu|cpu]     : Optional: Device to run the SYCL version"
-      << " Default is to use the GPU if available, if not fallback to CPU \n\n";
-}
-
-/*
- * Host-Code
- * Utility function to print stats
- */
-void PrintStats(double time, size_t n1, size_t n2, size_t n3,
-                unsigned int nIterations) {
-  float throughput_mpoints = 0.0f, mflops = 0.0f, normalized_time = 0.0f;
-  double mbytes = 0.0;
-
-  std::cout << "--------------------------------------\n";
-  if (0 < nIterations) {
-    normalized_time = (double)time / nIterations;
-    throughput_mpoints = ((n1 - 2 * kHalfLength) * (n2 - 2 * kHalfLength) *
-                          (n3 - 2 * kHalfLength)) /
-                          (normalized_time * 1e3f);
-    mflops = (7.0f * kHalfLength + 5.0f) * throughput_mpoints;
-    mbytes = 12.0f * throughput_mpoints;
-
-    std::cout << "time         : " << time / 1e3f << " secs\n";
-    std::cout << "throughput   : " << throughput_mpoints << " Mpts/s\n";
-    std::cout << "flops        : " << mflops / 1e3f << " GFlops\n";
-    std::cout << "bytes        : " << mbytes / 1e3f << " GBytes/s\n";
-  } else {
-    std::cout << "nIterations  : 0\n";
-    std::cout << "time         : Undefined\n";
-    std::cout << "throughput   : Undefined\n";
-    std::cout << "flops        : Undefined\n";
-    std::cout << "bytes        : Undefined\n";
-  }
-  std::cout << "\n--------------------------------------\n";
-  std::cout << "\n--------------------------------------\n";
-}
-
-/*
- * Host-Code
- * Utility function to calculate L2-norm between resulting buffer and reference
- * buffer
- */
-bool WithinEpsilon(float* output, float* reference, const size_t dim_x,
-                   const size_t dim_y, const size_t dim_z,
-                   const unsigned int radius, const int zadjust = 0,
-                   const float delta = 0.01f) {
-  std::ofstream error_file;
-  error_file.open("error_diff.txt");
-
-  bool error = false;
-  double norm2 = 0;
-
-  for (size_t iz = 0; iz < dim_z; iz++) {
-    for (size_t iy = 0; iy < dim_y; iy++) {
-      for (size_t ix = 0; ix < dim_x; ix++) {
-        if (ix >= radius && ix < (dim_x - radius) && iy >= radius &&
-            iy < (dim_y - radius) && iz >= radius &&
-            iz < (dim_z - radius + zadjust)) {
-          float difference = fabsf(*reference - *output);
-          norm2 += difference * difference;
-          if (difference > delta) {
-            error = true;
-            error_file << " ERROR: " << ix << ", " << iy << ", " << iz << "   "
-                       << *output << "   instead of " << *reference
-                       << "  (|e|=" << difference << ")\n";
-          }
-        }
-        ++output;
-        ++reference;
-      }
-    }
-  }
-
-  error_file.close();
-  norm2 = std::sqrt(norm2);
-  if (error) std::cout << "error (Euclidean norm): " << norm2 << "\n";
-  return error;
-}
diff --git a/sdk/samples/iso3dfd_dpcpp/third-party-programs.txt b/sdk/samples/iso3dfd_dpcpp/third-party-programs.txt
deleted file mode 100644
index e9f8042d..00000000
--- a/sdk/samples/iso3dfd_dpcpp/third-party-programs.txt
+++ /dev/null
@@ -1,253 +0,0 @@
-oneAPI Code Samples - Third Party Programs File
-
-This file contains the list of third party software ("third party programs")
-contained in the Intel software and their required notices and/or license
-terms. This third party software, even if included with the distribution of the
-Intel software, may be governed by separate license terms, including without
-limitation, third party license terms, other Intel software license terms, and
-open source software license terms. These separate license terms govern your use
-of the third party programs as set forth in the “third-party-programs.txt” or
-other similarly named text file.
- 
-Third party programs and their corresponding required notices and/or license
-terms are listed below.
-
---------------------------------------------------------------------------------
-
-1.  Nothings STB Libraries
-   
-stb/LICENSE
-
- This software is available under 2 licenses -- choose whichever you prefer.
- ------------------------------------------------------------------------------
- ALTERNATIVE A - MIT License
- Copyright (c) 2017 Sean Barrett
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal in
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- ------------------------------------------------------------------------------
- ALTERNATIVE B - Public Domain (www.unlicense.org)
- This is free and unencumbered software released into the public domain.
- Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
- software, either in source code form or as a compiled binary, for any purpose,
- commercial or non-commercial, and by any means.
- In jurisdictions that recognize copyright laws, the author or authors of this
- software dedicate any and all copyright interest in the software to the public
- domain. We make this dedication for the benefit of the public at large and to
- the detriment of our heirs and successors. We intend this dedication to be an
- overt act of relinquishment in perpetuity of all present and future rights to
- this software under copyright law.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-2.  FGPA example designs-gzip
-
-    SDL2.0
-
-zlib License
-
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-
---------------------------------------------------------------------------------
-
-3. Nbody
-   (c) 2019 Fabio Baruffa
-
-   Plotly.js
-   Copyright (c) 2020 Plotly, Inc
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-© 2020 GitHub, Inc.
-
---------------------------------------------------------------------------------
-
-4. GNU-EFI
-   Copyright (c) 1998-2000 Intel Corporation
-
-The files in the "lib" and "inc" subdirectories are using the EFI Application 
-Toolkit distributed by Intel at http://developer.intel.com/technology/efi
-
-This code is covered by the following agreement:
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE. THE EFI SPECIFICATION AND ALL OTHER INFORMATION
-ON THIS WEB SITE ARE PROVIDED "AS IS" WITH NO WARRANTIES, AND ARE SUBJECT
-TO CHANGE WITHOUT NOTICE.
-
---------------------------------------------------------------------------------
-
-5. Edk2
-   Copyright (c) 2019, Intel Corporation.  All rights reserved.
-
-   Edk2 Basetools
-   Copyright (c) 2019, Intel Corporation.  All rights reserved.
-
-SPDX-License-Identifier: BSD-2-Clause-Patent
-
---------------------------------------------------------------------------------
-
-6. Heat Transmission
-
-GNU LESSER GENERAL PUBLIC LICENSE
-Version 3, 29 June 2007
-
-Copyright © 2007 Free Software Foundation, Inc. <https://fsf.org/>
-
-Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
-
-This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.
-
-0. Additional Definitions.
-As used herein, “this License” refers to version 3 of the GNU Lesser General Public License, and the “GNU GPL” refers to version 3 of the GNU General Public License.
-
-“The Library” refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.
-
-An “Application” is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.
-
-A “Combined Work” is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the “Linked Version”.
-
-The “Minimal Corresponding Source” for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.
-
-The “Corresponding Application Code” for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.
-
-1. Exception to Section 3 of the GNU GPL.
-You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.
-
-2. Conveying Modified Versions.
-If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:
-
-a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or
-b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.
-3. Object Code Incorporating Material from Library Header Files.
-The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:
-
-a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.
-b) Accompany the object code with a copy of the GNU GPL and this license document.
-4. Combined Works.
-You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:
-
-a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.
-b) Accompany the Combined Work with a copy of the GNU GPL and this license document.
-c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.
-d) Do one of the following:
-0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
-1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.
-e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)
-5. Combined Libraries.
-You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:
-
-a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.
-b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.
-6. Revised Versions of the GNU Lesser General Public License.
-The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.
-
-If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.
-
---------------------------------------------------------------------------------
-7. Rodinia
-   Copyright (c)2008-2011 University of Virginia
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without royalty fees or other restrictions, provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-    * Neither the name of the University of Virginia, the Dept. of Computer Science, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OF VIRGINIA OR THE SOFTWARE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-If you use this software or a modified version of it, please cite the most relevant among the following papers:
-
- - M. A. Goodrum, M. J. Trotter, A. Aksel, S. T. Acton, and K. Skadron. Parallelization of Particle Filter Algorithms. In Proceedings of the 3rd Workshop on Emerging Applications and Many-core Architecture (EAMA), in conjunction with the IEEE/ACM International 
-Symposium on Computer Architecture (ISCA), June 2010.
-
- - S. Che, M. Boyer, J. Meng, D. Tarjan, J. W. Sheaffer, Sang-Ha Lee and K. Skadron.
-Rodinia: A Benchmark Suite for Heterogeneous Computing. IEEE International Symposium
-on Workload Characterization, Oct 2009.
-
-- J. Meng and K. Skadron. "Performance Modeling and Automatic Ghost Zone Optimization
-for Iterative Stencil Loops on GPUs." In Proceedings of the 23rd Annual ACM International
-Conference on Supercomputing (ICS), June 2009.
-
-- L.G. Szafaryn, K. Skadron and J. Saucerman. "Experiences Accelerating MATLAB Systems
-Biology Applications." in Workshop on Biomedicine in Computing (BiC) at the International
-Symposium on Computer Architecture (ISCA), June 2009.
-
-- M. Boyer, D. Tarjan, S. T. Acton, and K. Skadron. "Accelerating Leukocyte Tracking using CUDA:
-A Case Study in Leveraging Manycore Coprocessors." In Proceedings of the International Parallel
-and Distributed Processing Symposium (IPDPS), May 2009.
-
-- S. Che, M. Boyer, J. Meng, D. Tarjan, J. W. Sheaffer, and K. Skadron. "A Performance
-Study of General Purpose Applications on Graphics Processors using CUDA" Journal of
-Parallel and Distributed Computing, Elsevier, June 2008.
-
---------------------------------------------------------------------------------
-Other names and brands may be claimed as the property of others. 
-
---------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/sdk/samples/itt_ccl/CMakeLists.txt b/sdk/samples/itt_ccl/CMakeLists.txt
deleted file mode 100644
index 8e017d36..00000000
--- a/sdk/samples/itt_ccl/CMakeLists.txt
+++ /dev/null
@@ -1,97 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-cmake_minimum_required(VERSION 3.16)
-project(PTI_Samples_ITT_CCL CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-if (NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  message(WARNING "${PROJECT_NAME} is only supported in Linux")
-  return()
-endif()
-
-if(EXISTS "/etc/os-release")
-  file(STRINGS "/etc/os-release" os_release)
-  foreach(_line ${os_release})
-    if(_line MATCHES "^ID=")
-      string(REGEX REPLACE "^ID=\"?([^\"]*)\"?" "\\1" os_id "${_line}")
-    endif()
-  endforeach()
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if (NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-find_package(oneCCL 2021.17)
-find_package(MPI)
-
-if (NOT TARGET oneCCL)
-  message(WARNING "${PROJECT_NAME} requires a oneCCL installed.")
-  return()
-endif()
-
-if (NOT MPI_FOUND)
-  message(WARNING "${PROJECT_NAME} requires MPI to be installed.")
-  return()
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti)
-endif()
-
-option(PTI_BUILD_SYCL_ALLREDUCE_TEST "Build sycl_allreduce_test sample" ON)
-option(PTI_BUILD_SYCL_ALLREDUCE_USM_TEST "Build sycl_allreduce_usm_test sample" ON)
-
-if (PTI_BUILD_SYCL_ALLREDUCE_TEST AND NOT os_id STREQUAL "rocky")
-  add_executable(sycl_allreduce_test sycl_allreduce_test.cpp)
-
-  target_link_options(sycl_allreduce_test PUBLIC -fsycl)
-  target_compile_options(sycl_allreduce_test PUBLIC -fsycl -Wno-unused-parameter)
-
-  get_target_property(oneCCL_PATH oneCCL INTERFACE_INCLUDE_DIRECTORIES)
-  get_filename_component(oneCCL_ROOT ${oneCCL_PATH} DIRECTORY)
-
-  target_include_directories(sycl_allreduce_test PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities"
-                                                         "${PROJECT_SOURCE_DIR}/../../src/utils"
-                                                         "${PROJECT_SOURCE_DIR}/ccl_helpers")
-  target_include_directories(sycl_allreduce_test SYSTEM PRIVATE ${oneCCL_ROOT}/share/doc/ccl/examples/include)
-
-  target_compile_definitions(
-    sycl_allreduce_test
-    PRIVATE $<$<TARGET_EXISTS:Pti::pti_view>:USE_PTI_VIEW>
-  )
-
-  target_link_libraries(sycl_allreduce_test PUBLIC oneCCL MPI::MPI_CXX $<TARGET_NAME_IF_EXISTS:Pti::pti_view> ${FS_LIB})
-endif()
-
-if (PTI_BUILD_SYCL_ALLREDUCE_USM_TEST AND NOT os_id STREQUAL "rocky")
-  add_executable(sycl_allreduce_usm_test sycl_allreduce_usm_test.cpp)
-
-  target_link_options(sycl_allreduce_usm_test PUBLIC -fsycl)
-  target_compile_options(sycl_allreduce_usm_test PUBLIC -fsycl -Wno-unused-parameter)
-
-  target_include_directories(sycl_allreduce_usm_test PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities"
-                                                             "${PROJECT_SOURCE_DIR}/../../src/utils"
-                                                             "${PROJECT_SOURCE_DIR}/ccl_helpers")
-
-  target_compile_definitions(
-    sycl_allreduce_usm_test
-    PRIVATE $<$<TARGET_EXISTS:Pti::pti_view>:USE_PTI_VIEW>
-  )
-
-  get_target_property(oneCCL_PATH oneCCL INTERFACE_INCLUDE_DIRECTORIES)
-  get_filename_component(oneCCL_ROOT ${oneCCL_PATH} DIRECTORY)
-
-  target_link_libraries(sycl_allreduce_usm_test PUBLIC oneCCL MPI::MPI_CXX $<TARGET_NAME_IF_EXISTS:Pti::pti_view> ${FS_LIB})
-  target_include_directories(sycl_allreduce_usm_test SYSTEM PRIVATE ${oneCCL_ROOT}/share/doc/ccl/examples/include)
-endif()
diff --git a/sdk/samples/itt_ccl/ccl_helpers/base.hpp b/sdk/samples/itt_ccl/ccl_helpers/base.hpp
deleted file mode 100644
index f2b29a69..00000000
--- a/sdk/samples/itt_ccl/ccl_helpers/base.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- Copyright 2016-2020 Intel Corporation
- 
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- 
-     http://www.apache.org/licenses/LICENSE-2.0
- 
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-#pragma once
-
-#include "oneapi/ccl.hpp"
-
-#include <algorithm>
-#include <cassert>
-#include <chrono>
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <math.h>
-#include <mpi.h>
-#include <stdexcept>
-#include <stdio.h>
-#include <sys/syscall.h>
-#include <sys/time.h>
-#include <vector>
-#include <unistd.h>
-
-#ifdef CCL_ENABLE_SYCL
-#include <sycl/sycl.hpp>
-#endif // CCL_ENABLE_SYCL
-
-#define GETTID() syscall(SYS_gettid)
-
-#define ITERS                (16)
-#define COLL_ROOT            (0)
-#define MSG_SIZE_COUNT       (6)
-#define START_MSG_SIZE_POWER (10)
-
-#define PRINT(...) printf(__VA_ARGS__);printf("\n");
-
-#define PRINT_BY_ROOT(comm, ...) \
-    if (comm.rank() == 0) { \
-        printf(__VA_ARGS__); printf("\n"); \
-    }
-
-#define ASSERT(cond, ...) \
-    do { \
-        if (!(cond)) { \
-            printf("FAILED\n"); \
-            fprintf(stderr, \
-                    "(%ld): %s:%s:%d: ASSERT '%s' FAILED: ", \
-                    GETTID(), \
-                    __FILE__, \
-                    __FUNCTION__, \
-                    __LINE__, \
-                    #cond); \
-            fprintf(stderr, __VA_ARGS__); \
-            fprintf(stderr, "\n"); \
-            fflush(stderr); \
-            throw std::runtime_error("ASSERT FAILED"); \
-        } \
-    } while (0)
-
-#define MSG_LOOP(comm, per_msg_code) \
-    do { \
-        PRINT_BY_ROOT(comm, \
-                      "iters=%d, msg_size_count=%d, " \
-                      "start_msg_size_power=%d, coll_root=%d", \
-                      ITERS, \
-                      MSG_SIZE_COUNT, \
-                      START_MSG_SIZE_POWER, \
-                      COLL_ROOT); \
-        std::vector<size_t> msg_counts(MSG_SIZE_COUNT); \
-        std::vector<ccl::string_class> msg_match_ids(MSG_SIZE_COUNT); \
-        for (size_t idx = 0; idx < MSG_SIZE_COUNT; ++idx) { \
-            msg_counts[idx] = 1u << (START_MSG_SIZE_POWER + idx); \
-            msg_match_ids[idx] = std::to_string(msg_counts[idx]); \
-        } \
-        try { \
-            for (size_t idx = 0; idx < MSG_SIZE_COUNT; ++idx) { \
-                size_t msg_count = msg_counts[idx]; \
-                attr.set<ccl::operation_attr_id::match_id>(msg_match_ids[idx]); \
-                PRINT_BY_ROOT(comm, \
-                              "msg_count=%zu, match_id=%s", \
-                              msg_count, \
-                              attr.get<ccl::operation_attr_id::match_id>().c_str()); \
-                per_msg_code; \
-            } \
-        } \
-        catch (ccl::exception & e) { \
-            printf("FAILED\n"); \
-            fprintf(stderr, "ccl exception:\n%s\n", e.what()); \
-        } \
-        catch (...) { \
-            printf("FAILED\n"); \
-            fprintf(stderr, "other exception\n"); \
-        } \
-        PRINT_BY_ROOT(comm, "PASSED"); \
-    } while (0)
-
-inline double when(void) {
-    auto time = std::chrono::high_resolution_clock::now();
-    auto duration = std::chrono::duration<double, std::micro>(time.time_since_epoch());
-    return duration.count();
-}
-
-inline void mpi_finalize() {
-    int is_finalized = 0;
-    MPI_Finalized(&is_finalized);
-
-    if (!is_finalized)
-        MPI_Finalize();
-}
-
-inline bool is_valid_integer_option(const char* option) {
-    std::string str(option);
-    bool only_digits = (str.find_first_not_of("0123456789") == std::string::npos);
-    return (only_digits && atoi(option) >= 0);
-}
-
-inline bool is_valid_integer_option(int option) {
-    return (option >= 0);
-}
-
-inline int check_supported_options(const std::string& option_name,
-                                   const std::string& option_value,
-                                   const std::set<std::string>& supported_option_values) {
-    std::stringstream sstream;
-
-    if (supported_option_values.find(option_value) == supported_option_values.end()) {
-        PRINT("unsupported %s: %s", option_name.c_str(), option_value.c_str());
-
-        std::copy(supported_option_values.begin(),
-                  supported_option_values.end(),
-                  std::ostream_iterator<std::string>(sstream, " "));
-        PRINT("supported values: %s", sstream.str().c_str());
-        return -1;
-    }
-
-    return 0;
-}
-
-template <class Dtype, class Container>
-std::string find_str_val(Container& mp, const Dtype& key) {
-    typename std::map<Dtype, std::string>::iterator it;
-    it = mp.find(key);
-    if (it != mp.end())
-        return it->second;
-    return "";
-}
diff --git a/sdk/samples/itt_ccl/ccl_helpers/base_utils.hpp b/sdk/samples/itt_ccl/ccl_helpers/base_utils.hpp
deleted file mode 100644
index 49fe937a..00000000
--- a/sdk/samples/itt_ccl/ccl_helpers/base_utils.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- Copyright 2016-2020 Intel Corporation
- 
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- 
-     http://www.apache.org/licenses/LICENSE-2.0
- 
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-#pragma once
-
-#include <algorithm>
-#include <cstdlib>
-#include <iterator>
-#include <new>
-#include <sstream>
-#include <iostream>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-template <int CurIndex, class T, class U, class... Args>
-struct get_tuple_elem_index {
-    static constexpr int index = get_tuple_elem_index<CurIndex + 1, T, Args...>::index;
-};
-
-template <int CurIndex, class T, class... Args>
-struct get_tuple_elem_index<CurIndex, T, T, Args...> {
-    static constexpr int index = CurIndex;
-};
-
-template <class T, class... Args>
-typename std::remove_reference<typename std::remove_cv<T>::type>::type& ccl_tuple_get(
-    std::tuple<Args...>& t) {
-    using non_cv_type = typename std::remove_cv<T>::type;
-    using non_ref_type = typename std::remove_reference<non_cv_type>::type;
-    return std::get<get_tuple_elem_index<0, non_ref_type, Args...>::index>(t);
-}
-
-template <class T, class... Args>
-const typename std::remove_reference<typename std::remove_cv<T>::type>::type& ccl_tuple_get(
-    const std::tuple<Args...>& t) {
-    using non_cv_type = typename std::remove_cv<T>::type;
-    using non_ref_type = typename std::remove_reference<non_cv_type>::type;
-    return std::get<get_tuple_elem_index<0, non_ref_type, Args...>::index>(t);
-}
-
-template <class specific_tuple, class functor, size_t cur_index>
-void ccl_tuple_for_each_impl(specific_tuple&& t, functor f, std::true_type tuple_finished) {
-    // nothing to do
-}
-
-template <class specific_tuple, class functor, size_t cur_index>
-void ccl_tuple_for_each_impl(specific_tuple&& t, functor f, std::false_type tuple_not_finished) {
-    f(std::get<cur_index>(std::forward<specific_tuple>(t)));
-
-    constexpr std::size_t tuple_size =
-        std::tuple_size<typename std::remove_reference<specific_tuple>::type>::value;
-
-    using is_tuple_finished_t = std::integral_constant<bool, cur_index + 1 >= tuple_size>;
-
-    ccl_tuple_for_each_impl<specific_tuple, functor, cur_index + 1>(
-        std::forward<specific_tuple>(t), f, is_tuple_finished_t{});
-}
-
-template <class specific_tuple, class functor, size_t cur_index = 0>
-void ccl_tuple_for_each(specific_tuple&& t, functor f) {
-    constexpr std::size_t tuple_size =
-        std::tuple_size<typename std::remove_reference<specific_tuple>::type>::value;
-    static_assert(tuple_size != 0, "Nothing to do, tuple is empty");
-
-    using is_tuple_finished_t = std::integral_constant<bool, cur_index >= tuple_size>;
-    ccl_tuple_for_each_impl<specific_tuple, functor, cur_index>(
-        std::forward<specific_tuple>(t), f, is_tuple_finished_t{});
-}
-
-template <typename specific_tuple, size_t cur_index, typename functor, class... FunctionArgs>
-void ccl_tuple_for_each_indexed_impl(functor,
-                                     std::true_type tuple_finished,
-                                     const FunctionArgs&... args) {}
-
-template <typename specific_tuple, size_t cur_index, typename functor, class... FunctionArgs>
-void ccl_tuple_for_each_indexed_impl(functor f,
-                                     std::false_type tuple_not_finished,
-                                     const FunctionArgs&... args) {
-    using tuple_element_t = typename std::tuple_element<cur_index, specific_tuple>::type;
-
-    f.template invoke<cur_index, tuple_element_t>(args...);
-
-    constexpr std::size_t tuple_size =
-        std::tuple_size<typename std::remove_reference<specific_tuple>::type>::value;
-
-    using is_tuple_finished_t = std::integral_constant<bool, cur_index + 1 >= tuple_size>;
-
-    ccl_tuple_for_each_indexed_impl<specific_tuple, cur_index + 1, functor>(
-        f, is_tuple_finished_t{}, args...);
-}
-
-template <typename specific_tuple, typename functor, class... FunctionArgs>
-void ccl_tuple_for_each_indexed(functor f, const FunctionArgs&... args) {
-    constexpr std::size_t tuple_size =
-        std::tuple_size<typename std::remove_reference<specific_tuple>::type>::value;
-    static_assert(tuple_size != 0, "Nothing to do, tuple is empty");
-
-    using is_tuple_finished_t = std::false_type; //non-empty tuple started
-    ccl_tuple_for_each_indexed_impl<specific_tuple, 0, functor, FunctionArgs...>(
-        f, is_tuple_finished_t{}, args...);
-}
-
-template <class T, size_t align>
-struct aligned_allocator {
-    using value_type = T;
-    using pointer = T*;
-
-    template <class U>
-    struct rebind {
-        using other = aligned_allocator<U, align>;
-    };
-
-    aligned_allocator() = default;
-    ~aligned_allocator() = default;
-
-    template <class U, size_t Ualign>
-    constexpr aligned_allocator(const aligned_allocator<U, Ualign>&) noexcept {}
-
-    inline pointer allocate(size_t n) {
-        size_t size = sizeof(value_type) * n;
-        size_t aligned_size = (size + align - 1) & ~(align - 1);
-        void* ptr = aligned_alloc(align, aligned_size);
-        if (!ptr) {
-            throw std::bad_alloc();
-        }
-        return reinterpret_cast<pointer>(ptr);
-    }
-
-    inline void deallocate(pointer ptr, size_t size) noexcept {
-        free(ptr);
-    }
-};
-
-template <class T, size_t align = 4 * 1024>
-using aligned_vector = std::vector<T, aligned_allocator<T, align>>;
-
-namespace utils {
-
-template <typename T>
-inline void str_to_array(const char* input, std::vector<T>& output, char delimiter) {
-    if (!input) {
-        return;
-    }
-    std::stringstream ss(input);
-    T temp{};
-    while (ss >> temp) {
-        output.push_back(temp);
-        if (ss.peek() == delimiter) {
-            ss.ignore();
-        }
-    }
-}
-
-template <class Container>
-std::string vec_to_string(Container& elems) {
-    if (elems.empty()) {
-        return "<empty>";
-    }
-
-    size_t idx = 0;
-    std::ostringstream ss;
-    for (auto elem : elems) {
-        ss << elem;
-        idx++;
-        if (idx < elems.size()) {
-            ss << " ";
-        }
-    }
-    return ss.str();
-}
-
-template <typename T>
-void dump_vec(const std::vector<T>& vec, const std::string& name) {
-    std::cout << name << ": [";
-    for (const auto& item : vec) {
-        std::cout << item << ", ";
-    }
-    std::cout << "]\n";
-}
-
-} // namespace utils
diff --git a/sdk/samples/itt_ccl/ccl_helpers/sycl_base.hpp b/sdk/samples/itt_ccl/ccl_helpers/sycl_base.hpp
deleted file mode 100644
index b669cdc8..00000000
--- a/sdk/samples/itt_ccl/ccl_helpers/sycl_base.hpp
+++ /dev/null
@@ -1,710 +0,0 @@
-/*
- Copyright 2016-2020 Intel Corporation
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-#pragma once
-
-#include <algorithm>
-#if __has_include(<sycl/sycl.hpp>)
-#include <sycl/sycl.hpp>
-#else
-#error "Unsupported compiler"
-#endif
-#if __has_include(<CL/sycl/property_list.hpp>)
-#include <CL/sycl/property_list.hpp>
-#elif __has_include(<sycl/property_list.hpp>)
-#include <sycl/property_list.hpp>
-#else
-#error "Unsupported compiler"
-#endif
-#include <iostream>
-#include <map>
-#include <mpi.h>
-#include <numeric>
-#include <set>
-#include <string>
-#include <numeric>
-
-#include "base.hpp"
-#include "base_utils.hpp"
-#include "oneapi/ccl.hpp"
-
-#if defined(__INTEL_LLVM_COMPILER)
-#if (__INTEL_LLVM_COMPILER < 20230000)
-#define CCL_USE_SYCL121_API 1
-#else // (__INTEL_LLVM_COMPILER < 20230000)
-#define CCL_USE_SYCL121_API 0
-#endif // (__INTEL_LLVM_COMPILER < 20230000)
-#elif defined(__LIBSYCL_MAJOR_VERSION)
-#if (__LIBSYCL_MAJOR_VERSION < 6)
-#define CCL_USE_SYCL121_API 1
-#else // (__LIBSYCL_MAJOR_VERSION < 6)
-#define CCL_USE_SYCL121_API 0
-#endif // (__LIBSYCL_MAJOR_VERSION < 6)
-#else // __INTEL_LLVM_COMPILER || __LIBSYCL_MAJOR_VERSION
-#error "Unsupported compiler"
-#endif
-
-#ifdef SYCL_LANGUAGE_VERSION
-#define ICPX_VERSION __clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__
-#else // SYCL_LANGUAGE_VERSION
-#define ICPX_VERSION 0
-#endif // SYCL_LANGUAGE_VERSION
-
-namespace ccl {
-#if CCL_USE_SYCL121_API
-const auto cpu_selector_v = ::sycl::cpu_selector{};
-const auto gpu_selector_v = ::sycl::gpu_selector{};
-const auto default_selector_v = ::sycl::default_selector{};
-#else // CCL_USE_SYCL121_API
-inline const auto& cpu_selector_v = ::sycl::cpu_selector_v;
-inline const auto& gpu_selector_v = ::sycl::gpu_selector_v;
-inline const auto& default_selector_v = ::sycl::default_selector_v;
-#endif // CCL_USE_SYCL121_API
-} // namespace ccl
-
-/* help functions for sycl-specific base implementation */
-inline bool has_gpu() {
-    std::vector<sycl::device> devices = sycl::device::get_devices();
-    for (const auto& device : devices) {
-        if (device.is_gpu()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-inline bool has_accelerator() {
-    std::vector<sycl::device> devices = sycl::device::get_devices();
-    for (const auto& device : devices) {
-        if (device.is_accelerator()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-inline bool check_sycl_usm(sycl::queue& q, sycl::usm::alloc alloc_type) {
-    bool ret = true;
-
-    sycl::device d = q.get_device();
-
-    if ((alloc_type == sycl::usm::alloc::host) && (d.is_gpu() || d.is_accelerator()))
-        ret = false;
-
-    if ((alloc_type == sycl::usm::alloc::device) && !(d.is_gpu() || d.is_accelerator()))
-        ret = false;
-
-    if (!ret) {
-        std::cout << "incompatible device type and USM type\n";
-    }
-
-    return ret;
-}
-
-inline bool hide_platform_info() {
-    int hide_info = false;
-    char* hide_info_str = getenv("CCL_PLATFORM_INFO_HIDE");
-    if (hide_info_str) {
-        if (strcmp(hide_info_str, "0") == 0) {
-            hide_info = false;
-        }
-        else if (strcmp(hide_info_str, "1") == 0) {
-            hide_info = true;
-        }
-        else {
-            throw std::runtime_error("invalid value for CCL_PLATFORM_INFO_HIDE: " +
-                                     std::string(hide_info_str));
-        }
-    }
-    return hide_info;
-}
-
-inline std::string get_preferred_gpu_platform_name() {
-    std::string result;
-
-    std::string filter = "level-zero";
-    char* env = getenv("ONEAPI_DEVICE_SELECTOR");
-    if (env) {
-        if (std::strstr(env, "level_zero")) {
-            filter = "level-zero";
-        }
-        else if (std::strstr(env, "opencl")) {
-            filter = "opencl";
-        }
-        else {
-            throw std::runtime_error("invalid device filter: " + std::string(env));
-        }
-    }
-
-    auto plaform_list = sycl::platform::get_platforms();
-
-    for (const auto& platform : plaform_list) {
-        auto devices = platform.get_devices();
-        auto gpu_dev = std::find_if(devices.begin(), devices.end(), [](const sycl::device& d) {
-            return d.is_gpu();
-        });
-
-        if (gpu_dev == devices.end()) {
-            // std::cout << "platform [" << platform_name
-            //      << "] does not contain GPU devices, skipping\n";
-            continue;
-        }
-
-        auto platform_name = platform.get_info<sycl::info::platform::name>();
-        std::string platform_name_low_case;
-        platform_name_low_case.resize(platform_name.size());
-
-        std::transform(
-            platform_name.begin(), platform_name.end(), platform_name_low_case.begin(), ::tolower);
-
-        if (platform_name_low_case.find(filter) == std::string::npos) {
-            // std::cout << "platform [" << platform_name
-            //      << "] does not match with requested "
-            //      << filter << ", skipping\n";
-            continue;
-        }
-
-        result = platform_name;
-    }
-
-    if (result.empty())
-        throw std::runtime_error("can not find preferred GPU platform");
-
-    return result;
-}
-
-inline std::vector<sycl::device> create_sycl_gpu_devices(bool select_root_devices) {
-    constexpr char prefix[] = "-- ";
-
-    std::vector<sycl::device> result;
-    auto plaform_list = sycl::platform::get_platforms();
-    auto preferred_platform_name = get_preferred_gpu_platform_name();
-
-    std::stringstream ss;
-    std::stringstream ss_warn;
-
-    for (const auto& platform : plaform_list) {
-        auto platform_name = platform.get_info<sycl::info::platform::name>();
-        if (platform_name.compare(preferred_platform_name) != 0) {
-            continue;
-        }
-
-        auto device_list = platform.get_devices();
-        for (const auto& device : device_list) {
-            auto device_name = device.get_info<sycl::info::device::name>();
-
-            if (!device.is_gpu()) {
-                ss_warn << prefix << "device [" << device_name << "] is not GPU, skipping\n";
-                continue;
-            }
-
-            if (select_root_devices) {
-                result.push_back(device);
-                continue;
-            }
-
-            auto part_props = device.get_info<sycl::info::device::partition_properties>();
-
-            if (std::find(part_props.begin(),
-                          part_props.end(),
-                          sycl::info::partition_property::partition_by_affinity_domain) ==
-                part_props.end()) {
-                // ZE_FLAT_DEVICE_HIERARCHY=FLAT is by default now, meaning that
-                // tile is a root device, the warning is extra in this case
-                // ss_warn << prefix << "device [" << device_name
-                //         << "] does not support partition by affinity domain"
-                //         << ", use root device\n";
-                result.push_back(device);
-                continue;
-            }
-
-            auto part_affinity_domains =
-                device.get_info<sycl::info::device::partition_affinity_domains>();
-
-            if (std::find(part_affinity_domains.begin(),
-                          part_affinity_domains.end(),
-                          sycl::info::partition_affinity_domain::next_partitionable) ==
-                part_affinity_domains.end()) {
-                ss_warn << prefix << "device [" << device_name
-                        << "] does not support next_partitionable affinity domain"
-                        << ", use root device\n";
-                result.push_back(device);
-                continue;
-            }
-
-            auto sub_devices = device.create_sub_devices<
-                sycl::info::partition_property::partition_by_affinity_domain>(
-                sycl::info::partition_affinity_domain::next_partitionable);
-
-            size_t sub_devices_max =
-                device.template get_info<sycl::info::device::partition_max_sub_devices>();
-            if (sub_devices.size() != sub_devices_max) {
-                ss_warn << prefix << "device [" << device_name << "] expected " << sub_devices_max
-                        << " sub-devices, but got " << sub_devices.size();
-            }
-
-            if (sub_devices.empty()) {
-                ss_warn << prefix << "device [" << device_name << "] does not provide sub-devices"
-                        << ", use root device\n";
-                result.push_back(device);
-                continue;
-            }
-
-            result.insert(result.end(), sub_devices.begin(), sub_devices.end());
-        }
-    }
-
-    if (result.empty()) {
-        throw std::runtime_error("no GPU devices found");
-    }
-
-    if (!hide_platform_info()) {
-        ss << "preferred platform: " << preferred_platform_name << ", found: " << result.size()
-           << " GPU device(s)\n";
-    }
-    ss << ss_warn.str();
-    printf("%s", ss.str().c_str());
-
-    return result;
-}
-
-inline std::vector<sycl::queue> create_sycl_queues(const std::string& device_type,
-                                                   const std::vector<int>& ranks,
-                                                   bool select_root_devices = false,
-                                                   const sycl::property_list& queue_props = {}) {
-    std::vector<sycl::device> devices;
-
-    try {
-        if (device_type.compare("gpu") == 0) {
-            if (!has_gpu()) {
-                throw std::runtime_error("GPU is requested but not available");
-            }
-
-            /* GPU type has special handling to cover multi-tile case */
-            devices = create_sycl_gpu_devices(select_root_devices);
-        }
-        else {
-            if (device_type.compare("cpu") == 0) {
-                devices.push_back(sycl::device(ccl::cpu_selector_v));
-            }
-            else if (device_type.compare("default") == 0) {
-                if (!has_accelerator()) {
-                    devices.push_back(sycl::device(ccl::default_selector_v));
-                }
-                else {
-                    devices.push_back(sycl::device(ccl::cpu_selector_v));
-                    std::cout
-                        << "Accelerator is the first in device list, but unavailable for multiprocessing "
-                        << " cpu_selector has been created instead of default_selector.\n";
-                }
-            }
-            else {
-                throw std::runtime_error("Please provide device type: cpu | gpu | default");
-            }
-        }
-    }
-    catch (...) {
-        throw std::runtime_error("No devices of requested type available");
-    }
-
-    if (devices.empty()) {
-        throw std::runtime_error("No devices of requested type available");
-    }
-
-    int global_rank = 0, local_rank = 0;
-    int global_size = 0, local_size = 0;
-    MPI_Comm_rank(MPI_COMM_WORLD, &global_rank);
-    MPI_Comm_size(MPI_COMM_WORLD, &global_size);
-
-    MPI_Comm local_comm;
-    MPI_Comm_split_type(MPI_COMM_WORLD, MPI_COMM_TYPE_SHARED, 0, MPI_INFO_NULL, &local_comm);
-    MPI_Comm_rank(local_comm, &local_rank);
-    MPI_Comm_size(local_comm, &local_size);
-    MPI_Comm_free(&local_comm);
-
-    std::stringstream error_msg;
-
-    if (local_rank > global_rank) {
-        error_msg << "Local rank should be less or equal to global rank (local_rank: " << local_rank
-                  << ", global_rank: " << global_rank << ")";
-        throw std::runtime_error(error_msg.str());
-    }
-
-    if (local_size > global_size) {
-        error_msg << "Local size should be less or equal to global size (local_size: " << local_size
-                  << ", global_size: " << global_size << ")";
-        throw std::runtime_error(error_msg.str());
-    }
-
-    if (ranks.size() != 1) {
-        error_msg << "Unexpected number of device ranks: " << ranks.size();
-        throw std::runtime_error(error_msg.str());
-    }
-
-    if (ranks[0] != global_rank) {
-        error_msg << "Unexpected device rank: " << ranks[0] << ", expected: " << global_rank;
-        throw std::runtime_error(error_msg.str());
-    }
-
-    // use local rank for device selection
-    std::vector<int> local_ranks(1, local_rank);
-
-    std::vector<sycl::device> rank_devices;
-    for (size_t idx = 0; idx < local_ranks.size(); idx++) {
-        rank_devices.push_back(devices[local_ranks[idx] % devices.size()]);
-    }
-
-    if (rank_devices.empty()) {
-        throw std::runtime_error("No devices of requested type available for specified ranks");
-    }
-
-    sycl::context ctx;
-
-    try {
-        ctx = sycl::context(rank_devices);
-    }
-    catch (sycl::exception&) {
-        size_t preferred_idx = (local_ranks.back() / local_ranks.size()) % devices.size();
-        std::cout << "Can not create context from all rank devices of type: " << device_type
-                  << ", create context from single device, idx " << preferred_idx << "\n";
-        ctx = sycl::context(devices[preferred_idx]);
-    }
-
-    auto exception_handler = [&](sycl::exception_list elist) {
-        for (std::exception_ptr const& e : elist) {
-            try {
-                rethrow_exception(e);
-            }
-            catch (std::exception const& e) {
-                std::cout << "failure\n";
-            }
-        }
-    };
-
-    auto ctx_devices = ctx.get_devices();
-
-    if (ctx_devices.empty()) {
-        throw std::runtime_error("No devices of requested type available in context");
-    }
-
-    std::vector<sycl::queue> queues;
-
-    if (!hide_platform_info()) {
-        std::cout << "Created context from devices of type: " << device_type << "\n";
-        std::cout << "Devices [" << ctx_devices.size() << "]:\n";
-    }
-
-    for (size_t idx = 0; idx < ctx_devices.size(); idx++) {
-        if (!hide_platform_info()) {
-            std::cout << "[" << idx << "]: ["
-                      << ctx_devices[idx].get_info<sycl::info::device::name>() << "]\n";
-        }
-        queues.push_back(sycl::queue(ctx_devices[idx], exception_handler, queue_props));
-    }
-
-    return queues;
-}
-
-inline bool create_sycl_queue(const std::string& type,
-                              int rank,
-                              sycl::queue& q,
-                              const sycl::property_list& queue_props = {}) {
-    if (type == "gpu" || type == "cpu" || type == "host" || type == "default") {
-        try {
-            std::vector<int> ranks = { rank };
-            q = create_sycl_queues(type, ranks, false, queue_props)[0];
-            return true;
-        }
-        catch (std::exception& e) {
-            std::cerr << e.what() << "\n";
-            return false;
-        }
-    }
-    else {
-        std::cerr << "Unknown device type: " << type
-                  << ", please provide: cpu | gpu | host | default\n";
-        return false;
-    }
-}
-
-inline bool create_sycl_queue(int argc,
-                              char* argv[],
-                              int rank,
-                              sycl::queue& q,
-                              const sycl::property_list& queue_props = {}) {
-    return create_sycl_queue(((argc >= 2) ? argv[1] : "unknown"), rank, q, queue_props);
-}
-
-inline bool handle_exception(sycl::queue& q) {
-    try {
-        q.wait_and_throw();
-    }
-    catch (std::exception const& e) {
-        std::cout << "Caught synchronous SYCL exception:\n" << e.what() << "\n";
-        return false;
-    }
-    return true;
-}
-
-inline sycl::usm::alloc usm_alloc_type_from_string(const std::string& str) {
-    const std::map<std::string, sycl::usm::alloc> names{ {
-        { "host", sycl::usm::alloc::host },
-        { "device", sycl::usm::alloc::device },
-        { "shared", sycl::usm::alloc::shared },
-    } };
-
-    auto it = names.find(str);
-    if (it == names.end()) {
-        std::stringstream ss;
-        ss << "Invalid USM type requested: " << str << "\nSupported types are:\n";
-        for (const auto& v : names) {
-            ss << v.first << ", ";
-        }
-        throw std::runtime_error(ss.str());
-    }
-    return it->second;
-}
-
-inline std::pair<sycl::usm::alloc, std::string> take_usm_type(const int argc, char* str_type) {
-    std::map<sycl::usm::alloc, std::string> map_usm_type;
-    auto usm_alloc_type = sycl::usm::alloc::shared;
-    auto str_usm_alloc_type = "shared";
-    if (argc > 1) {
-        str_usm_alloc_type = str_type;
-        usm_alloc_type = usm_alloc_type_from_string(str_usm_alloc_type);
-    }
-
-    return std::make_pair(usm_alloc_type, str_usm_alloc_type);
-}
-
-template <typename T>
-struct buf_allocator {
-    const size_t alignment = 64;
-
-    buf_allocator(sycl::queue& q) : q(q) {}
-
-    buf_allocator& operator=(const buf_allocator&) = delete;
-    buf_allocator(const buf_allocator&) = delete;
-    buf_allocator(buf_allocator&&) = default;
-
-    ~buf_allocator() {
-        for (auto& ptr : memory_storage) {
-            sycl::free(ptr, q);
-        }
-    }
-
-    T* allocate(size_t count, sycl::usm::alloc alloc_type) {
-        T* ptr = nullptr;
-        if (alloc_type == sycl::usm::alloc::host)
-            ptr = sycl::aligned_alloc_host<T>(alignment, count, q);
-        else if (alloc_type == sycl::usm::alloc::device)
-            ptr = sycl::aligned_alloc_device<T>(alignment, count, q);
-        else if (alloc_type == sycl::usm::alloc::shared)
-            ptr = sycl::aligned_alloc_shared<T>(alignment, count, q);
-        else
-            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + " - unexpected alloc_type");
-
-        if (!ptr) {
-            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) +
-                                     " - failed to allocate buffer");
-        }
-
-        auto it = memory_storage.find(ptr);
-        if (it != memory_storage.end()) {
-            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) +
-                                     " - allocator already owns this pointer");
-        }
-        memory_storage.insert(ptr);
-
-        auto pointer_type = sycl::get_pointer_type(ptr, q.get_context());
-        if (pointer_type != alloc_type)
-            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) + " - pointer_type " +
-                                     std::to_string((int)pointer_type) +
-                                     " doesn't match with requested " +
-                                     std::to_string((int)alloc_type));
-
-        return ptr;
-    }
-
-    void deallocate(T* ptr) {
-        auto it = memory_storage.find(ptr);
-        if (it == memory_storage.end()) {
-            throw std::runtime_error(std::string(__PRETTY_FUNCTION__) +
-                                     " - allocator doesn't own this pointer");
-        }
-        free(ptr, q);
-        memory_storage.erase(it);
-    }
-
-    sycl::queue q;
-    std::set<T*> memory_storage;
-};
-
-inline sycl::event submit_barrier(sycl::queue queue) {
-#if ICPX_VERSION >= 140000
-    return queue.ext_oneapi_submit_barrier();
-#elif ICPX_VERSION < 140000
-    return queue.submit_barrier();
-#endif // ICPX_VERSION
-}
-
-enum class queue_type { in_order, out_of_order };
-
-inline std::string convert_queue_type(queue_type val) {
-    static std::unordered_map<queue_type, std::string> convert = {
-        { queue_type::in_order, "in_order" }, { queue_type::out_of_order, "out_of_order" }
-    };
-    return convert[val];
-}
-
-struct test_args {
-    int argc = 0;
-    char** argv = nullptr;
-    int rank = 0;
-    queue_type queue = queue_type::in_order;
-    size_t count = 0;
-    bool group_api = false;
-
-    static const size_t DEFAULT_COUNT = 10 * 1024 * 1024;
-
-    test_args(int argc, char* argv[], int rank)
-            : argc(argc),
-              argv(argv),
-              rank(rank),
-              count(DEFAULT_COUNT) {
-        parse();
-        print();
-    }
-
-    void print() const {
-        if (rank == 0) {
-            std::cout << "queue_type: " << convert_queue_type(queue) << "\n";
-            std::cout << "group_api: " << group_api << "\n";
-            std::cout << "count: " << count << "\n";
-        }
-    }
-
-    void print_help(const char* test) const {
-        std::cout << "Usage: " << test << " [--queue_type <queue_type>] [--count <data_count>]\n";
-        std::cout << "Options:\n";
-        std::cout
-            << " --queue_type <queue_type>   Choose in_order or out_of_order (default is in_order)\n";
-        std::cout << " --count <data_count>  Specify the data count\n";
-    }
-
-    void parse() {
-        std::unordered_map<std::string, std::string> args_map;
-        if (argc > 1) {
-            if ((std::strcmp(argv[1], "--help") == 0 || std::strcmp(argv[1], "-h") == 0)) {
-                if (rank == 0) {
-                    print_help(argv[0]);
-                }
-                exit(0);
-            }
-        }
-
-        // parse command line arguments
-        for (int i = 1; i < argc; ++i) {
-            std::string arg = argv[i];
-            if (arg.substr(0, 2) == "--") {
-                arg = arg.substr(2);
-                if (i + 1 < argc && argv[i + 1][0] != '-') {
-                    args_map[arg] = argv[i + 1];
-                    ++i;
-                }
-                else {
-                    args_map[arg] = "";
-                }
-            }
-        }
-
-        if (args_map.find("queue_type") != args_map.end()) {
-            std::string type_str = args_map["queue_type"];
-            if (type_str == "in_order") {
-                queue = queue_type::in_order;
-            }
-            else if (type_str == "out_of_order") {
-                queue = queue_type::out_of_order;
-            }
-            else {
-                std::cerr << "Invalid queue_type: " << type_str << std::endl;
-                exit(1);
-            }
-        }
-
-        if (args_map.find("group_api") != args_map.end()) {
-            std::string type_str = args_map["group_api"];
-            if (type_str == "1") {
-                group_api = true;
-            }
-            else if (type_str == "0") {
-                group_api = false;
-            }
-            else {
-                std::cerr << "Invalid group_api argument: " << type_str << std::endl;
-                exit(1);
-            }
-        }
-
-        if (args_map.find("count") != args_map.end()) {
-            std::string count_str = args_map["count"];
-            count = std::stoi(count_str);
-        }
-    }
-};
-
-// returns true if the queue is successfully created, otherwise false
-inline bool create_test_sycl_queue(const std::string& type,
-                                   int rank,
-                                   sycl::queue& q,
-                                   test_args& args) {
-    sycl::property_list props;
-
-    if (args.queue == queue_type::in_order) {
-        props = { sycl::property::queue::in_order{}, sycl::property::queue::enable_profiling{} };
-    }
-    else {
-        props = { sycl::property::queue::enable_profiling{} };
-    }
-
-    return create_sycl_queue(type, rank, q, props);
-}
-
-inline bool check_example_args(int argc, char* argv[]) {
-    if (argc < 3) {
-        std::cout << "usage: " << argv[0] << " <device_type> <alloc_type>\n";
-        std::cout << "device_type: 'cpu' or 'gpu'\n";
-        std::cout << "alloc_type: 'host', 'device', or 'shared'\n";
-        std::cout << "example: " << argv[0] << " cpu shared\n";
-        return false;
-    }
-
-    std::string device_type = argv[1];
-    std::string alloc_type = argv[2];
-
-    if (device_type != "cpu" && device_type != "gpu") {
-        std::cout << "error: Invalid device '" << device_type << "'.\n";
-        std::cout << "device_type must be either 'cpu' or 'gpu'.\n";
-        return false;
-    }
-
-    if (alloc_type != "host" && alloc_type != "device" && alloc_type != "shared") {
-        std::cout << "error: Invalid alloc_type '" << alloc_type << "'.\n";
-        std::cout << "alloc_type must be either 'host', 'device', or 'shared'.\n";
-        return false;
-    }
-
-    return true;
-}
diff --git a/sdk/samples/itt_ccl/sycl_allreduce_test.cpp b/sdk/samples/itt_ccl/sycl_allreduce_test.cpp
deleted file mode 100644
index 63819c42..00000000
--- a/sdk/samples/itt_ccl/sycl_allreduce_test.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- Copyright 2016-2020 Intel Corporation
- 
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
- 
-     http://www.apache.org/licenses/LICENSE-2.0
- 
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
-*/
-#include "sycl_base.hpp"
-
-using namespace std;
-using namespace sycl;
-
-//
-// Start of ITT tracing functions
-//
-#if defined(USE_PTI_VIEW)
-#include <iostream>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <string_view>
-#include <vector>
-#include <mutex>
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-// Global vector to store communication records
-std::vector<pti_view_record_comms> comms_vector;
-std::mutex buffer_mutex;
-
-// A lower bound of records to expect
-constexpr size_t kExpectedCommsRecords = 1;
-constexpr size_t kBufferSize = 1000;
-
-void StartTracing(){
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_COMMUNICATION));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-}
-
-void StopTracing() {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-}
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kBufferSize;
-}
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (buf) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-
-  std::lock_guard<std::mutex> lock(buffer_mutex);
-
-  pti_view_record_base *ptr = nullptr;
-  pti_result result = pti_result::PTI_SUCCESS;
-  bool has_error = false;
-
-  // Collect all records in the order they appear in the buffer
-  while (pti_result::PTI_STATUS_END_OF_BUFFER !=
-         (result = ptiViewGetNextRecord(buf, valid_buf_size, &ptr))) {
-    if (result != pti_result::PTI_SUCCESS) {
-      std::cerr << "Error retrieving the next record: " << result << std::endl;
-      has_error = true;
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-         std::cout << "Found Invalid Record" << '\n';
-         has_error = true;
-         break;
-      }
-      case pti_view_kind::PTI_VIEW_COMMUNICATION: {
-        // Capture the record into the vector
-        comms_vector.push_back(*reinterpret_cast<pti_view_record_comms *>(ptr));
-        break;
-      }
-      default: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cerr << "Unexpected record type: " << ptr->_view_kind << '\n';
-        break;
-      }
-    }
-    if (has_error) break;
-  }
-
-  // Always deallocate buffer, even on error
-  samples_utils::AlignedDealloc(buf);
-}
-
-void DumpCollectedRecords() {
-  std::lock_guard<std::mutex> lock(buffer_mutex);
-
-  std::cout << "\n=================================================\n";
-  std::cout << "DEBUG: Dumping collected communication records\n";
-  std::cout << "Total records collected: " << comms_vector.size() << "\n";
-  std::cout << "=================================================\n";
-
-  for (size_t i = 0; i < comms_vector.size(); ++i) {
-    std::cout << "\nRecord #" << (i + 1) << ":" << "\n";
-    std::cout << "---------------------------------------------------\n";
-    samples_utils::DumpRecord(&comms_vector[i]);
-  }
-
-  if (comms_vector.empty()) {
-    std::cout << "No communication records were collected.\n";
-  }
-  std::cout << "=================================================\n\n";
-}
-#endif
-
-//
-// End of ITT tracing functions
-//
-
-int main(int argc, char *argv[]) {
-    if (argc < 2) {
-        cout << "usage ./sycl_allreduce_test [device]\n";
-        cout << "device could be 'cpu' or 'gpu'\n";
-        cout << "example: ./sycl_allreduce_test cpu\n";
-        exit(1);
-    }
-
-    string device_type = argv[1];
-
-    if (device_type != "cpu" && device_type != "gpu") {
-        cout << "error: Invalid device '" << device_type << "'.\n";
-        cout << "device must be either 'cpu' or 'gpu'.\n";
-        exit(1);
-    }
-
-#if defined(USE_PTI_VIEW)
-    PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-    StartTracing();
-#endif
-
-    size_t count = 10 * 1024 * 1024;
-
-    int size = 0;
-    int rank = 0;
-
-    ccl::init();
-
-    MPI_Init(NULL, NULL);
-    MPI_Comm_size(MPI_COMM_WORLD, &size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-
-    atexit(mpi_finalize);
-
-    test_args args(argc, argv, rank);
-
-    if (args.count != args.DEFAULT_COUNT) {
-        count = args.count;
-    }
-
-    sycl::queue q;
-    if (!create_test_sycl_queue(device_type, rank, q, args))
-        return -1;
-
-    /* create kvs */
-    ccl::shared_ptr_class<ccl::kvs> kvs;
-    ccl::kvs::address_type main_addr;
-    if (rank == 0) {
-        kvs = ccl::create_main_kvs();
-        main_addr = kvs->get_address();
-        MPI_Bcast((void *)main_addr.data(), main_addr.size(), MPI_BYTE, 0, MPI_COMM_WORLD);
-    }
-    else {
-        MPI_Bcast((void *)main_addr.data(), main_addr.size(), MPI_BYTE, 0, MPI_COMM_WORLD);
-        kvs = ccl::create_kvs(main_addr);
-    }
-
-    /* create communicator */
-    auto dev = ccl::create_device(q.get_device());
-    auto ctx = ccl::create_context(q.get_context());
-    auto comm = ccl::create_communicator(size, rank, dev, ctx, kvs);
-
-    /* create stream */
-    auto stream = ccl::create_stream(q);
-
-    /* create buffers */
-    sycl::buffer<int> send_buf(count);
-    sycl::buffer<int> recv_buf(count);
-
-    {
-        /* open buffers and initialize them on the host side */
-        sycl::host_accessor send_buf_acc(send_buf, sycl::write_only);
-        sycl::host_accessor recv_buf_acc(recv_buf, sycl::write_only);
-        for (size_t i = 0; i < count; i++) {
-            send_buf_acc[i] = rank;
-            recv_buf_acc[i] = -1;
-        }
-    }
-
-    /* open send_buf and modify it on the device side */
-    q.submit([&](auto &h) {
-        sycl::accessor send_buf_acc(send_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            send_buf_acc[id] += 1;
-        });
-    });
-
-    /* do not wait completion of kernel, dependency will be resolved by sycl::buffer */
-
-    /* invoke allreduce */
-    ccl::allreduce(send_buf, recv_buf, count, ccl::reduction::sum, comm, stream).wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    q.submit([&](auto &h) {
-        sycl::accessor recv_buf_acc(recv_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf_acc[id] != size * (size + 1) / 2) {
-                recv_buf_acc[id] = -1;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor recv_buf_acc(recv_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (recv_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-#if defined(USE_PTI_VIEW)
-    StopTracing();
-    PTI_CHECK_SUCCESS(ptiFlushAllViews());
-    DumpCollectedRecords();
-
-    for (auto it = comms_vector.begin(); it != comms_vector.end(); ++it) {
-        if (it->_end_timestamp <= it->_start_timestamp) {
-            auto record_index = std::distance(comms_vector.begin(), it);
-            std::cerr << "ERROR: Record " << record_index << " has invalid timestamps: "
-                      << "end (" << it->_end_timestamp << ") <= start ("
-                      << it->_start_timestamp << ")" << std::endl;
-            return -1;
-        }
-    }
-
-    if (comms_vector.size() < kExpectedCommsRecords) {
-        std::cerr << "ERROR: Expected at least " << kExpectedCommsRecords
-                  << " records, but collected " << comms_vector.size() << std::endl;
-        return -1;
-    }
-#endif
-
-    return 0;
-}
diff --git a/sdk/samples/itt_ccl/sycl_allreduce_usm_test.cpp b/sdk/samples/itt_ccl/sycl_allreduce_usm_test.cpp
deleted file mode 100644
index ea5bffce..00000000
--- a/sdk/samples/itt_ccl/sycl_allreduce_usm_test.cpp
+++ /dev/null
@@ -1,823 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "sycl_base.hpp"
-
-using namespace std;
-using namespace sycl;
-
-//
-// Start of ITT tracing functions
-//
-#if defined(USE_PTI_VIEW)
-#include <iostream>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <string_view>
-#include <vector>
-#include <mutex>
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-// Global vector to store communication records
-std::vector<pti_view_record_comms> comms_vector;
-std::mutex buffer_mutex;
-
-// A lower bound of records to expect
-constexpr size_t kExpectedCommsRecords = 2;
-constexpr size_t kBufferSize = 1000;
-
-void StartTracing(){
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_COMMUNICATION));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-}
-
-void StopTracing() {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-}
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kBufferSize;
-}
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (buf) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-
-  std::lock_guard<std::mutex> lock(buffer_mutex);
-
-  pti_view_record_base *ptr = nullptr;
-  pti_result result = pti_result::PTI_SUCCESS;
-  bool has_error = false;
-
-  // Collect all records in the order they appear in the buffer
-  while (pti_result::PTI_STATUS_END_OF_BUFFER !=
-         (result = ptiViewGetNextRecord(buf, valid_buf_size, &ptr))) {
-    if (result != pti_result::PTI_SUCCESS) {
-      std::cerr << "Error retrieving the next record: " << result << std::endl;
-      has_error = true;
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-         std::cout << "Found Invalid Record" << '\n';
-         has_error = true;
-         break;
-      }
-      case pti_view_kind::PTI_VIEW_COMMUNICATION: {
-        // Capture the record into the vector
-        comms_vector.push_back(*reinterpret_cast<pti_view_record_comms *>(ptr));
-        break;
-      }
-      default: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cerr << "Unexpected record type: " << ptr->_view_kind << '\n';
-        break;
-      }
-    }
-    if (has_error) break;
-  }
-
-  // Always deallocate buffer, even on error
-  samples_utils::AlignedDealloc(buf);
-}
-
-void DumpCollectedRecords() {
-  std::lock_guard<std::mutex> lock(buffer_mutex);
-
-  std::cout << "\n=================================================\n";
-  std::cout << "DEBUG: Dumping collected communication records\n";
-  std::cout << "Total records collected: " << comms_vector.size() << "\n";
-  std::cout << "=================================================\n";
-
-  for (size_t i = 0; i < comms_vector.size(); ++i) {
-    std::cout << "\nRecord #" << (i + 1) << ":" << "\n";
-    std::cout << "---------------------------------------------------\n";
-    samples_utils::DumpRecord(&comms_vector[i]);
-  }
-
-  if (comms_vector.empty()) {
-    std::cout << "No communication records were collected.\n";
-  }
-  std::cout << "=================================================\n\n";
-}
-#endif
-
-//
-// End of ITT tracing functions
-//
-
-/*
- * Example for user-defined reduction operation.
- * Final result is compared with a regular sum operation.
- */
-int custom_sum_reduction(queue &q,
-                         ccl::communicator &comm,
-                         ccl::stream &stream,
-                         buf_allocator<int> &allocator,
-                         sycl::usm::alloc usm_alloc_type,
-                         [[maybe_unused]] int size,
-                         int rank,
-                         size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* create reference buffers */
-    auto send_buf_ref = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf_ref = allocator.allocate(count, usm_alloc_type);
-
-    /* create custom device side scalar multiplier */
-    int scalar_value = rank + 1;
-    auto custom_scalar = allocator.allocate(1, usm_alloc_type);
-
-    /* open buffers (user and reference) and modify them on the device side */
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + 1 + id;
-            recv_buf[id] = -1;
-
-            /* reference values multiplied by local scalar */
-            send_buf_ref[id] = send_buf[id] * scalar_value;
-            recv_buf_ref[id] = recv_buf[id];
-        });
-    });
-
-    /* open scalar buffer and modify it on the device side */
-    e = q.submit([&](sycl::handler &h) {
-        h.depends_on(e);
-        h.single_task([=]() {
-            custom_scalar[0] = scalar_value;
-        });
-    });
-
-    /* the scalar is in device-visible memory and will be dereferenced,
-     * while the collective is running.*/
-    ccl::reduction custom_op;
-    ccl::reduction_create_pre_mul_sum(&custom_op,
-                                      custom_scalar,
-                                      ccl::datatype::int32,
-                                      ccl::scalar_residence_type::scalar_device,
-                                      comm);
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke reference allreduce with sum reduction */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf_ref,
-                   recv_buf_ref,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::sum,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* invoke allreduce with user-defined reduction */
-    ccl::allreduce(
-        send_buf, recv_buf, count, ccl::datatype::int32, custom_op, comm, stream, attr, deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    sycl::buffer<int> result_buf(count);
-    sycl::buffer<int> expected_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        sycl::accessor result_buf_acc(result_buf, h, sycl::write_only);
-        sycl::accessor expected_buf_acc(expected_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf[id] != recv_buf_ref[id]) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-            /* debug info */
-            result_buf_acc[id] = recv_buf[id];
-            expected_buf_acc[id] = recv_buf_ref[id];
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor result_buf_acc(result_buf, sycl::read_only);
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        sycl::host_accessor expected_buf_acc(expected_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "CUSTOM FAILED at index " << i << ", value: " << result_buf_acc[i]
-                          << ", expected: " << expected_buf_acc[i] << "\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    /* destroy custom operation */
-    ccl::reduction_destroy(custom_op, comm);
-
-    return 0;
-}
-
-int sum_reduction(queue &q,
-                  ccl::communicator &comm,
-                  ccl::stream &stream,
-                  buf_allocator<int> &allocator,
-                  sycl::usm::alloc usm_alloc_type,
-                  int size,
-                  int rank,
-                  size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* open buffers and modify them on the device side */
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + id + 1;
-            recv_buf[id] = -1;
-        });
-    });
-
-    int check_sum = 0;
-    for (int i = 1; i <= size; ++i) {
-        check_sum += i;
-    }
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke allreduce */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf,
-                   recv_buf,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::sum,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf[id] != static_cast<int>(check_sum + size * id)) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    return 0;
-}
-
-int average_reduction(queue &q,
-                      ccl::communicator &comm,
-                      ccl::stream &stream,
-                      buf_allocator<int> &allocator,
-                      sycl::usm::alloc usm_alloc_type,
-                      int size,
-                      int rank,
-                      size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* open buffers and modify them on the device side */
-    /* Average allreduce calculation is the same as the sum example above,
-     * except the division by the number of nodes (size).
-     *
-     * Note that the sum is not divisible by the size for even-sized number
-     * of nodes and integer division is applied (fractional part is truncated)
-     * as seen in the example below.
-     *
-     * Example of send/recv/expected allreduce average initial data and results.
-     * RANK 0:
-     * * SEND          -> (1) (2) (3) (4) - initial data
-     * * RECV/EXPECTED -> (2) (3) (4) (5)
-     * RANK 1:
-     * * SEND          -> (2) (3) (4) (5) - initial data
-     * * RECV/EXPECTED -> (2) (3) (4) (5)
-     * RANK 2:
-     * * SEND          -> (3) (4) (5) (6) - initial data
-     * * RECV/EXPECTED -> (2) (3) (4) (5)
-     * RANK 3:
-     * * SEND          -> (4) (5) (6) (7) - initial data
-     * * RECV/EXPECTED -> (2) (3) (4) (5)
-    */
-
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + id + 1;
-            recv_buf[id] = -1;
-        });
-    });
-
-    int check_sum = 0;
-    for (int i = 1; i <= size; ++i) {
-        check_sum += i;
-    }
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke allreduce */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf,
-                   recv_buf,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::avg,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf[id] != static_cast<int>(check_sum / size + id)) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    return 0;
-}
-
-int min_reduction(queue &q,
-                  ccl::communicator &comm,
-                  ccl::stream &stream,
-                  buf_allocator<int> &allocator,
-                  sycl::usm::alloc usm_alloc_type,
-                  [[maybe_unused]] int size,
-                  int rank,
-                  size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* open buffers and modify them on the device side */
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + id + 1;
-            recv_buf[id] = -1;
-        });
-    });
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke allreduce */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf,
-                   recv_buf,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::min,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf[id] != static_cast<int>(id + 1)) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    return 0;
-}
-
-int max_reduction(queue &q,
-                  ccl::communicator &comm,
-                  ccl::stream &stream,
-                  buf_allocator<int> &allocator,
-                  sycl::usm::alloc usm_alloc_type,
-                  int size,
-                  int rank,
-                  size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* open buffers and modify them on the device side */
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + id + 1;
-            recv_buf[id] = -1;
-        });
-    });
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke allreduce */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf,
-                   recv_buf,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::max,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            if (recv_buf[id] != static_cast<int>(size + id)) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-    {
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    return 0;
-}
-
-int prod_reduction(queue &q,
-                   ccl::communicator &comm,
-                   ccl::stream &stream,
-                   buf_allocator<int> &allocator,
-                   sycl::usm::alloc usm_alloc_type,
-                   int size,
-                   int rank,
-                   size_t count) {
-    /* create buffers */
-    auto send_buf = allocator.allocate(count, usm_alloc_type);
-    auto recv_buf = allocator.allocate(count, usm_alloc_type);
-
-    /* open buffers and modify them on the device side */
-    auto e = q.submit([&](auto &h) {
-        h.parallel_for(count, [=](auto id) {
-            send_buf[id] = rank + id + 1;
-            recv_buf[id] = -1;
-        });
-    });
-
-    /* do not wait completion of kernel and provide it as dependency for operation */
-    vector<ccl::event> deps;
-    deps.push_back(ccl::create_event(e));
-
-    /* invoke allreduce */
-    auto attr = ccl::create_operation_attr<ccl::allreduce_attr>();
-    ccl::allreduce(send_buf,
-                   recv_buf,
-                   count,
-                   ccl::datatype::int32,
-                   ccl::reduction::prod,
-                   comm,
-                   stream,
-                   attr,
-                   deps)
-        .wait();
-
-    /* open recv_buf and check its correctness on the device side */
-    sycl::buffer<int> check_buf(count);
-    q.submit([&](auto &h) {
-        sycl::accessor check_buf_acc(check_buf, h, sycl::write_only);
-        h.parallel_for(count, [=](auto id) {
-            auto combination = [](int size, int id) -> int {
-                int result = 1;
-                for (int i = 0; i < size; ++i) {
-                    result *= size + id - i;
-                }
-                return result;
-            };
-
-            if (recv_buf[id] != static_cast<int>(combination(size, id))) {
-                check_buf_acc[id] = -1;
-            }
-            else {
-                check_buf_acc[id] = 0;
-            }
-        });
-    });
-
-    if (!handle_exception(q))
-        return -1;
-
-    /* print out the result of the test on the host side */
-
-    {
-        sycl::host_accessor check_buf_acc(check_buf, sycl::read_only);
-        size_t i;
-        for (i = 0; i < count; i++) {
-            if (check_buf_acc[i] == -1) {
-                std::cout << "FAILED\n";
-                break;
-            }
-        }
-        if (i == count) {
-            std::cout << "PASSED\n";
-        }
-    }
-
-    return 0;
-}
-
-int main(int argc, char *argv[]) {
-    if (!check_example_args(argc, argv))
-        exit(1);
-
-#if defined(USE_PTI_VIEW)
-    PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-    StartTracing();
-#endif
-
-    size_t count = 10 * 1024 * 1024;
-
-    int size = 0;
-    int rank = 0;
-
-    ccl::init();
-
-    MPI_Init(NULL, NULL);
-    MPI_Comm_size(MPI_COMM_WORLD, &size);
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-
-    atexit(mpi_finalize);
-
-    test_args args(argc, argv, rank);
-
-    if (args.count != args.DEFAULT_COUNT) {
-        count = args.count;
-    }
-
-    string device_type = argv[1];
-    string alloc_type = argv[2];
-
-    sycl::queue q;
-    if (!create_test_sycl_queue(device_type, rank, q, args))
-        return -1;
-
-    buf_allocator<int> allocator(q);
-
-    auto usm_alloc_type = usm_alloc_type_from_string(alloc_type);
-
-    if (!check_sycl_usm(q, usm_alloc_type)) {
-        return -1;
-    }
-
-    /* create kvs */
-    ccl::shared_ptr_class<ccl::kvs> kvs;
-    ccl::kvs::address_type main_addr;
-    if (rank == 0) {
-        kvs = ccl::create_main_kvs();
-        main_addr = kvs->get_address();
-        MPI_Bcast((void *)main_addr.data(), main_addr.size(), MPI_BYTE, 0, MPI_COMM_WORLD);
-    }
-    else {
-        MPI_Bcast((void *)main_addr.data(), main_addr.size(), MPI_BYTE, 0, MPI_COMM_WORLD);
-        kvs = ccl::create_kvs(main_addr);
-    }
-
-    /* create communicator */
-    auto dev = ccl::create_device(q.get_device());
-    auto ctx = ccl::create_context(q.get_context());
-    auto comm = ccl::create_communicator(size, rank, dev, ctx, kvs);
-
-    /* create stream */
-    auto stream = ccl::create_stream(q);
-
-    /* check skip conditions */
-    bool skip_case = false;
-    const char *esimd_env = std::getenv("CCL_SYCL_ESIMD");
-    if (esimd_env && std::string(esimd_env) == "1") {
-        skip_case = true;
-    }
-
-    /* run examples */
-    int ret = 0;
-
-    ret = sum_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-    if (ret == -1)
-        return -1;
-
-    if (!skip_case) {
-        ret = prod_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-        if (ret == -1)
-            return -1;
-
-        ret = min_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-        if (ret == -1)
-            return -1;
-
-        ret = max_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-        if (ret == -1)
-            return -1;
-    }
-
-    try {
-        ret = average_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-    }
-    catch (ccl::exception &e) {
-        std::string exception_msg(e.what());
-        std::string check_msg("average operation");
-        if (exception_msg.find(check_msg) != std::string::npos) {
-            std::cout << "SKIP: average operation is not supported for the scheduler path."
-                      << std::endl;
-            ret = 0;
-        }
-        else {
-            std::cout << e.what() << std::endl;
-            std::cout << "FAILED\n";
-            return -1;
-        }
-    }
-    catch (...) {
-        std::cout << "FAILED\n";
-        return -1;
-    }
-    if (ret == -1)
-        return -1;
-
-    if (!skip_case) {
-        try {
-            ret =
-                custom_sum_reduction(q, comm, stream, allocator, usm_alloc_type, size, rank, count);
-        }
-        catch (ccl::exception &e) {
-            std::string exception_msg(e.what());
-            std::string check_msg("user-defined reduction operation");
-            if (exception_msg.find(check_msg) != std::string::npos) {
-                std::cout
-                    << "SKIP: user-defined reduction operation is not supported for the scheduler or scale-out path."
-                    << std::endl;
-                ret = 0;
-            }
-            else {
-                std::cout << e.what() << std::endl;
-                std::cout << "FAILED\n";
-                return -1;
-            }
-        }
-        catch (...) {
-            std::cout << "FAILED\n";
-            return -1;
-        }
-        if (ret == -1)
-            return -1;
-    }
-
-#if defined(USE_PTI_VIEW)
-    // PTI Tracing finalization
-    StopTracing();
-    PTI_CHECK_SUCCESS(ptiFlushAllViews());
-    DumpCollectedRecords();
-
-    // Verify that every record in comms_vector has valid timestamps
-    for (auto it = comms_vector.begin(); it != comms_vector.end(); ++it) {
-        if (it->_end_timestamp <= it->_start_timestamp) {
-            auto record_index = std::distance(comms_vector.begin(), it);
-            std::cerr << "ERROR: Record " << record_index << " has invalid timestamps: "
-                      << "end (" << it->_end_timestamp << ") <= start ("
-                      << it->_start_timestamp << ")" << std::endl;
-            return -1;
-        }
-    }
-
-    // Verify we have collected records. We cannot fix it
-    // because depending on the mpiexec invocation this may change
-    if (comms_vector.size() <  kExpectedCommsRecords) {
-        std::cerr << "ERROR: Expected at least " << kExpectedCommsRecords
-                  << " records, but collected " << comms_vector.size() << std::endl;
-        return -1;
-    }
-
-    return 0;
-#else
-    return 0;
-#endif
-}
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/CMakeLists.txt b/sdk/samples/metrics_iso3dfd_dpcpp/CMakeLists.txt
deleted file mode 100644
index cfa6cc98..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-                      "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules/")
-include(macros)
-
-cmake_minimum_required(VERSION 3.14)
-
-project (METRICSISO3DFD)
-
-if (NOT CMAKE_BUILD_TYPE)
-    message (STATUS "Default CMAKE_BUILD_TYPE not set using Release with Debug Info")
-    set (CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE
-        STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel"
-        FORCE)
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler.")
-  return()
-endif()
-
-if (NOT TARGET DevUtilities::utils)
-  find_package(DevUtilities)
-endif()
-
-if (NOT TARGET DevUtilities::utils)
-  message(WARNING "${PROJECT_NAME} requires dev-utilities installed.")
-  return()
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-if (NOT TARGET LevelZero::level-zero)
-  find_package(LevelZero REQUIRED)
-endif()
-
-add_subdirectory (src)
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/License.txt b/sdk/samples/metrics_iso3dfd_dpcpp/License.txt
deleted file mode 100644
index e63c6e13..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/License.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-Copyright Intel Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/include/device_selector.hpp b/sdk/samples/metrics_iso3dfd_dpcpp/include/device_selector.hpp
deleted file mode 100644
index 6b8749d4..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/include/device_selector.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef DEVICESELECTOR_HPP
-#define DEVICESELECTOR_HPP
-
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <sycl/sycl.hpp>
-
-// This is the class provided to SYCL runtime by the application to decide
-// on which device to run, or whether to run at all.
-// When selecting a device, SYCL runtime first takes (1) a selector provided by
-// the program or a default one and (2) the set of all available devices. Then
-// it passes each device to the '()' operator of the selector. Device, for
-// which '()' returned the highest number, is selected. If a negative number
-// was returned for all devices, then the selection process will cause an
-// exception.
-class MyDeviceSelector {
- public:
-  MyDeviceSelector(const std::string &p) : pattern(p) {
-    // std::cout << "Looking for \"" << p << "\" devices" << std::endl;
-  }
-
-  // This is the function which gives a "rating" to devices.
-  int operator()(const sycl::device &device) const {
-    // The template parameter to device.get_info can be a variety of properties
-    // defined by the SYCL spec's sycl::info:: enum. Properties may have
-    // different types. Here we query name which is a string.
-    const std::string name = device.get_info<sycl::info::device::name>();
-    // std::cout << "Trying device: " << name << "..." << std::endl;
-    // std::cout << "  Vendor: " <<
-    // device.get_info<sycl::info::device::vendor>() << std::endl;
-
-    // Device with pattern in the name is prioritized:
-    return (name.find(pattern) != std::string::npos) ? 100 : 1;
-  }
-
- private:
-  std::string pattern;
-};
-
-#endif
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/include/iso3dfd.h b/sdk/samples/metrics_iso3dfd_dpcpp/include/iso3dfd.h
deleted file mode 100644
index 0b5d8a43..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/include/iso3dfd.h
+++ /dev/null
@@ -1,52 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <sycl/sycl.hpp>
-using namespace sycl;
-
-#include <algorithm>
-#include <chrono>
-#include <cmath>
-#include <cstring>
-#include <ctime>
-#include <fstream>
-#include <mutex>
-/*
- * Parameters to define coefficients
- * kHalfLength: Radius of the stencil
- * Sample source code is tested for kHalfLength=8 resulting in
- * 16th order Stencil finite difference kernel
- */
-constexpr float dt = 0.002f;
-constexpr float dxyz = 50.0f;
-constexpr unsigned int kHalfLength = 8;
-
-extern std::mutex global_cout_mtx;
-
-/*
- * Padding to test and eliminate shared local memory bank conflicts for
- * the shared local memory(slm) version of the kernel executing on GPU
- */
-constexpr unsigned int kPad = 0;
-
-bool Iso3dfdDevice(sycl::queue &q, float *ptr_next, float *ptr_prev, float *ptr_vel,
-                   float *ptr_coeff, size_t n1, size_t n2, size_t n3, size_t n1_block,
-                   size_t n2_block, size_t n3_block, size_t end_z, unsigned int num_iterations);
-
-void PrintTargetInfo(sycl::queue &q, unsigned int dim_x, unsigned int dim_y);
-
-void Usage(const std::string &program_name);
-
-void PrintStats(double time, size_t n1, size_t n2, size_t n3, unsigned int num_iterations);
-
-bool WithinEpsilon(float *output, float *reference, const size_t dim_x, const size_t dim_y,
-                   const size_t dim_z, const unsigned int radius, const int zadjust,
-                   const float delta);
-
-bool CheckGridDimension(size_t n1, size_t n2, size_t n3, unsigned int dim_x, unsigned int dim_y,
-                        unsigned int block_z);
-
-bool CheckBlockDimension(sycl::queue &q, unsigned int dim_x, unsigned int dim_y);
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/src/CMakeLists.txt b/sdk/samples/metrics_iso3dfd_dpcpp/src/CMakeLists.txt
deleted file mode 100644
index f6c30984..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/src/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-CheckExperimentalFilesystem()
-
-option(SHARED_KERNEL "Use SLM Kernel Version - Only for GPU" OFF)
-
-# Set default build type to RelWithDebInfo if not specified
-if(NOT CMAKE_BUILD_TYPE)
-  message(
-    STATUS "Default CMAKE_BUILD_TYPE not set using Release with Debug Info")
-  set(CMAKE_BUILD_TYPE
-      "RelWithDebInfo"
-      CACHE
-        STRING
-        "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel"
-        FORCE)
-endif()
-
-add_executable(metrics_iso3dfd iso3dfd.cpp iso3dfd_kernels.cpp utils.cpp)
-
-target_compile_options(metrics_iso3dfd PUBLIC -O3 -fsycl)
-target_link_options(metrics_iso3dfd PUBLIC -O3 -fsycl)
-
-target_include_directories(
-  metrics_iso3dfd PRIVATE ${PROJECT_SOURCE_DIR}/include
-                          ${PROJECT_SOURCE_DIR}/../samples_utilities
-                          ${PROJECT_SOURCE_DIR}/../../src/utils
-                          )
-
-target_link_libraries(metrics_iso3dfd PUBLIC spdlog::spdlog Pti::pti_view
-  DevUtilities::utils ${FS_LIB})
-
-if(SHARED_KERNEL)
-  target_compile_definitions(metrics_iso3dfd PUBLIC USED_SHARED)
-endif()
-
-if(WIN32)
-  add_custom_target(runmetricsiso metrics_iso3dfd 256 256 256 32 8 64 10 gpu)
-  add_custom_target(runmetricsiso_cpu metrics_iso3dfd 256 256 256 256 1 1 10 cpu)
-else()
-  add_custom_target(runmetricsiso metrics_iso3dfd 256 256 256 32 8 64 10 gpu)
-  add_custom_target(runmetricsiso_cpu metrics_iso3dfd 256 256 256 256 1 1 10 cpu)
-endif()
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd.cpp b/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd.cpp
deleted file mode 100644
index 89e67edc..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd.cpp
+++ /dev/null
@@ -1,421 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// ISO3DFD: Data Parallel C++ Language Basics Using 3D-Finite-Difference-Wave
-// Propagation
-//
-// ISO3DFD is a finite difference stencil kernel for solving the 3D acoustic
-// isotropic wave equation. Kernels in this sample are implemented as 16th order
-// in space, 2nd order in time scheme without boundary conditions. Using Data
-// Parallel C++, the sample can explicitly run on the GPU and/or CPU to
-// calculate a result.  If successful, the output will print the device name
-// where the SYCL code ran along with the grid computation metrics - flops
-// and effective throughput
-//
-// For comprehensive instructions regarding SYCL Programming, go to
-// https://software.intel.com/en-us/oneapi-programming-guide
-// and search based on relevant terms noted in the comments.
-//
-// SYCL material used in this code sample:
-//
-// SYCL Queues (including device selectors and exception handlers)
-// SYCL Custom device selector
-// SYCL Buffers and accessors (communicate data between the host and the
-// device)
-// SYCL Kernels (including parallel_for function and nd-range<3>
-// objects)
-// Shared Local Memory (SLM) optimizations (SYCL)
-// SYCL Basic synchronization (barrier function)
-//
-
-#include <dpc_common.hpp>
-
-#include <iostream>
-#include <string>
-#include <mutex>
-
-#include "iso3dfd.h"
-#include "device_selector.hpp"
-#include "metrics_utils.h"
-
-namespace oneapi {}
-using namespace oneapi;
-using namespace metrics_utils;
-
-std::mutex global_cout_mtx;
-
-/*
- * Host-Code
- * Function used for initialization
- */
-void Initialize(float* ptr_prev, float* ptr_next, float* ptr_vel, size_t n1,
-                size_t n2, size_t n3) {
-  {
-    const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-    std::cout << "Initializing ... \n";
-  }
-  size_t dim2 = n2 * n1;
-
-  for (size_t i = 0; i < n3; i++) {
-    for (size_t j = 0; j < n2; j++) {
-      size_t offset = i * dim2 + j * n1;
-#pragma omp simd
-      for (size_t k = 0; k < n1; k++) {
-        ptr_prev[offset + k] = 0.0f;
-        ptr_next[offset + k] = 0.0f;
-        ptr_vel[offset + k] =
-            2250000.0f * dt * dt;  // Integration of the v*v and dt*dt
-      }
-    }
-  }
-  // Add a source to initial wavefield as an initial condition
-  float val = 1.f;
-  for (int s = 5; s >= 0; s--) {
-    for (size_t i = n3 / 2 - s; i < n3 / 2 + s; i++) {
-      for (size_t j = n2 / 4 - s; j < n2 / 4 + s; j++) {
-        size_t offset = i * dim2 + j * n1;
-        for (size_t k = n1 / 4 - s; k < n1 / 4 + s; k++) {
-          ptr_prev[offset + k] = val;
-        }
-      }
-    }
-    val *= 10;
-  }
-}
-
-/*
- * Host-Code
- * OpenMP implementation for single iteration of iso3dfd kernel.
- * This function is used as reference implementation for verification and
- * also to compare performance of OpenMP and SYCL on CPU
- * Additional Details:
- * https://software.intel.com/en-us/articles/eight-optimizations-for-3-dimensional-finite-difference-3dfd-code-with-an-isotropic-iso
- */
-void Iso3dfdIteration(float* ptr_next_base, float* ptr_prev_base,
-                      float* ptr_vel_base, float* coeff, const size_t n1,
-                      const size_t n2, const size_t n3, const size_t n1_block,
-                      const size_t n2_block, const size_t n3_block) {
-  size_t dimn1n2 = n1 * n2;
-  size_t n3End = n3 - kHalfLength;
-  size_t n2End = n2 - kHalfLength;
-  size_t n1End = n1 - kHalfLength;
-
-#pragma omp parallel default(shared)
-#pragma omp for schedule(static) collapse(3)
-  for (size_t bz = kHalfLength; bz < n3End;
-       bz += n3_block) {  // start of cache blocking
-    for (size_t by = kHalfLength; by < n2End; by += n2_block) {
-      for (size_t bx = kHalfLength; bx < n1End; bx += n1_block) {
-        size_t izEnd = (std::min)(bz + n3_block, n3End);
-        size_t iyEnd = (std::min)(by + n2_block, n2End);
-        size_t ixEnd = (std::min)(n1_block, n1End - bx);
-        for (size_t iz = bz; iz < izEnd; iz++) {  // start of inner iterations
-          for (size_t iy = by; iy < iyEnd; iy++) {
-            float* ptr_next = ptr_next_base + iz * dimn1n2 + iy * n1 + bx;
-            float* ptr_prev = ptr_prev_base + iz * dimn1n2 + iy * n1 + bx;
-            float* ptr_vel = ptr_vel_base + iz * dimn1n2 + iy * n1 + bx;
-#pragma omp simd
-            for (size_t ix = 0; ix < ixEnd; ix++) {
-              float value = 0.0;
-              value += ptr_prev[ix] * coeff[0];
-#pragma unroll(kHalfLength)
-              for (unsigned int ir = 1; ir <= kHalfLength; ir++) {
-                value += coeff[ir] *
-                         ((ptr_prev[ix + ir] + ptr_prev[ix - ir]) +
-                          (ptr_prev[ix + ir * n1] + ptr_prev[ix - ir * n1]) +
-                          (ptr_prev[ix + ir * dimn1n2] +
-                           ptr_prev[ix - ir * dimn1n2]));
-              }
-              ptr_next[ix] =
-                  2.0f * ptr_prev[ix] - ptr_next[ix] + value * ptr_vel[ix];
-            }
-          }
-        }  // end of inner iterations
-      }
-    }
-  }  // end of cache blocking
-}
-
-/*
- * Host-Code
- * Driver function for ISO3DFD OpenMP code
- * Uses ptr_next and ptr_prev as ping-pong buffers to achieve
- * accelerated wave propagation
- */
-void Iso3dfd(float* ptr_next, float* ptr_prev, float* ptr_vel, float* coeff,
-             const size_t n1, const size_t n2, const size_t n3,
-             const unsigned int nreps, const size_t n1_block,
-             const size_t n2_block, const size_t n3_block) {
-  for (unsigned int it = 0; it < nreps; it += 1) {
-    Iso3dfdIteration(ptr_next, ptr_prev, ptr_vel, coeff, n1, n2, n3, n1_block,
-                     n2_block, n3_block);
-
-    // here's where boundary conditions and halo exchanges happen
-    // Swap previous & next between iterations
-    it++;
-    if (it < nreps)
-      Iso3dfdIteration(ptr_prev, ptr_next, ptr_vel, coeff, n1, n2, n3, n1_block,
-                       n2_block, n3_block);
-  }  // time loop
-}
-
-/*
- * Host-Code
- * Main function to drive the sample application
- */
-int main(int argc, char* argv[]) {
-  // Arrays used to update the wavefield
-  float* prev_base;
-  float* next_base;
-  // Array to store wave velocity
-  float* vel_base;
-  // Array to store results for comparison
-  float* temp;
-
-  bool sycl = true;
-  bool omp = true;
-  bool error = false;
-  bool is_gpu = false;
-  bool is_cpu = false;
-
-  size_t n1, n2, n3;
-  size_t n1_block, n2_block, n3_block;
-  unsigned int num_iterations;
-
-  uint8_t uuid[16];
-  bool sycl_device_has_uuid = false;
-
-  // Read Input Parameters
-  try {
-    n1 = std::stoi(argv[1]) + (2 * kHalfLength);
-    n2 = std::stoi(argv[2]) + (2 * kHalfLength);
-    n3 = std::stoi(argv[3]) + (2 * kHalfLength);
-    n1_block = std::stoi(argv[4]);
-    n2_block = std::stoi(argv[5]);
-    n3_block = std::stoi(argv[6]);
-    num_iterations = std::stoi(argv[7]);
-  }
-
-  catch (...) {
-    Usage(argv[0]);
-    return 1;
-  }
-
-  // Read optional arguments to select version and device
-  for (auto arg = 8; arg < argc; arg++) {
-    std::string arg_value = argv[arg];
-    std::transform(arg_value.begin(), arg_value.end(), arg_value.begin(), ::tolower);
-
-    if (arg_value == "omp") {
-      omp = true;
-      sycl = false;
-    } else if (arg_value == "sycl") {
-      omp = false;
-      sycl = true;
-    } else if (arg_value == "gpu") {
-      is_gpu = true;
-      is_cpu = false;
-    } else if (arg_value == "cpu") {
-      is_cpu = true;
-      is_gpu = false;
-    } else {
-      Usage(argv[0]);
-      return 1;
-    }
-  }
-
-  // Validate input sizes for the grid and block dimensions
-  if (CheckGridDimension(n1 - 2 * kHalfLength, n2 - 2 * kHalfLength,
-                         n3 - 2 * kHalfLength, n1_block, n2_block, n3_block)) {
-    Usage(argv[0]);
-    return 1;
-  }
-
-  // Compute the total size of grid
-  size_t nsize = n1 * n2 * n3;
-
-  try {
-    prev_base = new float[nsize];
-    next_base = new float[nsize];
-    vel_base = new float[nsize];
-  } catch (const std::bad_alloc& e) {
-    std::cerr << "Error: While attempting to allocate space for grid, caught exception: " << e.what() <<"."  <<  '\n';
-    return 1;
-  }
-
-  // Compute coefficients to be used in wavefield update
-  float coeff[kHalfLength + 1] = {-3.0548446,   +1.7777778,     -3.1111111e-1,
-                                  +7.572087e-2, -1.76767677e-2, +3.480962e-3,
-                                  -5.180005e-4, +5.074287e-5,   -2.42812e-6};
-
-  // Apply the DX DY and DZ to coefficients
-  coeff[0] = (3.0f * coeff[0]) / (dxyz * dxyz);
-  for (unsigned int i = 1; i <= kHalfLength; i++) {
-    coeff[i] = coeff[i] / (dxyz * dxyz);
-  }
-
-  {
-    const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-    std::cout << "Grid Sizes: " << n1 - 2 * kHalfLength << " "
-              << n2 - 2 * kHalfLength << " " << n3 - 2 * kHalfLength << "\n";
-    std::cout << "Memory Usage: " << ((3 * nsize * sizeof(float)) / (1024 * 1024))
-              << " MB\n";
-  }
-
-  // Check if running OpenMP OR Serial version on CPU
-  if (omp) {
-    {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-#if defined(_OPENMP)
-      std::cout << " ***** Running OpenMP variant *****\n";
-#else
-      std::cout << " ***** Running C++ Serial variant *****\n";
-#endif
-    }
-
-    // Initialize arrays and introduce initial conditions (source)
-    Initialize(prev_base, next_base, vel_base, n1, n2, n3);
-
-    // Start timer
-    dpc_common::TimeInterval t_ser;
-    // Invoke the driver function to perform 3D wave propagation
-    // using OpenMP/Serial version
-    Iso3dfd(next_base, prev_base, vel_base, coeff, n1, n2, n3, num_iterations,
-            n1_block, n2_block, n3_block);
-
-    // End timer
-    PrintStats(t_ser.Elapsed() * 1e3, n1, n2, n3, num_iterations);
-  }
-
-  // Check if running both OpenMP/Serial and SYCL version
-  // Keeping a copy of output buffer from OpenMP version
-  // for comparison
-  if (omp && sycl) {
-    temp = new float[nsize];
-    if (num_iterations % 2)
-      memcpy(temp, next_base, nsize * sizeof(float));
-    else
-      memcpy(temp, prev_base, nsize * sizeof(float));
-  }
-
-  // Check if running SYCL version
-  if (sycl) {
-    try {
-      bool metrics_enabled = (samples_utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-      if (!metrics_enabled) {
-        pti_result metric_result = ptiMetricsEnable(nullptr);
-        if (metric_result != PTI_SUCCESS) {
-          std::cerr << "Error: Failed to enable metrics on the system, set ZET_ENABLE_METRICS=1 to enable." << std::endl;
-          return 1;
-        }
-      }
-
-      {
-        const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-        std::cout << " ***** Running SYCL variant *****\n";
-      }
-      // Initialize arrays and introduce initial conditions (source)
-      Initialize(prev_base, next_base, vel_base, n1, n2, n3);
-
-      sycl::device dev;
-      // using the correct sycl device selector
-      if (is_gpu) {
-        dev = sycl::device(sycl::gpu_selector_v);
-      } else if (is_cpu) {
-        dev = sycl::device(sycl::cpu_selector_v);
-      } else {
-        std::cerr << "Using the default sycl device selector";
-        dev = sycl::device(sycl::default_selector_v);
-      }
-
-      // Create a device queue using SYCL class queue with the
-      // device selector
-      queue q(dev);
-      auto device = q.get_device();
-      if (device.has(aspect::ext_intel_device_info_uuid)) {
-        auto sycl_uuid = device.get_info<ext::intel::info::device::uuid>();
-        for (int i = 0; i < 16; i++) {
-          uuid[i] = static_cast<uint8_t>(sycl_uuid[i]);
-        }
-        sycl_device_has_uuid = true;
-      } else {
-        sycl_device_has_uuid = false;
-      }
-
-      // Validate if the block sizes selected are
-      // within range for the selected SYCL device
-      if (CheckBlockDimension(q, n1_block, n2_block)) {
-        Usage(argv[0]);
-        return 1;
-      }
-
-      // Start timer
-      dpc_common::TimeInterval t_dpc;
-
-      // Invoke the driver function to perform 3D wave propagation
-      // using SYCL version on the selected device
-      Iso3dfdDevice(q, next_base, prev_base, vel_base, coeff, n1, n2, n3,
-                    n1_block, n2_block, n3_block, n3 - kHalfLength,
-                    num_iterations);
-      // Wait for the commands to complete. Enforce synchronization on the command
-      // queue
-      q.wait_and_throw();
-
-      // End timer
-      PrintStats(t_dpc.Elapsed() * 1e3, n1, n2, n3, num_iterations);
-    } catch (const sycl::exception &e) {
-      std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-      std::cerr << "\tError code: " << e.code().value()
-                << "\n\tCategory: " << e.category().name()
-                << "\n\tMessage: " << e.code().message() << '\n';
-    } catch (const std::exception &e) {
-      std::cerr << "Error: Exception caught " << e.what() << '\n';
-    } catch (...) {
-      std::cerr << "Error: Unknown exception caught." << '\n';
-    }
-  }
-
-  // If running both OpenMP/Serial and SYCL version
-  // Comparing results
-  if (omp && sycl) {
-    if (num_iterations % 2) {
-      error = WithinEpsilon(next_base, temp, n1, n2, n3, kHalfLength, 0, 0.1f);
-    } else {
-      error = WithinEpsilon(prev_base, temp, n1, n2, n3, kHalfLength, 0, 0.1f);
-    }
-    if (error) {
-      std::cerr << "Final wavefields from SYCL device and CPU are not "
-                << "equivalent: Fail\n";
-    } else {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-      std::cout << "Final wavefields from SYCL device and CPU are equivalent:"
-                << " Success\n";
-    }
-    {
-      const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-      std::cout << "--------------------------------------\n";
-    }
-    delete[] temp;
-  }
-
-  delete[] prev_base;
-  delete[] next_base;
-  delete[] vel_base;
-
-  if (sycl) {
-    ptiMetricsDisable(nullptr);
-  }
-
-  // Check if the metrics collection was run on the same device as the compute device
-  if (sycl_device_has_uuid) {
-    MetricsProfiler::MetricsProfilerInstance().ValidateDeviceUuid(uuid);
-  }
-
-  // Check for data validity
-  MetricsProfiler::MetricsProfilerInstance().ValidateData();
-
-  return error ? 1 : 0;
-}
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd_kernels.cpp b/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd_kernels.cpp
deleted file mode 100644
index ebe56a04..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/src/iso3dfd_kernels.cpp
+++ /dev/null
@@ -1,551 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-// ISO3DFD: Data Parallel C++ Language Basics Using 3D-Finite-Difference-Wave
-// Propagation
-//
-// ISO3DFD is a finite difference stencil kernel for solving the 3D acoustic
-// isotropic wave equation which can be used as a proxy for propagating a
-// seismic wave. Kernels in this sample are implemented as 16th order in space,
-// with symmetric coefficients, and 2nd order in time scheme without boundary
-// conditions.. Using Data Parallel C++, the sample can explicitly run on the
-// GPU and/or CPU to propagate a seismic wave which is a compute intensive task.
-// If successful, the output will print the device name
-// where the SYCL code ran along with the grid computation metrics - flops
-// and effective throughput.
-//
-// For comprehensive instructions regarding SYCL Programming, go to
-// https://software.intel.com/en-us/oneapi-programming-guide
-// and search based on relevant terms noted in the comments.
-//
-// SYCL material used in this code sample:
-//
-// SYCL Queues (including device selectors and exception handlers)
-// SYCL Custom device selector
-// SYCL Buffers and accessors (communicate data between the host and the
-// device)
-// SYCL Kernels (including parallel_for function and nd-range<3>
-// objects)
-// Shared Local Memory (SLM) optimizations (SYCL)
-// SYCL Basic synchronization (barrier function)
-//
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <thread>
-
-#include "iso3dfd.h"
-#include "metrics_utils.h"
-#include "utils.h"
-
-using namespace metrics_utils;
-
-inline uint64_t GetTime() {
-#if defined(_WIN32)
-  LARGE_INTEGER ticks{{0, 0}};
-  LARGE_INTEGER frequency{{0, 0}};
-  BOOL status = QueryPerformanceFrequency(&frequency);
-
-  if (!status) {
-    std::cerr << "Could not query performance frequency" << '\n';
-    std::abort();
-  }
-
-  status = QueryPerformanceCounter(&ticks);
-
-  if (!status) {
-    std::cerr << "Could not query performance counter" << '\n';
-    std::abort();
-  }
-
-  return ticks.QuadPart * (NSEC_IN_SEC / frequency.QuadPart);
-#else
-  timespec ts{0, 0};
-  int status = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
-  if (status) {
-    std::cerr << "Error while getting time: " << std::strerror(errno) << '\n';
-    std::abort();
-  }
-  return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-#endif
-}
-/*
- * Device-Code - Optimized for GPU
- * SYCL implementation for single iteration of iso3dfd kernel
- * using shared local memory optimizations
- *
- * ND-Range kernel is used to spawn work-items in x, y dimension
- * Each work-item then traverses in the z-dimension
- *
- * z-dimension slicing can be used to vary the total number
- * global work-items.
- *
- * SLM Padding can be used to eliminate SLM bank conflicts if
- * there are any
- */
-void Iso3dfdIterationSLM(sycl::nd_item<3> &it, float *next, float *prev, float *vel,
-                         const float *coeff, float *tab, size_t nx, size_t nxy, size_t bx,
-                         size_t by, size_t z_offset, size_t full_end_z) {
-  // Compute local-id for each work-item
-  auto id0 = it.get_local_id(2);
-  auto id1 = it.get_local_id(1);
-
-  // Compute the position in local memory each work-item
-  // will fetch data from global memory into shared
-  // local memory
-  auto stride = it.get_local_range(2) + 2 * kHalfLength + kPad;
-  auto identifiant = (id0 + kHalfLength) + (id1 + kHalfLength) * stride;
-
-  // We compute the start and the end position in the grid
-  // for each work-item.
-  // Each work-items local value gid is updated to track the
-  // current cell/grid point it is working with.
-  // This position is calculated with the help of slice-ID and number of
-  // grid points each work-item will process.
-  // Offset of kHalfLength is also used to account for HALO
-  auto begin_z = it.get_global_id(0) * z_offset + kHalfLength;
-  auto end_z = begin_z + z_offset;
-  if (end_z > full_end_z) end_z = full_end_z;
-
-  auto gid = (it.get_global_id(2) + bx) + ((it.get_global_id(1) + by) * nx) + (begin_z * nxy);
-
-  // front and back temporary arrays are used to ensure
-  // the grid values in z-dimension are read once, shifted in
-  // these array and reused multiple times before being discarded
-  //
-  // This is an optimization technique to enable data-reuse and
-  // improve overall FLOPS to BYTES read ratio
-  float front[kHalfLength + 1];
-  float back[kHalfLength];
-  float c[kHalfLength + 1];
-
-  for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-    front[iter] = prev[gid + iter * nxy];
-  }
-  c[0] = coeff[0];
-
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    back[iter - 1] = prev[gid - iter * nxy];
-    c[iter] = coeff[iter];
-  }
-
-  // Shared Local Memory (SLM) optimizations (SYCL)
-  // Set some flags to indicate if the current work-item
-  // should read from global memory to shared local memory buffer
-  // or not
-  auto items_x = it.get_local_range(2);
-  auto items_y = it.get_local_range(1);
-
-  bool copy_halo_y = false, copy_halo_x = false;
-  if (id1 < kHalfLength) copy_halo_y = true;
-  if (id0 < kHalfLength) copy_halo_x = true;
-
-  for (auto i = begin_z; i < end_z; i++) {
-    // Shared Local Memory (SLM) optimizations (SYCL)
-    // If work-item is flagged to read into SLM buffer
-    if (copy_halo_y) {
-      tab[identifiant - kHalfLength * stride] = prev[gid - kHalfLength * nx];
-      tab[identifiant + items_y * stride] = prev[gid + items_y * nx];
-    }
-    if (copy_halo_x) {
-      tab[identifiant - kHalfLength] = prev[gid - kHalfLength];
-      tab[identifiant + items_x] = prev[gid + items_x];
-    }
-    tab[identifiant] = front[0];
-
-    // SYCL Basic synchronization (barrier function)
-    // Force synchronization within a work-group
-    // using barrier function to ensure
-    // all the work-items have completed reading into the SLM buffer
-    sycl::group_barrier(it.get_group());
-
-    // Only one new data-point read from global memory
-    // in z-dimension (depth)
-    front[kHalfLength] = prev[gid + kHalfLength * nxy];
-
-    // Stencil code to update grid point at position given by global id (gid)
-    // New time step for grid point is computed based on the values of the
-    // the immediate neighbors - horizontal, vertical and depth
-    // directions(kHalfLength number of points in each direction),
-    // as well as the value of grid point at a previous time step
-    //
-    // Neighbors in the depth (z-dimension) are read out of
-    // front and back arrays
-    // Neighbors in the horizontal and vertical (x, y dimension) are
-    // read from the SLM buffers
-    float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-    for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-      value += c[iter] *
-               (front[iter] + back[iter - 1] + tab[identifiant + iter] + tab[identifiant - iter] +
-                tab[identifiant + iter * stride] + tab[identifiant - iter * stride]);
-    }
-    next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-    // Update the gid to advance in the z-dimension
-    gid += nxy;
-
-    // Input data in front and back are shifted to discard the
-    // oldest value and read one new value.
-    for (unsigned int iter = kHalfLength - 1; iter > 0; iter--) {
-      back[iter] = back[iter - 1];
-    }
-    back[0] = front[0];
-
-    for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-      front[iter] = front[iter + 1];
-    }
-
-    // SYCL Basic synchronization (barrier function)
-    // Force synchronization within a work-group
-    // using barrier function to ensure that SLM buffers
-    // are not overwritten by next set of work-items
-    // (highly unlikely but not impossible)
-    sycl::group_barrier(it.get_group());
-  }
-}
-
-/*
- * Device-Code - Optimized for GPU, CPU
- * SYCL implementation for single iteration of iso3dfd kernel
- * without using any shared local memory optimizations
- *
- *
- * ND-Range kernel is used to spawn work-items in x, y dimension
- * Each work-item can then traverse in the z-dimension
- *
- * z-dimension slicing can be used to vary the total number
- * global work-items.
- *
- */
-void Iso3dfdIterationGlobal(sycl::nd_item<3> &it, float *next, float *prev, const float *vel,
-                            const float *coeff, int nx, int nxy, int bx, int by, int z_offset,
-                            size_t full_end_z) {
-  // We compute the start and the end position in the grid
-  // for each work-item.
-  // Each work-items local value gid is updated to track the
-  // current cell/grid point it is working with.
-  // This position is calculated with the help of slice-ID and number of
-  // grid points each work-item will process.
-  // Offset of kHalfLength is also used to account for HALO
-  auto begin_z = it.get_global_id(0) * z_offset + kHalfLength;
-  auto end_z = begin_z + z_offset;
-  if (end_z > full_end_z) end_z = full_end_z;
-
-  auto gid = (it.get_global_id(2) + bx) + ((it.get_global_id(1) + by) * nx) + (begin_z * nxy);
-
-  // front and back temporary arrays are used to ensure
-  // the grid values in z-dimension are read once, shifted in
-  // these array and reused multiple times before being discarded
-  //
-  // This is an optimization technique to enable data-reuse and
-  // improve overall FLOPS to BYTES read ratio
-  float front[kHalfLength + 1];
-  float back[kHalfLength];
-  float c[kHalfLength + 1];
-
-  for (unsigned int iter = 0; iter <= kHalfLength; iter++) {
-    front[iter] = prev[gid + iter * nxy];
-  }
-  c[0] = coeff[0];
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    c[iter] = coeff[iter];
-    back[iter - 1] = prev[gid - iter * nxy];
-  }
-
-  // Stencil code to update grid point at position given by global id (gid)
-  // New time step for grid point is computed based on the values of the
-  // the immediate neighbors - horizontal, vertical and depth
-  // directions(kHalfLength number of points in each direction),
-  // as well as the value of grid point at a previous time step
-
-  float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-  for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-    value += c[iter] * (front[iter] + back[iter - 1] + prev[gid + iter] + prev[gid - iter] +
-                        prev[gid + iter * nx] + prev[gid - iter * nx]);
-  }
-  next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-  // Update the gid and position in z-dimension and check if there
-  // is more work to do
-  gid += nxy;
-  begin_z++;
-
-  while (begin_z < end_z) {
-    // Input data in front and back are shifted to discard the
-    // oldest value and read one new value.
-    for (auto iter = kHalfLength - 1; iter > 0; iter--) {
-      back[iter] = back[iter - 1];
-    }
-    back[0] = front[0];
-
-    for (unsigned int iter = 0; iter < kHalfLength; iter++) {
-      front[iter] = front[iter + 1];
-    }
-
-    // Only one new data-point read from global memory
-    // in z-dimension (depth)
-    front[kHalfLength] = prev[gid + kHalfLength * nxy];
-
-    // Stencil code to update grid point at position given by global id (gid)
-    float value = c[0] * front[0];
-#pragma unroll(kHalfLength)
-    for (unsigned int iter = 1; iter <= kHalfLength; iter++) {
-      value += c[iter] * (front[iter] + back[iter - 1] + prev[gid + iter] + prev[gid - iter] +
-                          prev[gid + iter * nx] + prev[gid - iter * nx]);
-    }
-
-    next[gid] = 2.0f * front[0] - next[gid] + value * vel[gid];
-
-    gid += nxy;
-    begin_z++;
-  }
-}
-
-/*
- * Host-side SYCL Code
- *
- * Driver function for ISO3DFD SYCL code
- * Uses ptr_next and ptr_prev as ping-pong buffers to achieve
- * accelerated wave propagation
- *
- * This function uses SYCL buffers to facilitate host to device
- * buffer copies
- *
- */
-
-bool Iso3dfdDevice(sycl::queue &q, float *ptr_next, float *ptr_prev, float *ptr_vel,
-                   float *ptr_coeff, size_t n1, size_t n2, size_t n3, size_t n1_block,
-                   size_t n2_block, size_t n3_block, size_t end_z, unsigned int nIterations) {
-  auto nx = n1;
-  auto nxy = n1 * n2;
-
-  auto bx = kHalfLength;
-  auto by = kHalfLength;
-
-  // Display information about the selected device
-  PrintTargetInfo(q, n1_block, n2_block);
-
-  auto grid_size = nxy * n3;
-
-  {  // Begin buffer scope
-    // Create buffers using SYCL class buffer
-    buffer b_ptr_next(ptr_next, range(grid_size));
-    buffer b_ptr_prev(ptr_prev, range(grid_size));
-    buffer b_ptr_vel(ptr_vel, range(grid_size));
-    buffer b_ptr_coeff(ptr_coeff, range(kHalfLength + 1));
-
-    // Log available metrics and metrics groups per device
-    std::string discovery_filename =
-        "available_metrics_" + std::to_string(utils::GetPid()) + ".txt";
-    if (MetricsProfiler::MetricsProfilerInstance()
-            .InitializeMetricsCollection() /*true, discovery_filename)*/
-        != true) {
-      exit(-1);
-    }
-
-    std::string group_name;
-    pti_metrics_group_type group_type;
-
-    std::string sample_filename = "";
-    std::string lib_filename = "";
-
-    // Iterate over time steps
-    for (unsigned int i = 0; i < nIterations; i += 1) {
-      if (i == 0 || i == (nIterations / 2)) {
-        if (i == 0) {  // Collect a different group for the first half of the iterations
-          // TIME metric groups
-          group_name =
-              "ComputeBasic";  //"GpuOffload" "ComputeBasic" "MemProfile" "DataportProfile"
-                               //"L1ProfileReads"  "L1ProfileSlmBankConflicts" "L1ProfileWrites"
-          group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-        } else {  // collect a different metric group for the second half of the iterations
-          // Stop the collection for the first half of the iterations
-          if (MetricsProfiler::MetricsProfilerInstance().StopCollection() != true) {
-            exit(-1);
-          }
-
-          sample_filename = group_name + "_iso3dfd_pti_metric_sample_log_" +
-                            std::to_string(utils::GetPid()) + ".json";
-          // calculate metrics for the first half of the iterations
-          std::cout << "Calculating metrics for the first " << (nIterations / 2)
-                    << " iterations for group ***" << group_name << "***"
-                    << ". Will write to file: " << sample_filename << std::endl;
-          if (MetricsProfiler::MetricsProfilerInstance().GetCalculatedData(true, sample_filename) !=
-              true) {
-            exit(-1);
-          }
-
-          // Compare the result file generated by the sample to the result file generated by the
-          // metric library
-          CompareFiles(lib_filename, sample_filename);
-
-          DeleteFile(lib_filename);
-          DeleteFile(sample_filename);
-
-          // TIME metric groups for second half -- this needs to be *named* same across other
-          // architectures! Choose same group to ensure we do not fail on other architectures.
-          // group_name = "TestOa";
-          group_name =
-              "ComputeBasic";  //"GpuOffload" "ComputeBasic" "MemProfile" "DataportProfile"
-                               //"L1ProfileReads"  "L1ProfileSlmBankConflicts" "L1ProfileWrites"
-          group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-        }
-        std::cout << "Collecting metrics group ***" << group_name << "***" << std::endl;
-        lib_filename =
-            group_name + "_iso3dfd_pti_metric_lib_log_" + std::to_string(utils::GetPid()) + ".json";
-        if (MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-                group_name, group_type, true, lib_filename) != true) {
-          exit(-1);
-        }
-        if (MetricsProfiler::MetricsProfilerInstance().StartCollectionPaused() != true) {
-          exit(-1);
-        }
-      }
-
-      // Submit command group for execution
-      {
-        const std::lock_guard<std::mutex> cout_lock(global_cout_mtx);
-        std::cout << "Q Submitting at: " << i << ": " << std::dec << GetTime() << std::endl;
-      }
-      q.submit([&](auto &h) {
-        // Create accessors
-        accessor next(b_ptr_next, h);
-        accessor prev(b_ptr_prev, h);
-        accessor vel(b_ptr_vel, h, read_only);
-        accessor coeff(b_ptr_coeff, h, read_only);
-
-        // Define local and global range
-
-        // Define local ND range of work-items
-        // Size of each SYCL work-group selected here is a product of
-        // n2_block and n1_block which can be controlled by the input
-        // command line arguments
-        auto local_nd_range = range(1, n2_block, n1_block);
-
-        // Define global ND range of work-items
-        // Size of total number of work-items is selected based on the
-        // total grid size in first and second dimensions (XY-plane)
-        //
-        // Each of the work-item then works on computing
-        // one or more grid points. This value can be controlled by the
-        // input command line argument n3_block
-        //
-        // Effectively this implementation enables slicing of the full
-        // grid into smaller grid slices which can be computed in parallel
-        // to allow auto-scaling of the total number of work-items
-        // spawned to achieve full occupancy for small or larger accelerator
-        // devices
-        auto global_nd_range = range((n3 - 2 * kHalfLength) / n3_block, (n2 - 2 * kHalfLength),
-                                     (n1 - 2 * kHalfLength));
-
-        if (i == 0 || i == (nIterations / 2)) {
-          // metrics collection started in paused mode, resume
-          if (MetricsProfiler::MetricsProfilerInstance().ResumeCollection() != true) {
-            exit(-1);
-          }
-        }
-        // Add small sleep to separate metrics data stream from each iteration
-        std::this_thread::sleep_for(std::chrono::milliseconds(20));
-
-#ifdef USE_SHARED
-        // Using 3D-stencil kernel with Shared Local Memory (SLM)
-        // optimizations (SYCL) to improve effective FLOPS to BYTES
-        // ratio. By default, SLM code path is disabled in this
-        // code sample.
-        // SLM code path can be enabled by recompiling the SYCL source
-        // as follows:
-        // cmake -DSHARED_KERNEL=1 ..
-        // make -j`nproc`
-
-        // Define a range for SLM Buffer
-        // Padding can be used to avoid SLM bank conflicts
-        // By default padding is disabled in the sample code
-        auto local_range =
-            range((n1_block + (2 * kHalfLength) + kPad) * (n2_block + (2 * kHalfLength)));
-
-        //  Create an accessor for SLM buffer
-        accessor<float, 1, access::mode::read_write, access::target::local> tab(local_range, h);
-
-        // Send a SYCL kernel (lambda) for parallel execution
-        // The function that executes a single iteration is called
-        // "Iso3dfdIterationSLM"
-        // alternating the 'next' and 'prev' parameters which effectively
-        // swaps their content at every iteration.
-        if (i % 2 == 0)
-          h.parallel_for(nd_range(global_nd_range, local_nd_range), [=](auto it) {
-            Iso3dfdIterationSLM(it, next.get(), prev.get(), vel.get(), coeff.get(), tab.get(), nx,
-                                nxy, bx, by, n3_block, end_z);
-          });
-        else
-          h.parallel_for(nd_range(global_nd_range, local_nd_range), [=](auto it) {
-            Iso3dfdIterationSLM(it, prev.get(), next.get(), vel.get(), coeff.get(), tab.get(), nx,
-                                nxy, bx, by, n3_block, end_z);
-          });
-
-#else
-
-        // Use Global Memory version of the 3D-Stencil kernel.
-        // This code path is enabled by default
-
-        // Send a SYCL kernel (lambda) for parallel execution
-        // The function that executes a single iteration is called
-        // "Iso3dfdIterationGlobal"
-        // alternating the 'next' and 'prev' parameters which effectively
-        // swaps their content at every iteration.
-        if (i % 2 == 0)
-          h.parallel_for(nd_range(global_nd_range, local_nd_range), [=](auto it) {
-            auto next_ptr = next.template get_multi_ptr<sycl::access::decorated::no>();
-            auto prev_ptr = prev.template get_multi_ptr<sycl::access::decorated::no>();
-            auto vel_ptr = vel.template get_multi_ptr<sycl::access::decorated::no>();
-            auto coeff_ptr = coeff.template get_multi_ptr<sycl::access::decorated::no>();
-            Iso3dfdIterationGlobal(it, next_ptr.get(), prev_ptr.get(), vel_ptr.get(),
-                                   coeff_ptr.get(), nx, nxy, bx, by, n3_block, end_z);
-          });
-        else
-          h.parallel_for(nd_range(global_nd_range, local_nd_range), [=](auto it) {
-            auto next_ptr = next.template get_multi_ptr<sycl::access::decorated::no>();
-            auto prev_ptr = prev.template get_multi_ptr<sycl::access::decorated::no>();
-            auto vel_ptr = vel.template get_multi_ptr<sycl::access::decorated::no>();
-            auto coeff_ptr = coeff.template get_multi_ptr<sycl::access::decorated::no>();
-            Iso3dfdIterationGlobal(it, prev_ptr.get(), next_ptr.get(), vel_ptr.get(),
-                                   coeff_ptr.get(), nx, nxy, bx, by, n3_block, end_z);
-          });
-#endif
-      });
-      // Add small sleep to separate metrics data stream from each iteration
-      std::this_thread::sleep_for(std::chrono::milliseconds(20));
-    }
-    // Stop the collection for the second half of the iterations
-    if (MetricsProfiler::MetricsProfilerInstance().StopCollection() != true) {
-      exit(-1);
-    }
-
-    sample_filename =
-        group_name + "_iso3dfd_pti_metric_sample_log_" + std::to_string(utils::GetPid()) + ".json";
-    // calculate metrics
-    std::cout << "Calculating metrics for the second " << (nIterations / 2)
-              << " iterations for group ***" << group_name << "***"
-              << ". Will write to file: " << sample_filename << std::endl;
-    if (MetricsProfiler::MetricsProfilerInstance().GetCalculatedData(true, sample_filename) !=
-        true) {
-      exit(-1);
-    }
-
-    // Compare the result file generated by the sample to the result file generated by the metric
-    // library then delete them
-    CompareFiles(lib_filename, sample_filename);
-
-    DeleteFile(lib_filename);
-    DeleteFile(sample_filename);
-
-  }  // end buffer scope
-  return true;
-}
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/src/utils.cpp b/sdk/samples/metrics_iso3dfd_dpcpp/src/utils.cpp
deleted file mode 100644
index 9fed3ab9..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/src/utils.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-//==============================================================
-// Copyright © 2020 Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <sstream>
-#include "iso3dfd.h"
-
-/*
- * Host-Code
- * Utility function to validate grid and block dimensions
- */
-bool CheckGridDimension(size_t n1, size_t n2, size_t n3, unsigned int dim_x,
-                        unsigned int dim_y, unsigned int block_z) {
-  
-  if (0 == dim_x) {
-    std::cout << " ERROR: Invalid Grid Size: DIMX cannot be Zero\n";
-    return true;
-  }
-  if (0 == dim_y) {
-    std::cout << " ERROR: Invalid Grid Size: DIMY cannot be Zero\n";
-    return true;
-  }
-  if (0 == block_z) {
-    std::cout << " ERROR: Invalid Grid Size: BLOCKZ cannot be Zero\n";
-    return true;
-  }
-  
-  if (n1 % dim_x) {
-    std::cout << " ERROR: Invalid Grid Size: n1 should be multiple of DIMX - "
-              << dim_x << "\n";
-    return true;
-  }
-  if (n2 % dim_y) {
-    std::cout << " ERROR: Invalid Grid Size: n2 should be multiple of DIMY - "
-              << dim_y << "\n";
-    return true;
-  }
-  if (n3 % block_z) {
-    std::cout << " ERROR: Invalid Grid Size: n3 should be multiple of BLOCKZ - "
-              << block_z << "\n";
-    return true;
-  }
-
-  return false;
-}
-
-/*
- * Host-Code
- * Utility function to validate block sizes
- */
-bool CheckBlockDimension(sycl::queue& q, unsigned int dim_x,
-                         unsigned int dim_y) {
-  auto device = q.get_device();
-  auto max_block_size =
-      device.get_info<sycl::info::device::max_work_group_size>();
-
-  if ((max_block_size > 1) && (static_cast<std::size_t>(dim_x) * dim_y > max_block_size)) {
-    std::cout << "ERROR: Invalid block sizes: n1_Tblock * n2_Tblock should be "
-                 "less than or equal to "
-              << max_block_size << "\n";
-    return true;
-  }
-
-  return false;
-}
-
-/*
- * Host-Code
- * Utility function to print device info
- */
-void PrintTargetInfo(sycl::queue& q, unsigned int dim_x, unsigned int dim_y) {
-  auto device = q.get_device();
-  auto max_block_size =
-      device.get_info<sycl::info::device::max_work_group_size>();
-
-  auto max_exec_unit_count =
-      device.get_info<sycl::info::device::max_compute_units>();
-
-  std::cout << " Running on " << device.get_info<sycl::info::device::name>()
-            << "\n";
-  std::cout << " The Device Max Work Group Size is : " << max_block_size
-            << "\n";
-  std::cout << " The Device Max EUCount is : " << max_exec_unit_count << "\n";
-  std::cout << " The blockSize x is : " << dim_x << "\n";
-  std::cout << " The blockSize y is : " << dim_y << "\n";
-#ifdef USE_SHARED
-  std::cout << " Using Shared Local Memory Kernel\n";
-#else
-  std::cout << " Using Global Memory Kernel\n";
-
-#endif
-}
-
-/*
- * Host-Code
- * Utility function to get input arguments
- */
-void Usage(const std::string& programName) {
-  std::cout << " Incorrect parameters \n";
-  std::cout << " Usage: ";
-  std::cout << programName
-            << " n1 n2 n3 b1 b2 b3 Iterations [omp|sycl] [gpu|cpu] \n\n";
-  std::cout << " n1 n2 n3      : Grid sizes for the stencil \n";
-  std::cout << " b1 b2 b3      : cache block sizes for cpu openmp version.\n";
-  std::cout << " Iterations    : No. of timesteps. \n";
-  std::cout << " [omp|sycl]    : Optional: Run the OpenMP or the SYCL variant."
-            << " Default is to use both for validation \n";
-  std::cout
-      << " [gpu|cpu]     : Optional: Device to run the SYCL version"
-      << " Default is to use the GPU if available, if not fallback to CPU \n\n";
-}
-
-/*
- * Host-Code
- * Utility function to print stats
- */
-void PrintStats(double time, size_t n1, size_t n2, size_t n3,
-                unsigned int nIterations) {
-  float throughput_mpoints = 0.0f, mflops = 0.0f, normalized_time = 0.0f;
-  double mbytes = 0.0f;
-
-  std::cout << "--------------------------------------\n";
-  if (0 < nIterations) {
-    normalized_time = (double)time / nIterations;
-    throughput_mpoints = ((n1 - 2 * kHalfLength) * (n2 - 2 * kHalfLength) *
-                          (n3 - 2 * kHalfLength)) /
-                          (normalized_time * 1e3f);
-    mflops = (7.0f * kHalfLength + 5.0f) * throughput_mpoints;
-    mbytes = 12.0f * throughput_mpoints;
-
-    std::cout << "time         : " << time / 1e3f << " secs\n";
-    std::cout << "throughput   : " << throughput_mpoints << " Mpts/s\n";
-    std::cout << "flops        : " << mflops / 1e3f << " GFlops\n";
-    std::cout << "bytes        : " << mbytes / 1e3f << " GBytes/s\n";
-  } else {
-    std::cout << "nIterations  : 0\n";
-    std::cout << "time         : Undefined\n";
-    std::cout << "throughput   : Undefined\n";
-    std::cout << "flops        : Undefined\n";
-    std::cout << "bytes        : Undefined\n";
-  }
-  std::cout << "\n--------------------------------------\n";
-  std::cout << "\n--------------------------------------\n";
-}
-
-/*
- * Host-Code
- * Utility function to calculate L2-norm between resulting buffer and reference
- * buffer
- */
-bool WithinEpsilon(float* output, float* reference, const size_t dim_x,
-                   const size_t dim_y, const size_t dim_z,
-                   const unsigned int radius, const int zadjust = 0,
-                   const float delta = 0.01f) {
-  std::ofstream error_file;
-  std::stringstream error_stream;
-
-  bool error = false;
-  double norm2 = 0;
-
-  for (size_t iz = 0; iz < dim_z; iz++) {
-    for (size_t iy = 0; iy < dim_y; iy++) {
-      for (size_t ix = 0; ix < dim_x; ix++) {
-        if (ix >= radius && ix < (dim_x - radius) && iy >= radius &&
-            iy < (dim_y - radius) && iz >= radius &&
-            iz < (dim_z - radius + zadjust)) {
-          float difference = fabsf(*reference - *output);
-          norm2 += difference * difference;
-          if (difference > delta) {
-            error = true;
-            error_stream << " ERROR: " << ix << ", " << iy << ", " << iz << "   "
-                       << *output << "   instead of " << *reference
-                       << "  (|e|=" << difference << ")\n";
-          }
-        }
-        ++output;
-        ++reference;
-      }
-    }
-  }
-
-  norm2 = std::sqrt(norm2);
-  if (error) {
-     error_file.open("error_diff.txt");
-     error_file << error_stream.str();
-     error_file.close();
-     std::cout << "error (Euclidean norm): " << norm2 << "\n";
-  }
-  return error;
-}
diff --git a/sdk/samples/metrics_iso3dfd_dpcpp/third-party-programs.txt b/sdk/samples/metrics_iso3dfd_dpcpp/third-party-programs.txt
deleted file mode 100644
index e9f8042d..00000000
--- a/sdk/samples/metrics_iso3dfd_dpcpp/third-party-programs.txt
+++ /dev/null
@@ -1,253 +0,0 @@
-oneAPI Code Samples - Third Party Programs File
-
-This file contains the list of third party software ("third party programs")
-contained in the Intel software and their required notices and/or license
-terms. This third party software, even if included with the distribution of the
-Intel software, may be governed by separate license terms, including without
-limitation, third party license terms, other Intel software license terms, and
-open source software license terms. These separate license terms govern your use
-of the third party programs as set forth in the “third-party-programs.txt” or
-other similarly named text file.
- 
-Third party programs and their corresponding required notices and/or license
-terms are listed below.
-
---------------------------------------------------------------------------------
-
-1.  Nothings STB Libraries
-   
-stb/LICENSE
-
- This software is available under 2 licenses -- choose whichever you prefer.
- ------------------------------------------------------------------------------
- ALTERNATIVE A - MIT License
- Copyright (c) 2017 Sean Barrett
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal in
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
- ------------------------------------------------------------------------------
- ALTERNATIVE B - Public Domain (www.unlicense.org)
- This is free and unencumbered software released into the public domain.
- Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
- software, either in source code form or as a compiled binary, for any purpose,
- commercial or non-commercial, and by any means.
- In jurisdictions that recognize copyright laws, the author or authors of this
- software dedicate any and all copyright interest in the software to the public
- domain. We make this dedication for the benefit of the public at large and to
- the detriment of our heirs and successors. We intend this dedication to be an
- overt act of relinquishment in perpetuity of all present and future rights to
- this software under copyright law.
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-2.  FGPA example designs-gzip
-
-    SDL2.0
-
-zlib License
-
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-
---------------------------------------------------------------------------------
-
-3. Nbody
-   (c) 2019 Fabio Baruffa
-
-   Plotly.js
-   Copyright (c) 2020 Plotly, Inc
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-© 2020 GitHub, Inc.
-
---------------------------------------------------------------------------------
-
-4. GNU-EFI
-   Copyright (c) 1998-2000 Intel Corporation
-
-The files in the "lib" and "inc" subdirectories are using the EFI Application 
-Toolkit distributed by Intel at http://developer.intel.com/technology/efi
-
-This code is covered by the following agreement:
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
-INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE. THE EFI SPECIFICATION AND ALL OTHER INFORMATION
-ON THIS WEB SITE ARE PROVIDED "AS IS" WITH NO WARRANTIES, AND ARE SUBJECT
-TO CHANGE WITHOUT NOTICE.
-
---------------------------------------------------------------------------------
-
-5. Edk2
-   Copyright (c) 2019, Intel Corporation.  All rights reserved.
-
-   Edk2 Basetools
-   Copyright (c) 2019, Intel Corporation.  All rights reserved.
-
-SPDX-License-Identifier: BSD-2-Clause-Patent
-
---------------------------------------------------------------------------------
-
-6. Heat Transmission
-
-GNU LESSER GENERAL PUBLIC LICENSE
-Version 3, 29 June 2007
-
-Copyright © 2007 Free Software Foundation, Inc. <https://fsf.org/>
-
-Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
-
-This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.
-
-0. Additional Definitions.
-As used herein, “this License” refers to version 3 of the GNU Lesser General Public License, and the “GNU GPL” refers to version 3 of the GNU General Public License.
-
-“The Library” refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.
-
-An “Application” is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.
-
-A “Combined Work” is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the “Linked Version”.
-
-The “Minimal Corresponding Source” for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.
-
-The “Corresponding Application Code” for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.
-
-1. Exception to Section 3 of the GNU GPL.
-You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.
-
-2. Conveying Modified Versions.
-If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:
-
-a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or
-b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.
-3. Object Code Incorporating Material from Library Header Files.
-The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:
-
-a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.
-b) Accompany the object code with a copy of the GNU GPL and this license document.
-4. Combined Works.
-You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:
-
-a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.
-b) Accompany the Combined Work with a copy of the GNU GPL and this license document.
-c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.
-d) Do one of the following:
-0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
-1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.
-e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)
-5. Combined Libraries.
-You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:
-
-a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.
-b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.
-6. Revised Versions of the GNU Lesser General Public License.
-The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.
-
-If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.
-
---------------------------------------------------------------------------------
-7. Rodinia
-   Copyright (c)2008-2011 University of Virginia
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted without royalty fees or other restrictions, provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-    * Neither the name of the University of Virginia, the Dept. of Computer Science, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY OF VIRGINIA OR THE SOFTWARE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-If you use this software or a modified version of it, please cite the most relevant among the following papers:
-
- - M. A. Goodrum, M. J. Trotter, A. Aksel, S. T. Acton, and K. Skadron. Parallelization of Particle Filter Algorithms. In Proceedings of the 3rd Workshop on Emerging Applications and Many-core Architecture (EAMA), in conjunction with the IEEE/ACM International 
-Symposium on Computer Architecture (ISCA), June 2010.
-
- - S. Che, M. Boyer, J. Meng, D. Tarjan, J. W. Sheaffer, Sang-Ha Lee and K. Skadron.
-Rodinia: A Benchmark Suite for Heterogeneous Computing. IEEE International Symposium
-on Workload Characterization, Oct 2009.
-
-- J. Meng and K. Skadron. "Performance Modeling and Automatic Ghost Zone Optimization
-for Iterative Stencil Loops on GPUs." In Proceedings of the 23rd Annual ACM International
-Conference on Supercomputing (ICS), June 2009.
-
-- L.G. Szafaryn, K. Skadron and J. Saucerman. "Experiences Accelerating MATLAB Systems
-Biology Applications." in Workshop on Biomedicine in Computing (BiC) at the International
-Symposium on Computer Architecture (ISCA), June 2009.
-
-- M. Boyer, D. Tarjan, S. T. Acton, and K. Skadron. "Accelerating Leukocyte Tracking using CUDA:
-A Case Study in Leveraging Manycore Coprocessors." In Proceedings of the International Parallel
-and Distributed Processing Symposium (IPDPS), May 2009.
-
-- S. Che, M. Boyer, J. Meng, D. Tarjan, J. W. Sheaffer, and K. Skadron. "A Performance
-Study of General Purpose Applications on Graphics Processors using CUDA" Journal of
-Parallel and Distributed Computing, Elsevier, June 2008.
-
---------------------------------------------------------------------------------
-Other names and brands may be claimed as the property of others. 
-
---------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/sdk/samples/metrics_perf/CMakeLists.txt b/sdk/samples/metrics_perf/CMakeLists.txt
deleted file mode 100644
index e3026b8b..00000000
--- a/sdk/samples/metrics_perf/CMakeLists.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_METRICS_PERF CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(metrics_perf metrics_perf.cc)
-
-target_link_options(metrics_perf PUBLIC -fsycl)
-target_compile_options(metrics_perf PUBLIC -fsycl)
-target_include_directories(
-  metrics_perf PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities"
-                          "${PROJECT_SOURCE_DIR}/../../src/utils"
-                          )
-
-if (NOT TARGET Threads::Threads)
-  find_package(Threads REQUIRED)
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(metrics_perf PUBLIC spdlog::spdlog Pti::pti_view Threads::Threads)
-
diff --git a/sdk/samples/metrics_perf/metrics_perf.cc b/sdk/samples/metrics_perf/metrics_perf.cc
deleted file mode 100644
index 62d0bc6a..00000000
--- a/sdk/samples/metrics_perf/metrics_perf.cc
+++ /dev/null
@@ -1,698 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// PTI Metrics API Overhead Test
-
-#include <algorithm>
-#include <cassert>
-#include <chrono>
-#include <cmath>
-#include <cstdlib>
-#include <iomanip>
-#include <iostream>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "metrics_utils.h"
-#include "pti/pti_metrics.h"
-#include "samples_utils.h"
-
-namespace {
-
-// Test configuration
-constexpr int kNumIterations = 500;
-constexpr int kWarmupIterations = 10;
-constexpr unsigned kDefaultMatrixSize = 512;
-constexpr unsigned kMaxSize = 8192;
-constexpr unsigned kMinSize = 32;
-constexpr float kAValue = 0.128f;
-constexpr float kBValue = 0.256f;
-constexpr float kMaxEPS = 1.0e-4f;
-
-// Global test state
-std::vector<pti_device_properties_t> g_devices;
-std::vector<std::vector<pti_metrics_group_properties_t>> g_device_metric_groups;
-
-static float Check(const std::vector<float>& a, float value) {
-  assert(value > kMaxEPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                         float expected_result, bool verify_results = true) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    std::cerr << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-  if (verify_results) {
-    return Check(c, expected_result);
-  }
-  return 0.0f;
-}
-
-static void Compute(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, unsigned repeat_count,
-                    float expected_result, bool check_results = true) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    bool verify_itr = check_results && (i == 0 || i == repeat_count - 1);
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result, verify_itr);
-    if (verify_itr && eps > kMaxEPS) {
-      std::cerr << "[ERROR] Results are INCORRECT with accuracy: " << eps
-                << " while expected less than " << kMaxEPS << std::endl;
-    }
-  }
-}
-
-// Thread-safe device discovery
-bool DiscoverDevicesThreadSafe(std::vector<pti_device_properties_t>& devices) {
-  uint32_t device_count = 0;
-  pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-  if (result != PTI_SUCCESS || device_count == 0) {
-    return false;
-  }
-
-  devices.resize(device_count);
-  result = ptiMetricsGetDevices(devices.data(), &device_count);
-  return result == PTI_SUCCESS;
-}
-
-// Thread-safe metric groups discovery
-bool DiscoverMetricGroupsThreadSafe(pti_device_handle_t device_handle,
-                                    std::vector<pti_metrics_group_properties_t>& metric_groups) {
-  uint32_t group_count = 0;
-  pti_result result = ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count);
-  if (result != PTI_SUCCESS || group_count == 0) {
-    return false;
-  }
-
-  metric_groups.resize(group_count);
-  result = ptiMetricsGetMetricGroups(device_handle, metric_groups.data(), &group_count);
-  return result == PTI_SUCCESS;
-}
-
-// Find suitable metric group for collection
-pti_metrics_group_handle_t FindSuitableMetricGroup(
-    const std::vector<pti_metrics_group_properties_t>& groups) {
-  for (const auto& group : groups) {
-    if (group._type == PTI_METRIC_GROUP_TYPE_TIME_BASED) {
-      return group._handle;
-    }
-  }
-  for (const auto& group : groups) {
-    if (group._type == PTI_METRIC_GROUP_TYPE_EVENT_BASED) {
-      return group._handle;
-    }
-  }
-  return nullptr;
-}
-
-static void SetupMatrices(std::vector<float>& a, std::vector<float>& b, std::vector<float>& c,
-                          unsigned size) {
-  const size_t total_size = size * size;
-  a.assign(total_size, kAValue);
-  b.assign(total_size, kBValue);
-  c.assign(total_size, 0.0f);
-}
-
-static bool StartMetricsCollection(pti_device_handle_t device_handle,
-                                   pti_metrics_group_handle_t metrics_group_handle) {
-  pti_metrics_group_collection_params_t config_params = {};
-  config_params._struct_size = sizeof(config_params);
-  config_params._group_handle = metrics_group_handle;
-  config_params._sampling_interval = 100000;  // 100μs
-
-  if (ptiMetricsConfigureCollection(device_handle, &config_params, 1) != PTI_SUCCESS) {
-    std::cerr << "Failed to configure metrics collection" << std::endl;
-    return false;
-  }
-
-  if (ptiMetricsStartCollection(device_handle) != PTI_SUCCESS) {
-    std::cerr << "Failed to start metrics collection" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-static void StopMetricsCollection(pti_device_handle_t device_handle) {
-  if (ptiMetricsStopCollection(device_handle) != PTI_SUCCESS) {
-    std::cerr << "Failed to stop metrics collection" << std::endl;
-  }
-}
-
-// Helper function to get metrics sample count
-static uint32_t GetMetricsSampleCount(pti_device_handle_t device_handle,
-                                      pti_metrics_group_handle_t metrics_group_handle) {
-  uint32_t values_count = 0;
-  pti_result result =
-      ptiMetricsGetCalculatedData(device_handle, metrics_group_handle, nullptr, &values_count);
-  if (result != PTI_SUCCESS) {
-    if (result == PTI_ERROR_METRICS_NO_DATA_COLLECTED) {
-      return 0;  // No data collected is not an error for our reporting purposes
-    }
-    std::cerr << "Warning: Failed to get metrics data count, result: " << result << std::endl;
-    return 0;
-  }
-
-  uint32_t metric_count = 0;
-  for (size_t device_idx = 0; device_idx < g_device_metric_groups.size(); ++device_idx) {
-    for (const auto& group : g_device_metric_groups[device_idx]) {
-      if (group._handle == metrics_group_handle) {
-        metric_count = group._metric_count;
-        break;
-      }
-    }
-    if (metric_count > 0) break;  // Found it
-  }
-
-  if (metric_count == 0) {
-    std::cerr << "Warning: Could not find metric group in global list" << std::endl;
-    return 0;
-  }
-
-  return values_count / metric_count;
-}
-
-// Helper function to print metrics collection info
-static void PrintMetricsInfo(pti_device_handle_t device_handle,
-                             pti_metrics_group_handle_t metrics_group_handle,
-                             const std::string& test_name) {
-  uint32_t samples_count = GetMetricsSampleCount(device_handle, metrics_group_handle);
-  std::cout << test_name << " - Metrics samples collected: " << samples_count << std::endl;
-}
-
-// Warmup function for single queue
-static void WarmupSingleQueue(sycl::queue& queue, unsigned size, unsigned warmup_iterations) {
-  std::vector<float> a, b, c;
-  SetupMatrices(a, b, c, size);
-
-  Compute(queue, a, b, c, size, warmup_iterations, kAValue * kBValue * size, false);
-}
-
-// Warmup function for multiple queues
-static void WarmupMultiQueues(const std::vector<sycl::queue>& queues, unsigned size,
-                              unsigned warmup_iterations) {
-  std::vector<std::thread> warmup_threads;
-
-  for (const auto& queue : queues) {
-    warmup_threads.emplace_back([&queue, size, warmup_iterations]() {
-      std::vector<float> a, b, c;
-      SetupMatrices(a, b, c, size);
-      Compute(queue, a, b, c, size, warmup_iterations, kAValue * kBValue * size, false);
-    });
-  }
-
-  for (auto& thread : warmup_threads) {
-    if (thread.joinable()) {
-      thread.join();
-    }
-  }
-}
-
-static void WorkerThread(sycl::queue queue, pti_device_handle_t device_handle = nullptr,
-                         pti_metrics_group_handle_t metrics_group_handle = nullptr,
-                         unsigned iterations = kNumIterations, unsigned size = kDefaultMatrixSize,
-                         const std::string& thread_name = "Worker") {
-  std::vector<float> a, b, c;
-  SetupMatrices(a, b, c, size);
-
-  std::cout << thread_name << " - Starting computation" << std::endl;
-
-  // Start metrics if handles provided
-  bool metrics_started = false;
-  if (device_handle && metrics_group_handle) {
-    metrics_started = StartMetricsCollection(device_handle, metrics_group_handle);
-    if (!metrics_started) {
-      std::cerr << thread_name << " Thread failed to start metrics collection" << std::endl;
-      return;
-    }
-  }
-
-  Compute(queue, a, b, c, size, iterations, kAValue * kBValue * size, false);
-
-  if (metrics_started) {
-    StopMetricsCollection(device_handle);
-    PrintMetricsInfo(device_handle, metrics_group_handle, thread_name);
-  }
-}
-
-// Test 1: Baseline without profiling
-std::chrono::duration<double> RunBaselineTest(sycl::queue& queue, unsigned iterations,
-                                              unsigned size) {
-  WarmupSingleQueue(queue, size, kWarmupIterations);
-
-  std::vector<float> a, b, c;
-  SetupMatrices(a, b, c, size);
-
-  auto start_time = std::chrono::high_resolution_clock::now();
-  Compute(queue, a, b, c, size, iterations, kAValue * kBValue * size, false);
-  auto end_time = std::chrono::high_resolution_clock::now();
-
-  return end_time - start_time;
-}
-
-// Test 2: Single-threaded with profiling
-std::chrono::duration<double> RunSingleThreadedProfilingTest(
-    pti_device_handle_t device_handle, pti_metrics_group_handle_t metrics_group_handle,
-    sycl::queue& queue, unsigned iterations, unsigned size) {
-  WarmupSingleQueue(queue, size, kWarmupIterations);
-
-  std::vector<float> a, b, c;
-  SetupMatrices(a, b, c, size);
-
-  auto start_time = std::chrono::high_resolution_clock::now();
-
-  if (!StartMetricsCollection(device_handle, metrics_group_handle)) {
-    return std::chrono::duration<double>(0.0);
-  }
-
-  Compute(queue, a, b, c, size, iterations, kAValue * kBValue * size, false);
-  StopMetricsCollection(device_handle);
-
-  auto end_time = std::chrono::high_resolution_clock::now();
-
-  PrintMetricsInfo(device_handle, metrics_group_handle, "Single-threaded profiling test");
-
-  return end_time - start_time;
-}
-
-// Test 3: Multi-threaded without profiling
-std::chrono::duration<double> RunMultiThreadedTest(const std::vector<sycl::queue>& queues,
-                                                   unsigned iterations, unsigned size) {
-  WarmupMultiQueues(queues, size, kWarmupIterations);
-
-  auto start_time = std::chrono::high_resolution_clock::now();
-
-  std::vector<std::thread> threads;
-  size_t thread_count = (std::min)(queues.size(), static_cast<size_t>(2));
-
-  for (size_t i = 0; i < thread_count; ++i) {
-    std::string thread_name = "NoProfile-Thread-" + std::to_string(i);
-    threads.emplace_back(WorkerThread, queues[i], nullptr, nullptr, iterations, size, thread_name);
-  }
-
-  for (auto& thread : threads) {
-    if (thread.joinable()) {
-      thread.join();
-    }
-  }
-
-  auto end_time = std::chrono::high_resolution_clock::now();
-  return end_time - start_time;
-}
-
-// Test 4: Multi-threaded with profiling
-std::chrono::duration<double> RunMultiThreadedProfilingTest(
-    const std::vector<pti_device_handle_t>& device_handles,
-    const std::vector<pti_metrics_group_handle_t>& metrics_group_handles,
-    const std::vector<sycl::queue>& queues, unsigned iterations, unsigned size) {
-  WarmupMultiQueues(queues, size, kWarmupIterations);
-
-  auto start_time = std::chrono::high_resolution_clock::now();
-
-  std::vector<std::thread> threads;
-  size_t thread_count = (std::min)({device_handles.size(), queues.size(), static_cast<size_t>(2)});
-
-  for (size_t i = 0; i < thread_count; ++i) {
-    std::string thread_name = "Thread-" + std::to_string(i);
-    threads.emplace_back(WorkerThread, queues[i], device_handles[i], metrics_group_handles[i],
-                         iterations, size, thread_name);
-  }
-
-  for (auto& thread : threads) {
-    if (thread.joinable()) {
-      thread.join();
-    }
-  }
-
-  auto end_time = std::chrono::high_resolution_clock::now();
-  return end_time - start_time;
-}
-
-// Print all metric groups and their metrics properties
-void PrintAllMetrics() {
-  std::cout << "\n=== AVAILABLE METRICS GROUPS AND METRICS ===" << std::endl;
-
-  for (size_t dev_idx = 0; dev_idx < g_devices.size(); ++dev_idx) {
-    std::cout << "\n[DEVICE " << dev_idx << "]" << std::endl;
-    std::cout << "  Model: " << g_devices[dev_idx]._model_name << std::endl;
-    std::cout << "  Handle: " << g_devices[dev_idx]._handle << std::endl;
-
-    for (size_t grp_idx = 0; grp_idx < g_device_metric_groups[dev_idx].size(); ++grp_idx) {
-      const auto& group = g_device_metric_groups[dev_idx][grp_idx];
-
-      std::cout << "\n  [METRIC GROUP " << grp_idx << "]" << std::endl;
-      std::cout << "    Name: " << group._name << std::endl;
-      std::cout << "    Description: " << group._description << std::endl;
-      std::cout << "    Type: " << group._type;
-
-      // Decode type flags
-      std::cout << " (";
-      bool first = true;
-      if (group._type & PTI_METRIC_GROUP_TYPE_EVENT_BASED) {
-        std::cout << "EVENT";
-        first = false;
-      }
-      if (group._type & PTI_METRIC_GROUP_TYPE_TIME_BASED) {
-        if (!first) std::cout << " | ";
-        std::cout << "TIME";
-      }
-      std::cout << ")" << std::endl;
-
-      std::cout << "    Domain: " << group._domain << std::endl;
-      std::cout << "    Metric Count: " << group._metric_count << std::endl;
-      if (group._metric_count == 0) {
-        std::cout << "      No metrics in this group." << std::endl;
-        continue;
-      }
-
-      // Get and print individual metrics
-      std::vector<pti_metric_properties_t> metrics(group._metric_count);
-      pti_result result = ptiMetricsGetMetricsProperties(group._handle, metrics.data());
-
-      if (result == PTI_SUCCESS) {
-        for (uint32_t m = 0; m < group._metric_count; ++m) {
-          std::cout << "      [Metric " << m << "] " << metrics[m]._name << std::endl;
-          std::cout << "        Description: " << metrics[m]._description << std::endl;
-          std::cout << "        Metric Type: "
-                    << metrics_utils::GetMetricType(metrics[m]._metric_type) << std::endl;
-          std::cout << "        Value Type: "
-                    << metrics_utils::GetMetricValueType(metrics[m]._value_type) << std::endl;
-          std::cout << "        Units: " << metrics[m]._units << std::endl;
-        }
-      } else {
-        std::cout << "      ERROR: Failed to get metrics properties" << std::endl;
-      }
-    }
-  }
-  std::cout << "\n===========================================\n" << std::endl;
-}
-
-// Releases the ptiMetricsEnable() reference taken by InitializeTest(). main() has several exit
-// paths, so the matching ptiMetricsDisable() is done from a destructor rather than by hand.
-class MetricsEnableGuard {
- public:
-  MetricsEnableGuard() = default;
-  ~MetricsEnableGuard() {
-    if (enabled_) {
-      ptiMetricsDisable(nullptr);
-    }
-  }
-  MetricsEnableGuard(const MetricsEnableGuard&) = delete;
-  MetricsEnableGuard& operator=(const MetricsEnableGuard&) = delete;
-
-  void MarkEnabled() { enabled_ = true; }
-
- private:
-  bool enabled_ = false;
-};
-
-MetricsEnableGuard g_metrics_enable_guard;
-
-bool InitializeTest() {
-  bool metrics_enabled = (samples_utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-  if (!metrics_enabled) {
-    pti_result status = ptiMetricsEnable(nullptr);
-    if (status != PTI_SUCCESS) {
-      std::cerr << "ERROR: Metrics are not enabled. ZET_ENABLE_METRICS must be set to 1"
-                << std::endl;
-      return false;
-    }
-    g_metrics_enable_guard.MarkEnabled();
-  }
-
-  if (!DiscoverDevicesThreadSafe(g_devices)) {
-    std::cerr << "ERROR: Failed to discover devices" << std::endl;
-    return false;
-  }
-
-  if (g_devices.empty()) {
-    std::cerr << "ERROR: No devices available for testing" << std::endl;
-    return false;
-  }
-
-  g_device_metric_groups.resize(g_devices.size());
-  for (size_t i = 0; i < g_devices.size(); ++i) {
-    if (!DiscoverMetricGroupsThreadSafe(g_devices[i]._handle, g_device_metric_groups[i])) {
-      std::cerr << "ERROR: Failed to discover metric groups for device " << i << std::endl;
-      return false;
-    }
-    if (g_device_metric_groups[i].empty()) {
-      std::cerr << "ERROR: No metric groups for device " << i << std::endl;
-      return false;
-    }
-  }
-
-  return true;
-}
-
-}  // namespace
-
-void Usage(const char* name) {
-  std::cout << " Calculating floating point matrix multiply on gpu, compare the performance "
-               "with and without PTI Metrics API (Single and multi-thread)\n"
-            << "  Usage " << name << "  [ options ]" << std::endl;
-  std::cout << "--size [-s]       integer        " << "Matrix size, default: " << kDefaultMatrixSize
-            << std::endl;
-  std::cout << "--repeat [-r]     integer        "
-            << "Number of iterations, default: " << kNumIterations << std::endl;
-  std::cout << "--list-metrics    (no argument) "
-            << "List all available metrics groups and metrics, then exit" << std::endl;
-}
-
-int main(int argc, char* argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  unsigned repeat_count = kNumIterations;
-  unsigned size = kDefaultMatrixSize;
-  bool list_metrics_only = false;
-
-  try {
-    for (int i = 1; i < argc; i++) {
-      if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--size") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        size = (temp < kMinSize) ? kMinSize : (temp > kMaxSize) ? kMaxSize : temp;
-      } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--repeat") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        repeat_count = (temp < 1) ? 1 : temp;
-      } else if (strcmp(argv[i], "--list-metrics") == 0) {
-        list_metrics_only = true;
-      } else {
-        Usage(argv[0]);
-        return EXIT_SUCCESS;
-      }
-    }
-  } catch (...) {
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  if (!list_metrics_only) {
-    std::cout << "=== PTI Metrics API Overhead Test ===" << std::endl;
-    std::cout << "Matrix size: " << size << "x" << size << std::endl;
-    std::cout << "Iterations: " << repeat_count << std::endl;
-    std::cout << std::endl;
-  }
-
-  if (!InitializeTest()) {
-    return EXIT_FAILURE;
-  }
-
-  // If user just wants to list metrics, do that and exit
-  if (list_metrics_only) {
-    PrintAllMetrics();
-    return EXIT_SUCCESS;
-  }
-
-  try {
-    std::vector<sycl::device> sycl_devices;
-    std::vector<sycl::queue> queues;
-
-    auto all_devices = sycl::device::get_devices(sycl::info::device_type::gpu);
-    if (all_devices.empty()) {
-      std::cerr << "ERROR: No GPU devices found" << std::endl;
-      return EXIT_FAILURE;
-    }
-
-    size_t num_queues = (std::min)({all_devices.size(), g_devices.size(), static_cast<size_t>(2)});
-    sycl::property_list prop_list{sycl::property::queue::in_order()};
-
-    for (size_t i = 0; i < num_queues; ++i) {
-      sycl_devices.push_back(all_devices[i]);
-      queues.emplace_back(all_devices[i], sycl::async_handler{}, prop_list);
-      std::cout << "Queue " << i
-                << " created on device: " << all_devices[i].get_info<sycl::info::device::name>()
-                << std::endl;
-    }
-
-    if (queues.size() < 2) {
-      std::cout << "Warning: Only " << queues.size() << " device(s) available for testing"
-                << std::endl;
-    }
-
-    std::cout << "Device verification:" << std::endl;
-    for (size_t i = 0; i < queues.size(); ++i) {
-      auto device = queues[i].get_device();
-
-      try {
-        auto ze_device = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(device);
-
-        std::cout << "Queue[" << i << "] native device handle: " << ze_device << std::endl;
-      } catch (...) {
-        std::cout << "Queue[" << i << "] - Could not get native handle" << std::endl;
-      }
-    }
-
-    for (size_t i = 0; i < g_devices.size(); ++i) {
-      std::cout << "g_devices[" << i << "]._handle: " << g_devices[i]._handle << std::endl;
-      std::cout << "g_devices[" << i << "] UUID: ";
-      for (size_t j = 0; j < PTI_MAX_DEVICE_UUID_SIZE; ++j) {
-        std::cout << std::hex << std::setw(2) << std::setfill('0')
-                  << static_cast<unsigned int>(g_devices[i]._uuid[j]);
-      }
-      std::cout << std::dec << std::setfill(' ') << std::endl;
-    }
-
-    std::cout << std::endl;
-
-    pti_device_handle_t device_handle = g_devices[0]._handle;
-    pti_metrics_group_handle_t metrics_group_handle =
-        FindSuitableMetricGroup(g_device_metric_groups[0]);
-
-    if (metrics_group_handle == nullptr) {
-      std::cerr << "ERROR: No suitable metric group found" << std::endl;
-      return EXIT_FAILURE;
-    }
-
-    std::cout << "Running tests..." << std::endl;
-
-    sycl::queue& primary_queue = queues[0];
-
-    // 1. Single thread baseline (no profiling)
-    std::cout << "=== Running Single thread baseline (no profiling) ===" << std::endl;
-    auto single_baseline_time = RunBaselineTest(primary_queue, repeat_count, size);
-    double single_baseline_throughput =
-        static_cast<double>(repeat_count) / single_baseline_time.count();
-
-    // 2. Single thread with profiling
-    std::cout << "=== Running Single thread with PTI Metrics profiling ===" << std::endl;
-    auto single_profiling_time = RunSingleThreadedProfilingTest(device_handle, metrics_group_handle,
-                                                                primary_queue, repeat_count, size);
-    double single_profiling_throughput =
-        static_cast<double>(repeat_count) / single_profiling_time.count();
-
-    // Calculate overheads
-    double single_overhead_pct = ((single_profiling_time.count() - single_baseline_time.count()) /
-                                  single_baseline_time.count()) *
-                                 100.0;
-
-    double multi_baseline_throughput = 0.0;
-    double multi_profiling_throughput = 0.0;
-    double multi_overhead_pct = 0.0;
-    std::chrono::duration<double> multi_baseline_time{};
-    std::chrono::duration<double> multi_profiling_time{};
-
-    // Only run multi-threaded tests if we have multiple devices/queues
-    if (queues.size() >= 2 && g_devices.size() >= 2) {
-      // 3. Multi-threaded baseline (no profiling)
-      std::cout << "=== Running Multiple thread baseline (no profiling) ===" << std::endl;
-      multi_baseline_time = RunMultiThreadedTest(queues, repeat_count, size);
-      multi_baseline_throughput = (2.0 * repeat_count) / multi_baseline_time.count();
-
-      // 4. Multi-threaded with profiling
-      std::vector<pti_device_handle_t> device_handles;
-      std::vector<pti_metrics_group_handle_t> group_handles;
-
-      device_handles = {g_devices[0]._handle, g_devices[1]._handle};
-      group_handles = {FindSuitableMetricGroup(g_device_metric_groups[0]),
-                       FindSuitableMetricGroup(g_device_metric_groups[1])};
-
-      std::cout << "=== Running Multiple thread with PTI Metrics profiling ===" << std::endl;
-      multi_profiling_time =
-          RunMultiThreadedProfilingTest(device_handles, group_handles, queues, repeat_count, size);
-      multi_profiling_throughput = (2.0 * repeat_count) / multi_profiling_time.count();
-
-      multi_overhead_pct = ((multi_profiling_time.count() - multi_baseline_time.count()) /
-                            multi_baseline_time.count()) *
-                           100.0;
-
-    } else {
-      std::cout << "Less than 2 devices, skipping multiple device tests..." << std::endl;
-    }
-
-    std::cout << std::endl;
-
-    const auto default_precision = std::cout.precision();
-    std::cout << "=== RESULTS ===" << std::endl;
-    std::cout << std::fixed << std::setprecision(2);
-
-    std::cout << "1 thread baseline (no profiling):  " << single_baseline_throughput
-              << " kernels/sec" << std::endl;
-    std::cout << "1 thread with profiling:           " << single_profiling_throughput
-              << " kernels/sec" << std::endl;
-    if (g_devices.size() >= 2) {
-      std::cout << "2 threads baseline (no profiling): " << multi_baseline_throughput
-                << " kernels/sec" << std::endl;
-      std::cout << "2 threads with profiling:          " << multi_profiling_throughput
-                << " kernels/sec" << std::endl;
-    }
-
-    std::cout << std::endl;
-    std::cout << "=== OVERHEAD ===" << std::endl;
-    std::cout << "Single-threaded profiling overhead: " << single_overhead_pct << "%" << std::endl;
-    if (g_devices.size() >= 2) {
-      std::cout << "Multi-threaded profiling overhead:  " << multi_overhead_pct << "%" << std::endl;
-    }
-    std::cout << std::setprecision(default_precision) << std::defaultfloat;
-
-  } catch (const std::exception& e) {
-    std::cerr << "ERROR: " << e.what() << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  return exit_code;
-}
diff --git a/sdk/samples/metrics_scope/CMakeLists.txt b/sdk/samples/metrics_scope/CMakeLists.txt
deleted file mode 100644
index ba46f103..00000000
--- a/sdk/samples/metrics_scope/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_METRICS_SCOPE CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-# TODO: find_package(IntelSYCL)?
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if (NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(metrics_scope main_metrics_scope.cc client.cc)
-
-target_link_options(metrics_scope PUBLIC -fsycl)
-target_compile_options(metrics_scope PUBLIC -fsycl)
-
-target_include_directories(metrics_scope PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(metrics_scope PUBLIC Pti::pti_view LevelZero::level-zero)
diff --git a/sdk/samples/metrics_scope/client.cc b/sdk/samples/metrics_scope/client.cc
deleted file mode 100644
index ee5fcffd..00000000
--- a/sdk/samples/metrics_scope/client.cc
+++ /dev/null
@@ -1,290 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-/**
- * @file client.cc
- * @brief PTI Scope Metrics collection tool implementation
- *
- * This file demonstrates how to use the PTI Scope Metrics library to collect
- * GPU performance metrics during kernel execution.
- */
-
-#include "client.h"
-
-#include <array>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_metrics_scope.h"
-#include "samples_utils.h"
-
-/**
- * Terminologies:
- *  - Collection buffer(s) - buffer(s) contains raw collection data, owned by the PTI Metrics Scope
- * Interface; buffer size is setup by the user.
- *  - Metrics buffer(s)    - buffer(s) contains a set of uniform records
- * (pti_metrics_scope_record_t), owned by the user; those records are populated by the PTI Metrics
- * Scope Interface
- */
-namespace {
-// Tool resources
-pti_scope_collection_handle_t scope_handle = nullptr;
-
-void PrintMetadata(const pti_metrics_scope_record_metadata_t& metadata) {
-  std::cout << "Metrics Metadata set to " << metadata._struct_size << " bytes\n\n";
-  std::cout << "Metadata for all records:\n";
-  std::cout << "  Metrics count per record: " << metadata._metrics_count << "\n";
-  for (uint32_t i = 0; i < metadata._metrics_count; ++i) {
-    const char* units = metadata._metric_units[i] ? metadata._metric_units[i] : "";
-    std::cout << "  [" << i << "] " << metadata._metric_names[i] << " (" << units << ")\n";
-  }
-}
-
-void PrintMetricValue(const pti_metrics_scope_record_t& record, uint32_t metric_index,
-                      const pti_metrics_scope_record_metadata_t& metadata) {
-  std::cout << "      " << metadata._metric_names[metric_index] << ": ";
-  switch (metadata._value_types[metric_index]) {
-    case PTI_METRIC_VALUE_TYPE_UINT32:
-      std::cout << record._metrics_values[metric_index].ui32;
-      break;
-    case PTI_METRIC_VALUE_TYPE_UINT64:
-      std::cout << record._metrics_values[metric_index].ui64;
-      break;
-    case PTI_METRIC_VALUE_TYPE_FLOAT32:
-      std::cout << record._metrics_values[metric_index].fp32;
-      break;
-    case PTI_METRIC_VALUE_TYPE_FLOAT64:
-      std::cout << record._metrics_values[metric_index].fp64;
-      break;
-    case PTI_METRIC_VALUE_TYPE_BOOL8:
-      std::cout << (record._metrics_values[metric_index].b8 ? "true" : "false");
-      break;
-    default:
-      std::cout << " ";
-  }
-  if (metadata._metric_units[metric_index] && strlen(metadata._metric_units[metric_index]) > 0) {
-    std::cout << " " << metadata._metric_units[metric_index];
-  }
-  std::cout << "\n";
-}
-
-void PrintRecord(size_t record_index, const pti_metrics_scope_record_t& record,
-                 const pti_metrics_scope_record_metadata_t& metadata) {
-  std::cout << "\n  Kernel " << record_index << ":\n";
-  std::cout << "      ID: " << record._kernel_id << "\n";
-  if (record._kernel_name) {
-    std::cout << "      Kernel Name: " << record._kernel_name << "\n";
-  }
-  for (uint32_t m = 0; m < metadata._metrics_count; ++m) {
-    PrintMetricValue(record, m, metadata);
-  }
-}
-
-void ProcessCollectionBuffer(size_t buffer_index,
-                             const pti_metrics_scope_record_metadata_t& metadata) {
-  std::cout << "\n" << std::string(80, '-') << "\n";
-  std::cout << "                    Processing Collection Buffer " << buffer_index << "\n";
-  std::cout << std::string(80, '-') << "\n";
-
-  void* collection_buffer = nullptr;
-  size_t actual_collection_buffer_size = 0;
-  PTI_CHECK_SUCCESS(ptiMetricsScopeGetCollectionBuffer(
-      scope_handle, buffer_index, &collection_buffer, &actual_collection_buffer_size));
-
-  pti_metrics_scope_collection_buffer_properties_t props;
-  props._struct_size = sizeof(pti_metrics_scope_collection_buffer_properties_t);
-  pti_result result =
-      ptiMetricsScopeGetCollectionBufferProperties(scope_handle, collection_buffer, &props);
-  if (result != PTI_SUCCESS) {
-    std::cerr << "Failed to get buffer properties for buffer " << buffer_index
-              << ", error: " << result << "\n";
-    return;
-  }
-
-  std::cout << "Collection Buffer " << buffer_index << " properties:\n";
-  std::cout << "  Device: " << reinterpret_cast<void*>(props._device_handle) << "\n";
-  std::cout << "  Records/Scopes: " << props._num_scopes << "\n";
-  std::cout << std::dec << "  Used Collection Buffer Size: " << actual_collection_buffer_size
-            << " bytes\n";
-  std::cout << "  Collected Group Name: " << props._metric_group_name << "\n\n\n";
-
-  size_t required_metrics_buffer_size = 0;
-  size_t records_count = 0;
-  result = ptiMetricsScopeQueryMetricsBufferSize(scope_handle, collection_buffer,
-                                                 &required_metrics_buffer_size, &records_count);
-  if (result != PTI_SUCCESS) {
-    std::cerr << "Failed to query buffer size for buffer " << buffer_index << ", error: " << result
-              << "\n";
-    return;
-  }
-
-  std::cout << "Required metrics buffer size: " << required_metrics_buffer_size << " bytes\n";
-  std::cout << "Records count: " << records_count << "\n";
-
-  if (records_count == 0) {
-    return;
-  }
-
-  std::vector<uint8_t> metrics_buffer;
-  try {
-    metrics_buffer.resize(required_metrics_buffer_size);
-  } catch (const std::exception&) {
-    std::cerr << "Failed to allocate metrics buffer\n";
-    return;
-  }
-
-  std::cout << "Successfully allocated metrics buffer size: " << required_metrics_buffer_size
-            << " bytes\n\n";
-
-  size_t actual_records_count = 0;
-  result = ptiMetricsScopeCalculateMetrics(scope_handle, collection_buffer, metrics_buffer.data(),
-                                           required_metrics_buffer_size, &actual_records_count);
-  if (result != PTI_SUCCESS) {
-    std::cout << "\n  Failed to calculate metrics for buffer " << buffer_index
-              << ", error: " << result << "\n";
-    return;
-  }
-
-  std::cout << "Calculated records: " << actual_records_count << "\n";
-  std::cout << "\n";
-  std::cout << "       FORMATTED METRICS DISPLAY\n";
-
-  auto records = reinterpret_cast<pti_metrics_scope_record_t*>(metrics_buffer.data());
-  for (size_t r = 0; r < actual_records_count; ++r) {
-    PrintRecord(r, records[r], metadata);
-  }
-}
-
-void DisableViews() {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-}
-
-}  // namespace
-
-void StartProfiling(const std::vector<pti_device_handle_t>& device_handles) {
-  // For now, need ptiView to enable ptiCallback
-  auto dummy_provide = [](unsigned char** buf, std::size_t* buf_size) {
-    *buf_size = sizeof(pti_view_record_kernel) * 100;
-    void* ptr = ::operator new(*buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-  };
-  auto dummy_parse = [](unsigned char* buf, std::size_t, std::size_t) {
-    if (buf) {
-      ::operator delete(buf);
-    }
-  };
-
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(dummy_provide, dummy_parse));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-
-  // Step 1: Enable scope metrics collection
-  PTI_CHECK_SUCCESS(ptiMetricsScopeEnable(&scope_handle));
-
-  std::cout << "Scope metrics collection enabled \n\n";
-
-  pti_metrics_scope_mode_t collection_mode = PTI_METRICS_SCOPE_AUTO_KERNEL;
-
-  // Build metric names to collect (all must belong to a single metric group on each device).
-  // In auto-detect mode all devices must share the same model (uniformity check) so the same
-  // metric group resolves on every device.
-  auto metric_names = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};  // metrics in ComputeBasic group
-
-  // Step 2: Configure metrics.
-  // Two modes are supported:
-  //  - Auto-detect: pass devices=nullptr, count=0 to profile every available GPU.
-  //    All devices must be the same model; otherwise
-  //    PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM is returned.
-  //  - Explicit:    pass a non-null array of one or more device handles to profile that subset.
-  if (device_handles.empty()) {
-    PTI_CHECK_SUCCESS(ptiMetricsScopeConfigure(scope_handle, collection_mode, nullptr, 0,
-                                               metric_names.data(),
-                                               static_cast<uint32_t>(metric_names.size())));
-    std::cout << "Scope metrics collection configured (auto-detect: all available devices)\n\n";
-  } else {
-    auto mutable_handles = device_handles;
-    PTI_CHECK_SUCCESS(
-        ptiMetricsScopeConfigure(scope_handle, collection_mode, mutable_handles.data(),
-                                 static_cast<uint32_t>(mutable_handles.size()), metric_names.data(),
-                                 static_cast<uint32_t>(metric_names.size())));
-    std::cout << "Scope metrics collection configured (explicit: " << mutable_handles.size()
-              << " device(s))\n\n";
-  }
-
-  // Step 3: Query estimated raw collection buffer size for expected number of kernels per device.
-  // The capacity set in step 4 is the per-collection-buffer size; the library will rotate
-  // through additional buffers per (device, thread) as needed during collection.
-  size_t expected_kernels = 5;
-  size_t estimated_collection_buffer_size = 0;
-  PTI_CHECK_SUCCESS(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, expected_kernels,
-                                                             &estimated_collection_buffer_size));
-
-  std::cout << std::dec << "Estimated raw collection buffer size for " << expected_kernels
-            << " kernels: " << estimated_collection_buffer_size << " bytes\n";
-
-  // Step 4: Set collection buffer size (capacity)
-  PTI_CHECK_SUCCESS(
-      ptiMetricsScopeSetCollectionBufferSize(scope_handle, estimated_collection_buffer_size));
-
-  std::cout << "Collection buffer capacity set to " << estimated_collection_buffer_size
-            << " bytes\n\n";
-
-  // Step 5: Start metrics collection
-  PTI_CHECK_SUCCESS(ptiMetricsScopeStartCollection(scope_handle));
-
-  std::cout << "Scope metrics collection started\n\n";
-  return;
-}
-
-void StopProfiling() {
-  // Step 1: Stop metrics collection
-  PTI_CHECK_SUCCESS(ptiMetricsScopeStopCollection(scope_handle));
-  std::cout << "Scope metrics collection stopped\n";
-
-  // Step 2: Get metadata once per scope (reusable for all buffers/records)
-  pti_metrics_scope_record_metadata_t metadata;
-  metadata._struct_size = sizeof(pti_metrics_scope_record_metadata_t);
-  PTI_CHECK_SUCCESS(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata));
-  PrintMetadata(metadata);
-
-  // Step 3: Iterate collection buffers
-  size_t collection_buffer_count = 0;
-  PTI_CHECK_SUCCESS(
-      ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &collection_buffer_count));
-  std::cout << "\nNumber of collection buffers used: " << collection_buffer_count << "\n";
-
-  if (collection_buffer_count == 0) {
-    std::cout << "No data collected - this might indicate:\n";
-    std::cout << "  1. Callbacks were not triggered\n";
-    std::cout << "  2. No GPU kernels were detected\n";
-    std::cout << "  3. Query data collection failed\n";
-  } else {
-    for (size_t i = 0; i < collection_buffer_count; ++i) {
-      ProcessCollectionBuffer(i, metadata);
-    }
-  }
-
-  // Step 4: Disable scope collection and views
-  PTI_CHECK_SUCCESS(ptiMetricsScopeDisable(scope_handle));
-  std::cout << "\n\nScope metrics collection disabled\n";
-
-  DisableViews();
-
-  std::cout << "Example completed successfully\n";
-}
diff --git a/sdk/samples/metrics_scope/client.h b/sdk/samples/metrics_scope/client.h
deleted file mode 100644
index 927da456..00000000
--- a/sdk/samples/metrics_scope/client.h
+++ /dev/null
@@ -1,20 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef CLIENT_H_
-#define CLIENT_H_
-
-#include <vector>
-
-#include "pti/pti.h"
-
-// Start metrics scope collection.
-// Empty `device_handles` enables auto-detect mode (all uniform GPUs are profiled).
-// Non-empty `device_handles` profiles only the listed devices in explicit mode.
-void StartProfiling(const std::vector<pti_device_handle_t>& device_handles = {});
-
-void StopProfiling();
-
-#endif  // CLIENT_H_
diff --git a/sdk/samples/metrics_scope/main_metrics_scope.cc b/sdk/samples/metrics_scope/main_metrics_scope.cc
deleted file mode 100644
index 58e38b84..00000000
--- a/sdk/samples/metrics_scope/main_metrics_scope.cc
+++ /dev/null
@@ -1,381 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-/**
- * @file main_metrics_scope.cc
- * @brief Example usage of PTI Metrics Scopes library
- *
- * Demonstrates two modes of metrics scope collection:
- *   - Auto-detect (default, or `--devices=auto`): a profiler is lazily created
- *     for each level_zero GPU the workload actually uses.
- *   - Explicit (`--devices=0,2,3`): only the listed device indices are profiled.
- *
- * By default the GEMM workload runs on the same devices being profiled.
- * `--workload`/`-w` decouples the two so the workload can target a different
- * GPU subset (e.g. profile auto, run only on GPU 1) -- used by the
- * multi-process test driver to exercise auto-detect lazy construction.
- *
- * Wall-clock markers and a GPU count line are emitted on stdout (prefixed
- * with [PTI_MP]) so external test drivers can verify collection windows
- * overlap across processes.
- */
-
-#include <algorithm>
-#include <cassert>
-#include <chrono>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <set>
-#include <stdexcept>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "client.h"
-
-#define NSEC_IN_SEC 1'000'000'000
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static uint64_t WallClockNs() {
-  using namespace std::chrono;
-  return duration_cast<nanoseconds>(system_clock::now().time_since_epoch()).count();
-}
-
-static float Check(const std::vector<float> &a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-// GEMM kernel function
-void GEMM(const float *a, const float *b, float *c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue &queue, const std::vector<float> &a,
-                         const std::vector<float> &b, std::vector<float> &c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    [[maybe_unused]] sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  std::cout << "Matrix multiplication done. Checking result.." << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue &queue, const std::vector<float> &a, const std::vector<float> &b,
-                    std::vector<float> &c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-}
-
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-void Usage(const char *name) {
-  std::cout << " Calculating floating point matrix multiply on selected GPU(s).\n"
-            << "  Usage " << name << "  [ options ]\n";
-  std::cout
-      << "--devices  [-d]  string         "
-      << "Comma-separated indices (e.g. 0,2,3) or \"auto\" to profile GPU(s) the workload uses. "
-         "Default: auto\n";
-  std::cout << "--workload [-w]  string         "
-            << "Comma-separated indices or \"auto\". Selects which GPU(s) the GEMM runs on. "
-               "Default: matches --devices\n";
-  std::cout << "--size     [-s]  integer        " << "Matrix size. Default: 1024 (max " << max_size
-            << ")\n";
-  std::cout << "--repeat   [-r]  integer        " << "Repetition count per device. Default: 1\n";
-  std::cout << "--help     [-h]                 Print this help message.\n";
-}
-
-static std::vector<sycl::device> EnumerateLevelZeroGpuDevices() {
-  std::vector<sycl::device> all_devices;
-  for (auto &platform : sycl::platform::get_platforms()) {
-    if (platform.get_backend() != sycl::backend::ext_oneapi_level_zero) {
-      continue;
-    }
-    for (auto &dev : platform.get_devices(sycl::info::device_type::gpu)) {
-      all_devices.push_back(dev);
-    }
-  }
-  return all_devices;
-}
-
-// Map a sycl::device on the level_zero backend to its native L0 handle, which
-// equals the pti_device_handle_t the metrics scope API expects.
-static pti_device_handle_t GetPtiHandleFromSyclDevice(const sycl::device &dev) {
-  try {
-    auto *native = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(dev);
-    return static_cast<pti_device_handle_t>(native);
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Failed to get native handle for device: " << e.what() << '\n';
-  } catch (...) {
-    std::cerr << "Error: Failed to get native handle for device" << '\n';
-  }
-  return nullptr;
-}
-
-namespace {
-
-// Result of parsing a comma-separated index list. Success when `error` is empty.
-struct ParsedDeviceIndices {
-  std::vector<unsigned> indices;
-  std::string error;
-};
-
-// Parse a comma-separated list of indices into a sorted, deduped vector.
-static ParsedDeviceIndices ParseDeviceIndices(const std::string &csv, size_t num_available) {
-  ParsedDeviceIndices result;
-  std::set<unsigned> unique_indices;
-  size_t pos = 0;
-  while (pos <= csv.size()) {
-    size_t comma = csv.find(',', pos);
-    std::string token =
-        csv.substr(pos, (comma == std::string::npos) ? std::string::npos : comma - pos);
-    if (token.empty()) {
-      result.error = "empty device index in --devices=" + csv;
-      return result;
-    }
-    try {
-      size_t consumed = 0;
-      auto parsed = std::stoul(token, &consumed);
-      if (consumed != token.size()) {
-        result.error = "non-numeric device index '" + token + "' in --devices=" + csv;
-        return result;
-      }
-      if (parsed >= num_available) {
-        if (num_available == 0) {
-          result.error = "no devices available, but --devices=" + csv;
-        } else {
-          result.error = "device index " + token + " out of range (have " +
-                         std::to_string(num_available) + " device(s), valid: 0.." +
-                         std::to_string(num_available - 1) + ")";
-        }
-        return result;
-      }
-      unique_indices.insert(static_cast<unsigned>(parsed));
-    } catch (const std::exception &) {
-      result.error = "could not parse device index '" + token + "' in --devices=" + csv;
-      return result;
-    }
-    if (comma == std::string::npos) {
-      break;
-    }
-    pos = comma + 1;
-  }
-  result.indices.assign(unique_indices.begin(), unique_indices.end());
-  return result;
-}
-
-}  // namespace
-
-int main(int argc, char *argv[]) {
-  std::cout << "PTI Metrics Scope Example\n";
-
-  unsigned size = 1024;
-  unsigned repeat_count = 1;
-  std::string devices_arg = "auto";
-  std::string workload_arg;  // empty = inherit from devices_arg
-
-  try {
-    for (int i = 1; i < argc; i++) {
-      if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
-        Usage(argv[0]);
-        return EXIT_SUCCESS;
-      } else if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--size") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-      } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--repeat") == 0) {
-        i++;
-        repeat_count = std::stoul(argv[i]);
-      } else if (strcmp(argv[i], "-d") == 0 || strcmp(argv[i], "--devices") == 0) {
-        i++;
-        devices_arg = argv[i];
-      } else if (strcmp(argv[i], "-w") == 0 || strcmp(argv[i], "--workload") == 0) {
-        i++;
-        workload_arg = argv[i];
-      } else {
-        std::cerr << "Error: Unknown option: " << argv[i] << '\n';
-        Usage(argv[0]);
-        return EXIT_FAILURE;
-      }
-    }
-  } catch (...) {
-    std::cerr << "Error: Failed to parse command line arguments\n";
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  if (workload_arg.empty()) {
-    workload_arg = devices_arg;
-  }
-
-  // Enumerate available L0 GPUs first so we can validate --devices indices.
-  std::vector<sycl::device> all_sycl_devices = EnumerateLevelZeroGpuDevices();
-  if (all_sycl_devices.empty()) {
-    std::cerr << "Error: No level_zero GPU devices found.\n";
-    return EXIT_FAILURE;
-  }
-
-  // Resolve --devices into pti_handles passed to StartProfiling.
-  std::vector<pti_device_handle_t> pti_handles;
-  const bool profile_auto = (devices_arg == "auto");
-  if (!profile_auto) {
-    ParsedDeviceIndices parsed = ParseDeviceIndices(devices_arg, all_sycl_devices.size());
-    if (!parsed.error.empty()) {
-      std::cerr << "Error: " << parsed.error << '\n';
-      Usage(argv[0]);
-      return EXIT_FAILURE;
-    }
-    pti_handles.reserve(parsed.indices.size());
-    for (unsigned idx : parsed.indices) {
-      auto *pti_handle = GetPtiHandleFromSyclDevice(all_sycl_devices[idx]);
-      if (pti_handle) {
-        pti_handles.push_back(pti_handle);
-      }
-    }
-    if (pti_handles.empty()) {
-      std::cerr << "Error: No valid device handles found for --devices=" << devices_arg << '\n';
-      return EXIT_FAILURE;
-    }
-  }
-
-  // Resolve --workload into the SYCL device set the GEMM loop runs on.
-  std::vector<sycl::device> workload_sycl_devices;
-  const bool workload_auto = (workload_arg == "auto");
-  if (workload_auto) {
-    workload_sycl_devices = all_sycl_devices;
-  } else {
-    ParsedDeviceIndices parsed = ParseDeviceIndices(workload_arg, all_sycl_devices.size());
-    if (!parsed.error.empty()) {
-      std::cerr << "Error: " << parsed.error << '\n';
-      Usage(argv[0]);
-      return EXIT_FAILURE;
-    }
-    workload_sycl_devices.reserve(parsed.indices.size());
-    for (unsigned idx : parsed.indices) {
-      workload_sycl_devices.push_back(all_sycl_devices[idx]);
-    }
-  }
-
-  std::cout << "[PTI_MP] gpu_count=" << all_sycl_devices.size() << '\n';
-  for (size_t i = 0; i < workload_sycl_devices.size(); ++i) {
-    std::cout << "[PTI_MP] workload_device_handle[" << i
-              << "]=" << GetPtiHandleFromSyclDevice(workload_sycl_devices[i]) << '\n';
-  }
-  std::cout << "Discovered " << all_sycl_devices.size() << " GPU device(s):\n";
-  for (size_t i = 0; i < all_sycl_devices.size(); ++i) {
-    std::cout << "  [" << i << "] " << all_sycl_devices[i].get_info<sycl::info::device::name>()
-              << "\n";
-  }
-  std::cout << (profile_auto ? "Auto-detect mode: profiling all available devices.\n"
-                             : "Explicit mode: profiling " + std::to_string(pti_handles.size()) +
-                                   " selected device(s).\n");
-  std::cout << (workload_auto ? "Workload: GEMM on every available GPU.\n"
-                              : "Workload: GEMM on " +
-                                    std::to_string(workload_sycl_devices.size()) + " device(s).\n");
-
-  int exit_code = EXIT_SUCCESS;
-  StartProfiling(pti_handles);
-
-  uint64_t collection_start_wall_ns = WallClockNs();
-  std::cout << "[PTI_MP] collection_window_start_ns=" << collection_start_wall_ns << '\n';
-  std::cout.flush();
-
-  std::cout << "Running GEMM workload on selected GPU(s)...\n";
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size << " x " << size << ", repeats "
-            << repeat_count << " times per device)\n";
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  sycl::property_list prop_list{sycl::property::queue::in_order()};
-
-  try {
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    for (size_t i = 0; i < workload_sycl_devices.size(); ++i) {
-      std::cout << "\n--- Running GEMM on device [" << i
-                << "]: " << workload_sycl_devices[i].get_info<sycl::info::device::name>()
-                << " ---\n";
-      sycl::queue queue(workload_sycl_devices[i], sycl::async_handler{}, prop_list);
-      std::fill(c.begin(), c.end(), 0.0f);
-      Compute(queue, a, b, c, size, repeat_count, expected_result);
-    }
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    std::cout << "Total execution time across all devices: " << time.count() << " sec" << std::endl;
-
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-
-  std::cout << "GPU workload completed\n";
-
-  uint64_t collection_stop_wall_ns = WallClockNs();
-  std::cout << "[PTI_MP] collection_window_stop_ns=" << collection_stop_wall_ns << '\n';
-  std::cout.flush();
-
-  StopProfiling();
-
-  return exit_code;
-}
diff --git a/sdk/samples/omp_vec_add/CMakeLists.txt b/sdk/samples/omp_vec_add/CMakeLists.txt
deleted file mode 100644
index 92024563..00000000
--- a/sdk/samples/omp_vec_add/CMakeLists.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_OMP_VEC_ADD C)
-
-# compiler needs to be checked, if not icx then return early with warning message
-if (NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
-  message(WARNING "${PROJECT_NAME} requires a Intel OMP enabled compiler")
-  return()
-endif()
-
-if (NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-
-add_executable(omp_vec_add main.c)
-
-target_include_directories(omp_vec_add PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-set(OPENMP_FLAGS
-  $<$<PLATFORM_ID:Linux>:-fiopenmp -fopenmp-targets=spir64>
-  $<$<PLATFORM_ID:Windows>:-Qiopenmp -Qopenmp-targets=spir64>
-)
-
-# spir64 does not support PTI's __declspec(dllimport)
-# This might be a compiler issue.
-target_compile_options(omp_vec_add PUBLIC ${OPENMP_FLAGS}
-  $<$<PLATFORM_ID:Windows>:-Wno-ignored-attributes>)
-
-target_link_options(omp_vec_add PUBLIC ${OPENMP_FLAGS})
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(omp_vec_add PUBLIC Pti::pti_view)
diff --git a/sdk/samples/omp_vec_add/main.c b/sdk/samples/omp_vec_add/main.c
deleted file mode 100644
index dd9ca591..00000000
--- a/sdk/samples/omp_vec_add/main.c
+++ /dev/null
@@ -1,226 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <string.h>
-
-#include "pti/pti_view.h"
-#include "samples_c_utils.h"
-
-const unsigned long long kRequestedRecordCount = 64ULL;
-const unsigned long long kRequestedBufferSize =
-    kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-void StartTracing(void) {
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DRIVER_API));
-  PTI_CHECK_SUCCESS(
-      ptiViewEnableDriverApiClass(1, PTI_API_CLASS_GPU_OPERATION_CORE, PTI_API_GROUP_LEVELZERO));
-}
-
-void StopTracing(void) {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DRIVER_API));
-}
-
-void ProvideBuffer(unsigned char** buf, size_t* buf_size) {
-  *buf = (unsigned char*)malloc(kRequestedBufferSize);
-  if (!*buf) {
-    fprintf(stderr, "Unable to allocate buffer for PTI tracing\n");
-    exit(EXIT_FAILURE);
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-void ParseBuffer(unsigned char* buf, size_t buf_size, size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    fprintf(stderr, "Received empty buffer\n");
-    if (valid_buf_size) {
-      free(buf);
-    }
-    return;
-  }
-  pti_view_record_base* ptr = NULL;
-  while (true) {
-    pti_result buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == PTI_STATUS_END_OF_BUFFER) {
-      printf("Reached End of buffer\n");
-      break;
-    }
-    if (buf_status != PTI_SUCCESS) {
-      fprintf(stderr, "Found Error Parsing Records from PTI\n");
-      break;
-    }
-    if (ptr->_view_kind == PTI_VIEW_INVALID) {
-      printf("Found Invalid Record\n");
-      continue;
-    }
-    switch (ptr->_view_kind) {
-      case PTI_VIEW_DRIVER_API: {
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        printf("Found Driver Api Record\n");
-        DumpRecordApi((pti_view_record_api*)ptr);
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        break;
-      }
-      case PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        printf("Found Memory Record\n");
-        DumpRecordMemoryCopy((pti_view_record_memory_copy*)ptr);
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        break;
-      }
-      case PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        printf("Found Memory Record\n");
-        DumpRecordMemoryFill((pti_view_record_memory_fill*)ptr);
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        break;
-      }
-      case PTI_VIEW_DEVICE_GPU_KERNEL: {
-        bool with_sycl_info = false;
-        pti_view_record_kernel* rec = (pti_view_record_kernel*)ptr;
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        printf("Found Kernel Record\n");
-        DumpRecordKernel(rec, with_sycl_info);
-        printf(
-            "--------------------------------------------------------------------------------\n");
-        uint64_t exec_time[] = {rec->_append_timestamp, rec->_submit_timestamp,
-                                rec->_start_timestamp, rec->_end_timestamp};
-        if (IsMonotonicUint64(exec_time, 4)) {
-          printf("------------>     All Monotonic\n");
-        } else {
-          printf("------------>     Something wrong: NOT All monotonic\n");
-        }
-        break;
-      }
-      default: {
-        fprintf(stderr, "This shouldn't happen\n");
-        break;
-      }
-    }
-  }
-  free(buf);
-}
-
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-void Usage(const char* name) {
-  printf(" Calculating floating point matrix multiply on gpu\n");
-  printf(
-      "%s [ [gpu|cpu|host, default=gpu],  [matrix size, default=1024, max=%u], [repetition count, "
-      "default=4]] \n",
-      name, max_size);
-}
-
-void Compute(unsigned int size) {
-  const unsigned int N = (size > 0) ? size : 2048;
-
-  // Allocate arrays using standard C malloc
-  int* a = (int*)malloc(N * sizeof(int));
-  int* b = (int*)malloc(N * sizeof(int));
-  int* c = (int*)malloc(N * sizeof(int));
-
-  if (!a || !b || !c) {
-    fprintf(stderr, "Memory allocation failed\n");
-    free(a);
-    free(b);
-    free(c);
-    exit(EXIT_FAILURE);
-  }
-
-  // Initialize arrays
-  for (unsigned int i = 0; i < N; ++i) {
-    a[i] = i;
-    b[i] = i * 2;
-  }
-
-  // Initialize result array to zero
-  memset(c, 0, N * sizeof(int));
-
-  // Use direct pointers for OpenMP target mapping
-  int* A = a;
-  int* B = b;
-  int* C = c;
-
-// GPU code using OpenMP target directives
-#pragma omp target map(to : A[0 : N], B[0 : N]) map(from : C[0 : N])
-#pragma omp parallel for
-  for (unsigned int i = 0; i < N; ++i) {
-    C[i] = A[i] + B[i];
-  }
-
-  // Verify results
-  for (unsigned int i = 0; i < N; ++i) {
-    if (((unsigned int)C[i]) != (3 * i)) {
-      fprintf(stderr, "Data mismatch found. Expected %d but actual %d\n", 3 * i, C[i]);
-      free(a);
-      free(b);
-      free(c);
-      exit(EXIT_FAILURE);
-    }
-  }
-
-  // Clean up memory
-  free(a);
-  free(b);
-  free(c);
-}
-
-int main(int argc, char* argv[]) {
-  // Prolog - PTI SDK setup
-  // 1. Set callbacks for buffer management
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-  // 2. Start Tracing
-  StartTracing();
-
-  // Default values
-  unsigned int repeat_count = 1;
-  unsigned int size = 2048;
-
-  unsigned long temp = size;
-  if (argc > 1) {
-    char* endptr;
-    temp = strtoul(argv[1], &endptr, 10);
-    if (*endptr != '\0' || endptr == argv[1]) {
-      fprintf(stderr, "Invalid number format for size: %s\n", argv[1]);
-      temp = size;  // Use default value on error
-    }
-    size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-  }
-  if (argc > 2) {
-    char* endptr;
-    temp = strtoul(argv[2], &endptr, 10);
-    if (*endptr != '\0' || endptr == argv[2]) {
-      fprintf(stderr, "Invalid number format for repeat count: %s\n", argv[2]);
-      temp = 1;  // Use default value on error
-    }
-    repeat_count = (temp < 1) ? 1 : temp;
-  }
-
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    // let's use omp method to compute
-    Compute(size);
-  }
-
-  // Epilog - PTI SDK teardown
-  StopTracing();
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-
-  printf("Profiling is stopped\n");
-  printf("Application is completed successfully\n");
-  return 0;
-}
diff --git a/sdk/samples/onemkl_gemm/CMakeLists.txt b/sdk/samples/onemkl_gemm/CMakeLists.txt
deleted file mode 100644
index fbe3ef56..00000000
--- a/sdk/samples/onemkl_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_ONEMKL_GEMM CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-if (NOT TARGET MKL::MKL)
-  find_package(MKL CONFIG PATHS $ENV{MKLROOT} NO_DEFAULT_PATH)
-  message(STATUS "Imported oneMKL targets: ${MKL_IMPORTED_TARGETS}")
-endif()
-
-if (NOT TARGET MKL::MKL)
-  message(WARNING "${PROJECT_NAME} requires oneMKL installed")
-  return()
-endif()
-
-add_executable(onemkl_gemm_exe onemkl_gemm.cc)
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(onemkl_gemm_exe PUBLIC MKL::MKL MKL::MKL_SYCL Pti::pti_view)
-target_include_directories(onemkl_gemm_exe
-                           PRIVATE "${PROJECT_SOURCE_DIR}/../../src/utils"
-                           "${PROJECT_SOURCE_DIR}/../samples_utilities")
diff --git a/sdk/samples/onemkl_gemm/onemkl_gemm.cc b/sdk/samples/onemkl_gemm/onemkl_gemm.cc
deleted file mode 100644
index 05de4be9..00000000
--- a/sdk/samples/onemkl_gemm/onemkl_gemm.cc
+++ /dev/null
@@ -1,301 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <exception>
-#include <iostream>
-#include <oneapi/mkl.hpp>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "samples_utils.h"
-
-void StartTracing() {
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-}
-
-void StopTracing() {
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-}
-
-template <typename T>
-void MklGemm(void) {
-  // Create a sycl device of type GPU
-  sycl::device my_device;
-  try {
-    my_device = sycl::device(sycl::gpu_selector_v);
-  } catch (...) {
-    std::cerr << "Warning: GPU not found !" << std::endl;
-    throw;
-  }
-
-  if constexpr (!std::is_same_v<T, std::complex<float>> && sizeof(T) > sizeof(float)) {
-    if (!my_device.has(sycl::aspect::fp64)) {
-      std::cerr << "Warning: GPU device does not support fp64. Skipping operation" << std::endl;
-      return;
-    }
-  }
-
-  // Create asynchronous exceptions handler to be attached to queue.
-  // Not required; can provide helpful information in case the system isn’t correctly configured.
-  auto my_exception_handler = [](sycl::exception_list exceptions) {
-    for (std::exception_ptr const &e : exceptions) {
-      try {
-        std::rethrow_exception(e);
-      } catch (sycl::exception const &e) {
-        std::cerr << "Caught asynchronous SYCL exception:\n" << e.what() << std::endl;
-      } catch (std::exception const &e) {
-        std::cerr << "Caught asynchronous STL exception:\n" << e.what() << std::endl;
-      }
-    }
-  };
-
-  // Create sycl queue
-#if __INTEL_LLVM_COMPILER >= 20240000
-  sycl::property_list prop{sycl::property::queue::in_order()};
-#else
-  sycl::property_list prop{};
-#endif
-  sycl::queue main_queue(my_device, my_exception_handler, prop);
-  // Create sycl context
-  auto main_context = main_queue.get_context();
-  int m = 16;
-  int n = 16;
-  int k = 16;
-
-  int lda = 16;
-  int ldb = 16;
-  int ldc = 16;
-  int sizea, sizeb, sizec = ldc * n;
-
-  T alpha = 1.0f;
-  T beta = 2.0f;
-
-  constexpr auto trans_a = oneapi::mkl::transpose::trans;
-  constexpr auto trans_b = oneapi::mkl::transpose::nontrans;
-
-  sizea = lda * m;  // sizea = (trans_a == oneapi::mkl::transpose::nontrans) ? lda * k : lda * m;
-  sizeb = ldb * n;  // sizeb = (trans_b == oneapi::mkl::transpose::nontrans) ? ldb * n : ldb * k;
-
-  // Allocate host memory
-  std::vector<T> hostA(sizea);
-  std::vector<T> hostB(sizeb);
-  std::vector<T> hostC(sizec);
-
-  // Allocate device memory
-  auto devA = static_cast<T *>(malloc_device(sizea * sizeof(T), main_queue));
-  auto devB = static_cast<T *>(malloc_device(sizeb * sizeof(T), main_queue));
-  auto devC = static_cast<T *>(malloc_device(sizec * sizeof(T), main_queue));
-  if (!devA || !devB || !devC) {
-    throw std::runtime_error("Failed to allocate USM memory.");
-  }
-
-  main_queue.memset(devA, 0, sizea * sizeof(T)).wait();
-
-  // Initialize host matrices
-  for (int i = 0; i < m * k; i++) {
-    hostA[i] = i;
-  }
-
-  for (int i = 0; i < k * n; i++) {
-    hostB[i] = i;
-  }
-
-  for (int i = 0; i < m * n; i++) {
-    hostC[i] = 0;
-  }
-
-  // Transfer the host data to device
-  main_queue.memcpy(devA, hostA.data(), sizea * sizeof(T));
-  main_queue.wait();
-  main_queue.memcpy(devB, hostB.data(), sizeb * sizeof(T));
-  main_queue.wait();
-  main_queue.memcpy(devC, hostC.data(), sizec * sizeof(T));
-  main_queue.wait();
-
-  sycl::event gemm_done;
-
-  // Execute oneMKL GEMM
-  try {
-    gemm_done = oneapi::mkl::blas::gemm(main_queue, trans_a, trans_b, m, n, k, alpha, devA, lda,
-                                        devB, ldb, beta, devC, ldc);
-  } catch (sycl::exception const &e) {
-    std::cout << "\t\tCaught synchronous SYCL exception during GEMM:\n" << e.what() << std::endl;
-  }
-  gemm_done.wait();
-
-  // Read the device produced results to host memory
-  main_queue.memcpy(hostC.data(), devC, sizec * sizeof(T));
-  main_queue.wait();
-
-#ifdef VERBOSE
-  for (int i = 0; i < m * n; i++) {
-    std::cout << hostC[i] << " ";
-  }
-  std::cout << "\n";
-#endif
-  free(devA, main_context);
-  free(devB, main_context);
-  free(devC, main_context);
-}
-
-int main() {
-  int exit_code = EXIT_SUCCESS;
-
-  try {
-    // Setup PTI call backs
-    PTI_THROW(ptiViewSetCallbacks(
-        [](auto **buf, auto *buf_size) {
-          *buf_size = sizeof(pti_view_record_kernel) * 100;
-          void *ptr = ::operator new(*buf_size);
-          ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-          *buf = reinterpret_cast<unsigned char *>(ptr);
-          if (!*buf) {
-            std::abort();
-          }
-          return;
-        },
-        [](auto *buf, auto buf_size, auto valid_buf_size) {
-          if (!buf_size || !valid_buf_size || !buf_size) {
-            std::cerr << "Received empty buffer" << '\n';
-            if (valid_buf_size) {
-              ::operator delete(buf);
-            }
-            return;
-          }
-          pti_view_record_base *ptr = nullptr;
-          while (true) {
-            auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-            if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-              std::cout << "Reached End of buffer" << '\n';
-              break;
-            }
-            if (buf_status != pti_result::PTI_SUCCESS) {
-              std::cerr << "Found Error Parsing Records from PTI" << '\n';
-              break;
-            }
-            switch (ptr->_view_kind) {
-              case pti_view_kind::PTI_VIEW_INVALID: {
-                std::cout << "Found Invalid Record" << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                std::cout << "Found Sycl Runtime Record" << '\n';
-                samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                std::cout << "Found Memory Record" << '\n';
-                samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill *>(ptr));
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                std::cout << "Found Memory Record" << '\n';
-                samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy *>(ptr));
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-                pti_view_record_kernel *rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                std::cout << "Found Kernel Record" << '\n';
-                samples_utils::DumpRecord(rec);
-
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                if (samples_utils::IsMonotonic({rec->_sycl_task_begin_timestamp,
-                                                rec->_sycl_enqk_begin_timestamp,
-                                                rec->_append_timestamp, rec->_submit_timestamp,
-                                                rec->_start_timestamp, rec->_end_timestamp})) {
-                  std::cout << "------------>     All Monotonic" << std::endl;
-                } else {
-                  std::cout << "------------>     Something wrong: NOT All monotonic" << std::endl;
-                }
-                if (rec->_sycl_task_begin_timestamp == 0)
-                  std::cout << "------------>     Something wrong: Sycl Task Begin Time is 0"
-                            << std::endl;
-                if (rec->_sycl_enqk_begin_timestamp == 0)
-                  std::cout << "------------>     Something wrong: Sycl Enq Launch Kernel Time is 0"
-                            << std::endl;
-
-                break;
-              }
-              default: {
-                std::cerr << "This shouldn't happen" << '\n';
-                break;
-              }
-            }
-          }
-          ::operator delete(buf);
-        }));
-
-    // Initiate PTI Tracing
-    StartTracing();
-    // Invoke SGEMM
-    MklGemm<float>();
-    // Stop PTI tracing
-    StopTracing();
-
-    // Initiate PTI Tracing
-    StartTracing();
-    // Invoke DGEMM
-    MklGemm<double>();
-    // Stop PTI tracing
-    StopTracing();
-
-    // Initiate PTI Tracing
-    StartTracing();
-    // Invoke CGEMM
-    MklGemm<std::complex<float>>();
-    // Stop PTI tracing
-    StopTracing();
-
-    // Initiate PTI Tracing
-    StartTracing();
-    // Invoke ZGEMM
-    MklGemm<std::complex<double>>();
-
-    StopTracing();
-
-    PTI_THROW(ptiFlushAllViews());
-
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  // Flush all the PTI views
-  return exit_code;
-}
diff --git a/sdk/samples/pc_sampling/CMakeLists.txt b/sdk/samples/pc_sampling/CMakeLists.txt
deleted file mode 100644
index 29beb1de..00000000
--- a/sdk/samples/pc_sampling/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_PC_SAMPLING CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(pc_sampling main.cc pc_sampling_client.cc)
-
-target_link_options(pc_sampling PUBLIC -fsycl)
-target_compile_options(pc_sampling PUBLIC -fsycl)
-target_include_directories(
-  pc_sampling PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities"
-                          "${PROJECT_SOURCE_DIR}/../../src/utils"
-                          )
-
-if (NOT TARGET Threads::Threads)
-  find_package(Threads REQUIRED)
-endif()
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(pc_sampling PUBLIC spdlog::spdlog Pti::pti_view Threads::Threads)
-
-
diff --git a/sdk/samples/pc_sampling/main.cc b/sdk/samples/pc_sampling/main.cc
deleted file mode 100644
index 6901a720..00000000
--- a/sdk/samples/pc_sampling/main.cc
+++ /dev/null
@@ -1,414 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-/**
- * @file main.cc
- * @brief PC Sampling sample demonstrating GPU EU Stall Sampling workflow.
- *
- * This sample demonstrates the complete PC sampling workflow:
- *   1. Initialize environment and enable PTI kernel view
- *   2. Enable PC sampling
- *   3. Configure PC sampling with devices and sampling period (optional)
- *   4. Set and query the collection buffer size (optional)
- *   5. Start PC sampling collection
- *   6. Run compute workloads (two GEMM kernels)
- *   7. Stop PC sampling collection
- *   8. Print collected stall data
- *   9. Disable PC sampling
- *  10. Cleanup environment
- *
- * The PC sampling API calls are separated into pc_sampling_client.h/pc_sampling_client.cc
- * to demonstrate how users can integrate metric collection into their applications.
- */
-
-#include <algorithm>
-#include <charconv>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <sycl/sycl.hpp>
-#include <system_error>
-#include <vector>
-
-#include "pc_sampling_client.h"
-
-//-----------------------------------------------------------------------------
-// Configuration Constants
-//-----------------------------------------------------------------------------
-
-constexpr float kAValue = 0.128f;
-constexpr float kBValue = 0.256f;
-constexpr float kMaxEps = 1.0e-4f;
-constexpr unsigned kDefaultMatrixSize = 1024;
-constexpr unsigned kMaxMatrixSize = 8192;
-constexpr unsigned kMinMatrixSize = 32;
-constexpr unsigned kDefaultRepeatCount = 1;
-constexpr unsigned kMaxRepeatCount = 100;
-constexpr uint32_t kDefaultSamplingPeriodNs = 50'000;  // 50 µs sampling period
-constexpr uint32_t kMinSamplingPeriodNs = 1'000;       // 1 µs minimum
-constexpr uint32_t kMaxSamplingPeriodNs = 10'000'000;  // 10 ms maximum
-
-class PrimaryGEMMKernel;
-class SecondaryGEMMKernel;
-
-//-----------------------------------------------------------------------------
-// GEMM Kernel Implementation
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Matrix multiplication kernel function.
- */
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-/**
- * @brief Verify matrix multiplication results.
- */
-static float CheckResults(const std::vector<float>& c, float expected_value) {
-  float eps = 0.0f;
-  for (size_t i = 0; i < c.size(); ++i) {
-    eps += std::fabs((c[i] - expected_value) / expected_value);
-  }
-  return eps / c.size();
-}
-
-/**
- * @brief Run GEMM kernel and verify results.
- */
-template <typename KernelName>
-static bool RunGEMM(sycl::queue& queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, float expected_result) {
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<KernelName>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_ptr.get(), b_ptr.get(), c_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-
-  } catch (const sycl::exception& e) {
-    std::cerr << "SYCL Exception: " << e.what() << std::endl;
-    return false;
-  }
-
-  float eps = CheckResults(c, expected_result);
-  bool passed = (eps < kMaxEps);
-  std::cout << "GEMM results are " << (passed ? "CORRECT" : "INCORRECT") << " (accuracy: " << eps
-            << ")" << std::endl;
-  return passed;
-}
-
-/**
- * @brief Run GEMM kernel multiple times.
- */
-template <typename KernelName>
-static bool RunGEMMMultiple(sycl::queue& queue, const std::vector<float>& a,
-                            const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                            unsigned repeat_count, float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    std::cout << "  Iteration " << (i + 1) << "/" << repeat_count << ": ";
-    if (!RunGEMM<KernelName>(queue, a, b, c, size, expected_result)) {
-      std::cerr << "GEMM execution failed at iteration " << (i + 1) << std::endl;
-      return false;
-    }
-  }
-
-  return true;
-}
-
-template <typename KernelName>
-static bool RunGEMMWorkload(sycl::queue& queue, unsigned size, unsigned repeat_count,
-                            const char* workload_name) {
-  std::cout << workload_name << " kernel " << repeat_count << " time(s) (matrix size: " << size
-            << "x" << size << ")..." << std::endl;
-
-  std::vector<float> a(size * size, kAValue);
-  std::vector<float> b(size * size, kBValue);
-  std::vector<float> c(size * size, 0.0f);
-  float expected_result = kAValue * kBValue * size;
-
-  return RunGEMMMultiple<KernelName>(queue, a, b, c, size, repeat_count, expected_result);
-}
-
-//-----------------------------------------------------------------------------
-// Command Line Parsing
-//-----------------------------------------------------------------------------
-
-struct SampleConfig {
-  unsigned matrix_size;
-  unsigned repeat_count;
-  uint32_t sampling_period_ns;
-  size_t collection_buffer_size;  // 0 keeps the PTI default
-};
-
-void Usage(const char* name) {
-  std::cout << "Usage: " << name << " [options]" << std::endl;
-  std::cout << "\nOptions:" << std::endl;
-  std::cout << "  --size [-s]     <size>     Matrix size (default: " << kDefaultMatrixSize
-            << ", range: " << kMinMatrixSize << "-" << kMaxMatrixSize << ")" << std::endl;
-  std::cout << "  --repeat [-r]   <count>    Number of times to run each GEMM kernel (default: "
-            << kDefaultRepeatCount << ", max: " << kMaxRepeatCount << ")" << std::endl;
-  std::cout << "  --period [-p]   <ns>       Sampling period in nanoseconds (default: "
-            << kDefaultSamplingPeriodNs << ", range: " << kMinSamplingPeriodNs << "-"
-            << kMaxSamplingPeriodNs << ")" << std::endl;
-  std::cout << "  --buffer [-b]   <bytes>    Collection buffer size in decimal bytes (default: PTI "
-               "default; "
-               "positive multiple of 64, at most 64 MiB)"
-            << std::endl;
-  std::cout << "  --help [-h]                Display this help message" << std::endl;
-  std::cout << "\nExample:" << std::endl;
-  std::cout << "  " << name << " --size 2048 --repeat 5 --period 100000" << std::endl;
-  std::cout << "  " << name << " -s 512 -r 3 -p 25000 -b 65536" << std::endl;
-}
-
-/**
- * @brief Parse command line arguments and populate configuration.
- * @return true on success, false on error or help request
- */
-enum class CommandLineParseResult { kSuccess, kHelp, kError };
-
-CommandLineParseResult ParseCommandLine(int argc, char* argv[], SampleConfig& config) {
-  // Set defaults
-  config.matrix_size = kDefaultMatrixSize;
-  config.repeat_count = kDefaultRepeatCount;
-  config.sampling_period_ns = kDefaultSamplingPeriodNs;
-  config.collection_buffer_size = 0;
-  try {
-    for (int i = 1; i < argc; ++i) {
-      if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
-        Usage(argv[0]);
-        return CommandLineParseResult::kHelp;
-      } else if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--size") == 0) {
-        if (++i >= argc) {
-          std::cerr << "Error: --size requires an argument" << std::endl;
-          Usage(argv[0]);
-          return CommandLineParseResult::kError;
-        }
-        unsigned temp = std::stoul(argv[i]);
-        config.matrix_size = std::clamp(temp, kMinMatrixSize, kMaxMatrixSize);
-        if (temp != config.matrix_size) {
-          std::cout << "Note: Matrix size clamped to valid range [" << kMinMatrixSize << ", "
-                    << kMaxMatrixSize << "]" << std::endl;
-        }
-      } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--repeat") == 0) {
-        if (++i >= argc) {
-          std::cerr << "Error: --repeat requires an argument" << std::endl;
-          Usage(argv[0]);
-          return CommandLineParseResult::kError;
-        }
-        unsigned temp = std::stoul(argv[i]);
-        config.repeat_count = std::min(temp, kMaxRepeatCount);
-        if (temp != config.repeat_count) {
-          std::cout << "Note: Repeat count clamped to maximum " << kMaxRepeatCount << std::endl;
-        }
-      } else if (strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "--period") == 0) {
-        if (++i >= argc) {
-          std::cerr << "Error: --period requires an argument" << std::endl;
-          Usage(argv[0]);
-          return CommandLineParseResult::kError;
-        }
-        uint32_t temp = std::stoul(argv[i]);
-        config.sampling_period_ns = std::clamp(temp, kMinSamplingPeriodNs, kMaxSamplingPeriodNs);
-        if (temp != config.sampling_period_ns) {
-          std::cout << "Note: Sampling period clamped to valid range [" << kMinSamplingPeriodNs
-                    << ", " << kMaxSamplingPeriodNs << "] ns" << std::endl;
-        }
-      } else if (strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "--buffer") == 0) {
-        if (++i >= argc) {
-          std::cerr << "Error: --buffer requires an argument" << std::endl;
-          Usage(argv[0]);
-          return CommandLineParseResult::kError;
-        }
-        const char* const buffer_value = argv[i];
-        const char* const buffer_value_end = buffer_value + std::strlen(buffer_value);
-        size_t parsed_buffer_size = 0;
-        const auto [parsed_end, parse_error] =
-            std::from_chars(buffer_value, buffer_value_end, parsed_buffer_size);
-        if (parse_error != std::errc{} || parsed_end != buffer_value_end ||
-            parsed_buffer_size == 0) {
-          std::cerr << "Error: invalid --buffer value '" << buffer_value
-                    << "'; expected a positive decimal byte count" << std::endl;
-          Usage(argv[0]);
-          return CommandLineParseResult::kError;
-        }
-        config.collection_buffer_size = parsed_buffer_size;
-      } else {
-        std::cerr << "Error: Unknown option '" << argv[i] << "'" << std::endl;
-        Usage(argv[0]);
-        return CommandLineParseResult::kError;
-      }
-    }
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Failed to parse command line arguments: " << e.what() << std::endl;
-    Usage(argv[0]);
-    return CommandLineParseResult::kError;
-  }
-
-  return CommandLineParseResult::kSuccess;
-}
-
-//-----------------------------------------------------------------------------
-// Main Entry Point
-//-----------------------------------------------------------------------------
-
-int main(int argc, char* argv[]) {
-  // Parse command line arguments
-  SampleConfig config;
-  const CommandLineParseResult parse_result = ParseCommandLine(argc, argv, config);
-  if (parse_result == CommandLineParseResult::kHelp) {
-    return EXIT_SUCCESS;
-  }
-  if (parse_result == CommandLineParseResult::kError) {
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "\n========================================" << std::endl;
-  std::cout << "PC Sampling Sample" << std::endl;
-  std::cout << "========================================" << std::endl;
-  std::cout << "Configuration:" << std::endl;
-  std::cout << "  Matrix size: " << config.matrix_size << "x" << config.matrix_size << std::endl;
-  std::cout << "  Repeat count per kernel: " << config.repeat_count << std::endl;
-  std::cout << "  Sampling period: " << config.sampling_period_ns << " ns ("
-            << (config.sampling_period_ns / 1000.0f) << " µs)" << std::endl;
-
-  // Select GPU device
-  sycl::device device;
-  try {
-    device = sycl::device(sycl::gpu_selector_v);
-  } catch (const sycl::exception& e) {
-    std::cerr << "Failed to select GPU device: " << e.what() << std::endl;
-    std::cerr << "PC Sampling requires a GPU device" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "Target device: " << device.get_info<sycl::info::device::name>() << std::endl;
-
-  // Step 1: Initialize profiling environment (PTI view setup)
-  if (!InitializeProfilingEnvironment()) {
-    std::cerr << "Failed to initialize profiling environment" << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  // Step 2: Enable PC sampling (ptiPcSamplingEnable)
-  if (EnablePcSampling() != PTI_SUCCESS) {
-    std::cerr << "Failed to enable PC sampling" << std::endl;
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 3: Configure PC sampling (ptiPcSamplingConfigure)
-  // This step is optional: skipping it makes Step 5 collect with the PTI defaults
-  // Pass nullptr and 0 to profile all available devices.
-  // Users can pass specific device handles to profile a subset:
-  //   pti_device_handle_t devices[] = {device_handle_1, device_handle_2};
-  //   ConfigurePcSampling(devices, 2, config.sampling_period_ns);
-  if (ConfigurePcSampling(nullptr, 0, config.sampling_period_ns) != PTI_SUCCESS) {
-    std::cerr << "Failed to configure PC sampling" << std::endl;
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 4: Set (optional) and query the collection buffer size
-  // (ptiPcSamplingSetCollectionBufferSize / ptiPcSamplingQueryCollectionBufferSize)
-  if ((config.collection_buffer_size != 0 &&
-       SetPcSamplingCollectionBufferSize(config.collection_buffer_size) != PTI_SUCCESS) ||
-      !PrintPcSamplingCollectionBufferSize()) {
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 5: Start PC sampling collection (ptiPcSamplingStartCollection)
-  if (!StartPcSamplingCollection()) {
-    std::cerr << "Failed to start PC sampling collection" << std::endl;
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 6: Run compute workloads (two GEMM kernels)
-  // Run the same kernels but with different names so they will be identified as different kernels
-  // in the profiling data.
-  std::cout << "\n=== Running Compute Workload ===" << std::endl;
-  std::cout << "Executing two GEMM kernels with matrix size " << config.matrix_size << "x"
-            << config.matrix_size << std::endl;
-
-  // Create SYCL queue
-  sycl::property_list props{sycl::property::queue::in_order()};
-  sycl::queue queue(device, sycl::async_handler{}, props);
-
-  if (!RunGEMMWorkload<PrimaryGEMMKernel>(queue, config.matrix_size, config.repeat_count,
-                                          "Primary GEMM")) {
-    std::cerr << "Primary GEMM workload failed" << std::endl;
-    StopPcSamplingCollection();
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  if (!RunGEMMWorkload<SecondaryGEMMKernel>(queue, config.matrix_size, config.repeat_count,
-                                            "Secondary GEMM")) {
-    std::cerr << "Secondary GEMM workload failed" << std::endl;
-    StopPcSamplingCollection();
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  std::cout << "GEMM kernel executions completed" << std::endl;
-
-  // Step 7: Stop PC sampling collection (ptiPcSamplingStopCollection)
-  if (!StopPcSamplingCollection()) {
-    std::cerr << "Failed to stop PC sampling collection" << std::endl;
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 8: Print collected stall data before releasing the handle
-  if (!PrintPcSamplingData()) {
-    std::cerr << "Failed to print stall data" << std::endl;
-    DisablePcSampling();
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 9: Disable PC sampling (ptiPcSamplingDisable)
-  if (!DisablePcSampling()) {
-    std::cerr << "Failed to disable PC sampling" << std::endl;
-    CleanupProfilingEnvironment();
-    return EXIT_FAILURE;
-  }
-
-  // Step 10: Cleanup environment (PTI view cleanup)
-  CleanupProfilingEnvironment();
-
-  std::cout << "\n========================================" << std::endl;
-  std::cout << "PC Sampling sample completed successfully!" << std::endl;
-  std::cout << "========================================" << std::endl;
-
-  return EXIT_SUCCESS;
-}
diff --git a/sdk/samples/pc_sampling/pc_sampling_client.cc b/sdk/samples/pc_sampling/pc_sampling_client.cc
deleted file mode 100644
index 77e1afec..00000000
--- a/sdk/samples/pc_sampling/pc_sampling_client.cc
+++ /dev/null
@@ -1,501 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-/**
- * @file pc_sampling.cc
- * @brief PC Sampling API implementation for metric collection.
- *
- * This file contains the implementation of PC sampling lifecycle management:
- *   - Environment initialization (PTI view setup)
- *   - PC sampling enable/configure/start/stop/retrieve/print/disable workflow
- *   - Buffer management for PC sampling data collection
- *   - Environment cleanup
- */
-
-#include "pc_sampling_client.h"
-
-#include <algorithm>
-#include <cstdlib>
-#include <cstring>
-#include <iomanip>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "pti/pti_pc_sampling.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-namespace {
-
-// PC sampling collection handle
-pti_pc_sampling_handle_t g_pc_sampling_handle = nullptr;
-
-// Buffer size for PTI view tracing
-constexpr auto kRequestedBufferSize = 1024 * 1024;  // 1 MB buffer
-
-size_t CountDecimalDigits(uint64_t value) {
-  size_t digits = 1;
-  while (value >= 10) {
-    value /= 10;
-    ++digits;
-  }
-  return digits;
-}
-
-// Buffer callback to provide memory for PTI tracing
-void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing" << std::endl;
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-// Buffer callback to parse/deallocate PTI tracing data
-void ParseBuffer(unsigned char* buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << std::endl;
-    if (buf) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-  // Buffer parsing can be implemented here if needed.
-  // For this sample, we just deallocate the buffer.
-  samples_utils::AlignedDealloc(buf);
-}
-
-}  // namespace
-
-bool InitializeProfilingEnvironment(std::ostream& output) {
-  output << "=== Initializing Profiling Environment ===" << std::endl;
-
-  // Set up buffer callbacks for PTI view
-  pti_result status = ptiViewSetCallbacks(ProvideBuffer, ParseBuffer);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to set view callbacks: " << ptiResultTypeToString(status) << std::endl;
-    return false;
-  }
-
-  // Enable kernel view - required before PC sampling
-  status = ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to enable kernel view: " << ptiResultTypeToString(status) << std::endl;
-    return false;
-  }
-
-  output << "Kernel view enabled successfully" << std::endl;
-  return true;
-}
-
-pti_result EnablePcSampling(std::ostream& output) {
-  output << "\n=== Enabling PC Sampling ===" << std::endl;
-
-  pti_result status = ptiPcSamplingEnable(&g_pc_sampling_handle);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to enable PC sampling: " << ptiResultTypeToString(status) << " ("
-              << static_cast<int>(status) << ")" << std::endl;
-    return status;
-  }
-
-  output << "PC Sampling enabled successfully" << std::endl;
-  return PTI_SUCCESS;
-}
-
-pti_result ConfigurePcSampling(const pti_device_handle_t* devices, size_t device_count,
-                               uint32_t sampling_period_ns, std::ostream& output) {
-  output << "\n=== Configuring PC Sampling ===" << std::endl;
-
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Call EnablePcSampling() first." << std::endl;
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  // Configure PC sampling with specified devices and sampling period.
-  // Pass devices=nullptr, device_count=0 to profile all available devices.
-  // User can pass specific device handles to profile a subset of devices.
-  pti_result status =
-      ptiPcSamplingConfigure(g_pc_sampling_handle, devices, device_count, sampling_period_ns);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to configure PC sampling: " << ptiResultTypeToString(status) << " ("
-              << static_cast<int>(status) << ")" << std::endl;
-    return status;
-  }
-
-  if (devices == nullptr) {
-    output << "PC Sampling configured for all available devices (sampling period: "
-           << sampling_period_ns << " ns)" << std::endl;
-  } else {
-    output << "PC Sampling configured for " << device_count
-           << " device(s) (sampling period: " << sampling_period_ns << " ns)" << std::endl;
-  }
-
-  return PTI_SUCCESS;
-}
-
-pti_result SetPcSamplingCollectionBufferSize(size_t buffer_size, std::ostream& output) {
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Call EnablePcSampling() first." << std::endl;
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result status = ptiPcSamplingSetCollectionBufferSize(g_pc_sampling_handle, buffer_size);
-  if (status == PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV) {
-    output << "Requested collection buffer size " << buffer_size
-           << " bytes is overridden by PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE" << std::endl;
-    return PTI_SUCCESS;
-  }
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to set PC sampling collection buffer size: "
-              << ptiResultTypeToString(status) << " (" << static_cast<int>(status) << ")"
-              << std::endl;
-    return status;
-  }
-  return PTI_SUCCESS;
-}
-
-bool PrintPcSamplingCollectionBufferSize(std::ostream& output) {
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Call EnablePcSampling() first." << std::endl;
-    return false;
-  }
-
-  size_t effective_collection_buffer_size = 0;
-  const pti_result status = ptiPcSamplingQueryCollectionBufferSize(
-      g_pc_sampling_handle, &effective_collection_buffer_size);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to query PC sampling collection buffer size: "
-              << ptiResultTypeToString(status) << " (" << static_cast<int>(status) << ")"
-              << std::endl;
-    return false;
-  }
-
-  output << "PC sampling collection buffer: " << effective_collection_buffer_size << " bytes"
-         << std::endl;
-  return true;
-}
-
-bool StartPcSamplingCollection(std::ostream& output) {
-  output << "\n=== Starting PC Sampling Collection ===" << std::endl;
-
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Call EnablePcSampling() first." << std::endl;
-    return false;
-  }
-
-  pti_result status = ptiPcSamplingStartCollection(g_pc_sampling_handle);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to start PC sampling collection: " << ptiResultTypeToString(status) << " ("
-              << static_cast<int>(status) << ")" << std::endl;
-    return false;
-  }
-
-  output << "PC Sampling collection started successfully" << std::endl;
-  return true;
-}
-
-bool StopPcSamplingCollection(std::ostream& output) {
-  output << "\n=== Stopping PC Sampling Collection ===" << std::endl;
-
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Nothing to stop." << std::endl;
-    return false;
-  }
-
-  pti_result status = ptiPcSamplingStopCollection(g_pc_sampling_handle);
-  if (status != PTI_SUCCESS && status != PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED) {
-    std::cerr << "Failed to stop PC sampling collection: " << ptiResultTypeToString(status) << " ("
-              << static_cast<int>(status) << ")" << std::endl;
-    return false;
-  }
-
-  output << "PC Sampling collection stopped successfully" << std::endl;
-  return true;
-}
-
-bool DisablePcSampling(std::ostream& output) {
-  output << "\n=== Disabling PC Sampling ===" << std::endl;
-
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Nothing to disable." << std::endl;
-    return false;
-  }
-
-  pti_result status = ptiPcSamplingDisable(g_pc_sampling_handle);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to disable PC sampling: " << ptiResultTypeToString(status) << " ("
-              << static_cast<int>(status) << ")" << std::endl;
-    return false;
-  }
-
-  output << "PC Sampling disabled and resources freed successfully" << std::endl;
-  g_pc_sampling_handle = nullptr;
-  return true;
-}
-
-bool HasObservedPcSamplingKernels() {
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Cannot query observed kernels." << std::endl;
-    return false;
-  }
-
-  size_t device_count = 0;
-  pti_result status = ptiPcSamplingGetProfiledDevices(g_pc_sampling_handle, nullptr, &device_count);
-  if (status != PTI_SUCCESS || device_count == 0) {
-    return false;
-  }
-
-  std::vector<pti_device_handle_t> devices(device_count);
-  status = ptiPcSamplingGetProfiledDevices(g_pc_sampling_handle, devices.data(), &device_count);
-  if (status != PTI_SUCCESS) {
-    return false;
-  }
-
-  for (pti_device_handle_t device : devices) {
-    size_t kernel_count = 0;
-    status =
-        ptiPcSamplingGetObservedKernelHandles(g_pc_sampling_handle, device, nullptr, &kernel_count);
-    if (status != PTI_SUCCESS) {
-      return false;
-    }
-    if (kernel_count != 0) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool PrintPcSamplingData(std::ostream& output) {
-  if (!g_pc_sampling_handle) {
-    std::cerr << "PC sampling handle is null. Cannot print stall data." << std::endl;
-    return false;
-  }
-
-  output << "\n=== PC Sampling Stall Data ===" << std::endl;
-
-  // Print Stall Reasons types and descriptions
-  size_t reason_count = 0;
-  pti_result status = ptiPcSamplingGetStallReasons(g_pc_sampling_handle, nullptr, &reason_count);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to query stall reason count: " << ptiResultTypeToString(status)
-              << std::endl;
-    return false;
-  }
-
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& r : reasons) {
-    r._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-  status = ptiPcSamplingGetStallReasons(g_pc_sampling_handle, reasons.data(), &reason_count);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to retrieve stall reasons: " << ptiResultTypeToString(status) << std::endl;
-    return false;
-  }
-
-  output << "Stall reasons (" << reason_count << "):" << std::endl;
-  for (size_t i = 0; i < reason_count; ++i) {
-    const char* name = reasons[i]._name ? reasons[i]._name : "<null>";
-    const char* desc = reasons[i]._description ? reasons[i]._description : "<null>";
-    output << "  [" << i << "] " << name << ": " << desc << std::endl;
-  }
-
-  // Print profiled devices
-  size_t device_count = 0;
-  status = ptiPcSamplingGetProfiledDevices(g_pc_sampling_handle, nullptr, &device_count);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to query profiled device count: " << ptiResultTypeToString(status)
-              << std::endl;
-    return false;
-  }
-
-  if (device_count == 0) {
-    output << "No profiled devices found." << std::endl;
-    return true;
-  }
-
-  std::vector<pti_device_handle_t> devices(device_count);
-  status = ptiPcSamplingGetProfiledDevices(g_pc_sampling_handle, devices.data(), &device_count);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to retrieve profiled devices: " << ptiResultTypeToString(status)
-              << std::endl;
-    return false;
-  }
-
-  // Print device specific data
-  for (size_t d = 0; d < device_count; ++d) {
-    output << "\n--- Device " << (d + 1) << "/" << device_count << " ---" << std::endl;
-
-    // Print device status
-    pti_pc_sampling_device_status_t device_status{};
-    device_status._struct_size = sizeof(device_status);
-    status = ptiPcSamplingGetDeviceStatus(g_pc_sampling_handle, devices[d], &device_status);
-    if (status == PTI_SUCCESS) {
-      output << "  Total samples collected : " << device_status._total_sample_count << std::endl;
-      output << "  Total PCs sampled       : " << device_status._total_pc_count << std::endl;
-      output << "  Samples dropped         : " << (device_status._samples_dropped ? "Yes" : "No")
-             << std::endl;
-    } else {
-      std::cerr << "  Warning: Failed to get device status: " << ptiResultTypeToString(status)
-                << std::endl;
-    }
-
-    // Print kernel amount
-    size_t kernel_count = 0;
-    status = ptiPcSamplingGetObservedKernelHandles(g_pc_sampling_handle, devices[d], nullptr,
-                                                   &kernel_count);
-    if (status != PTI_SUCCESS) {
-      std::cerr << "  Failed to query kernel handle count: " << ptiResultTypeToString(status)
-                << std::endl;
-      continue;
-    }
-
-    if (kernel_count == 0) {
-      output << "  No kernels with samples found for this device." << std::endl;
-      continue;
-    }
-
-    std::vector<uint64_t> kernel_handles(kernel_count);
-    status = ptiPcSamplingGetObservedKernelHandles(g_pc_sampling_handle, devices[d],
-                                                   kernel_handles.data(), &kernel_count);
-    if (status != PTI_SUCCESS) {
-      std::cerr << "  Failed to retrieve kernel handles: " << ptiResultTypeToString(status)
-                << std::endl;
-      continue;
-    }
-
-    output << "  Kernels with samples: " << kernel_count << std::endl;
-
-    // Print per kernel data
-    for (size_t k = 0; k < kernel_count; ++k) {
-      // Print kernel info
-      pti_pc_sampling_kernel_info_t kernel_info{};
-      kernel_info._struct_size = sizeof(kernel_info);
-      status = ptiPcSamplingGetObservedKernelInfo(g_pc_sampling_handle, devices[d],
-                                                  kernel_handles[k], &kernel_info);
-      if (status != PTI_SUCCESS) {
-        std::cerr << "  Failed to retrieve kernel info: " << ptiResultTypeToString(status)
-                  << std::endl;
-        continue;
-      }
-
-      const size_t kernel_reason_count = kernel_info._reason_count;
-      std::vector<uint64_t> aggregated_samples(kernel_reason_count, 0);
-      kernel_info._aggregated_samples = aggregated_samples.data();
-      status = ptiPcSamplingGetObservedKernelInfo(g_pc_sampling_handle, devices[d],
-                                                  kernel_handles[k], &kernel_info);
-      if (status != PTI_SUCCESS) {
-        std::cerr << "  Failed to retrieve aggregated kernel samples: "
-                  << ptiResultTypeToString(status) << std::endl;
-        continue;
-      }
-
-      const char* kernel_name = kernel_info._kernel_name ? kernel_info._kernel_name : "<unknown>";
-      output << "\n  Kernel [" << (k + 1) << "/" << kernel_count << "]: " << kernel_name
-             << std::endl;
-      output << "    Instructions with samples: " << kernel_info._instructions_with_samples_count
-             << std::endl;
-
-      // Aggregated stall counts across all instructions in this kernel
-      output << "    Aggregated stall samples:" << std::endl;
-      bool any_nonzero = false;
-      for (size_t r = 0; r < kernel_reason_count; ++r) {
-        if (aggregated_samples[r] > 0) {
-          const char* rname = r < reason_count && reasons[r]._name ? reasons[r]._name : "<unknown>";
-          output << "      " << rname << ": " << aggregated_samples[r] << std::endl;
-          any_nonzero = true;
-        }
-      }
-      if (!any_nonzero) {
-        output << "      (no stall samples recorded)" << std::endl;
-      }
-
-      const size_t instr_count = kernel_info._instructions_with_samples_count;
-      if (instr_count == 0 || kernel_reason_count == 0) {
-        continue;
-      }
-
-      // Print per-instruction stall breakdown
-      std::vector<pti_pc_sampling_instruction_t> instructions(instr_count);
-      std::vector<uint64_t> samples(instr_count * kernel_reason_count, 0);
-      status = ptiPcSamplingGetSamplesPerInstruction(g_pc_sampling_handle, devices[d],
-                                                     kernel_handles[k], instructions.data(),
-                                                     instr_count, samples.data(), samples.size());
-      if (status != PTI_SUCCESS) {
-        std::cerr << "    Failed to retrieve per-instruction samples: "
-                  << ptiResultTypeToString(status) << std::endl;
-        continue;
-      }
-
-      // Pre-compute per-column width: max(header name length, max value digits)
-      std::vector<size_t> col_widths(kernel_reason_count);
-      for (size_t r = 0; r < kernel_reason_count; ++r) {
-        const char* rname = r < reason_count && reasons[r]._name ? reasons[r]._name : "<unknown>";
-        col_widths[r] = std::strlen(rname);
-      }
-      for (size_t i = 0; i < instr_count; ++i) {
-        for (size_t r = 0; r < kernel_reason_count; ++r) {
-          size_t val_width = CountDecimalDigits(samples[i * kernel_reason_count + r]);
-          col_widths[r] = std::max(col_widths[r], val_width);
-        }
-      }
-
-      output << "    Per-instruction stall samples:" << std::endl;
-
-      // Header row
-      output << "      " << std::left << std::setw(10) << "Offset";
-      for (size_t r = 0; r < kernel_reason_count; ++r) {
-        const char* rname = r < reason_count && reasons[r]._name ? reasons[r]._name : "<unknown>";
-        output << " | " << std::left << std::setw(col_widths[r]) << rname;
-      }
-      output << std::endl;
-
-      // Separator row
-      output << "      " << std::string(10, '-');
-      for (size_t r = 0; r < kernel_reason_count; ++r) {
-        output << "-+-" << std::string(col_widths[r], '-');
-      }
-      output << std::endl;
-
-      // Data rows
-      for (size_t i = 0; i < instr_count; ++i) {
-        output << "      0x" << std::right << std::hex << std::setw(8) << std::setfill('0')
-               << instructions[i]._instruction_offset << std::setfill(' ') << std::dec;
-        if (instructions[i]._source_info && instructions[i]._source_info->_file_path) {
-          output << " [" << instructions[i]._source_info->_file_path << ":"
-                 << instructions[i]._source_info->_file_line << "]";
-        }
-        for (size_t r = 0; r < kernel_reason_count; ++r) {
-          output << " | " << std::right << std::setw(col_widths[r])
-                 << samples[i * kernel_reason_count + r];
-        }
-        output << std::endl;
-      }
-    }
-  }
-
-  return true;
-}
-
-void CleanupProfilingEnvironment(std::ostream& output) {
-  output << "\n=== Cleaning Up Profiling Environment ===" << std::endl;
-
-  // Disable kernel view
-  pti_result status = ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL);
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to disable kernel view: " << ptiResultTypeToString(status) << std::endl;
-  } else {
-    output << "Kernel view disabled successfully" << std::endl;
-  }
-  status = ptiFlushAllViews();
-  if (status != PTI_SUCCESS) {
-    std::cerr << "Failed to flush PTI views: " << ptiResultTypeToString(status) << std::endl;
-  } else {
-    output << "PTI views flushed successfully" << std::endl;
-  }
-}
diff --git a/sdk/samples/pc_sampling/pc_sampling_client.h b/sdk/samples/pc_sampling/pc_sampling_client.h
deleted file mode 100644
index 55395fde..00000000
--- a/sdk/samples/pc_sampling/pc_sampling_client.h
+++ /dev/null
@@ -1,76 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef PC_SAMPLING_H_
-#define PC_SAMPLING_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-
-#include "pti/pti.h"
-
-// Initialize PTI view subsystem required for profiling.
-// Must be called before EnablePcSampling().
-// Note: This is a temporary requirement which will be removed in future when
-//  PC sampling can be enabled without enabling kernel view from the app.
-bool InitializeProfilingEnvironment(std::ostream& output = std::cout);
-
-// Enable PC sampling and create a collection handle.
-// This corresponds to ptiPcSamplingEnable().
-// Must be called before ConfigurePcSampling() and StartPcSamplingCollection().
-pti_result EnablePcSampling(std::ostream& output = std::cout);
-
-// Configure PC sampling with device selection and sampling period.
-// Parameters:
-//   devices: Array of device handles to profile, or nullptr to profile all available devices.
-//   device_count: Number of devices in the array, or 0 when devices is nullptr.
-//   sampling_period_ns: Sampling period in nanoseconds (e.g., 50000 for 50µs).
-// This corresponds to ptiPcSamplingConfigure().
-// Optional: skip it to collect with the PTI defaults. When used, it must be called after
-// EnablePcSampling() and before StartPcSamplingCollection().
-pti_result ConfigurePcSampling(const pti_device_handle_t* devices, size_t device_count,
-                               uint32_t sampling_period_ns, std::ostream& output = std::cout);
-
-// Set the collection-buffer size (ptiPcSamplingSetCollectionBufferSize).
-// Optional: PTI uses its default size otherwise. A valid PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE
-// environment variable takes precedence; that case is reported but not treated as a failure.
-// Must be called after EnablePcSampling() and before StartPcSamplingCollection().
-pti_result SetPcSamplingCollectionBufferSize(size_t buffer_size, std::ostream& output = std::cout);
-
-// Query and print the collection-buffer size resolved by PTI.
-// Must be called after EnablePcSampling() and before StartPcSamplingCollection().
-bool PrintPcSamplingCollectionBufferSize(std::ostream& output = std::cout);
-
-// Start PC sampling collection.
-// This corresponds to ptiPcSamplingStartCollection().
-// Must be called after EnablePcSampling(). Applies the default configuration when
-// ConfigurePcSampling() was not called.
-bool StartPcSamplingCollection(std::ostream& output = std::cout);
-
-// Stop PC sampling collection.
-// This corresponds to ptiPcSamplingStopCollection().
-// Must be called after StartPcSamplingCollection() and before DisablePcSampling().
-bool StopPcSamplingCollection(std::ostream& output = std::cout);
-
-// Disable PC sampling and free resources.
-// This corresponds to ptiPcSamplingDisable().
-// Must be called after StopPcSamplingCollection().
-bool DisablePcSampling(std::ostream& output = std::cout);
-
-// Retrieve and print PC sampling data collected during the last sampling session.
-// Must be called after StopPcSamplingCollection() and before DisablePcSampling().
-// Prints stall reason descriptions, per-device collection statistics, per-kernel
-// aggregated stall counts, and per-instruction stall breakdowns.
-bool PrintPcSamplingData(std::ostream& output = std::cout);
-
-// Returns true when at least one kernel has sampled instructions.
-bool HasObservedPcSamplingKernels();
-
-// Cleanup PTI view subsystem.
-// Should be called at the end of the program.
-void CleanupProfilingEnvironment(std::ostream& output = std::cout);
-
-#endif  // PC_SAMPLING_H_
diff --git a/sdk/samples/pc_sampling_profiler/CMakeLists.txt b/sdk/samples/pc_sampling_profiler/CMakeLists.txt
deleted file mode 100644
index e39ea6cd..00000000
--- a/sdk/samples/pc_sampling_profiler/CMakeLists.txt
+++ /dev/null
@@ -1,55 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_PC_SAMPLING_PROFILER CXX)
-
-# LD_PRELOAD injection and the __libc_start_main wrapper are glibc/Linux only.
-if(NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  message(STATUS "${PROJECT_NAME} is supported on Linux only")
-  return()
-endif()
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-if(NOT TARGET LevelZero::level-zero)
-  list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/Modules")
-  find_package(LevelZero REQUIRED)
-endif()
-
-add_library(pc_sampling_profiler_collector SHARED collector.cc ../pc_sampling/pc_sampling_client.cc)
-target_include_directories(pc_sampling_profiler_collector
-                           PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-target_link_libraries(pc_sampling_profiler_collector
-                      PRIVATE Pti::pti_view Threads::Threads ${CMAKE_DL_LIBS})
-set_target_properties(pc_sampling_profiler_collector PROPERTIES CXX_VISIBILITY_PRESET hidden)
-
-add_executable(pc_sampling_profiler launcher.cc)
-add_dependencies(pc_sampling_profiler pc_sampling_profiler_collector)
-target_compile_definitions(
-  pc_sampling_profiler
-  PRIVATE PC_SAMPLING_COLLECTOR_PATH="$<TARGET_FILE:pc_sampling_profiler_collector>")
-
-if(has_sycl)
-  add_executable(pc_sampling_profiler_gemm gemm.cc)
-  target_link_options(pc_sampling_profiler_gemm PRIVATE -fsycl)
-  target_compile_options(pc_sampling_profiler_gemm PRIVATE -fsycl)
-endif()
-
-configure_file("${CMAKE_CURRENT_SOURCE_DIR}/gemm.spv" "${CMAKE_CURRENT_BINARY_DIR}/gemm.spv"
-               COPYONLY)
-add_executable(pc_sampling_profiler_l0_gemm l0_gemm.cc)
-target_link_libraries(pc_sampling_profiler_l0_gemm PRIVATE LevelZero::level-zero)
diff --git a/sdk/samples/pc_sampling_profiler/README.md b/sdk/samples/pc_sampling_profiler/README.md
deleted file mode 100644
index 6912c00b..00000000
--- a/sdk/samples/pc_sampling_profiler/README.md
+++ /dev/null
@@ -1,93 +0,0 @@
-# PC Sampling Profiler Sample
-
-This sample collects PC Sampling (EuStallSampling) data from an **unmodified** application (Level Zero, SYCL, or PyTorch XPU).
-The launcher `pc_sampling_profiler` preloads the collector library
-`libpc_sampling_profiler_collector.so` into the application; the collector drives the PTI PC
-Sampling API and prints a per-kernel, per-instruction stall report.
-
-The PTI calls and the report come from the client in the [`pc_sampling`](../pc_sampling) sample;
-this sample only decides when collection starts and stops.
-
-## Requirements
-
-- Linux and Intel oneAPI (`icpx`).
-- Python with PyTorch XPU support, compatible with the sourced oneAPI, for the PyTorch workload.
-- A GPU and driver with PC Sampling support.
-
-## Build
-
-The sample is built with the PTI SDK, which also provides Level Zero. From the `sdk` directory,
-with the oneAPI environment set up, into a new build directory:
-
-```bash
-cmake -B build-pc-sampling -DCMAKE_BUILD_TYPE=Release \
-  -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/icpx_toolchain.cmake
-cmake --build build-pc-sampling --parallel --target pc_sampling_profiler \
-  pc_sampling_profiler_collector pc_sampling_profiler_l0_gemm pc_sampling_profiler_gemm
-```
-
-The launcher embeds the absolute path of the collector library, so the build directory cannot be
-moved or installed.
-
-## Run
-
-From the `sdk` directory, in the same terminal, writing each report to `reports/`:
-
-```bash
-B=build-pc-sampling
-mkdir -p reports
-$B/bin/pc_sampling_profiler -o reports/l0.txt -- \
-  $B/bin/pc_sampling_profiler_l0_gemm $B/samples/pc_sampling_profiler/gemm.spv
-$B/bin/pc_sampling_profiler -o reports/sycl.txt -- \
-  $B/bin/pc_sampling_profiler_gemm --size 2048 --repeat 3
-$B/bin/pc_sampling_profiler -o reports/pytorch.txt -- \
-  python samples/pc_sampling_profiler/pytorch_train.py
-```
-
-The bundled workloads are a Level Zero GEMM (`gemm.spv` is built from `gemm.cl`), a SYCL GEMM,
-and a small PyTorch XPU training script (`pytorch_train.py`). None of them uses PTI. Any Level
-Zero, SYCL, or PyTorch XPU application can be profiled the same way.
-
-| Option | Description |
-| --- | --- |
-| `--period`, `-p` `<ns>` | Sampling period, 1000-10000000 ns (default 50000) |
-| `--output`, `-o` `<file>` | Write the report to `<file>` instead of standard error |
-| `--help`, `-h` | Usage |
-
-The launcher `exec`s the application, so its exit status is preserved.
-
-## How it works
-
-`LD_PRELOAD` is what lets the collector run inside an unmodified application. The collector
-interposes a single function, glibc's `__libc_start_main`, to wrap the application's `main`:
-
-1. Before `main`, it enables the PTI kernel view and PC sampling and starts collection. PTI
-   initializes Level Zero and enables metrics itself, so
-   every module and kernel the application creates afterwards is observed, whichever runtime
-   (Level Zero, SYCL, PyTorch) creates it.
-2. Before the application’s exit handlers run and while the GPU runtime is still alive, the
-   collector stops collection and writes the report: stall reasons, sample totals per device,
-   and aggregated and per-instruction stall counts for every sampled kernel. The report goes to
-   standard error unless `--output` is given; errors always go to standard error.
-
-No Level Zero or higher-level runtime API is interposed, so the collector works the same with any
-Level Zero loader.
-
-`LD_PRELOAD` is inherited by child processes, but a process that enables PC sampling can block
-while another one is sampling the GPU. The collector therefore samples only the first process
-that loads it: that process records its PID in `PTI_PC_SAMPLING_PID`, and descendants that see a
-different PID run unprofiled. The launcher clears the variable before `exec`, and the application
-keeps the launcher's PID.
-
-## Known limitations
-
-- Only the launched process is profiled.
-- Static and setuid binaries cannot be profiled: the dynamic loader ignores `LD_PRELOAD` for them.
-- The target application must not use the PTI SDK itself. Only one PC sampling handle can exist.
-- Threads of the profiled process share one collection. Children created with `fork()` without
-  `exec()` inherit the parent's collector and GPU runtime state and are not supported. The
-  collector skips finalization in a forked child to avoid using that inherited state.
-- Other GPU processes running at the same time contend for the EU stall stream.
-- No report is produced when the application uses `_exit()` or `_Exit()`, is interrupted with
-  Ctrl-C, or is killed by a signal. These termination paths bypass exit handlers.
-- The application's exit status does not reflect profiling failures; check standard error.
diff --git a/sdk/samples/pc_sampling_profiler/collector.cc b/sdk/samples/pc_sampling_profiler/collector.cc
deleted file mode 100644
index 36b8c73a..00000000
--- a/sdk/samples/pc_sampling_profiler/collector.cc
+++ /dev/null
@@ -1,168 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <dlfcn.h>
-#include <unistd.h>
-
-#include <cstdint>
-#include <cstdlib>
-#include <fstream>
-#include <iostream>
-#include <mutex>
-#include <string>
-
-#include "../pc_sampling/pc_sampling_client.h"
-#include "pti/pti.h"
-
-namespace {
-
-constexpr uint32_t kDefaultSamplingPeriodNs = 50'000;
-
-bool g_active = false;
-pid_t g_owner_pid = 0;
-std::mutex g_stop_mutex;
-
-std::ofstream g_output_file;
-std::ostream* g_output = &std::cerr;
-
-// Set only by the launcher, which validates the range.
-uint32_t SamplingPeriodFromEnvironment() {
-  const char* value = std::getenv("PTI_PC_SAMPLING_PERIOD_NS");
-  return value != nullptr ? static_cast<uint32_t>(std::strtoul(value, nullptr, 10))
-                          : kDefaultSamplingPeriodNs;
-}
-
-void ConfigureOutput() {
-  const char* output_path = std::getenv("PTI_PC_SAMPLING_OUTPUT");
-  if (output_path == nullptr) {
-    return;
-  }
-
-  g_output_file.open(output_path, std::ios::out | std::ios::trunc);
-  if (!g_output_file) {
-    std::cerr << "Unable to open PC sampling output file '" << output_path
-              << "'; writing to standard error" << std::endl;
-    return;
-  }
-  g_output = &g_output_file;
-  std::cerr << "PC sampling output file: " << output_path << std::endl;
-}
-
-// LD_PRELOAD is inherited, but a process enabling PC sampling blocks while another one samples,
-// so only the first process started with the collector samples and its descendants do not.
-bool ClaimCollection() {
-  const std::string pid = std::to_string(getpid());
-  const char* owner = std::getenv("PTI_PC_SAMPLING_PID");
-  if (owner != nullptr) {
-    return pid == owner;
-  }
-  return setenv("PTI_PC_SAMPLING_PID", pid.c_str(), 1) == 0;
-}
-
-void StopCollectionAndReport() {
-  if (getpid() != g_owner_pid) {
-    return;
-  }
-
-  std::lock_guard<std::mutex> lock(g_stop_mutex);
-  if (!g_active) {
-    return;
-  }
-  g_active = false;
-
-  if (StopPcSamplingCollection(*g_output)) {
-    PrintPcSamplingData(*g_output);
-  }
-  DisablePcSampling(*g_output);
-  CleanupProfilingEnvironment(*g_output);
-  g_output->flush();
-}
-
-// Releases whatever it acquired on failure.
-bool InitializeCollector() {
-  std::ostream* output_stream;
-  {
-    std::lock_guard<std::mutex> lock(g_stop_mutex);
-    ConfigureOutput();
-    output_stream = g_output;
-  }
-  std::ostream& output = *output_stream;
-  output << "\n=== PC Sampling Profiler Collector ===" << std::endl;
-
-  if (!InitializeProfilingEnvironment(output)) {
-    return false;
-  }
-
-  if (EnablePcSampling(output) == PTI_SUCCESS) {
-    if (ConfigurePcSampling(nullptr, 0, SamplingPeriodFromEnvironment(), output) == PTI_SUCCESS &&
-        StartPcSamplingCollection(output)) {
-      return true;
-    }
-    DisablePcSampling(output);
-  }
-  CleanupProfilingEnvironment(output);
-  return false;
-}
-
-using MainFunction = int (*)(int, char**, char**);
-MainFunction g_application_main = nullptr;
-
-// Collection spans main(): PTI initializes Level Zero itself, so no runtime API is interposed,
-// and the report runs before atexit handlers and static destructors tear the runtime down.
-// glibc passes envp even to a two-parameter main, so the indirect call below is expected to
-// mismatch the callee's declared type and -fsanitize=function must not flag it.
-#ifdef __clang__
-__attribute__((no_sanitize("function")))
-#endif
-int MainWrapper(int argc, char** argv, char** envp) {
-  g_owner_pid = getpid();
-  g_active = ClaimCollection() && InitializeCollector();
-  const int status = g_application_main(argc, argv, envp);
-  StopCollectionAndReport();
-  return status;
-}
-
-}  // namespace
-
-extern "C" __attribute__((visibility("default"), noreturn)) void exit(int status) noexcept {
-  using ExitFunction = void (*)(int);
-  static auto real_exit = reinterpret_cast<ExitFunction>(dlsym(RTLD_NEXT, "exit"));
-  if (real_exit == nullptr) {
-    std::abort();
-  }
-
-  StopCollectionAndReport();
-  real_exit(status);
-  __builtin_unreachable();
-}
-
-extern "C" __attribute__((visibility("default"), noreturn)) void quick_exit(int status) noexcept {
-  using QuickExitFunction = void (*)(int);
-  static auto real_quick_exit = reinterpret_cast<QuickExitFunction>(dlsym(RTLD_NEXT, "quick_exit"));
-  if (real_quick_exit == nullptr) {
-    std::abort();
-  }
-
-  StopCollectionAndReport();
-  real_quick_exit(status);
-  __builtin_unreachable();
-}
-
-extern "C" __attribute__((visibility("default"))) int __libc_start_main(
-    MainFunction main_function, int argc, char** argv, MainFunction init, void (*fini)(void),
-    void (*rtld_fini)(void), void* stack_end) {
-  // glibc declares init as __typeof(main), hence MainFunction here; it is only forwarded.
-  using LibcStartMainFunction =
-      int (*)(MainFunction, int, char**, MainFunction, void (*)(void), void (*)(void), void*);
-  static auto real_libc_start_main =
-      reinterpret_cast<LibcStartMainFunction>(dlsym(RTLD_NEXT, "__libc_start_main"));
-  if (real_libc_start_main == nullptr) {
-    std::abort();
-  }
-
-  g_application_main = main_function;
-  return real_libc_start_main(MainWrapper, argc, argv, init, fini, rtld_fini, stack_end);
-}
diff --git a/sdk/samples/pc_sampling_profiler/gemm.cc b/sdk/samples/pc_sampling_profiler/gemm.cc
deleted file mode 100644
index 05664189..00000000
--- a/sdk/samples/pc_sampling_profiler/gemm.cc
+++ /dev/null
@@ -1,160 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-constexpr float kAValue = 0.128f;
-constexpr float kBValue = 0.256f;
-constexpr float kMaxEps = 1.0e-4f;
-constexpr unsigned kDefaultMatrixSize = 1024;
-constexpr unsigned kMaxMatrixSize = 8192;
-constexpr unsigned kMinMatrixSize = 32;
-constexpr unsigned kDefaultRepeatCount = 1;
-constexpr unsigned kMaxRepeatCount = 100;
-
-class GEMMKernel;
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  const int row = id.get(0);
-  const int column = id.get(1);
-  float sum = 0.0f;
-  for (unsigned index = 0; index < size; ++index) {
-    sum += a[row * size + index] * b[index * size + column];
-  }
-  c[row * size + column] = sum;
-}
-
-float CheckResults(const std::vector<float>& c, float expected_value) {
-  float epsilon = 0.0f;
-  for (size_t index = 0; index < c.size(); ++index) {
-    epsilon += std::fabs((c[index] - expected_value) / expected_value);
-  }
-  return epsilon / c.size();
-}
-
-bool RunGEMM(sycl::queue& queue, const std::vector<float>& a, const std::vector<float>& b,
-             std::vector<float>& c, unsigned size, float expected_result) {
-  try {
-    sycl::buffer<float, 1> a_buffer(a.data(), a.size());
-    sycl::buffer<float, 1> b_buffer(b.data(), b.size());
-    sycl::buffer<float, 1> c_buffer(c.data(), c.size());
-    queue.submit([&](sycl::handler& command_group) {
-      auto a_accessor = a_buffer.get_access<sycl::access::mode::read>(command_group);
-      auto b_accessor = b_buffer.get_access<sycl::access::mode::read>(command_group);
-      auto c_accessor = c_buffer.get_access<sycl::access::mode::write>(command_group);
-      command_group.parallel_for<GEMMKernel>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        GEMM(a_accessor.get_multi_ptr<sycl::access::decorated::no>().get(),
-             b_accessor.get_multi_ptr<sycl::access::decorated::no>().get(),
-             c_accessor.get_multi_ptr<sycl::access::decorated::no>().get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& exception) {
-    std::cerr << "SYCL exception: " << exception.what() << std::endl;
-    return false;
-  }
-
-  const float epsilon = CheckResults(c, expected_result);
-  const bool passed = epsilon < kMaxEps;
-  std::cout << "GEMM results are " << (passed ? "CORRECT" : "INCORRECT")
-            << " (accuracy: " << epsilon << ")" << std::endl;
-  return passed;
-}
-
-bool RunGEMMWorkload(sycl::queue& queue, unsigned size, unsigned repeat_count) {
-  std::vector<float> a(size * size, kAValue);
-  std::vector<float> b(size * size, kBValue);
-  std::vector<float> c(size * size, 0.0f);
-  const float expected_result = kAValue * kBValue * size;
-
-  std::cout << "GEMM kernel " << repeat_count << " time(s) (matrix size: " << size << "x" << size
-            << ")..." << std::endl;
-  for (unsigned iteration = 0; iteration < repeat_count; ++iteration) {
-    std::cout << "  Iteration " << (iteration + 1) << "/" << repeat_count << ": ";
-    if (!RunGEMM(queue, a, b, c, size, expected_result)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-struct GemmConfig {
-  unsigned matrix_size = kDefaultMatrixSize;
-  unsigned repeat_count = kDefaultRepeatCount;
-};
-
-void Usage(const char* name) {
-  std::cout << "Usage: " << name << " [options]" << std::endl;
-  std::cout << "  --size [-s] <size>     Matrix size (default: " << kDefaultMatrixSize
-            << ", range: " << kMinMatrixSize << "-" << kMaxMatrixSize << ")" << std::endl;
-  std::cout << "  --repeat [-r] <count>  Number of kernel executions (default: "
-            << kDefaultRepeatCount << ", max: " << kMaxRepeatCount << ")" << std::endl;
-}
-
-enum class ParseResult { kRun, kHelp, kError };
-
-ParseResult ParseCommandLine(int argc, char* argv[], GemmConfig& config) {
-  try {
-    for (int index = 1; index < argc; ++index) {
-      if (std::strcmp(argv[index], "-h") == 0 || std::strcmp(argv[index], "--help") == 0) {
-        Usage(argv[0]);
-        return ParseResult::kHelp;
-      }
-      if (std::strcmp(argv[index], "-s") == 0 || std::strcmp(argv[index], "--size") == 0) {
-        if (++index >= argc || argv[index][0] == '-') {
-          throw std::invalid_argument("--size requires a positive argument");
-        }
-        config.matrix_size = std::clamp(static_cast<unsigned>(std::stoul(argv[index])),
-                                        kMinMatrixSize, kMaxMatrixSize);
-        continue;
-      }
-      if (std::strcmp(argv[index], "-r") == 0 || std::strcmp(argv[index], "--repeat") == 0) {
-        if (++index >= argc || argv[index][0] == '-') {
-          throw std::invalid_argument("--repeat requires a positive argument");
-        }
-        config.repeat_count =
-            std::min(static_cast<unsigned>(std::stoul(argv[index])), kMaxRepeatCount);
-        continue;
-      }
-      throw std::invalid_argument(std::string("unknown option '") + argv[index] + "'");
-    }
-  } catch (const std::exception& exception) {
-    std::cerr << "Error: " << exception.what() << std::endl;
-    Usage(argv[0]);
-    return ParseResult::kError;
-  }
-  return ParseResult::kRun;
-}
-
-int main(int argc, char* argv[]) {
-  GemmConfig config;
-  switch (ParseCommandLine(argc, argv, config)) {
-    case ParseResult::kHelp:
-      return EXIT_SUCCESS;
-    case ParseResult::kError:
-      return EXIT_FAILURE;
-    case ParseResult::kRun:
-      break;
-  }
-
-  try {
-    sycl::queue queue(sycl::gpu_selector_v, sycl::async_handler{},
-                      sycl::property_list{sycl::property::queue::in_order()});
-    std::cout << "Target device: " << queue.get_device().get_info<sycl::info::device::name>()
-              << std::endl;
-    return RunGEMMWorkload(queue, config.matrix_size, config.repeat_count) ? EXIT_SUCCESS
-                                                                           : EXIT_FAILURE;
-  } catch (const sycl::exception& exception) {
-    std::cerr << "Failed to select GPU device: " << exception.what() << std::endl;
-    return EXIT_FAILURE;
-  }
-}
diff --git a/sdk/samples/pc_sampling_profiler/gemm.cl b/sdk/samples/pc_sampling_profiler/gemm.cl
deleted file mode 100644
index d74b9110..00000000
--- a/sdk/samples/pc_sampling_profiler/gemm.cl
+++ /dev/null
@@ -1,10 +0,0 @@
-__kernel void GEMM(__global float* a, __global float* b,
-                    __global float* c, int size) {
-  int j = get_global_id(0);
-  int i = get_global_id(1);
-  float sum = 0.0f;
-  for (int k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
\ No newline at end of file
diff --git a/sdk/samples/pc_sampling_profiler/gemm.spv b/sdk/samples/pc_sampling_profiler/gemm.spv
deleted file mode 100644
index b31c2d35..00000000
Binary files a/sdk/samples/pc_sampling_profiler/gemm.spv and /dev/null differ
diff --git a/sdk/samples/pc_sampling_profiler/l0_gemm.cc b/sdk/samples/pc_sampling_profiler/l0_gemm.cc
deleted file mode 100644
index 303d4002..00000000
--- a/sdk/samples/pc_sampling_profiler/l0_gemm.cc
+++ /dev/null
@@ -1,179 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <level_zero/ze_api.h>
-
-#include <cmath>
-#include <cstdint>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-void Check(ze_result_t result, const char* operation) {
-  if (result != ZE_RESULT_SUCCESS) {
-    throw std::runtime_error(std::string(operation) +
-                             " failed: " + std::to_string(static_cast<uint32_t>(result)));
-  }
-}
-
-int main(int argc, char** argv) {
-  if (argc != 2) {
-    std::cerr << "Usage: " << argv[0] << " <gemm.spv>\n";
-    return 1;
-  }
-
-  try {
-    std::ifstream input(argv[1], std::ios::binary);
-    if (!input) {
-      throw std::runtime_error("cannot open SPIR-V kernel");
-    }
-    std::vector<char> binary(std::istreambuf_iterator<char>{input}, {});
-    if (binary.empty()) {
-      throw std::runtime_error("SPIR-V kernel is empty");
-    }
-
-    Check(zeInit(ZE_INIT_FLAG_GPU_ONLY), "zeInit");
-    uint32_t driver_count = 0;
-    Check(zeDriverGet(&driver_count, nullptr), "zeDriverGet(count)");
-    std::vector<ze_driver_handle_t> drivers(driver_count);
-    Check(zeDriverGet(&driver_count, drivers.data()), "zeDriverGet");
-    ze_driver_handle_t driver = nullptr;
-    ze_device_handle_t device = nullptr;
-    for (auto candidate : drivers) {
-      uint32_t device_count = 0;
-      Check(zeDeviceGet(candidate, &device_count, nullptr), "zeDeviceGet(count)");
-      std::vector<ze_device_handle_t> devices(device_count);
-      Check(zeDeviceGet(candidate, &device_count, devices.data()), "zeDeviceGet");
-      for (auto candidate_device : devices) {
-        ze_device_properties_t properties{};
-        properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-        Check(zeDeviceGetProperties(candidate_device, &properties), "zeDeviceGetProperties");
-        if (properties.type == ZE_DEVICE_TYPE_GPU) {
-          driver = candidate;
-          device = candidate_device;
-          break;
-        }
-      }
-      if (device != nullptr) break;
-    }
-    if (device == nullptr) throw std::runtime_error("no Level Zero GPU found");
-
-    ze_context_desc_t context_desc{};
-    context_desc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
-    ze_context_handle_t context = nullptr;
-    Check(zeContextCreate(driver, &context_desc, &context), "zeContextCreate");
-    ze_module_desc_t module_desc{};
-    module_desc.stype = ZE_STRUCTURE_TYPE_MODULE_DESC;
-    module_desc.format = ZE_MODULE_FORMAT_IL_SPIRV;
-    module_desc.inputSize = binary.size();
-    module_desc.pInputModule = reinterpret_cast<const uint8_t*>(binary.data());
-    ze_module_handle_t module = nullptr;
-    Check(zeModuleCreate(context, device, &module_desc, &module, nullptr), "zeModuleCreate");
-    ze_kernel_desc_t kernel_desc{};
-    kernel_desc.stype = ZE_STRUCTURE_TYPE_KERNEL_DESC;
-    kernel_desc.pKernelName = "GEMM";
-    ze_kernel_handle_t kernel = nullptr;
-    Check(zeKernelCreate(module, &kernel_desc, &kernel), "zeKernelCreate");
-
-    constexpr uint32_t size = 2048;
-    constexpr uint32_t repeats = 20;
-    constexpr size_t bytes = static_cast<size_t>(size) * size * sizeof(float);
-    std::vector<float> a(size * size, 0.128f);
-    std::vector<float> b(size * size, 0.256f);
-    std::vector<float> c(size * size);
-    ze_device_mem_alloc_desc_t alloc_desc{};
-    alloc_desc.stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC;
-    void* device_a = nullptr;
-    void* device_b = nullptr;
-    void* device_c = nullptr;
-    Check(zeMemAllocDevice(context, &alloc_desc, bytes, 64, device, &device_a),
-          "zeMemAllocDevice(a)");
-    Check(zeMemAllocDevice(context, &alloc_desc, bytes, 64, device, &device_b),
-          "zeMemAllocDevice(b)");
-    Check(zeMemAllocDevice(context, &alloc_desc, bytes, 64, device, &device_c),
-          "zeMemAllocDevice(c)");
-    Check(zeKernelSetArgumentValue(kernel, 0, sizeof(device_a), &device_a),
-          "zeKernelSetArgumentValue(a)");
-    Check(zeKernelSetArgumentValue(kernel, 1, sizeof(device_b), &device_b),
-          "zeKernelSetArgumentValue(b)");
-    Check(zeKernelSetArgumentValue(kernel, 2, sizeof(device_c), &device_c),
-          "zeKernelSetArgumentValue(c)");
-    Check(zeKernelSetArgumentValue(kernel, 3, sizeof(size), &size),
-          "zeKernelSetArgumentValue(size)");
-
-    uint32_t group_x = 0, group_y = 0, group_z = 0;
-    Check(zeKernelSuggestGroupSize(kernel, size, size, 1, &group_x, &group_y, &group_z),
-          "zeKernelSuggestGroupSize");
-    if (size % group_x != 0 || size % group_y != 0) {
-      throw std::runtime_error("unsupported group size");
-    }
-    Check(zeKernelSetGroupSize(kernel, group_x, group_y, group_z), "zeKernelSetGroupSize");
-
-    uint32_t group_count = 0;
-    Check(zeDeviceGetCommandQueueGroupProperties(device, &group_count, nullptr),
-          "zeDeviceGetCommandQueueGroupProperties(count)");
-    std::vector<ze_command_queue_group_properties_t> groups(group_count);
-    for (auto& group : groups) group.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_GROUP_PROPERTIES;
-    Check(zeDeviceGetCommandQueueGroupProperties(device, &group_count, groups.data()),
-          "zeDeviceGetCommandQueueGroupProperties");
-    uint32_t ordinal = group_count;
-    for (uint32_t index = 0; index < group_count; ++index) {
-      if (groups[index].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
-        ordinal = index;
-        break;
-      }
-    }
-    if (ordinal == group_count) throw std::runtime_error("no compute queue group");
-
-    ze_command_list_desc_t list_desc{};
-    list_desc.stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC;
-    list_desc.commandQueueGroupOrdinal = ordinal;
-    ze_command_list_handle_t list = nullptr;
-    Check(zeCommandListCreate(context, device, &list_desc, &list), "zeCommandListCreate");
-    Check(zeCommandListAppendMemoryCopy(list, device_a, a.data(), bytes, nullptr, 0, nullptr),
-          "zeCommandListAppendMemoryCopy(a)");
-    Check(zeCommandListAppendMemoryCopy(list, device_b, b.data(), bytes, nullptr, 0, nullptr),
-          "zeCommandListAppendMemoryCopy(b)");
-    ze_group_count_t dispatch{size / group_x, size / group_y, 1};
-    for (uint32_t index = 0; index < repeats; ++index) {
-      Check(zeCommandListAppendLaunchKernel(list, kernel, &dispatch, nullptr, 0, nullptr),
-            "zeCommandListAppendLaunchKernel");
-    }
-    Check(zeCommandListAppendMemoryCopy(list, c.data(), device_c, bytes, nullptr, 0, nullptr),
-          "zeCommandListAppendMemoryCopy(c)");
-    Check(zeCommandListClose(list), "zeCommandListClose");
-
-    ze_command_queue_desc_t queue_desc{};
-    queue_desc.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC;
-    queue_desc.ordinal = ordinal;
-    ze_command_queue_handle_t queue = nullptr;
-    Check(zeCommandQueueCreate(context, device, &queue_desc, &queue), "zeCommandQueueCreate");
-    Check(zeCommandQueueExecuteCommandLists(queue, 1, &list, nullptr),
-          "zeCommandQueueExecuteCommandLists");
-    Check(zeCommandQueueSynchronize(queue, UINT64_MAX), "zeCommandQueueSynchronize");
-
-    const float expected = 0.128f * 0.256f * size;
-    if (std::fabs(c.front() - expected) > 0.01f || std::fabs(c.back() - expected) > 0.01f) {
-      throw std::runtime_error("GEMM output mismatch");
-    }
-    std::cout << "Level Zero GEMM: " << repeats << " launches, valid output " << c.front() << '\n';
-
-    Check(zeCommandQueueDestroy(queue), "zeCommandQueueDestroy");
-    Check(zeCommandListDestroy(list), "zeCommandListDestroy");
-    Check(zeMemFree(context, device_a), "zeMemFree(a)");
-    Check(zeMemFree(context, device_b), "zeMemFree(b)");
-    Check(zeMemFree(context, device_c), "zeMemFree(c)");
-    Check(zeKernelDestroy(kernel), "zeKernelDestroy");
-    Check(zeModuleDestroy(module), "zeModuleDestroy");
-    Check(zeContextDestroy(context), "zeContextDestroy");
-  } catch (const std::exception& error) {
-    std::cerr << error.what() << '\n';
-    return 1;
-  }
-}
diff --git a/sdk/samples/pc_sampling_profiler/launcher.cc b/sdk/samples/pc_sampling_profiler/launcher.cc
deleted file mode 100644
index df825e8c..00000000
--- a/sdk/samples/pc_sampling_profiler/launcher.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <unistd.h>
-
-#include <cerrno>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <string>
-
-namespace {
-
-constexpr uint32_t kMinSamplingPeriodNs = 1'000;
-constexpr uint32_t kMaxSamplingPeriodNs = 10'000'000;
-
-void Usage(const char* name) {
-  std::cout << "Usage: " << name << " [options] -- <application> [arguments...]" << std::endl;
-  std::cout << "\nOptions:" << std::endl;
-  std::cout << "  --period [-p] <ns>  Sampling period in nanoseconds (range: "
-            << kMinSamplingPeriodNs << "-" << kMaxSamplingPeriodNs << ")" << std::endl;
-  std::cout << "  --output [-o] <file>  Write stall data to <file> instead of standard error"
-            << std::endl;
-  std::cout << "  --help [-h]         Display this help message" << std::endl;
-  std::cout << "\nExample:" << std::endl;
-  std::cout << "  " << name << " -- ./pc_sampling_profiler_l0_gemm ./gemm.spv" << std::endl;
-  std::cout << "  " << name << " -- ./pc_sampling_profiler_gemm --size 2048 --repeat 3"
-            << std::endl;
-  std::cout << "  " << name << " -p 100000 -o stalls.txt -- ./my_application --arg value"
-            << std::endl;
-}
-
-bool ParsePeriod(const char* argument, uint32_t* result) {
-  char* end = nullptr;
-  const unsigned long value = std::strtoul(argument, &end, 10);
-  if (end == argument || *end != '\0' || value < kMinSamplingPeriodNs ||
-      value > kMaxSamplingPeriodNs) {
-    return false;
-  }
-  *result = static_cast<uint32_t>(value);
-  return true;
-}
-
-}  // namespace
-
-int main(int argc, char* argv[]) {
-  int target_index = 0;
-  unsetenv("PTI_PC_SAMPLING_PERIOD_NS");
-  unsetenv("PTI_PC_SAMPLING_OUTPUT");
-
-  for (int index = 1; index < argc; ++index) {
-    const char* argument = argv[index];
-    if (std::strcmp(argument, "--") == 0) {
-      target_index = index + 1;
-      break;
-    }
-    if (std::strcmp(argument, "-h") == 0 || std::strcmp(argument, "--help") == 0) {
-      Usage(argv[0]);
-      return EXIT_SUCCESS;
-    }
-    if (std::strcmp(argument, "-p") == 0 || std::strcmp(argument, "--period") == 0) {
-      uint32_t period = 0;
-      if (++index >= argc || !ParsePeriod(argv[index], &period)) {
-        std::cerr << "Error: --period requires a value in range [" << kMinSamplingPeriodNs << ", "
-                  << kMaxSamplingPeriodNs << "] ns" << std::endl;
-        Usage(argv[0]);
-        return EXIT_FAILURE;
-      }
-      setenv("PTI_PC_SAMPLING_PERIOD_NS", std::to_string(period).c_str(), 1);
-      continue;
-    }
-    if (std::strcmp(argument, "-o") == 0 || std::strcmp(argument, "--output") == 0) {
-      if (++index >= argc || argv[index][0] == '\0') {
-        std::cerr << "Error: --output requires a file path" << std::endl;
-        Usage(argv[0]);
-        return EXIT_FAILURE;
-      }
-      setenv("PTI_PC_SAMPLING_OUTPUT", argv[index], 1);
-      continue;
-    }
-
-    std::cerr << "Error: unknown option '" << argument << "'" << std::endl;
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  if (target_index == 0 || target_index >= argc) {
-    std::cerr << "Error: expected an application after --" << std::endl;
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  if (access(PC_SAMPLING_COLLECTOR_PATH, R_OK) != 0) {
-    std::cerr << "Error: collector library '" << PC_SAMPLING_COLLECTOR_PATH
-              << "' is not readable: " << std::strerror(errno) << std::endl;
-    return EXIT_FAILURE;
-  }
-
-  const char* previous_preload = std::getenv("LD_PRELOAD");
-  std::string preload = PC_SAMPLING_COLLECTOR_PATH;
-  if (previous_preload != nullptr && previous_preload[0] != '\0') {
-    preload += ":";
-    preload += previous_preload;
-  }
-
-  setenv("LD_PRELOAD", preload.c_str(), 1);
-  // An inherited owner PID would keep the target from sampling; exec keeps this PID for it.
-  unsetenv("PTI_PC_SAMPLING_PID");
-
-  execvp(argv[target_index], argv + target_index);
-  std::cerr << "Error: failed to execute '" << argv[target_index] << "': " << std::strerror(errno)
-            << std::endl;
-  return EXIT_FAILURE;
-}
diff --git a/sdk/samples/pc_sampling_profiler/pytorch_train.py b/sdk/samples/pc_sampling_profiler/pytorch_train.py
deleted file mode 100644
index 614e56f0..00000000
--- a/sdk/samples/pc_sampling_profiler/pytorch_train.py
+++ /dev/null
@@ -1,52 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-import sys
-import time
-
-try:
-    import torch
-    from torch import nn
-except ModuleNotFoundError as e:
-    if e.name != "torch":
-        raise
-    print(f"PyTorch is not installed for {sys.executable}")
-    sys.exit(77)
-
-if not torch.xpu.is_available():
-    print("PyTorch XPU device is not available")
-    sys.exit(77)
-
-device = "xpu"
-torch.manual_seed(0)
-
-model = nn.Sequential(
-    nn.Conv2d(3, 32, 3, padding=1),
-    nn.ReLU(),
-    nn.MaxPool2d(2),
-    nn.Conv2d(32, 64, 3, padding=1),
-    nn.ReLU(),
-    nn.MaxPool2d(2),
-    nn.Flatten(),
-    nn.Linear(64 * 16 * 16, 256),
-    nn.ReLU(),
-    nn.Linear(256, 10),
-).to(device)
-optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
-loss_fn = nn.CrossEntropyLoss()
-
-inputs = torch.randn(128, 3, 64, 64, device=device)
-targets = torch.randint(0, 10, (128,), device=device)
-
-start = time.perf_counter()
-for _ in range(50):
-    optimizer.zero_grad()
-    loss = loss_fn(model(inputs), targets)
-    loss.backward()
-    optimizer.step()
-torch.xpu.synchronize()
-print(
-    f"PyTorch XPU training: loss {loss.item():.4f}, {time.perf_counter() - start:.2f} s"
-)
diff --git a/sdk/samples/samples_utilities/metrics_utils.h b/sdk/samples/samples_utilities/metrics_utils.h
deleted file mode 100644
index 885a5a09..00000000
--- a/sdk/samples/samples_utilities/metrics_utils.h
+++ /dev/null
@@ -1,675 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef METRICS_UTILS_H_
-#define METRICS_UTILS_H_
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wignored-attributes"
-#endif
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/pattern_formatter.h>
-#include <spdlog/sinks/basic_file_sink.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <iomanip>
-#include <random>
-
-#include "pti/pti_metrics.h"
-#include "samples_utils.h"
-#include "utils.h"
-
-namespace metrics_utils {
-
-inline std::string GetGroupType(pti_metrics_group_type type) {
-  std::string flag_name = "";
-  if (type & PTI_METRIC_GROUP_TYPE_EVENT_BASED) {
-    flag_name = "EVENT";
-  }
-
-  if (type & PTI_METRIC_GROUP_TYPE_TIME_BASED) {
-    if (!flag_name.empty()) flag_name += "|";
-    flag_name += "TIME";
-  }
-
-  if (!flag_name.empty()) {
-    return flag_name;
-  }
-
-  return "UNKNOWN";
-}
-
-inline std::string GetMetricType(pti_metric_type type) {
-  switch (type) {
-    case PTI_METRIC_TYPE_DURATION:
-      return "DURATION";
-    case PTI_METRIC_TYPE_EVENT:
-      return "EVENT";
-    case PTI_METRIC_TYPE_EVENT_WITH_RANGE:
-      return "EVENT_WITH_RANGE";
-    case PTI_METRIC_TYPE_THROUGHPUT:
-      return "THROUGHPUT";
-    case PTI_METRIC_TYPE_TIMESTAMP:
-      return "TIMESTAMP";
-    case PTI_METRIC_TYPE_FLAG:
-      return "FLAG";
-    case PTI_METRIC_TYPE_RATIO:
-      return "RATIO";
-    case PTI_METRIC_TYPE_RAW:
-      return "RAW";
-    case PTI_METRIC_TYPE_IP:
-      return "IP";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline std::string GetMetricValueType(pti_metric_value_type type) {
-  switch (type) {
-    case PTI_METRIC_VALUE_TYPE_UINT32:
-      return "UINT32";
-    case PTI_METRIC_VALUE_TYPE_UINT64:
-      return "UINT64";
-    case PTI_METRIC_VALUE_TYPE_FLOAT32:
-      return "FLOAT32";
-    case PTI_METRIC_VALUE_TYPE_FLOAT64:
-      return "FLOAT64";
-    case PTI_METRIC_VALUE_TYPE_BOOL8:
-      return "BOOL8";
-    case PTI_METRIC_VALUE_TYPE_STRING:
-      return "STRING";
-    case PTI_METRIC_VALUE_TYPE_UINT8:
-      return "UINT8";
-    case PTI_METRIC_VALUE_TYPE_UINT16:
-      return "BOOL8";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline pti_device_handle_t GetDevice(uint32_t device_id) {
-  // Step1: discover available supported device count
-  uint32_t device_count = 0;
-  pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-  if (result != PTI_SUCCESS || device_count == 0) {
-    std::cerr << "Failed to discover supported devices" << std::endl;
-    return nullptr;  // exit function
-  }
-
-  // Step2: get available devices in device_buffer
-  std::vector<pti_device_properties_t> device_buffer(device_count);
-
-  result = ptiMetricsGetDevices(device_buffer.data(), &device_count);
-  if (result != PTI_SUCCESS || device_buffer.empty()) {
-    std::cerr << "Failed to discover supported devices" << std::endl;
-    return nullptr;  // exit function
-  }
-
-  pti_device_handle_t device_handle = nullptr;
-  if (device_id < device_count) {
-    device_handle = device_buffer[device_id]._handle;
-  }
-
-  return device_handle;
-}
-
-inline pti_metrics_group_handle_t FindMetricGroup(pti_device_handle_t device_handle,
-                                                  std::string &group_name,
-                                                  pti_metrics_group_type group_type) {
-  if (device_handle == nullptr) {
-    return nullptr;
-  }
-
-  uint32_t group_count = 0;
-  pti_result result = ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count);
-  if (result != PTI_SUCCESS || group_count == 0) {
-    std::cerr << "Failed to discover metric groups on specified device:" << std::endl;
-    return nullptr;
-  }
-
-  std::vector<pti_metrics_group_properties_t> groups_buffer(group_count);
-
-  result = ptiMetricsGetMetricGroups(device_handle, groups_buffer.data(), &group_count);
-  if (result != PTI_SUCCESS || group_count == 0 || groups_buffer.empty()) {
-    std::cerr << "Failed to discover metric groups" << std::endl;
-    return nullptr;
-  }
-
-  pti_metrics_group_handle_t group_handle = nullptr;
-  // Iterate through metric groups
-  for (uint32_t i = 0; i < group_count; i++) {
-    if (group_name == groups_buffer[i]._name && groups_buffer[i]._type == group_type) {
-      group_handle = groups_buffer[i]._handle;
-      break;
-    }
-  }
-
-  return group_handle;
-}
-
-inline std::string PrintTypedValue(const pti_value_t value, pti_metric_value_type type,
-                                   uint8_t precision = 2) {
-  std::stringstream stream;
-  switch (type) {
-    case PTI_METRIC_VALUE_TYPE_UINT32:
-      return std::to_string(value.ui32);
-    case PTI_METRIC_VALUE_TYPE_UINT64:
-      return std::to_string(value.ui64);
-    case PTI_METRIC_VALUE_TYPE_FLOAT32:
-      stream << std::fixed << std::setprecision(precision) << value.fp32;
-      return stream.str();
-    case PTI_METRIC_VALUE_TYPE_FLOAT64:
-      stream << std::fixed << std::setprecision(precision) << value.fp64;
-      return stream.str();
-    case PTI_METRIC_VALUE_TYPE_BOOL8:
-      return std::to_string(static_cast<uint32_t>(value.b8));
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline bool CompareFiles(const std::string &filename1, const std::string &filename2) {
-  std::ifstream file1(filename1, std::ifstream::binary | std::ifstream::ate);
-  std::ifstream file2(filename2, std::ifstream::binary | std::ifstream::ate);
-
-  bool match = false;
-  if (file1.fail() || file2.fail()) {
-    // files not available for comparison
-    return true;
-  }
-  file1.seekg(0, std::ifstream::end);
-  file2.seekg(0, std::ifstream::end);
-  if (file1.tellg() != file2.tellg()) {
-    match = false;  // sizes don't match
-  } else {
-    file1.seekg(0, std::ifstream::beg);
-    file2.seekg(0, std::ifstream::beg);
-    // compare content of both files
-    match =
-        std::equal(std::istreambuf_iterator<char>(file1.rdbuf()), std::istreambuf_iterator<char>(),
-                   std::istreambuf_iterator<char>(file2.rdbuf()));
-  }
-  std::cout << "file 1: " << filename1 << " and file 2: " << filename2;
-  if (match) {
-    std::cout << " match : Success" << std::endl;
-  } else {
-    std::cout << " don't match : Fail" << std::endl;
-  }
-  std::cout << "--------------------------------------" << std::endl;
-
-  return match;
-}
-
-inline void DeleteFile(const std::string &filename) {
-  try {
-    pti::utils::filesystem::remove(filename);
-  } catch (const pti::utils::filesystem::filesystem_error &err) {
-    std::cout << "filesystem error: " << err.what() << '\n';
-  }
-}
-
-class MetricsProfiler {
- private:
-  MetricsProfiler() {
-    configured_device_handle_ = nullptr;
-    configured_group_handle_ = nullptr;
-    data_checked_ = false;
-    data_valid_ = true;
-  }
-
- public:
-  MetricsProfiler(const MetricsProfiler &) = delete;
-  MetricsProfiler &operator=(const MetricsProfiler &) = delete;
-  MetricsProfiler(MetricsProfiler &&) = delete;
-  MetricsProfiler &operator=(MetricsProfiler &&) = delete;
-
-  ~MetricsProfiler() {
-    devices_.clear();
-    for (auto it = groups_.begin(); it != groups_.end(); it++) {
-      free(it->second._metric_properties);
-    }
-    groups_.clear();
-  }
-
-  // Initializes the metric collection by discovering devices that the metrics
-  // collection can be done on, the metric groups that each device supports
-  // and metrics in each metric group
-  // If log_metrics is true,
-  //  then function will also log discovered devices, metric groups
-  //  supported per device and metrics within each metric group.
-  //  if file_name is specified, a file with specified name is used for logging
-  //  if fine_name is empty, function will log to console
-  bool InitializeMetricsCollection(bool log_metrics = false, std::string filename = std::string()) {
-    // Step1: discover available supported devices
-    uint32_t device_count = 0;
-    pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-    if (result != PTI_SUCCESS || device_count == 0) {
-      std::cerr << "Failed to discover supported devices" << std::endl;
-      return false;
-    }
-
-    std::shared_ptr<spdlog::logger> logger = utils::GetLogStream(log_metrics, std::move(filename));
-
-    std::vector<pti_device_properties_t> device_buffer(device_count);
-
-    result = ptiMetricsGetDevices(device_buffer.data(), &device_count);
-    if (result != PTI_SUCCESS || device_buffer.empty()) {
-      std::cerr << "Failed to discover supported devices" << std::endl;
-      return false;
-    }
-
-    std::stringstream out;
-    // Iterate through devices
-    for (uint32_t i = 0; i < device_count; i++) {
-      devices_[device_buffer[i]._handle] = device_buffer[i];
-      out << "\nDEVICE(" << i << ")" << "-> handle: "
-          << std::to_string((unsigned long long)(void **)(device_buffer[i]._handle))
-          << " | model name: " << device_buffer[i]._model_name << " | dbdf: ["
-          << +device_buffer[i]._address._domain << ":" << +device_buffer[i]._address._bus << ":"
-          << +device_buffer[i]._address._device << ":" << +device_buffer[i]._address._function
-          << "]";
-
-      std::string uuid = samples_utils::StringifyUuid(device_buffer[i]._uuid, " | UUID: ");
-
-      out << uuid << std::endl;
-
-      // Step2: discover available metric groups
-      uint32_t group_count = 0;
-      result = ptiMetricsGetMetricGroups(device_buffer[i]._handle, nullptr, &group_count);
-      if (result != PTI_SUCCESS || group_count == 0) {
-        std::cerr << "Failed to discover metric groups on device:" << i << std::endl;
-        continue;  // Try next device
-      }
-
-      std::vector<pti_metrics_group_properties_t> groups_buffer(group_count);
-
-      result =
-          ptiMetricsGetMetricGroups(device_buffer[i]._handle, groups_buffer.data(), &group_count);
-      if (result != PTI_SUCCESS || group_count == 0 || groups_buffer.empty()) {
-        std::cerr << "Failed to discover metric groups" << std::endl;
-        continue;  // Try next device
-      }
-
-      // Iterate through metric groups
-      for (uint32_t j = 0; j < group_count; j++) {
-        out << "\t METRIC GROUP(" << j << ")" << "-> handle: "
-            << std::to_string((unsigned long long)(void **)(groups_buffer[j]._handle))
-            << " | name: " << groups_buffer[j]._name
-            << " | description: " << groups_buffer[j]._description << std::endl
-            << "\t\t | type: " << groups_buffer[j]._type << "["
-            << GetGroupType(groups_buffer[j]._type) << "]"
-            << " | metric count: " << groups_buffer[j]._metric_count
-            << " | domain: " << groups_buffer[j]._domain << std::endl;
-
-        // Step3: discover available metrics in metric group
-        if (groups_buffer[i]._metric_count == 0) {
-          std::cerr << "Failed to discover metrics in metric group:" << j << " on device:" << i
-                    << std::endl;
-          continue;  // Try next metric group
-        }
-
-        groups_buffer[j]._metric_properties = (pti_metric_properties_t *)malloc(
-            sizeof(pti_metric_properties_t) * groups_buffer[j]._metric_count);
-
-        result = ptiMetricsGetMetricsProperties(groups_buffer[j]._handle,
-                                                groups_buffer[j]._metric_properties);
-
-        if (result != PTI_SUCCESS || groups_buffer[j]._metric_properties == nullptr) {
-          std::cerr << "Failed to discover metrics in metric group:" << j << " on device: " << i
-                    << std::endl;
-          free(groups_buffer[j]._metric_properties);
-          continue;  // Try next metric group
-        }
-        groups_[groups_buffer[j]._handle] = groups_buffer[j];
-        // Iterate through metrics
-        for (uint32_t k = 0; k < groups_buffer[j]._metric_count; k++) {
-          out << "\t\t\t METRIC(" << k << ")" << "-> handle: "
-              << std::to_string(
-                     (unsigned long long)(void **)(groups_buffer[j]._metric_properties[k]._handle))
-              << " | name: " << groups_buffer[j]._metric_properties[k]._name
-              << " | description: " << groups_buffer[j]._metric_properties[k]._description
-              << std::endl
-              << "\t\t\t\t | metric type: " << groups_buffer[j]._metric_properties[k]._metric_type
-              << "[" << GetMetricType(groups_buffer[j]._metric_properties[k]._metric_type) << "]"
-              << " | value type: " << groups_buffer[j]._metric_properties[k]._value_type << "["
-              << GetMetricValueType(groups_buffer[j]._metric_properties[k]._value_type) << "]"
-              << " | units: " << groups_buffer[j]._metric_properties[k]._units << std::endl;
-        }
-      }
-    }
-    logger->info(out.str());
-    logger->flush();
-    return true;
-  }
-
-  // configure the metric groups for collection
-  //  if log_data is true,
-  //  if filename is specified, then the library will log calculated data to the specified file
-  //  name when Calculate API is called if filename is not specified, the the library will log
-  //  calculated data to console when calculate API is called
-  bool ConfigureMetricGroups(std::string &group_name, pti_metrics_group_type group_type,
-                             bool log_data = false, std::string filename = std::string()) {
-    // Basic group info
-    uint32_t group_count = 1;
-
-    // Setup env vars
-    if (log_data) {
-      utils::SetEnv("PTI_LogToFile", "1");
-      std::cout << "Environment variable PTI_LogToFile set to 1" << std::endl;
-
-      if (filename != "") {
-        utils::SetEnv("PTI_LogFileName", filename.c_str());
-        std::cout << "Environment variable PTI_LogFileName set to " << filename << std::endl;
-      }
-    }
-
-    // Get a device handle
-    configured_device_handle_ = GetDevice(0);  // first device
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "Can't find a supported device" << std::endl;
-      return false;
-    }
-
-    // Get group handle
-    configured_group_handle_ = FindMetricGroup(configured_device_handle_, group_name, group_type);
-    pti_metrics_group_handle_t groups[] = {configured_group_handle_};
-    if (groups[0] == nullptr) {
-      std::cerr << "Can't find metric group on specified device" << std::endl;
-      return false;
-    }
-
-    pti_metrics_group_collection_params_t config_collection_params{};
-    config_collection_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-    config_collection_params._group_handle = configured_group_handle_;
-    config_collection_params._sampling_interval = 100000;  // ns
-    std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer = {
-        config_collection_params};
-    if (ptiMetricsConfigureCollection(configured_device_handle_,
-                                      config_collection_params_buffer.data(),
-                                      group_count) != PTI_SUCCESS) {
-      std::cerr << "Failed to configure collection" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  bool StartCollection() {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "Start: Invalid device handle" << std::endl;
-      return false;
-    }
-
-    if (ptiMetricsStartCollection(configured_device_handle_) != PTI_SUCCESS) {
-      std::cerr << "Failed to start collection" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  bool StartCollectionPaused() {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "StartPaused: Invalid device handle" << std::endl;
-      return false;
-    }
-
-    if (ptiMetricsStartCollectionPaused(configured_device_handle_) != PTI_SUCCESS) {
-      std::cerr << "Failed to start collection in paused mode" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  // Not implemented yet
-  bool PauseCollection() {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "Pause: Invalid device handle" << std::endl;
-      return false;
-    }
-
-    if (ptiMetricsPauseCollection(configured_device_handle_) != PTI_SUCCESS) {
-      std::cerr << "Failed to pause collection" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  bool ResumeCollection() {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "Resume: Invalid device handle" << std::endl;
-      return false;
-    }
-
-    if (ptiMetricsResumeCollection(configured_device_handle_) != PTI_SUCCESS) {
-      std::cerr << "Failed to resume collection" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  bool StopCollection() {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "Stop: Invalid device handle" << std::endl;
-      return false;
-    }
-
-    if (ptiMetricsStopCollection(configured_device_handle_) != PTI_SUCCESS) {
-      std::cerr << "Failed to stop collection" << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  // Get Calculated data from the collection run
-  // If log_data is true,
-  //  then function will also log calculated data.
-  //  if file_name is specified, a file with specified name is used for logging
-  //  if fine_name is empty, function will log to std out
-  bool GetCalculatedData(bool log_data = false, std::string filename = std::string()) {
-    if (configured_device_handle_ == nullptr) {
-      std::cerr << "In " << __func__ << ", configured_device_handle_ is null" << std::endl;
-      return false;
-    }
-    uint32_t total_values_count = 0;
-    pti_result result = ptiMetricsGetCalculatedData(
-        configured_device_handle_, configured_group_handle_, nullptr, &total_values_count);
-    if (result != PTI_SUCCESS || total_values_count == 0) {
-      std::cerr << "In " << __func__ << ", ptiMetricsGetCalculatedData returned "
-                << ptiResultTypeToString(result) << ",  total_values_count = " << total_values_count
-                << std::endl;
-      return false;
-    }
-
-    std::vector<pti_value_t> metrics_values_buffer(total_values_count);
-
-    result = ptiMetricsGetCalculatedData(configured_device_handle_, configured_group_handle_,
-                                         metrics_values_buffer.data(), &total_values_count);
-
-    if (result != PTI_SUCCESS || total_values_count == 0 || metrics_values_buffer.empty()) {
-      std::cerr << "In " << __func__ << ", failed to capture collected data, "
-                << "ptiMetricsGetCalculatedData returned " << ptiResultTypeToString(result)
-                << std::endl;
-      return false;
-    }
-
-    if (configured_group_handle_ == nullptr ||
-        groups_.find(configured_group_handle_) == groups_.end()) {
-      std::cerr << "Failed to process collected data" << std::endl;
-      return false;
-    }
-
-    pti_metrics_group_properties_t collected_group = groups_[configured_group_handle_];
-
-    if (collected_group._metric_properties == nullptr) {
-      std::cerr << "Failed to process collected data: no metrics properties found in metric group"
-                << std::endl;
-      return false;
-    }
-
-    std::string group_name = collected_group._name;
-    std::string str = "";
-    uint32_t buffer_idx = 0;
-    uint64_t ts = 0;
-    uint32_t per_sample_values_count = collected_group._metric_count;
-    uint32_t sample_count = total_values_count / per_sample_values_count;
-
-    if (log_data && !filename.empty()) {
-      std::cout << "logging to Filename: " << filename << std::endl;
-    }
-
-    std::shared_ptr<spdlog::logger> logger = utils::GetLogStream(log_data, std::move(filename));
-
-    float activePercent = 0.0;
-    float stallPercent = 0.0;
-    float occupancyPercent = 0.0;
-    bool busy = false;
-    logger->info("{\n\t\"displayTimeUnit\": \"us\",\n\t\"traceEvents\": [");
-    for (uint32_t i = 0; i < sample_count; i++) {
-      if (buffer_idx != 0) {
-        str += ",";
-      }
-      str += " {\n\t\t\"args\": {\n";
-      activePercent = 0.0;
-      stallPercent = 0.0;
-      occupancyPercent = 0.0;
-      busy = false;
-      for (uint32_t j = 0; j < per_sample_values_count; j++) {
-        std::string metric_name;
-        std::string units;
-        pti_metric_value_type type;
-        metric_name = collected_group._metric_properties[j]._name;
-        units = collected_group._metric_properties[j]._units;
-        type = collected_group._metric_properties[j]._value_type;
-        if (units == "percent") {
-          units = "%";
-        }
-        if (!units.empty() && units != "(null)") {
-          metric_name += "[" + units + "]";
-        }
-        pti_value_t value = metrics_values_buffer[buffer_idx++];
-        if (metric_name.find("QueryBeginTime") != std::string::npos ||
-            metric_name.find("StartTimestamp") != std::string::npos) {  // Added for trace groups
-          ts = value.ui64;
-        } else {
-          if (metric_name.find("StopTimestamp") != std::string::npos) {
-            value.ui64 = value.ui64 / 1000;  // convert to us
-          }
-          if (j != 0) {
-            str += ",\n";
-          }
-          str += "\t\t\t\"" + metric_name + "\": " + PrintTypedValue(value, type);
-
-          // data validation
-          if (metric_name.find("XVE_STALL") != std::string::npos) {
-            stallPercent = static_cast<float>(value.fp32);
-          } else if (metric_name.find("XVE_ACTIVE") != std::string::npos) {
-            activePercent = static_cast<float>(value.fp32);
-          } else if (metric_name.find("OCCUPANCY_ALL") != std::string::npos) {
-            occupancyPercent = static_cast<float>(value.fp32);
-          } else if (metric_name.find("XVE_BUSY") != std::string::npos) {
-            busy = static_cast<bool>(value.ui64);
-          }
-        }
-      }
-      // check that STALL % + ACTIVE % ~= OCCUPENCY % when OCCUPENCY %~= 100%+/-0.5%
-      if (busy) {
-        data_checked_ = true;
-        if (occupancyPercent < 100.5 && occupancyPercent > 99.5) {
-          if ((activePercent + stallPercent) > 99.5 && (activePercent + stallPercent) < 100.5) {
-            std::cout << "PASS: DATA VALID: ";
-          } else {
-            std::cout << "FAIL: DATA INVALID: ";
-            data_valid_ = false;
-          }
-          std::cout << std::fixed << std::setprecision(2) << "active percent:" << activePercent
-                    << "% + stall percent:" << stallPercent
-                    << "% ~= occupancy percent:" << occupancyPercent << "%" << std::endl;
-        }
-      }
-
-      str += "\n\t\t\t},\n";
-      str += "\t\t\t\"cat\": \"" + group_name + "\",\n";
-      str += "\t\t\t\"name\": \"" + group_name + "\",\n";
-      str += "\t\t\t\"ph\": \"C\",\n";
-      str += "\t\t\t\"pid\": 0,\n";
-      str += "\t\t\t\"tid\": 0,\n";
-      str += "\t\t\t\"ts\": " + std::to_string(ts / 1000) + "\n";
-      str += "\t\t}";
-    }
-
-    logger->info(str);
-    logger->info("\n\t]\n}\n");
-    logger->flush();
-    return true;
-  }
-
-  bool ValidateData() {
-    if (data_checked_) {
-      std::cout << "Data validity check";
-      if (data_valid_) {
-        std::cout << " : Success";
-      } else {
-        std::cout << " : Fail";
-      }
-      std::cout << std::endl << "--------------------------------------" << std::endl;
-    }
-    return data_checked_ ? data_valid_ : true;
-  }
-
-  bool ValidateDeviceUuid(uint8_t *uuid) {
-    if (devices_.find(configured_device_handle_) == devices_.end()) {
-      std::cout << "ERROR: can't find configured device" << std::endl;
-      return false;
-    }
-
-    auto device_uuid = devices_[configured_device_handle_]._uuid;
-    for (uint32_t i = 0; i < PTI_MAX_DEVICE_UUID_SIZE; i++) {
-      if (device_uuid[i] != uuid[i]) {
-        std::cout
-            << "Device used for metric data collection and the compute device are not equivalent"
-            << "Metric device: " << samples_utils::StringifyUuid(device_uuid, " | UUID: ")
-            << "Compute device: " << samples_utils::StringifyUuid(uuid, " | UUID: ") << " : Fail"
-            << std::endl
-            << "--------------------------------------" << std::endl;
-        return false;
-      }
-    }
-    std::cout << "Device used for metric data collection and the compute device are equivalent"
-              << samples_utils::StringifyUuid(uuid, " | UUID: ") << " : Success" << std::endl
-              << "--------------------------------------" << std::endl;
-    return true;
-  }
-
-  std::unordered_map<pti_device_handle_t, pti_device_properties_t> GetDevices() { return devices_; }
-
-  std::unordered_map<pti_metrics_group_handle_t, pti_metrics_group_properties_t> GetMetricGroups() {
-    return groups_;
-  }
-
-  pti_metrics_group_handle_t GetConfiguredMetricGroupHandle() { return configured_group_handle_; }
-
-  pti_device_handle_t GetConfiguredDeviceHandle() { return configured_device_handle_; }
-
- private:
-  std::unordered_map<pti_device_handle_t, pti_device_properties_t> devices_;
-  std::unordered_map<pti_metrics_group_handle_t, pti_metrics_group_properties_t> groups_;
-  pti_metrics_group_handle_t configured_group_handle_;
-  pti_device_handle_t configured_device_handle_;
-  bool data_checked_;
-  bool data_valid_;
-
- public:
-  inline static auto &MetricsProfilerInstance() {
-    static MetricsProfiler metrics_profiler{};
-    return metrics_profiler;
-  }
-};
-}  // namespace metrics_utils
-#endif
diff --git a/sdk/samples/samples_utilities/samples_c_utils.h b/sdk/samples/samples_utilities/samples_c_utils.h
deleted file mode 100644
index 74a71559..00000000
--- a/sdk/samples/samples_utilities/samples_c_utils.h
+++ /dev/null
@@ -1,274 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SAMPLES_C_UTILS_H_
-#define SAMPLES_C_UTILS_H_
-#include <inttypes.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_view.h"
-
-#define PTI_CHECK_SUCCESS(X)                                                                \
-  do {                                                                                      \
-    if (X != PTI_SUCCESS) {                                                                 \
-      fprintf(stderr, "PTI CALL FAILED: " #X " WITH ERROR %s\n", ptiResultTypeToString(X)); \
-      exit(EXIT_FAILURE);                                                                   \
-    }                                                                                       \
-  } while (0)
-
-void PrintUuidC(uint8_t* uuid, const char* prefix) {
-  printf("%s", prefix);
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-}
-
-void DumpRecordKernel(pti_view_record_kernel* record, bool with_sycl_rec) {
-  if (NULL == record) return;
-
-  printf("Kernel Name: %s\n", record->_name);
-  printf("               Ze Kernel Append Time: %" PRIu64 " ns\n", record->_append_timestamp);
-  printf("               Ze Kernel Submit Time: %" PRIu64 " ns\n", record->_submit_timestamp);
-  printf("                Ze Kernel Start Time: %" PRIu64 " ns\n", record->_start_timestamp);
-  printf("                  Ze Kernel End Time: %" PRIu64 " ns\n", record->_end_timestamp);
-  printf("Kernel Queue Handle: %p\n", record->_queue_handle);
-  printf("Kernel Queue ID: %" PRIu64 "\n", record->_sycl_queue_id);
-  printf("Kernel CommandList Context Handle: %p\n", record->_context_handle);
-  printf("Kernel Id: %" PRIu64 "\n", record->_kernel_id);
-  printf("Correlation Id: %u\n", record->_correlation_id);
-  printf("Kernel Thread Id: %u\n", record->_thread_id);
-  if (with_sycl_rec) {
-    printf("         Sycl Kernel Task Begin Time: %" PRIu64 " ns\n",
-           record->_sycl_task_begin_timestamp);
-    printf("Sycl Kernel EnqueueKernel Begin Time: %" PRIu64 " ns\n",
-           record->_sycl_enqk_begin_timestamp);
-  }
-  printf("Kernel Execution Time: %" PRIu64 " ns\n",
-         record->_end_timestamp - record->_start_timestamp);
-  printf("Kernel File Name: %s:%" PRIu64 "\n", record->_source_file_name,
-         record->_source_line_number);
-  printf("Kernel Device: %s\n", record->_pci_address);
-
-  // Print UUID
-  printf("Kernel Device UUID: ");
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", record->_device_uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-
-  if (with_sycl_rec) {
-    printf("Kernel NodeID:InvocationID %" PRIu64 ":%u\n", record->_sycl_node_id,
-           record->_sycl_invocation_id);
-  }
-}
-
-void DumpRecordMemoryCopy(pti_view_record_memory_copy* record) {
-  if (NULL == record) return;
-
-  printf("Memory Op: %s\n", record->_name);
-  printf("Memory Device: %s\n", record->_pci_address);
-
-  // Print UUID
-  printf("Memory Device UUID: ");
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", record->_device_uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-
-  printf("Memory Op Execution Time: %" PRIu64 " ns\n",
-         record->_end_timestamp - record->_start_timestamp);
-  printf("               Memory Op Append Time: %" PRIu64 " ns\n", record->_append_timestamp);
-  printf("               Memory Op Submit Time: %" PRIu64 " ns\n", record->_submit_timestamp);
-  printf("                Memory Op Start Time: %" PRIu64 " ns\n", record->_start_timestamp);
-  printf("                  Memory Op End Time: %" PRIu64 " ns\n", record->_end_timestamp);
-  printf("Memory Op Queue Handle: %p\n", record->_queue_handle);
-  printf("Memory Op Queue ID: %" PRIu64 "\n", record->_sycl_queue_id);
-  printf("Memory Op CommandList Context Handle: %p\n", record->_context_handle);
-  printf("Memory Op Id: %" PRIu64 "\n", record->_mem_op_id);
-  printf("Memory Bytes Copied: %" PRIu64 "\n", record->_bytes);
-  printf("Memory Op Thread Id: %u\n", record->_thread_id);
-  printf("Correlation Id: %u\n", record->_correlation_id);
-  printf("Memory Copy Type: %s\n", ptiViewMemcpyTypeToString(record->_memcpy_type));
-  printf("Memory Copy Source: %s\n", ptiViewMemoryTypeToString(record->_mem_src));
-  printf("Memory Copy Destination: %s\n", ptiViewMemoryTypeToString(record->_mem_dst));
-}
-
-void DumpRecordMemoryCopyP2p(pti_view_record_memory_copy_p2p* record) {
-  if (NULL == record) return;
-
-  printf("Memory Op: %s\n", record->_name);
-  printf("Memory Source Device: %s\n", record->_src_pci_address);
-  printf("Memory Destination Device: %s\n", record->_dst_pci_address);
-
-  // Print source UUID
-  printf("Memory Source Device UUID: ");
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", record->_src_uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-
-  // Print destination UUID
-  printf("Memory Destination Device UUID: ");
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", record->_dst_uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-
-  printf("Memory Op Execution Time: %" PRIu64 " ns\n",
-         record->_end_timestamp - record->_start_timestamp);
-  printf("               Memory Op Append Time: %" PRIu64 " ns\n", record->_append_timestamp);
-  printf("               Memory Op Submit Time: %" PRIu64 " ns\n", record->_submit_timestamp);
-  printf("                Memory Op Start Time: %" PRIu64 " ns\n", record->_start_timestamp);
-  printf("                  Memory Op End Time: %" PRIu64 " ns\n", record->_end_timestamp);
-  printf("Memory Op Queue Handle: %p\n", record->_queue_handle);
-  printf("Memory Op Queue ID: %" PRIu64 "\n", record->_sycl_queue_id);
-  printf("Memory Op CommandList Context Handle: %p\n", record->_context_handle);
-  printf("Memory Op Id: %" PRIu64 "\n", record->_mem_op_id);
-  printf("Memory Bytes Copied: %" PRIu64 "\n", record->_bytes);
-  printf("Memory Op Thread Id: %u\n", record->_thread_id);
-  printf("Correlation Id: %u\n", record->_correlation_id);
-  printf("Memory Copy Type: %s\n", ptiViewMemcpyTypeToString(record->_memcpy_type));
-  printf("Memory Copy Source: %s\n", ptiViewMemoryTypeToString(record->_mem_src));
-  printf("Memory Copy Destination: %s\n", ptiViewMemoryTypeToString(record->_mem_dst));
-}
-
-void DumpRecordMemoryFill(pti_view_record_memory_fill* record) {
-  if (NULL == record) return;
-
-  printf("Memory Op: %s\n", record->_name);
-  printf("Memory Device: %s\n", record->_pci_address);
-
-  // Print UUID
-  printf("Memory Device UUID: ");
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    printf("%02x", record->_device_uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) printf("-");
-  }
-  printf("\n");
-
-  printf("Memory Op Execution Time: %" PRIu64 " ns\n",
-         record->_end_timestamp - record->_start_timestamp);
-  printf("               Memory Op Append Time: %" PRIu64 " ns\n", record->_append_timestamp);
-  printf("               Memory Op Submit Time: %" PRIu64 " ns\n", record->_submit_timestamp);
-  printf("               Memory Op Start Time: %" PRIu64 " ns\n", record->_start_timestamp);
-  printf("                  Memory Op End Time: %" PRIu64 " ns\n", record->_end_timestamp);
-  printf("Memory Op Queue Handle: %p\n", record->_queue_handle);
-  printf("Memory Op Queue ID: %" PRIu64 "\n", record->_sycl_queue_id);
-  printf("Memory Op CommandList Context Handle: %p\n", record->_context_handle);
-  printf("Memory Op Id: %" PRIu64 "\n", record->_mem_op_id);
-  printf("Memory Op Thread Id: %u\n", record->_thread_id);
-  printf("Memory Bytes Transferred: %" PRIu64 "\n", record->_bytes);
-  printf("Memory Value for Set: %" PRIu64 "\n", record->_value_for_set);
-  printf("Correlation Id: %u\n", record->_correlation_id);
-  printf("Memory Fill Type: %u\n", record->_mem_type);
-}
-
-void DumpRecordApi(pti_view_record_api* record) {
-  if (NULL == record) return;
-
-  const char* api_name = NULL;
-  pti_result result = ptiViewGetApiIdName(record->_api_group, record->_api_id, &api_name);
-  if (result != PTI_SUCCESS) {
-    printf("Error getting API name: %s\n", ptiResultTypeToString(result));
-    return;
-  }
-
-  printf("Api Function Name: %s\n", api_name);
-  printf("Api Function CBID: %u\n", record->_api_id);
-  printf("Api Start Time: %" PRIu64 " ns\n", record->_start_timestamp);
-  printf("  Api End Time: %" PRIu64 " ns\n", record->_end_timestamp);
-  printf("Api Process Id: %u\n", record->_process_id);
-  printf("Api Thread Id: %u\n", record->_thread_id);
-  printf("Api Correlation Id: %u\n", record->_correlation_id);
-  printf("Api Return: %u\n", record->_return_code);
-}
-
-void DumpRecordSynchronization(pti_view_record_synchronization* record) {
-  if (NULL == record) return;
-
-  switch (record->_synch_type) {
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_EXECUTION:
-      printf("Barrier Synch Type: Execution Barrier\n");
-      break;
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_MEMORY:
-      printf("Barrier Synch Type: Memory Coherency Barrier\n");
-      break;
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_FENCE:
-      printf("Fence Synch Type: Execution\n");
-      break;
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_EVENT:
-      printf("Event Synch Type: Host\n");
-      break;
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_LIST:
-      printf("CommandList Synch Type: Host\n");
-      break;
-    case PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_QUEUE:
-      printf("CommandQueue Synch Type: Host\n");
-      break;
-    default:
-      break;
-  }
-
-  printf("Synch Start Time: %" PRIu64 "\n", record->_start_timestamp);
-  printf("  Synch End Time: %" PRIu64 "\n", record->_end_timestamp);
-  printf("  Synch Duration: %" PRIu64 " ns\n", record->_end_timestamp - record->_start_timestamp);
-  printf("Synch Thread Id: %u\n", record->_thread_id);
-  printf("Synch Correlation Id: %u\n", record->_correlation_id);
-  printf("Synch BE Queue Handle: %p\n", record->_queue_handle);
-  printf("Synch BE Context Handle: %p\n", record->_context_handle);
-  printf("Synch BE Event Handle: %p\n", record->_event_handle);
-  printf("Synch BE Number Wait Events: %u\n", record->_number_wait_events);
-  printf("Synch Api Function CBID: %u\n", record->_api_id);
-  printf("Synch Api Group ID: %u\n", record->_api_group);
-  printf("Synch Api Return Code: %u\n", record->_return_code);
-
-  const char* api_name = NULL;
-  pti_result result = ptiViewGetApiIdName(PTI_API_GROUP_LEVELZERO, record->_api_id, &api_name);
-  if (result == PTI_SUCCESS) {
-    printf("Synch Api Function Name: %s\n", api_name);
-  }
-}
-
-void DumpRecordOverhead(pti_view_record_overhead* record) {
-  if (NULL == record) return;
-
-  printf("Overhead Kind : %s\n", ptiViewOverheadKindToString(record->_overhead_kind));
-  printf("Overhead Time Duration(ns): %" PRIu64 "\n", record->_overhead_duration_ns);
-  printf("Overhead Count: %" PRIu64 "\n", record->_overhead_count);
-  printf("Overhead Start Timestamp(ns): %" PRIu64 "\n", record->_overhead_start_timestamp_ns);
-  printf("Overhead End Timestamp(ns): %" PRIu64 "\n", record->_overhead_end_timestamp_ns);
-  printf("Overhead ThreadId: %u\n", record->_overhead_thread_id);
-}
-
-void DumpRecordExternalCorrelation(pti_view_record_external_correlation* record) {
-  if (NULL == record) return;
-
-  printf("External Correlation Kind : %u\n", record->_external_kind);
-  printf("Correlation Id: %u\n", record->_correlation_id);
-  printf("External Id: %" PRIu64 "\n", record->_external_id);
-}
-
-bool IsMonotonicUint64(const uint64_t* array, size_t count) {
-  if (array == NULL || count <= 1) {
-    return true;
-  }
-
-  for (size_t i = 1; i < count; ++i) {
-    if (array[i - 1] > array[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-#endif  // SAMPLES_C_UTILS_H_
diff --git a/sdk/samples/samples_utilities/samples_utils.h b/sdk/samples/samples_utilities/samples_utils.h
deleted file mode 100644
index d4405655..00000000
--- a/sdk/samples/samples_utilities/samples_utils.h
+++ /dev/null
@@ -1,557 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SAMPLES_UTILS_H_
-#define SAMPLES_UTILS_H_
-#include <cstddef>
-#include <iomanip>
-#include <iostream>
-#include <locale>
-#include <sstream>
-#include <stdexcept>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_version.h"
-#include "pti/pti_view.h"
-
-namespace samples_utils {
-#define PTI_THROW(X)                                                                      \
-  do {                                                                                    \
-    if (X != pti_result::PTI_SUCCESS) {                                                   \
-      std::string error_msg =                                                             \
-          "PTI CALL FAILED: " #X " WITH ERROR: " + std::string{ptiResultTypeToString(X)}; \
-      throw std::runtime_error(error_msg);                                                \
-    }                                                                                     \
-  } while (0)
-
-#define PTI_CHECK_SUCCESS(X)                                                            \
-  do {                                                                                  \
-    if (X != pti_result::PTI_SUCCESS) {                                                 \
-      std::cerr << "PTI CALL FAILED: " #X << " WITH ERROR " << ptiResultTypeToString(X) \
-                << std::endl;                                                           \
-      std::exit(EXIT_FAILURE);                                                          \
-    }                                                                                   \
-  } while (0)
-
-inline constexpr auto kDefaultPtiBufferAlignment = std::align_val_t{1};
-
-template <typename T>
-[[nodiscard]] inline T* AlignedAlloc(std::size_t size, std::align_val_t align) {
-  try {
-    return static_cast<T*>(::operator new(size, align));
-  } catch (const std::bad_alloc& e) {
-    std::cerr << "Alloc failed " << e.what() << '\n';
-    return nullptr;
-  }
-}
-
-template <typename T>
-inline void AlignedDealloc(T* buf_ptr, std::align_val_t align) {
-  try {
-    ::operator delete(buf_ptr, align);
-  } catch (...) {
-    std::cerr << "DeAlloc failed, abort" << '\n';
-    std::abort();
-  }
-}
-
-template <typename T>
-[[nodiscard]] inline T* AlignedAlloc(std::size_t size) {
-  return AlignedAlloc<T>(size, kDefaultPtiBufferAlignment);
-}
-
-template <typename T>
-inline void AlignedDealloc(T* buf_ptr) {
-  return AlignedDealloc<T>(buf_ptr, kDefaultPtiBufferAlignment);
-}
-
-// Helper class and function: formats an int with thousands separator
-// e.g. 1234567890 -> 1'234'567'890
-// when manually comparing timestamps in tests
-class ApostropheNumpunct : public std::numpunct<char> {
- protected:
-  char do_thousands_sep() const override { return '\''; }
-  std::string do_grouping() const override { return "\3"; }
-};
-
-template <typename T>
-inline std::string AposFormat(T value) {
-  static_assert(std::is_unsigned<T>::value, "Unsigned integer type required");
-  std::ostringstream oss;
-  static std::locale apostrophe_locale(std::locale::classic(), new ApostropheNumpunct);
-  oss.imbue(apostrophe_locale);
-  oss << value;
-  return oss.str();
-}
-
-template <typename... T>
-constexpr std::size_t ValidateTimestamps(T... args) {
-  using TimestampType = std::common_type_t<T...>;
-  constexpr auto count = sizeof...(args);
-  static_assert(count > 1, "Must provide more than one timestamp to validate");
-  std::size_t found_issues = 0;
-  TimestampType prev_stamp = 0;
-
-  // Use fold expressions to find issues with timestamps
-  // https://en.cppreference.com/w/cpp/language/fold
-  // this could probably be simplified if we do not care about the number of
-  // timestamp issues (we might be able to remove the lambda).
-  (
-      [&] {
-        auto next_stamp = args;
-        if (!(prev_stamp <= next_stamp)) {
-          found_issues++;
-        }
-        prev_stamp = next_stamp;
-      }(),
-      ...);
-  return found_issues;
-}
-
-//
-// Returns:    True  - if a_list passed in is a monotonically increasing sequence.
-//             False - if not.
-// Assumption: Operator <= is well defined for this type already.
-//
-template <typename T>
-inline bool IsMonotonic(std::initializer_list<T> a_list) {
-  bool current_state = true;
-  T previous = a_list.begin()[0];
-  for (auto item : a_list) {
-    current_state = current_state && (previous <= item);
-    if (!current_state) return false;
-    previous = item;
-  }
-  return true;
-}
-
-inline std::string StringifyUuid(uint8_t* uuid, std::string additional_string) {
-  std::stringstream sstream;
-  sstream << additional_string;
-  sstream << std::hex << std::setfill('0');
-  for (uint32_t i = 1; i <= PTI_MAX_DEVICE_UUID_SIZE; ++i) {
-    sstream << std::setw(2);
-    sstream << static_cast<uint16_t>(uuid[PTI_MAX_DEVICE_UUID_SIZE - i]);
-    if (i == 4 || i == 6 || i == 8 || i == 10) sstream << "-";
-  }
-  sstream << std::setfill(' ') << std::dec;
-  return sstream.str();
-}
-
-inline void PrintUuid(uint8_t* uuid, std::string additional_string) {
-  std::cout << StringifyUuid(uuid, std::move(additional_string)) << std::endl;
-}
-
-inline void DumpRecord(pti_view_record_kernel* record) {
-  if (nullptr == record) return;
-
-  std::cout << "Kernel Name: " << record->_name << '\n';
-  std::cout << "Kernel Execution Time: "
-            << AposFormat(record->_end_timestamp - record->_start_timestamp) << " ns" << '\n';
-  std::cout << "               Ze Kernel Append Time: " << AposFormat(record->_append_timestamp)
-            << " ns" << '\n';
-  std::cout << "               Ze Kernel Submit Time: " << AposFormat(record->_submit_timestamp)
-            << " ns" << '\n';
-  std::cout << "                Ze Kernel Start Time: " << AposFormat(record->_start_timestamp)
-            << " ns" << '\n';
-  std::cout << "                  Ze Kernel End Time: " << AposFormat(record->_end_timestamp)
-            << " ns" << '\n';
-  std::cout << "Kernel Queue Handle: " << record->_queue_handle << '\n';
-  std::cout << "Kernel Queue ID: " << record->_sycl_queue_id << '\n';
-  std::cout << "Kernel CommandList Context Handle: " << record->_context_handle << '\n';
-  std::cout << "Kernel Id: " << std::dec << record->_kernel_id << '\n';
-  std::cout << "Correlation Id: " << std::dec << record->_correlation_id << '\n';
-  std::cout << "Kernel Thread Id: " << std::dec << record->_thread_id << '\n';
-  std::cout << "         Sycl Kernel Task Begin Time: " << std::dec
-            << record->_sycl_task_begin_timestamp << " ns" << '\n';
-  std::cout << "Sycl Kernel EnqueueKernel Begin Time: " << std::dec
-            << record->_sycl_enqk_begin_timestamp << " ns" << '\n';
-  std::cout << "Kernel File Name: " << record->_source_file_name << ":"
-            << record->_source_line_number << '\n';
-  std::cout << "Kernel Device: " << record->_pci_address << '\n';
-  PrintUuid(record->_device_uuid, "Kernel Device UUID: ");
-  std::cout << "Kernel NodeID:InvocationID " << record->_sycl_node_id << ':'
-            << record->_sycl_invocation_id << '\n';
-}
-
-inline void DumpRecord(pti_view_record_kernel_v2* record) {
-  if (nullptr == record) return;
-  DumpRecord(reinterpret_cast<pti_view_record_kernel*>(record));
-  std::cout << "Device Handle: " << record->_device_handle << '\n';
-  std::cout << "Kernel engine ordinal: " << record->_engine_ordinal << '\n';
-  std::cout << "Kernel engine index: " << record->_engine_index << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_copy* record) {
-  if (nullptr == record) return;
-
-  std::cout << "Memory Op: " << record->_name << '\n';
-  std::cout << "Memory Device: " << record->_pci_address << '\n';
-  PrintUuid(record->_device_uuid, "Memory Device UUID: ");
-  std::cout << "Memory Op Execution Time: "
-            << AposFormat(record->_end_timestamp - record->_start_timestamp) << " ns" << '\n';
-  std::cout << "               Memory Op Append Time: " << AposFormat(record->_append_timestamp)
-            << " ns" << '\n';
-  std::cout << "               Memory Op Submit Time: " << AposFormat(record->_submit_timestamp)
-            << " ns" << '\n';
-  std::cout << "                Memory Op Start Time: " << AposFormat(record->_start_timestamp)
-            << " ns" << '\n';
-  std::cout << "                  Memory Op End Time: " << AposFormat(record->_end_timestamp)
-            << " ns" << '\n';
-  std::cout << "Memory Op Queue Handle: " << record->_queue_handle << '\n';
-  std::cout << "Memory Op Queue ID: " << record->_sycl_queue_id << '\n';
-  std::cout << "Memory Op CommandList Context Handle: " << record->_context_handle << '\n';
-  std::cout << "Memory Op Id: " << std::dec << record->_mem_op_id << '\n';
-  std::cout << "Memory Bytes Copied: " << std::dec << record->_bytes << '\n';
-  std::cout << "Memory Op Thread Id: " << std::dec << record->_thread_id << '\n';
-  std::cout << "Correlation Id: " << std::dec << record->_correlation_id << '\n';
-  std::cout << "Memory Copy Type: " << std::dec << ptiViewMemcpyTypeToString(record->_memcpy_type)
-            << '\n';
-  std::cout << "Memory Copy Source: " << std::dec << ptiViewMemoryTypeToString(record->_mem_src)
-            << '\n';
-  std::cout << "Memory Copy Destination: " << std::dec
-            << ptiViewMemoryTypeToString(record->_mem_dst) << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_copy_v2* record) {
-  if (nullptr == record) return;
-  DumpRecord(reinterpret_cast<pti_view_record_memory_copy*>(record));
-  std::cout << "Device Handle: " << record->_device_handle << '\n';
-  std::cout << "Memory Copy engine ordinal: " << record->_engine_ordinal << '\n';
-  std::cout << "Memory Copy engine index: " << record->_engine_index << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_copy_p2p* record) {
-  if (nullptr == record) return;
-
-  std::cout << "Memory Op: " << record->_name << '\n';
-  std::cout << "Memory Source Device: " << record->_src_pci_address << '\n';
-  std::cout << "Memory Destination Device: " << record->_dst_pci_address << '\n';
-  PrintUuid(record->_src_uuid, "Memory Source Device UUID: ");
-  PrintUuid(record->_dst_uuid, "Memory Destination Device UUID: ");
-  std::cout << "Memory Op Execution Time: " << record->_end_timestamp - record->_start_timestamp
-            << " ns" << '\n';
-  std::cout << "               Memory Op Append Time: " << AposFormat(record->_append_timestamp)
-            << " ns" << '\n';
-  std::cout << "               Memory Op Submit Time: " << AposFormat(record->_submit_timestamp)
-            << " ns" << '\n';
-  std::cout << "                Memory Op Start Time: " << AposFormat(record->_start_timestamp)
-            << " ns" << '\n';
-  std::cout << "                  Memory Op End Time: " << AposFormat(record->_end_timestamp)
-            << " ns" << '\n';
-  std::cout << "Memory Op Queue Handle: " << record->_queue_handle << '\n';
-  std::cout << "Memory Op Queue ID: " << record->_sycl_queue_id << '\n';
-  std::cout << "Memory Op CommandList Context Handle: " << record->_context_handle << '\n';
-  std::cout << "Memory Op Id: " << std::dec << record->_mem_op_id << '\n';
-  std::cout << "Memory Bytes Copied: " << std::dec << record->_bytes << '\n';
-  std::cout << "Memory Op Thread Id: " << std::dec << record->_thread_id << '\n';
-  std::cout << "Correlation Id: " << std::dec << record->_correlation_id << '\n';
-  std::cout << "Memory Copy Type: " << std::dec << ptiViewMemcpyTypeToString(record->_memcpy_type)
-            << '\n';
-  std::cout << "Memory Copy Source: " << std::dec << ptiViewMemoryTypeToString(record->_mem_src)
-            << '\n';
-  std::cout << "Memory Copy Destination: " << std::dec
-            << ptiViewMemoryTypeToString(record->_mem_dst) << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_copy_p2p_v2* record) {
-  if (nullptr == record) return;
-  DumpRecord(reinterpret_cast<pti_view_record_memory_copy_p2p*>(record));
-  std::cout << "Source Device Handle: " << record->_src_device_handle << '\n';
-  std::cout << "Destination Device Handle: " << record->_dst_device_handle << '\n';
-  std::cout << "Memory Copy engine ordinal: " << record->_engine_ordinal << '\n';
-  std::cout << "Memory Copy engine index: " << record->_engine_index << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_fill* record) {
-  if (nullptr == record) return;
-  std::cout << "Memory Op: " << record->_name << '\n';
-  std::cout << "Memory Device: " << record->_pci_address << '\n';
-  PrintUuid(record->_device_uuid, "Memory Device UUID: ");
-  std::cout << "Memory Op Execution Time: "
-            << AposFormat(record->_end_timestamp - record->_start_timestamp) << " ns" << '\n';
-  std::cout << "               Memory Op Append Time: " << AposFormat(record->_append_timestamp)
-            << " ns" << '\n';
-  std::cout << "               Memory Op Submit Time: " << AposFormat(record->_submit_timestamp)
-            << " ns" << '\n';
-  std::cout << "               Memory Op Start Time: " << AposFormat(record->_start_timestamp)
-            << " ns" << '\n';
-  std::cout << "                  Memory Op End Time: " << AposFormat(record->_end_timestamp)
-            << " ns" << '\n';
-  std::cout << "Memory Op Queue Handle: " << record->_queue_handle << '\n';
-  std::cout << "Memory Op Queue ID: " << record->_sycl_queue_id << '\n';
-  std::cout << "Memory Op CommandList Context Handle: " << record->_context_handle << '\n';
-  std::cout << "Memory Op Id: " << std::dec << record->_mem_op_id << '\n';
-  std::cout << "Memory Op Thread Id: " << std::dec << record->_thread_id << '\n';
-  std::cout << "Memory Bytes Transferred: " << record->_bytes << '\n';
-  std::cout << "Memory Value for Set: " << record->_value_for_set << '\n';
-  std::cout << "Correlation Id: " << std::dec << record->_correlation_id << '\n';
-  std::cout << "Memory Fill Type: " << std::dec << record->_mem_type << '\n';
-}
-
-inline void DumpRecord(pti_view_record_memory_fill_v2* record) {
-  if (nullptr == record) return;
-  DumpRecord(reinterpret_cast<pti_view_record_memory_fill*>(record));
-  std::cout << "Device Handle: " << record->_device_handle << '\n';
-  std::cout << "Memory Fill engine ordinal: " << record->_engine_ordinal << '\n';
-  std::cout << "Memory Fill engine index: " << record->_engine_index << '\n';
-}
-
-inline void DumpRecord(pti_view_record_api* record) {
-  if (nullptr == record) return;
-  const char* api_name = nullptr;
-  PTI_THROW(ptiViewGetApiIdName(record->_api_group, record->_api_id, &api_name));
-  std::cout << "Api Function Name: " << api_name << '\n';
-  std::cout << "Api Function Id:   " << record->_api_id << '\n';
-  std::cout << "Correlation Id:    " << record->_correlation_id << '\n';
-  std::cout << "Api Execution Time: "
-            << AposFormat(record->_end_timestamp - record->_start_timestamp) << " ns" << '\n';
-  std::cout << "Api Start Time:     " << AposFormat(record->_start_timestamp) << " ns" << '\n';
-  std::cout << "Api End Time:       " << AposFormat(record->_end_timestamp) << " ns" << '\n';
-  std::cout << "Process Id:     " << record->_process_id << '\n';
-  std::cout << "Thread Id:      " << record->_thread_id << '\n';
-  std::cout << "Return Code:      " << record->_return_code << '\n';
-}
-
-inline void DumpRecord(pti_view_record_comms* record) {
-  if (nullptr == record) {
-    return;
-  }
-
-  std::cout << "ITT Api Execution Time: "
-            << AposFormat(record->_end_timestamp - record->_start_timestamp) << " ns" << '\n';
-  std::cout << "Api Start Time: " << AposFormat(record->_start_timestamp) << " ns" << '\n';
-  std::cout << "Api End Time: " << AposFormat(record->_end_timestamp) << " ns" << '\n';
-  std::cout << "Process Id: " << record->_process_id << '\n';
-  std::cout << "Thread Id: " << record->_thread_id << '\n';
-  std::cout << "Send_size: " << record->_send_size << '\n';
-  std::cout << "Recv_size: " << record->_recv_size << '\n';
-  std::cout << "Communicator Id: " << record->_communicator_id << '\n';
-  std::cout << "ITT CMD: <" << record->_name << ">\n";
-}
-
-inline void DumpRecord(pti_view_record_synchronization* record) {
-  if (nullptr == record) return;
-  switch (record->_synch_type) {
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_EXECUTION: {
-      std::cout << "Barrier Synch Type: Execution Barrier\n";
-    }; break;
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_MEMORY: {
-      std::cout << "Barrier Synch Type: Memory Coherency Barrier\n";
-    }; break;
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_FENCE: {
-      std::cout << "Fence Synch Type: Execution\n";
-    }; break;
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_EVENT: {
-      std::cout << "Event Synch Type: Host\n";
-    }; break;
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_LIST: {
-      std::cout << "CommandList Synch Type: Host\n";
-    }; break;
-    case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_QUEUE: {
-      std::cout << "CommandQueue Synch Type: Host\n";
-    }; break;
-    default:
-      break;
-  }
-  std::cout << "Synch Start Time: " << record->_start_timestamp << '\n';
-  std::cout << "  Synch End Time: " << record->_end_timestamp << '\n';
-  std::cout << "  Synch Duration: " << record->_end_timestamp - record->_start_timestamp << "ns\n";
-  std::cout << "Synch Thread Id: " << record->_thread_id << '\n';
-  std::cout << "Synch Correlation Id: " << record->_correlation_id << '\n';
-  std::cout << "Synch BE Queue Handle: " << record->_queue_handle << '\n';
-  std::cout << "Synch BE Context Handle: " << record->_context_handle << '\n';
-  std::cout << "Synch BE Event Handle: " << record->_event_handle << '\n';
-  std::cout << "Synch BE Number Wait Events: " << record->_number_wait_events << '\n';
-  std::cout << "Synch Api Function Id: " << record->_api_id << '\n';
-  std::cout << "Synch Api Group Id:    " << record->_api_group << '\n';
-  std::cout << "Synch Api Return Code: " << record->_return_code << '\n';
-  const char* api_name = nullptr;
-  PTI_THROW(
-      ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, record->_api_id, &api_name));
-  std::cout << "Synch Api Function Name: " << api_name << '\n';
-}
-
-inline void DumpRecord(pti_view_record_overhead* record) {
-  if (nullptr == record) return;
-  std::cout << "Overhead Kind : " << ptiViewOverheadKindToString(record->_overhead_kind) << '\n';
-  std::cout << "Overhead Time Duration(ns): " << record->_overhead_duration_ns << '\n';
-  std::cout << "Overhead Count: " << record->_overhead_count << '\n';
-  std::cout << "Overhead Start Timestamp(ns): " << record->_overhead_start_timestamp_ns << '\n';
-  std::cout << "Overhead End Timestamp(ns): " << record->_overhead_end_timestamp_ns << '\n';
-  std::cout << "Overhead ThreadId: " << record->_overhead_thread_id << '\n';
-  // std::cout << "Overhead API Responsible : "
-  //<< record->_overhead_api_name << '\n';
-}
-
-inline void DumpRecord(pti_view_record_external_correlation* record) {
-  if (nullptr == record) return;
-  std::cout << "External Correlation Kind: " << record->_external_kind << '\n';
-  std::cout << "Correlation Id: " << record->_correlation_id << '\n';
-  std::cout << "External Id: " << record->_external_id << '\n';
-}
-
-inline std::string GetCommandListTypeString(pti_backend_command_list_type cmd_list_type) {
-  std::string result;
-  if (cmd_list_type & PTI_BACKEND_COMMAND_LIST_TYPE_UNKNOWN) {
-    result += " | Unknown";
-  }
-  if (cmd_list_type & PTI_BACKEND_COMMAND_LIST_TYPE_IMMEDIATE) {
-    result += " | Immediate";
-  }
-  if (cmd_list_type & PTI_BACKEND_COMMAND_LIST_TYPE_MUTABLE) {
-    result += " | Mutable";
-  }
-
-  if (!result.empty()) {
-    result = result.substr(3);  // remove leading " | "
-  } else {
-    result = "INVALID_VALUE";
-  }
-  return result;
-}
-
-inline std::string GetOperationTypeString(pti_gpu_operation_kind operation_kind) {
-  std::string result;
-  switch (operation_kind) {
-    case (PTI_GPU_OPERATION_KIND_KERNEL):
-      result = "Kernel";
-      break;
-    case (PTI_GPU_OPERATION_KIND_MEMORY):
-      result = "Memory";
-      break;
-    case (PTI_GPU_OPERATION_KIND_OTHER):
-      result = "Other";
-      break;
-    default:
-      result = "Unknown";
-      break;
-  }
-  return result;
-}
-
-inline void DumpCallbackData(pti_callback_domain domain, pti_api_group_id driver_api_group_id,
-                             uint32_t driver_api_id, pti_backend_ctx_t backend_context,
-                             void* cb_data, void* global_user_data, void** instance_user_data) {
-  std::cout << "=== Callback Data Dump ===" << std::endl;
-  std::cout << "Domain: " << ptiCallbackDomainTypeToString(domain)
-            << ", Backend Context: " << backend_context << std::endl;
-
-  const char* api_name = nullptr;
-  if (PTI_SUCCESS == ptiViewGetApiIdName(driver_api_group_id, driver_api_id, &api_name)) {
-    std::cout << "Driver API Group Id/API Id/Name: " << driver_api_group_id << "/" << driver_api_id
-              << "/" << api_name << std::endl;
-  } else {
-    std::cout << "Driver API Group Id/API Id/Name: " << driver_api_group_id << "/" << driver_api_id
-              << "/Unknown" << std::endl;
-  }
-  if (cb_data != nullptr) {
-    switch (domain) {
-      case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED:
-      case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED:
-      case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED: {
-        pti_callback_gpu_op_data* gpu_op_data = static_cast<pti_callback_gpu_op_data*>(cb_data);
-        std::cout << "GPU Operation Data:" << std::endl;
-        std::cout << "  Phase: " << ptiCallbackPhaseTypeToString(gpu_op_data->_phase) << std::endl;
-        if (domain != PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED) {
-          std::cout << "  Command List Handle: " << gpu_op_data->_cmd_list_handle << std::endl;
-          std::cout << "  Command List Type:   "
-                    << GetCommandListTypeString(gpu_op_data->_cmd_list_properties) << std::endl;
-          std::cout << "  Queue Handle:        " << gpu_op_data->_queue_handle << std::endl;
-          std::cout << "  Correlation Id:      " << gpu_op_data->_correlation_id << std::endl;
-        }
-        std::cout << "  Device Handle: " << gpu_op_data->_device_handle << std::endl;
-        std::cout << "  Return Code: " << gpu_op_data->_return_code << std::endl;
-        std::cout << "  Operation Count: " << gpu_op_data->_operation_count << std::endl;
-
-        if (gpu_op_data->_operation_details != nullptr) {
-          pti_gpu_op_details* op_details =
-              static_cast<pti_gpu_op_details*>(gpu_op_data->_operation_details);
-          std::cout << "  GPU Operations Details:" << std::endl;
-          for (uint32_t i = 0; i < gpu_op_data->_operation_count; ++i, ++op_details) {
-            std::cout << " -- Operation Kind: "
-                      << GetOperationTypeString(op_details->_operation_kind) << std::endl;
-            std::cout << "    Operation Id: " << op_details->_operation_id << std::endl;
-            std::cout << "    Kernel Handle: " << op_details->_kernel_handle << std::endl;
-            if (op_details->_name != nullptr) {
-              std::cout << "    Name: " << op_details->_name << std::endl;
-            }
-          }
-        }
-        break;
-      }
-      case PTI_CB_DOMAIN_INTERNAL_THREADS:
-      case PTI_CB_DOMAIN_INTERNAL_EVENT: {
-        pti_internal_callback_data* internal_data =
-            static_cast<pti_internal_callback_data*>(cb_data);
-        std::cout << "Internal Callback Data:" << std::endl;
-        std::cout << "  Phase: " << ptiCallbackPhaseTypeToString(internal_data->_phase) << " ("
-                  << internal_data->_phase << ")" << std::endl;
-        std::cout << "  Detail: " << internal_data->_detail << std::endl;
-        if (internal_data->_message != nullptr) {
-          std::cout << "  Message: " << internal_data->_message << std::endl;
-        }
-        break;
-      }
-      default:
-        std::cout << "Unknown domain type for callback data" << std::endl;
-        break;
-    }
-  } else {
-    std::cout << "Callback data is null" << std::endl;
-  }
-
-  if (global_user_data != nullptr) {
-    std::cout << "Global User Data: " << global_user_data << std::endl;
-  }
-
-  if (instance_user_data != nullptr && *instance_user_data != nullptr) {
-    std::cout << "Instance User Data: " << *instance_user_data << std::endl;
-  }
-
-  std::cout << "=========================" << std::endl;
-}
-
-inline std::string GetEnv(const char* name) {
-  if (name == nullptr) {
-    return std::string();
-  }
-#if defined(_WIN32)
-  char* value = nullptr;
-  errno_t status = _dupenv_s(&value, nullptr, name);
-  if (status != 0 || value == nullptr) {
-    return std::string();
-  }
-  std::string result(value);
-  free(value);
-  return result;
-#else
-  const char* value = getenv(name);
-  if (value == nullptr) {
-    return std::string();
-  }
-  return std::string(value);
-#endif
-}
-
-inline bool CheckEnvVarOrSuggest(const char* name, const char* expected_value) {
-  if (name == nullptr || expected_value == nullptr) {
-    return false;
-  }
-  if (GetEnv(name) == expected_value) {
-    return true;
-  }
-  std::cerr << "WARNING: " << name << " is not set to " << expected_value
-            << ". Suggest to set it:\n";
-#if defined(_WIN32)
-  std::cerr << "  set " << name << "=" << expected_value << "\n";
-#else
-  std::cerr << "  export " << name << "=" << expected_value << "\n";
-#endif
-  return false;
-}
-
-}  // namespace samples_utils
-#endif
diff --git a/sdk/samples/vector_sq_add/CMakeLists.txt b/sdk/samples/vector_sq_add/CMakeLists.txt
deleted file mode 100644
index ef87e6f7..00000000
--- a/sdk/samples/vector_sq_add/CMakeLists.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_KERNEL_V CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if(NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(vec_sqadd vector_sq_add.cc)
-
-target_link_options(vec_sqadd PUBLIC -fsycl)
-target_compile_options(vec_sqadd PUBLIC -fsycl)
-target_include_directories(vec_sqadd
-                           PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(vec_sqadd PUBLIC Pti::pti_view)
-
diff --git a/sdk/samples/vector_sq_add/vector_sq_add.cc b/sdk/samples/vector_sq_add/vector_sq_add.cc
deleted file mode 100644
index 54b34a0e..00000000
--- a/sdk/samples/vector_sq_add/vector_sq_add.cc
+++ /dev/null
@@ -1,371 +0,0 @@
-// ==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Based on Vector Add example from OneAPI samples
-// ==============================================================
-#include <cmath>
-#include <cstring>
-#include <iostream>
-#include <map>
-#include <set>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-void StartTracing() {
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION));
-}
-
-void StopTracing() {
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION));
-}
-
-constexpr std::size_t kVectorSize = 5000;
-
-void PrintQueueInfo(const sycl::queue &sycl_queue) {
-  auto queue_type = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(sycl_queue);
-#if __LIBSYCL_MAJOR_VERSION > 6 || (__LIBSYCL_MAJOR_VERSION == 6 && __LIBSYCL_MINOR_VERSION >= 2)
-  // 1 (default)
-  if (auto *ptr_queue_handle = std::get_if<ze_command_list_handle_t>(&queue_type)) {
-    std::cout << "Queue ptr: " << static_cast<const void *>(&sycl_queue)
-              << ", native queue: " << static_cast<const void *>(ptr_queue_handle)
-              << ", native device: "
-              << static_cast<const void *>(sycl::get_native<sycl::backend::ext_oneapi_level_zero>(
-                     sycl_queue.get_device()))
-              << '\n';
-    // 0
-  } else if (auto *ptr_queue_handle = std::get_if<ze_command_queue_handle_t>(&queue_type)) {
-    std::cout << "Queue ptr: " << static_cast<const void *>(&sycl_queue)
-              << ", native queue: " << static_cast<const void *>(ptr_queue_handle)
-              << ", native device: "
-              << static_cast<const void *>(sycl::get_native<sycl::backend::ext_oneapi_level_zero>(
-                     sycl_queue.get_device()))
-              << '\n';
-
-  } else {
-    std::cerr << "Underlying level zero queue handle could not be obtained." << '\n';
-  }
-#else
-  std::cout << "Queue ptr: " << static_cast<const void *>(&sycl_queue) << ", native queue: "
-            << static_cast<const void *>(
-                   sycl::get_native<sycl::backend::ext_oneapi_level_zero>(sycl_queue))
-            << ", native device: "
-            << static_cast<const void *>(
-                   sycl::get_native<sycl::backend::ext_oneapi_level_zero>(sycl_queue.get_device()))
-            << '\n';
-#endif
-}
-
-//************************************
-// Vector square in SYCL on device: modifies each input vector
-//************************************
-template <typename T>
-void VecSq(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-}
-
-//************************************
-// Vector add in SYCL on device: returns sum in 4th parameter "sq_add".
-//************************************
-template <typename T>
-void VecAdd(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector,
-            std::vector<T> &sq_add) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-  sycl::buffer sum_buf(sq_add.data(), num_items);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_only);
-    sycl::accessor b(b_buf, h, sycl::read_only);
-    sycl::accessor sum(sum_buf, h, sycl::write_only, sycl::no_init);
-    h.parallel_for(num_items, [=](auto i) { sum[i] = a[i] + b[i]; });
-  });
-  q.wait();
-}
-
-template <typename T>
-void PrintResults(const std::vector<T> &sq_add, int n) {
-  double sum = 0;
-  for (int i = 0; i < n; i++) {
-    sum += sq_add[i];
-  }
-  std::cout << "find result: " << sum / static_cast<double>(n) << '\n';
-}
-
-template <typename T>
-void RunProfiledVecSqAdd(sycl::queue &sycl_queue) {
-  std::vector<T> a(kVectorSize);
-  std::vector<T> b(kVectorSize);
-  std::vector<T> c(2 * kVectorSize);
-  std::vector<T> d(2 * kVectorSize);
-  std::vector<T> sq_add(kVectorSize);
-  std::vector<T> sq_add2(2 * kVectorSize);
-  uint64_t corr_id = 0;
-
-  for (size_t i = 0; i < kVectorSize; i++) {
-    a[i] = std::sin(i);
-    b[i] = std::cos(i);
-    c[2 * i] = std::sin(i) * std::sin(i);
-    c[2 * i + 1] = std::sin(i);
-    d[2 * i] = std::cos(i) * std::cos(i);
-    d[2 * i + 1] = std::cos(i);
-  }
-
-  VecSq(sycl_queue, a, b);
-
-  // Submitting different kernels in the regions with different correlation IDs
-
-  StartTracing();
-  PTI_THROW(
-      ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1, 1));
-  VecSq(sycl_queue, a, b);
-  PTI_THROW(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1,
-                                            &corr_id));
-  if (corr_id != 1) {
-    std::cerr << "Wrong correlation ID (should be 1): " << corr_id << '\n';
-  }
-  StopTracing();
-  PrintResults(sq_add, kVectorSize);
-
-  VecAdd(sycl_queue, a, b, sq_add);
-  PrintResults(sq_add, kVectorSize);
-
-  StartTracing();
-  PTI_THROW(
-      ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1, 2));
-  VecAdd(sycl_queue, c, d, sq_add2);
-  PTI_THROW(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1,
-                                            &corr_id));
-  if (corr_id != 2) {
-    std::cerr << "Wrong correlation ID (should be 2): " << corr_id << '\n';
-  }
-  PrintResults(sq_add2, 2 * kVectorSize);
-}
-
-// These structures are to store the correlation between the external annotations and
-// the runtime APIs calls and GPU kernel/mem ops
-std::map<std::pair<pti_view_external_kind, uint64_t>, std::vector<uint32_t> > external_corr_map;
-std::map<uint32_t, std::string> runtime_enq_2_gpu_kernel_name_map;
-std::map<uint32_t, std::string> runtime_enq_2_gpu_mem_op_name_map;
-
-int main() {
-  int exit_code = EXIT_SUCCESS;
-
-  try {
-    PTI_THROW(ptiViewSetCallbacks(
-        [](auto **buf, auto *buf_size) {
-          *buf_size = sizeof(pti_view_record_kernel) * 100;
-          void *ptr = ::operator new(*buf_size);
-          ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-          *buf = reinterpret_cast<unsigned char *>(ptr);
-          if (!*buf) {
-            std::abort();
-          }
-          return;
-        },
-        [](auto *buf, auto buf_size, auto valid_buf_size) {
-          if (!buf_size || !valid_buf_size || !buf_size) {
-            std::cerr << "Received empty buffer" << '\n';
-            if (valid_buf_size) {
-              ::operator delete(buf);
-            }
-            return;
-          }
-          pti_view_record_base *ptr = nullptr;
-          while (true) {
-            auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-            if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-              std::cout << "Reached End of buffer" << '\n';
-              break;
-            }
-            if (buf_status != pti_result::PTI_SUCCESS) {
-              std::cerr << "Found Error Parsing Records from PTI" << '\n';
-              break;
-            }
-            switch (ptr->_view_kind) {
-              case pti_view_kind::PTI_VIEW_INVALID: {
-                std::cout << "Found Invalid Record" << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                std::cout << "Found API Runtime Record" << '\n';
-                auto *rec = reinterpret_cast<pti_view_record_api *>(ptr);
-                const char *api_name = nullptr;
-                PTI_THROW(ptiViewGetApiIdName(rec->_api_group, rec->_api_id, &api_name));
-                if (strstr(api_name, "EnqueueKernel") != nullptr) {
-                  runtime_enq_2_gpu_kernel_name_map[rec->_correlation_id] = "unknown_at_this_point";
-                }
-                if (strstr(api_name, "EnqueueMem") != nullptr) {
-                  runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = "unknown_at_this_point";
-                }
-                samples_utils::DumpRecord(rec);
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                auto *rec = reinterpret_cast<pti_view_record_memory_copy *>(ptr);
-                runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = rec->_name;
-                std::cout << "Found Memory Record" << '\n';
-                samples_utils::DumpRecord(rec);
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                auto *rec = reinterpret_cast<pti_view_record_memory_fill *>(ptr);
-                runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = rec->_name;
-                std::cout << "Found Memory Record" << '\n';
-                samples_utils::DumpRecord(rec);
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                auto *rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-                runtime_enq_2_gpu_kernel_name_map[rec->_correlation_id] = rec->_name;
-                std::cout << "Found Kernel Record" << '\n';
-                samples_utils::DumpRecord(rec);
-
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                if (samples_utils::IsMonotonic({rec->_sycl_task_begin_timestamp,
-                                                rec->_sycl_enqk_begin_timestamp,
-                                                rec->_append_timestamp, rec->_submit_timestamp,
-                                                rec->_start_timestamp, rec->_end_timestamp})) {
-                  std::cout << "------------>     All Monotonic" << std::endl;
-                } else {
-                  std::cerr << "------------>     Something wrong: NOT All monotonic" << std::endl;
-                };
-                if (rec->_sycl_task_begin_timestamp == 0) {
-                  std::cerr << "------------>     Something wrong: Sycl Task "
-                               "Begin Time is 0"
-                            << std::endl;
-                }
-                if (rec->_sycl_enqk_begin_timestamp == 0) {
-                  std::cerr << "------------>     Something wrong: Sycl Enq "
-                               "Launch Kernel Time is 0"
-                            << std::endl;
-                }
-
-                break;
-              }
-              case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-                std::cout << "---------------------------------------------------"
-                             "-----------------------------"
-                          << '\n';
-                auto *rec = reinterpret_cast<pti_view_record_external_correlation *>(ptr);
-
-                external_corr_map[std::pair{rec->_external_kind, rec->_external_id}].push_back(
-                    rec->_correlation_id);
-                samples_utils::DumpRecord(rec);
-                break;
-              }
-              default: {
-                std::cerr << "This shouldn't happen" << '\n';
-                break;
-              }
-            }
-          }
-          ::operator delete(buf);
-        }));
-
-#if __INTEL_LLVM_COMPILER >= 20240000
-    sycl::property_list prop{sycl::property::queue::in_order()};
-#else
-    sycl::property_list prop{};
-#endif
-    sycl::queue q(sycl::gpu_selector_v, prop);
-    PrintQueueInfo(q);
-
-    if (q.get_device().has(sycl::aspect::fp64)) {
-      RunProfiledVecSqAdd<double>(q);
-    } else {
-      RunProfiledVecSqAdd<float>(q);
-    }
-
-    StopTracing();
-    PTI_THROW(ptiFlushAllViews());
-
-    // This piece demonstartes what could be learnt from a use of the external correlation API
-    std::cout << "\nUser annotations via External Correlation API:\n";
-    for (auto &corr : external_corr_map) {
-      std::cout << "External Range: Kind: " << static_cast<int>(corr.first.first)
-                << ", ID: " << corr.first.second << ", Correlation IDs: ";
-      std::set<uint32_t> kernel_ids;
-      std::set<uint32_t> memory_ids;
-      for (auto &id : corr.second) {
-        std::cout << id << ", ";
-        if (runtime_enq_2_gpu_kernel_name_map.find(id) != runtime_enq_2_gpu_kernel_name_map.end()) {
-          kernel_ids.insert(id);
-        }
-        if (runtime_enq_2_gpu_mem_op_name_map.find(id) != runtime_enq_2_gpu_mem_op_name_map.end()) {
-          memory_ids.insert(id);
-        }
-      }
-      std::cout << "\n\n"
-                << "Kernel(s) in this Range: " << '\n';
-      for (auto &id : kernel_ids) {
-        std::cout << "Correlation ID: " << id << " " << runtime_enq_2_gpu_kernel_name_map[id]
-                  << '\n';
-      }
-      std::cout << '\n' << "Memory Op(s) in this Range: " << '\n';
-      for (auto &id : memory_ids) {
-        std::cout << "Correlation ID: " << id << " " << runtime_enq_2_gpu_mem_op_name_map[id]
-                  << '\n';
-      }
-      std::cout << '\n';
-    }
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  return exit_code;
-}
diff --git a/sdk/samples/view_record_versioned/CMakeLists.txt b/sdk/samples/view_record_versioned/CMakeLists.txt
deleted file mode 100644
index 8135a54a..00000000
--- a/sdk/samples/view_record_versioned/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-cmake_minimum_required(VERSION 3.14)
-
-project(PTI_Samples_VIEW_RECORD_VERSIONED CXX)
-
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-# TODO: find_package(IntelSYCL)?
-include(CheckCXXCompilerFlag)
-check_cxx_compiler_flag("-fsycl" has_sycl)
-
-if (NOT has_sycl)
-  message(WARNING "${PROJECT_NAME} requires a sycl compatible compiler")
-  return()
-endif()
-
-add_executable(view_record_versioned main.cc)
-
-target_link_options(view_record_versioned PUBLIC -fsycl)
-target_compile_options(view_record_versioned PUBLIC -fsycl)
-
-target_include_directories(view_record_versioned PRIVATE "${PROJECT_SOURCE_DIR}/../samples_utilities")
-
-# Allow building in-source and out-of-source
-if (NOT TARGET Pti::pti_view)
-  find_package(Pti REQUIRED)
-endif()
-
-target_link_libraries(view_record_versioned PUBLIC Pti::pti_view)
diff --git a/sdk/samples/view_record_versioned/main.cc b/sdk/samples/view_record_versioned/main.cc
deleted file mode 100644
index 39c19bd0..00000000
--- a/sdk/samples/view_record_versioned/main.cc
+++ /dev/null
@@ -1,503 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-/**
- * @brief Demonstrates how to write backward-compatible PTI tracing code that works
- *        across different library versions by checking ptiVersion() at runtime.
- *
- * PTI library evolves its view record structures over time. To maintain compatibility:
- *
- * 1. Query the PTI version at startup:
- *      pti_version version = ptiVersion();
- *
- * 2. Use version checks to select the appropriate record structures:
- *    - Version >= 1.0 or 0.18+: Use v2 structures (pti_view_record_kernel_v2,
- *      pti_view_record_memory_copy_v2, pti_view_record_memory_fill_v2)
- *    - Version < 0.18: Use older structures (pti_view_record_kernel,
- *      pti_view_record_memory_copy, pti_view_record_memory_fill)
- *
- * 3. The version check pattern:
- *      if (version._major >= 1 || (version._major == 0 && version._minor > 17)) {
- *          // Use v2 record structures
- *          auto* rec = reinterpret_cast<pti_view_record_kernel_v2*>(ptr);
- *      } else {
- *          // Use older record structures
- *          auto* rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
- *      }
- *
- * This approach allows application to:
- * - Work with both older and newer PTI library versions
- * - Access new fields in v2 structures when available
- * - Gracefully degrade to older structures on older systems
- *
- * Note: Every new view record is extension of the previous version. Any new fields are added to the
- * end of the structure. This way, when we cast a buffer of records to an older structure, the new
- * fields are simply ignored, ensuring backward compatibility.
- */
-
-#include <string.h>
-
-#include <cmath>
-#include <cstdlib>
-#include <memory>
-#include <sycl/sycl.hpp>
-
-#include "pti/pti_version.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-#define NSEC_IN_SEC 1'000'000'000
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-pti_version gPtiVersion = {0, 0, 0};
-constexpr auto kRequestedRecordCount = 5'000'000ULL;
-constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-void EnableIndividualDriverApis() {
-  PTI_CHECK_SUCCESS(
-      ptiViewEnableDriverApi(1, pti_api_group_id::PTI_API_GROUP_LEVELZERO,
-                             pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernel_id));
-}
-
-void StartTracing() {
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DRIVER_API));
-  EnableIndividualDriverApis();
-}
-
-void StopTracing() {
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD));
-  PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DRIVER_API));
-}
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-void ParseBuffer_v2(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (buf) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_overhead *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Driver Api Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy_v2 *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill_v2 *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        pti_view_record_kernel_v2 *rec = reinterpret_cast<pti_view_record_kernel_v2 *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        if (samples_utils::IsMonotonic({rec->_sycl_task_begin_timestamp,
-                                        rec->_sycl_enqk_begin_timestamp, rec->_append_timestamp,
-                                        rec->_submit_timestamp, rec->_start_timestamp,
-                                        rec->_end_timestamp})) {
-          std::cout << "------------>     All Monotonic" << std::endl;
-        } else {
-          std::cerr << "------------>     Something wrong: NOT All monotonic" << std::endl;
-        }
-        if (rec->_sycl_task_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Task "
-                       "Begin Time is 0"
-                    << std::endl;
-        }
-        if (rec->_sycl_enqk_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Enq "
-                       "Launch Kernel Time is 0"
-                    << std::endl;
-        }
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-void ParseBuffer_v1(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (buf) {
-      samples_utils::AlignedDealloc(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      std::cout << "Reached End of buffer" << '\n';
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_overhead *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Driver Api Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_copy *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_memory_fill *>(ptr));
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        pti_view_record_kernel *rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-        samples_utils::DumpRecord(rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        if (samples_utils::IsMonotonic({rec->_sycl_task_begin_timestamp,
-                                        rec->_sycl_enqk_begin_timestamp, rec->_append_timestamp,
-                                        rec->_submit_timestamp, rec->_start_timestamp,
-                                        rec->_end_timestamp})) {
-          std::cout << "------------>     All Monotonic" << std::endl;
-        } else {
-          std::cerr << "------------>     Something wrong: NOT All monotonic" << std::endl;
-        }
-        if (rec->_sycl_task_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Task "
-                       "Begin Time is 0"
-                    << std::endl;
-        }
-        if (rec->_sycl_enqk_begin_timestamp == 0) {
-          std::cerr << "------------>     Something wrong: Sycl Enq "
-                       "Launch Kernel Time is 0"
-                    << std::endl;
-        }
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  // Dispatch to the appropriate parser based on PTI version at runtime:
-  // - v2 parser: PTI >= 1.0 or PTI 0.18+ (uses pti_view_record_*_v2 structures)
-  // - v1 parser: PTI < 0.18 (uses older pti_view_record_* structures)
-  if (gPtiVersion._major >= 1 || (gPtiVersion._major == 0 && gPtiVersion._minor > 17)) {
-    ParseBuffer_v2(buf, buf_size, valid_buf_size);
-  } else {
-    ParseBuffer_v1(buf, buf_size, valid_buf_size);
-  }
-}
-
-static float Check(const std::vector<float> &a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float *a, const float *b, float *c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue, const std::vector<float> &a,
-                         const std::vector<float> &b, std::vector<float> &c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  double time = 0.0;
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-
-    auto start = event.get_profiling_info<sycl::info::event_profiling::command_start>();
-    auto end = event.get_profiling_info<sycl::info::event_profiling::command_end>();
-    time = static_cast<double>(end - start) / NSEC_IN_SEC;
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  std::cout << "Matrix multiplication time: " << time << " sec" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue, const std::vector<float> &a, const std::vector<float> &b,
-                    std::vector<float> &c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-}
-
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-void Usage(const char *name) {
-  std::cout << " Calculating floating point matrix multiply on gpu\n";
-  std::cout << name
-            << " [ [gpu|cpu|host, default=gpu],  [matrix size, default=1024, max=" << max_size
-            << "], [repetition count, default=4]] \n";
-}
-
-int main(int argc, char *argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  // Query the PTI library version at runtime to determine which view record
-  // structures to use when parsing buffers. Newer versions (>= 0.18) provide
-  // v2 structures (e.g., pti_view_record_kernel_v2) with additional fields over
-  // older version structures. Store the version globally so the buffer parsing
-  // callback can select the appropriate record types.
-  gPtiVersion = ptiVersion();
-
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-  StartTracing();
-  unsigned repeat_count = 1;
-  unsigned size = 1024;
-  sycl::device dev;
-  try {
-    dev = sycl::device(sycl::gpu_selector_v);
-    if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-      dev = sycl::device(sycl::cpu_selector_v);
-      std::cerr << "PTI doesn't support cpu profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
-      std::cerr << "PTI doesn't support host profiling yet" << '\n';
-      std::exit(EXIT_FAILURE);
-    }
-
-    unsigned temp = size;
-    if (argc > 2) {
-      temp = std::stoul(argv[2]);
-      size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-    }
-
-    if (argc > 3) {
-      temp = std::stoul(argv[3]);
-      repeat_count = (temp < 1) ? 1 : temp;
-    }
-  } catch (const sycl::exception &e) {
-    Usage(argv[0]);
-    std::cerr << "Error: Exception caught while executing SYCL " << e.what() << '\n';
-    std::cerr << "Unable to select valid sycl device" << '\n';
-    return EXIT_FAILURE;
-  } catch (...) {
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::enable_profiling(),
-                                sycl::property::queue::in_order()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);   // Main runandcheck kernel
-  sycl::queue queue1(dev, sycl::async_handler{}, prop_list);  // Main runandcheck kernel
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size << " x " << size << ", repeats "
-            << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: "
-            << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-            << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  try {
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    Compute(queue1, a, b, c, size, repeat_count, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    std::cout << "Total execution time with tracing: " << time.count() << " sec" << std::endl;
-
-    start = std::chrono::steady_clock::now();
-    expected_result = A_VALUE * B_VALUE * size;
-
-    Compute(std::move(queue), a, b, c, size, repeat_count, expected_result);
-    end = std::chrono::steady_clock::now();
-    time = end - start;
-
-    std::cout << "Total execution time without tracing: " << time.count() << " sec" << std::endl;
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  StopTracing();
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-
-  return exit_code;
-}
diff --git a/sdk/src/consumer_thread.h b/sdk/src/consumer_thread.h
deleted file mode 100644
index 5bd46b59..00000000
--- a/sdk/src/consumer_thread.h
+++ /dev/null
@@ -1,148 +0,0 @@
-// ==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_CONSUMER_THREAD_H_
-#define SRC_CONSUMER_THREAD_H_
-
-/**
- * \internal
- * \file consumer_thread.h
- * \brief Thread that returns buffers to the user via user defined callback.
- *
- * Starts a thread on construction. Operates on queue of moveable callable
- * objects (buffer(s) and callback). This makes it easier to either wait for
- * user to parse buffers with a future or "PushAndForget" and ignore the
- * result.
- *
- * Note: MSVC has a bug with std::packaged_task. Therefore, our implementation on
- * Windows and Linux is slightly different. https://github.com/microsoft/STL/issues/321
- *
- */
-#include <spdlog/spdlog.h>
-
-#include <atomic>
-#include <future>
-#include <thread>
-
-#include "view_buffer.h"
-
-namespace pti::view {
-
-#if !defined(_MSC_VER)
-using TaskType = std::packaged_task<void()>;
-#else
-using TaskType = std::function<void()>;
-#endif
-
-constexpr auto kDefaultBufferQueueDepth = 50UL;
-constexpr auto kBufQueueDepthMult = 2UL;
-
-/**
- * \internal
- * \brief Class that starts a thread that is meant to return buffers to the
- * user.
- *
- * This can accept moveable C++ callable objects; however, it is tuned for
- * ViewBuffers.
- * In C++23, std::move_only_function is introduced. That would be a
- * optimization one could make to this class (along with std::jthread in C++20).
- *
- */
-class BufferConsumer {
- public:
-  BufferConsumer() {
-    const auto threads_supported = std::thread::hardware_concurrency();
-    if (threads_supported) {
-      queue_.SetBufferDepth(kBufQueueDepthMult * threads_supported);
-    }
-    consumer_ = std::thread(&BufferConsumer::Run, this);
-  }
-
-  BufferConsumer(const BufferConsumer&) = delete;
-  BufferConsumer& operator=(const BufferConsumer&) = delete;
-  BufferConsumer(BufferConsumer&&) = delete;
-  BufferConsumer& operator=(BufferConsumer&&) = delete;
-
-  virtual ~BufferConsumer() {
-    try {
-      Stop();
-      if (consumer_.joinable()) {
-        consumer_.join();
-      }
-    } catch ([[maybe_unused]] const std::exception& e) {
-      SPDLOG_ERROR("Exception caught in {}: {}", __FUNCTION__, e.what());
-    } catch (...) {
-      SPDLOG_ERROR("Unknown caught in {}", __FUNCTION__);
-    }
-  }
-
-  /**
-   * \internal
-   * Add callback that returns user's buffer.
-   *
-   * \param callable (callable object: functor, lambda, function)
-   * \return std::future<void> lets us wait for the result (useful for flush)
-   */
-  template <typename T>
-  inline auto Push(T&& callable) {
-#if !defined(_MSC_VER)
-    auto delivery = std::packaged_task<void()>(std::move(callable));
-    auto delivery_future = delivery.get_future();
-    queue_.Push(std::move(delivery));
-#else
-    auto delivery = std::make_shared<std::packaged_task<void()> >(std::move(callable));
-    auto delivery_future = delivery->get_future();
-    queue_.Push([delivery = std::move(delivery)]() { (*delivery)(); });
-#endif
-    return delivery_future;
-  }
-
-  /**
-   * \internal
-   * Add callback that returns user's buffer. Don't care when it returns.
-   *
-   * \param callable (callable object: functor, lambda, function)
-   */
-  template <typename T>
-  inline void PushAndForget(T&& callable) {
-#if !defined(_MSC_VER)
-    queue_.Push(std::packaged_task<void()>(std::move(callable)));
-#else
-    auto ptr = std::make_shared<T>(std::move(callable));
-    queue_.Push([ptr = std::move(ptr)]() { return (*ptr)(); });
-#endif
-  }
-
-  /**
-   * \internal
-   * Signal to the consumer thread to stop
-   *
-   * \warning should rarely be used. Stops PTI's global buffer consumer
-   */
-  inline void Stop() {
-    stop_thread_ = true;
-    queue_.ResetBufferDepth();
-#if !defined(_MSC_VER)
-    queue_.Push(std::packaged_task<void()>([] {}));
-#else
-    queue_.Push(std::function<void()>([] {}));
-#endif
-  }
-
- private:
-  void Run() {
-    while (!stop_thread_) {
-      auto delivery = queue_.Pop();
-      delivery();
-    }
-  }
-
-  std::atomic<bool> stop_thread_ = false;
-  utilities::ViewRecordBufferQueue<TaskType> queue_{kDefaultBufferQueueDepth};
-  std::thread consumer_;
-};
-}  // namespace pti::view
-
-#endif  // SRC_CONSUMER_THREAD_H_
diff --git a/sdk/src/default_buffer_callbacks.h b/sdk/src/default_buffer_callbacks.h
deleted file mode 100644
index dd7acdd0..00000000
--- a/sdk/src/default_buffer_callbacks.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_DEFAULT_BUFFER_CALLBACKS_H_
-#define SRC_DEFAULT_BUFFER_CALLBACKS_H_
-
-#include <iostream>
-#include <memory>
-
-#include "view_record_info.h"
-
-namespace pti {
-namespace view {
-namespace defaults {
-constexpr std::size_t kBufferAlignment = 8;
-constexpr std::size_t kDefaultSizeOfBuffer = 1'000 * SizeOfLargestViewRecord();
-
-void DefaultBufferAllocation(unsigned char** buf, std::size_t* buf_size) {
-  *buf_size = kDefaultSizeOfBuffer;
-  auto* ptr = ::operator new(*buf_size);
-  ptr = std::align(kBufferAlignment, sizeof(unsigned char), ptr, *buf_size);
-  *buf = static_cast<unsigned char*>(ptr);
-  if (!*buf) {
-    std::cerr << "Unable to allocate memory for default buffer" << '\n';
-    std::abort();
-  }
-}
-
-void DefaultRecordParser(unsigned char* const buf, [[maybe_unused]] std::size_t buf_size,
-                         std::size_t valid_buf_size) {
-  if (valid_buf_size) {
-    ::operator delete(buf);
-  }
-}
-}  // namespace defaults
-}  // namespace view
-}  // namespace pti
-#endif  // SRC_DEFAULT_BUFFER_CALLBACKS_H
diff --git a/sdk/src/gen_tracing_callbacks.py b/sdk/src/gen_tracing_callbacks.py
deleted file mode 100644
index 89172b97..00000000
--- a/sdk/src/gen_tracing_callbacks.py
+++ /dev/null
@@ -1,1381 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-import bisect
-
-# Parse Level Zero Headers ####################################################
-# Extract registerable apis from 2 headers (ze_api.h, layers/zel_tracing_register_cb.h)
-# Generate a tracing.gen file to be included into ze_collector.h that can be used to register callbacks.
-
-FILE_OPEN_PERMISSIONS = 0o600
-DEFAULT_UNIFIED_RUNTIME_PUBLIC_HEADERS = ["ur_api.h", "sycl/ur_api.h"]
-
-
-# https://docs.python.org/3/library/functions.html#open
-def default_file_opener(path, flags):
-    return os.open(path, flags, mode=FILE_OPEN_PERMISSIONS)
-
-
-def get_ur_api_file_path(include_file_path, include_file=None):
-    """
-    Given include file path (typically passed to the compiler and found by the
-    build system), find where the unified runtime public API header file is.
-    """
-
-    # Invalid directory.
-    if os.path.exists(include_file_path) == False:
-        raise Exception("Passed non-existent file path for UR headers")
-
-    ur_file_path = include_file_path
-
-    # Assume passed the full path to file.
-    if os.path.isfile(ur_file_path) == True:
-        return ur_file_path
-
-    if include_file != None:
-        ur_file_path = os.path.join(ur_file_path, include_file)
-
-        if os.path.exists(ur_file_path) == False:
-            raise Exception("Passed non-existent file path for UR headers")
-
-        return ur_file_path
-
-    for header in DEFAULT_UNIFIED_RUNTIME_PUBLIC_HEADERS:
-        if os.path.isfile(os.path.join(ur_file_path, header)):
-            ur_file_path = os.path.join(ur_file_path, header)
-            break
-
-    return ur_file_path
-
-
-#
-# Extracts api function names and version from ur_api.h and returns as list.
-# Note:  The ur_api.h contains predefined ids for each api -- assumption is no
-# recycle on deprecation. There was a recycled id in the past with oneAPI 2025.1
-# (URT-967).
-#
-# Each API has an enum value and associated comment with the api name.
-# This can be either on the same line or on the line before the enum value.
-#
-def get_ur_api_list(ur_file_path):
-    ur_enum_defs = []  # list of "ApiName,ApiId"
-    ur_function_id_found = False
-    ur_api_version = None
-    current_ur_api_name = ""
-    API_NAME_COMMENT_PREFIX = "Enumerator for ::"
-    with open(ur_file_path, "rt", opener=default_file_opener) as ur_file:
-        for line in ur_file:
-            line = line.strip()
-            if "version v" in line:
-                ur_api_version = line
-            if ur_function_id_found and "UR_FUNCTION_FORCE_UINT32" not in line:
-                if line.startswith("UR_FUNCTION_"):
-                    api_id = line[line.find("=") + 1 : line.find(",")].strip()
-                    # If line has comment with API name, extract and prioritize it as current
-                    if API_NAME_COMMENT_PREFIX in line:
-                        # Line with API_NAME_COMMENT_PREFIXApiName -> ApiName
-                        current_ur_api_name = line.split(API_NAME_COMMENT_PREFIX)[
-                            1
-                        ].strip()
-                    api_name = current_ur_api_name
-                    ur_enum_defs.append(api_name.strip() + "," + api_id)
-                elif line.startswith("/// " + API_NAME_COMMENT_PREFIX):
-                    # Line with API_NAME_COMMENT_PREFIXApiName -> ApiName
-                    current_ur_api_name = line.split(API_NAME_COMMENT_PREFIX)[1].strip()
-            elif "ur_function_t" in line:
-                ur_function_id_found = True
-        return (ur_enum_defs, ur_api_version)
-
-
-def get_current_ur_api_list(pti_file_path):
-    ur_enum_defs = []  # list of "ApiName,ApiId"
-    ur_function_id_found = False
-    ur_api_version = None
-    current_ur_api_name = ""
-    with open(pti_file_path, "rt", opener=default_file_opener) as ur_file:
-        for line in ur_file:
-            line = line.strip()
-            if "version v" in line:
-                ur_api_version = line.split("ApiVersion:")[1].strip()
-            if ur_function_id_found:
-                if line.startswith("ur"):
-                    api_id = line[line.find("=") + 1 : line.find(",")].strip()
-                    current_ur_api_name = line.split("_id")[0].strip()
-                    api_name = current_ur_api_name
-                    ur_enum_defs.append(api_name.strip() + "," + api_id)
-            elif "typedef enum" in line:
-                ur_function_id_found = True
-
-        return (ur_enum_defs, ur_api_version)
-
-
-#
-# Generates an API func_name -> <exposed apiid> mapping for all L0 API registerable functions.
-# returns a dict of this to caller.
-#
-def get_apiids_per_category(src_path, category_dict):
-    apiids_dict_per_category = {}
-    # for category, callback_list in category_dict.items():
-    for cat_key, callback_list in category_dict.items():
-        category = cat_key[0]
-        api_group = cat_key[1]
-        print("getting existing: working with: ", category, api_group)
-        apiids_file_path = os.path.join(
-            src_path, "pti_" + category + "_" + api_group + "_api_ids.h"
-        )
-        if os.path.exists(apiids_file_path):
-            apiids_dict = {}
-            apiids_set = set()
-            apiids_counter = 0
-            with open(apiids_file_path, "rt", opener=default_file_opener) as f:
-                f.seek(0)
-                reserved_found = False
-                id = 0
-                for line in f:
-                    if line.find("reserved_") != -1:
-                        reserved_found = True
-                    elif line.find("pti_api_id_") != -1:
-                        reserved_found = False
-                    elif reserved_found and (
-                        (line.strip().startswith("ze") != -1)
-                        or (line.strip().startswith("cl") != -1)
-                    ):
-                        items = line.split("=")
-                        assert len(items) == 2
-                        id = items[1].split(",")
-                        apiids_dict[items[0].strip()] = id[0]
-                        apiids_set.add(int(id[0]))
-                        apiids_dict["next_elem_index"] = max(apiids_set) + 1
-                        apiids_counter += 1
-                        # print(items, apiids_counter, id[0], len(apiids_set))
-                        assert apiids_counter == len(apiids_set), (
-                            "Duplicated api_id found in existing"
-                        )
-
-            # print(apiids_dict["next_elem_index"])
-            apiids_dict_per_category[cat_key] = apiids_dict.copy()
-    return apiids_dict_per_category
-
-
-# Generates a func_name -> <name of matching param structure> mapping for all L0 API registerable functions.
-# returns a dict of this to caller.
-# e.g entry in dict:  'zeCommandListAppendLaunchKernel': 'ze_command_list_append_launch_kernel_params_t* '
-
-
-def gen_func_param_dict(api_files):
-    func_dict = {}
-    for api_filepath in api_files:
-        with open(api_filepath, "rt", opener=default_file_opener) as f:
-            f.seek(0)
-            # for line in f.readlines():
-            for line in f:
-                if line.find("version v") != -1:
-                    L0_api_version = line
-                    print(line)
-                if line.find("ZE_APICALL") != -1 and line.find("ze_pfn") != -1:
-                    items = line.split("ze_pfn")
-                    assert len(items) == 2
-                    assert items[1].find("Cb_t") != -1
-                    items = items[1].split("Cb_t")
-                    assert len(items) == 2
-                    func_dict["ze" + items[0].strip()] = [
-                        next(f).strip(),
-                        next(f).strip(),
-                    ]
-                    # func_list.append("ze" + items[0].strip())
-                    # print("FUNC_LIST -- next line: ",next(f).split("* params,")[0])
-    return (func_dict, L0_api_version)
-
-
-def gen_apiid_header(api_file, header_string, api_version_info):
-    api_file.write("//==============================================================\n")
-    api_file.write("// Copyright (C) Intel Corporation\n")
-    api_file.write("//\n")
-    api_file.write("// SPDX-License-Identifier: MIT\n")
-    api_file.write("// =============================================================\n")
-    api_file.write("\n")
-    api_file.write("#ifndef PTI_API_ID_" + header_string + "_H_\n")
-    api_file.write("#define PTI_API_ID_" + header_string + "_H_\n")
-    api_file.write("\n")
-    api_file.write("// ========= This file is autogenerated - do not modify ========\n")
-    if api_version_info:
-        api_file.write(
-            "// ========= Api file version used for generation: =============\n"
-        )
-        api_file.write("//    ApiFile: " + api_version_info[1] + "\n")
-        api_file.write("// ApiVersion:" + api_version_info[0] + "\n")
-        api_file.write("//             " + api_version_info[2] + "\n")
-        api_file.write("//             " + api_version_info[3] + "\n")
-    api_file.write("\n\n")
-
-
-def gen_apiid_terminate_header(api_file):
-    api_file.write("#endif\n")
-
-
-def get_new_version_tag(api_name):
-    """Get a version to append to enum member"""
-    VERSION_SEPARATOR = "_v"
-    STARTING_VERSION_TAG = VERSION_SEPARATOR + "2"
-
-    version_to_add = STARTING_VERSION_TAG
-    # urApiFunction_v<> -> [urApiFunction, v<>]
-    api_ver = api_name.split("_")
-    if len(api_ver) >= 2:
-        if "v" in api_ver[1]:
-            # Shave off 'v'
-            version_to_add = f"{VERSION_SEPARATOR}{int(api_ver[1][1:]) + 1}"
-    return version_to_add
-
-
-def strip_version_from_api_name(api_name):
-    # urApiFunction_v<> -> urApiFunction
-    stripped_name = api_name.split("_", 1)[0].strip()
-    return stripped_name
-
-
-def reverse_bi_dict(dict_to_reverse):
-    reversed_dict = {}
-    for key, value in dict_to_reverse.items():
-        if value not in reversed_dict:
-            reversed_dict[value] = key
-        else:
-            raise ValueError(
-                f"Duplicate value {value}. This is not a bidirectional map. E.g., make sure api ids are unique."
-            )
-    return reversed_dict
-
-
-def generate_api_file_portion(
-    apiids_file_path,
-    enum_definition_list,
-    category,
-    api_group,
-    existing_apiids,
-    dst_validation_file,
-    version_dict,
-):
-    API_ID_ENUM_INTERVAL = 1
-    with open(apiids_file_path, "wt", opener=default_file_opener) as f:
-        gen_apiid_header(
-            f, category.upper() + "_" + api_group.upper(), version_dict[api_group]
-        )
-        f.write("typedef enum _pti_api_id_" + category + "_" + api_group + " {\n")
-        f.write("    reserved_" + category + "_" + api_group + "_id=" + str(0) + ",\n")
-        next_id = int(existing_apiids.get("next_elem_index", API_ID_ENUM_INTERVAL))
-        if existing_apiids:
-            del existing_apiids["next_elem_index"]
-        id_counter = 0
-        id_set = set()
-        sorted_api_list = []
-        existing_api_id_to_enum_map = reverse_bi_dict(existing_apiids)
-
-        for enum_def in enum_definition_list:
-            next_enum_def = enum_def.partition(",")
-            apiid = int(existing_apiids.get(next_enum_def[0] + "_id", 0))
-            add_version = False
-
-            if apiid == 0 and len(next_enum_def) >= 3:
-                enum_mem = existing_api_id_to_enum_map.get(next_enum_def[2], None)
-                if enum_mem and enum_mem.startswith(next_enum_def[0]):
-                    apiid = int(next_enum_def[2])
-
-            if apiid == 0:  # not known, no existing id
-                if (
-                    next_enum_def[2] == ""
-                ):  # and no default value in the header file, create one.
-                    apiid = next_id
-                    if bool(id_set) and (
-                        next_id < max(id_set)
-                    ):  # set is not empty and current next_id is lesser.
-                        apiid = max(id_set) + 1
-                    else:
-                        next_id += 1
-                else:  # there is a default value in the header -- use it.
-                    # 'Recycle' case. We break our API by removing an existing
-                    # enum definition if it has changed ID in the header.
-                    if next_enum_def[2] in existing_api_id_to_enum_map:
-                        del existing_apiids[
-                            existing_api_id_to_enum_map[next_enum_def[2]]
-                        ]
-                    apiid = int(next_enum_def[2])
-            else:
-                if (
-                    len(next_enum_def) >= 3
-                    and next_enum_def[2]
-                    and int(next_enum_def[2]) != apiid
-                ):
-                    # We need to create a new enum value but leave the old one in place.
-                    # enum_mem = api_id_to_enum_map.get(int(items[2]), None)
-                    # if enum_mem:
-                    print(
-                        "Warning: Existing apiid for ",
-                        next_enum_def[0],
-                        " is different from the one in the header file. Existing: ",
-                        apiid,
-                        " vs Next: ",
-                        next_enum_def[2],
-                    )
-                    # 'Recycle' case. We break our API by allowing the enum to be reused by a future API.
-                    # This shouldn't happen after 2025.3.
-                    if next_enum_def[2] in existing_api_id_to_enum_map:
-                        del existing_apiids[
-                            existing_api_id_to_enum_map[next_enum_def[2]]
-                        ]
-
-                    add_version = True
-                    # Keep the existing API id
-                    existing_apiids[next_enum_def[0] + "_id"] = apiid
-                    # Use the new API id from the header file
-                    apiid = int(next_enum_def[2])
-                else:
-                    del existing_apiids[next_enum_def[0] + "_id"]
-
-            version_to_add = ""
-            if add_version:
-                version_to_add = get_new_version_tag(next_enum_def[0])
-
-            enum_line = f"{next_enum_def[0]}{version_to_add}_id=" + str(apiid)
-
-            api_id_and_line = (apiid, enum_line)
-            if api_id_and_line not in sorted_api_list:
-                bisect.insort(sorted_api_list, api_id_and_line)
-
-            id_counter += 1
-            id_set.add(apiid)
-
-            assert len(id_set) == id_counter, (
-                "Duplicated api id generated or found when creating from existing"
-            )
-            dst_validation_file.write(
-                "PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_"
-                + api_group.upper()
-                + ","
-                + str(apiid)
-                + ","
-                + "&api_name));\n"
-            )
-            dst_validation_file.write(
-                'EXPECT_STREQ(api_name, "'
-                + strip_version_from_api_name(next_enum_def[0])
-                + '");\n'
-            )
-
-        for func in existing_apiids:
-            apiid = existing_apiids[func]
-            if apiid not in id_set:
-                print("Existing: ", func, apiid)
-                api_id_and_line = (int(apiid), func + "=" + str(apiid))
-                if api_id_and_line not in sorted_api_list:
-                    bisect.insort(sorted_api_list, api_id_and_line)
-
-        enum_members = list()
-        for func in sorted_api_list:
-            # urApiFunction_v<>_id -> urApiFunction_v<>,
-            enum_members.append(f"{func[1].rsplit('_', 1)[0]},")
-            f.write("    " + func[1] + ",\n")
-        f.write(" } pti_api_id_" + category + "_" + api_group + ";\n")
-        f.write("\n")
-        gen_apiid_terminate_header(f)
-        return enum_members
-
-
-def generate_cb_api_file_info(cb_api_file, callbacks, category, api_group, regen=True):
-    cb_api_file.write(
-        "inline static std::unordered_map<uint32_t, const char*> pti_api_id_"
-        + category
-        + "_"
-        + api_group
-        + "_func_name =\n"
-    )
-    cb_api_file.write("  {\n")
-    if regen:
-        for func in callbacks:
-            items = func.partition(",")
-            cb_api_file.write(
-                "    {pti_api_id_"
-                + category
-                + "_"
-                + api_group
-                + "::"
-                + items[0]
-                + '_id, "'
-                + strip_version_from_api_name(items[0])
-                + '"},\n'
-            )
-    else:
-        for key in callbacks.keys():
-            items = key.split("_", 1)
-            cb_api_file.write(
-                "    {pti_api_id_"
-                + category
-                + "_"
-                + api_group
-                + "::"
-                + key
-                + ', "'
-                + items[0].strip()
-                + '"},\n'
-            )
-    cb_api_file.write("  }; \n\n")
-
-
-def generate_state_file_info(
-    api_state_file, callbacks, category, api_group, regen=True
-):
-    api_state_file.write(
-        "inline std::mutex " + api_group + "_set_granularity_map_mtx;\n"
-    )
-    api_state_file.write(
-        "inline std::unordered_map<uint32_t, uint32_t> pti_api_id_"
-        + category
-        + "_"
-        + api_group
-        + "_state =\n"
-    )
-    api_state_file.write("  {\n")
-    if regen:
-        for func in callbacks:
-            items = func.partition(",")
-            api_state_file.write(
-                "    {pti_api_id_"
-                + category
-                + "_"
-                + api_group
-                + "::"
-                + items[0]
-                + "_id, "
-                + "1"
-                + "},\n"
-            )
-    else:
-        for key in callbacks.keys():
-            api_state_file.write(
-                "    {pti_api_id_"
-                + category
-                + "_"
-                + api_group
-                + "::"
-                + key
-                + ", "
-                + "1"
-                + "},\n"
-            )
-    api_state_file.write("  }; \n\n")
-
-
-#
-# Generates Individual api_group related apiId files -- this is mapping of api functions to either generated apiId (where apiId is
-#    missing from the api header file (e.g. ze_api.h) or parsed apiId (where apiId is found in api file).
-# Input params:
-#     dst_path -- where will these apiid files be generated.
-#     cb_api_file -- file where the mapping from apiid -> function name will be kept -- this is needed for GetName from apiid.
-#     category_dict -- internal dictionary of (category, api_group): function_list.  Function list is parsed from api headers.
-#     existing_apiids_dict -- internal dictionary of parsed already known(existing) to pti apiid files in the dst_path.
-#     api_state_file -- full path to file where we will put the std::maps for keeping state information of api_id enables/disables
-#                       default is 1 -- that is all are enabled -- the state is controlled explicitly in the view_handler.
-#     dst_validation_file -- full path to temporary file we use to generate a validation test case.
-#     version_dict -- internal dictionary that keeps the parsed from api headers file version information (e.g from ze_api.h)
-#     regen_api_files -- flag which notes to the function whether user is requesting the api id files to be regenerated.
-#
-def gen_apiid_files_per_category(
-    dst_path,
-    cb_api_file,
-    category_dict,
-    existing_apiids_dict,
-    api_state_file,
-    dst_validation_file,
-    version_dict,
-    regen_api_files,
-):
-    # for category, callback_list in category_dict.items():
-    for cat_key, callback_list in category_dict.items():
-        category = cat_key[0]
-        api_group = cat_key[1]
-        apiids_file_path = os.path.join(
-            dst_path, "pti_" + category + "_" + api_group + "_api_ids.h"
-        )
-        existing_apiids = existing_apiids_dict.get(cat_key, {})
-        print("Generation: Working with: ", api_group)
-        print(existing_apiids.get("next_elem_index", 1))
-        if regen_api_files:
-            generated_apis = generate_api_file_portion(
-                apiids_file_path,
-                callback_list,
-                category,
-                api_group,
-                existing_apiids,
-                dst_validation_file,
-                version_dict,
-            )
-            generate_cb_api_file_info(
-                cb_api_file, generated_apis, category, api_group, regen_api_files
-            )
-
-            generate_state_file_info(
-                api_state_file, generated_apis, category, api_group, regen_api_files
-            )
-        else:
-            print(
-                "Skipped api_id generation - rebuilding collateral files from existing API files"
-            )
-            del existing_apiids["next_elem_index"]
-            generate_cb_api_file_info(
-                cb_api_file, existing_apiids, category, api_group, regen_api_files
-            )
-
-            generate_state_file_info(
-                api_state_file, existing_apiids, category, api_group, regen_api_files
-            )
-
-
-# Generates EnableTracing function and populates with registerable signatures for all APIs: partitioned by all or just kfunc.
-def gen_api(
-    f,
-    func_list,
-    kfunc_list,
-    exclude_from_epilogue_list,
-    exclude_from_prologue_list,
-    dst_api_dlsym_public_file,
-    dst_api_dlsym_private_file,
-    existing_apiid_dict,
-    regen_api_files,
-):
-    f.write("void EnableTracer(zel_tracer_handle_t tracer) {\n")
-    f.write("\n")
-    f.write("  if (options_.api_tracing) {\n")
-    cat_key = ("driver", "levelzero")
-    existing_apiids = existing_apiid_dict.get(cat_key, {})
-    for func in func_list:
-        #        f.write(
-        #            "    zelTracer"
-        #            + func[2:]
-        #            + "RegisterCallback("
-        #            + "tracer, ZEL_REGISTER_PROLOGUE, "
-        #            + func
-        #            + "OnEnter);\n"
-        #        )
-        #        f.write(
-        #            "    zelTracer"
-        #            + func[2:]
-        #            + "RegisterCallback("
-        #            + "tracer, ZEL_REGISTER_EPILOGUE, "
-        #            + func
-        #            + "OnExit);\n"
-        #        )
-        offset = 2
-        dst_api_dlsym_private_file.write(
-            "LEVEL_ZERO_LOADER_GET_SYMBOL(zelTracer"
-            + func[offset:]
-            + "RegisterCallback);\n"
-        )
-        dst_api_dlsym_public_file.write(
-            "decltype(&zelTracer"
-            + func[offset:]
-            + "RegisterCallback) zelTracer"
-            + func[offset:]
-            + "RegisterCallback_ = nullptr;  // NOLINT\n"
-        )
-        f.write(
-            "    if (pti::PtiLzTracerLoader::Instance().zelTracer"
-            + func[offset:]
-            + "RegisterCallback_) {\n"
-        )
-        f.write(
-            "        pti::PtiLzTracerLoader::Instance().zelTracer"
-            + func[offset:]
-            + "RegisterCallback_("
-            + "tracer, ZEL_REGISTER_PROLOGUE, "
-            + func
-            + "OnEnter);\n"
-        )
-        f.write(
-            "        pti::PtiLzTracerLoader::Instance().zelTracer"
-            + func[offset:]
-            + "RegisterCallback_("
-            + "tracer, ZEL_REGISTER_EPILOGUE, "
-            + func
-            + "OnExit);\n"
-        )
-        f.write("    }\n")
-    f.write("  }\n")
-
-    f.write(
-        "  else if (options_.kernel_tracing || IsAnyCallbackSubscriberActive() ) {\n"
-    )
-    offset = 2
-    for func in kfunc_list:
-        # if func not in exclude_from_prologue_list:
-        #    f.write(
-        #        "    zelTracer"
-        #        + func[2:]
-        #        + "RegisterCallback("
-        #        + "tracer, ZEL_REGISTER_PROLOGUE, "
-        #        + func
-        #        + "OnEnter);\n"
-        #    )
-        # if func not in exclude_from_epilogue_list:
-        #    f.write(
-        #        "    zelTracer"
-        #        + func[2:]
-        #        + "RegisterCallback("
-        #        + "tracer, ZEL_REGISTER_EPILOGUE, "
-        #        + func
-        #        + "OnExit);\n"
-        #    )
-        f.write(
-            "    if (pti::PtiLzTracerLoader::Instance().zelTracer"
-            + func[offset:]
-            + "RegisterCallback_) {\n"
-        )
-        if func not in exclude_from_prologue_list:
-            f.write(
-                "        pti::PtiLzTracerLoader::Instance().zelTracer"
-                + func[offset:]
-                + "RegisterCallback_("
-                + "tracer, ZEL_REGISTER_PROLOGUE, "
-                + func
-                + "OnEnter);\n"
-            )
-        if func not in exclude_from_epilogue_list:
-            f.write(
-                "        pti::PtiLzTracerLoader::Instance().zelTracer"
-                + func[offset:]
-                + "RegisterCallback_("
-                + "tracer, ZEL_REGISTER_EPILOGUE, "
-                + func
-                + "OnExit);\n"
-            )
-        f.write("    }\n")
-    f.write("  }\n")
-
-    f.write("\n")
-    f.write("  ze_result_t status = ZE_RESULT_SUCCESS;\n")
-    f.write("\n")
-    f.write("  overhead::Init();\n")
-    f.write("  status = zelTracerSetEnabled(tracer, true);\n")
-    f.write("  overhead_fini(zelTracerSetEnabled_id);\n")
-    f.write("  PTI_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-    f.write("}\n")
-    f.write("\n")
-
-
-# TODO -- is this needed?
-def gen_structure_type_converter(f, enum_map):
-    struct_type_enum = {}
-    for name in enum_map["ze_structure_type_t"]:
-        struct_type_enum[name] = int(enum_map["ze_structure_type_t"][name])
-    struct_type_enum = sorted(struct_type_enum.items(), key=lambda x: x[1])
-    assert "ze_structure_type_t" in enum_map
-    f.write("static const char* GetStructureTypeString(unsigned structure_type) {\n")
-    f.write("  switch (structure_type) {\n")
-    for name, value in struct_type_enum:
-        f.write("    case " + name + ":\n")
-        f.write('      return "' + name + '";\n')
-    f.write("    default:\n")
-    f.write("      break;\n")
-    f.write("  }\n")
-    f.write('  return "UNKNOWN";\n')
-    f.write("}\n")
-    f.write("\n")
-
-
-# TODO -- is this needed?
-def gen_result_converter(f, enum_map):
-    result_enum = {}
-    for name in enum_map["ze_result_t"]:
-        result_enum[name] = int(enum_map["ze_result_t"][name])
-    result_enum = sorted(result_enum.items(), key=lambda x: x[1])
-    assert "ze_result_t" in enum_map
-    f.write("static const char* GetResultString(unsigned result) {\n")
-    f.write("  switch (result) {\n")
-    for name, value in result_enum:
-        f.write("    case " + name + ":\n")
-        f.write('      return "' + name + '";\n')
-    f.write("    default:\n")
-    f.write("      break;\n")
-    f.write("  }\n")
-    f.write('  return "UNKNOWN";\n')
-    f.write("}\n")
-    f.write("\n")
-
-
-# Checks if forwarding callback exists in ze_collector.h -- used to check before the stub issues the forwarding call.
-def get_kernel_tracing_callback(func):
-    d = os.path.dirname(os.path.abspath(__file__))
-    cb = ""
-    with open(
-        os.path.join(d, "levelzero", "ze_collector.h"), opener=default_file_opener
-    ) as fp:
-        if func in fp.read():
-            cb = func
-        fp.close()
-        return cb
-
-
-# Generate the OnEnter stub and issue forwarding call if cb exists in ze_collector.h
-def gen_enter_callback(f, func, synchronize_func_list_on_enter, hybrid_mode_func_list):
-    f.write("  [[maybe_unused]] ZeCollector* collector =\n")
-    f.write("    static_cast<ZeCollector*>(global_data);\n")
-    if func not in hybrid_mode_func_list:
-        f.write("  if (collector->options_.hybrid_mode) return;\n")
-
-    f.write("  ze_instance_data.callback_id_ = " + func + "_id;\n")
-    if func in synchronize_func_list_on_enter:
-        f.write("  std::vector<uint64_t> kids;\n")
-
-    cb = get_kernel_tracing_callback("OnEnter" + func[2:])
-    if cb != "":
-        f.write("\n")
-        f.write(
-            "  if (collector->options_.kernel_tracing || collector->IsAnyCallbackSubscriberActive() ) { \n"
-        )
-        if func in synchronize_func_list_on_enter:
-            f.write(
-                "    " + cb + "(params, global_data, instance_user_data, &kids); \n"
-            )
-            f.write("    if (kids.size() != 0) {\n")
-            f.write(
-                "        ze_instance_data.kid = kids[0];\n"
-            )  # pass kid to the exit callback
-            f.write("    }\n")
-            f.write("    else {\n")
-            f.write("        ze_instance_data.kid = (uint64_t)(-1);\n")
-            f.write("    }\n")
-        else:
-            f.write("    " + cb + "(params, global_data, instance_user_data); \n")
-        f.write("  }\n")
-    f.write("\n")
-
-    f.write("  uint64_t start_time_host = 0;\n")
-    f.write("  start_time_host = utils::GetTime();\n")
-
-    f.write("  ze_instance_data.start_time_host = start_time_host;\n")
-
-
-# Generate the OnExit stub and issue forwarding call if cb exists in ze_collector.h
-def gen_exit_callback(
-    f,
-    func,
-    return_value,
-    submission_func_list,
-    synchronize_func_list_on_enter,
-    synchronize_func_list_on_exit,
-    hybrid_mode_func_list,
-    km_rt_func_list,
-    ze_gen_func_list,
-    existing_apiid_dict,
-    regen_api_files,
-    synchronization_viewkind_api_list,
-):
-    cat_key = ("driver", "levelzero")
-    existing_apiids = existing_apiid_dict.get(cat_key, {})
-
-    f.write("  [[maybe_unused]] ZeCollector* collector =\n")
-    f.write("    static_cast<ZeCollector*>(global_data);\n")
-    if func not in hybrid_mode_func_list:
-        f.write("  if (collector->options_.hybrid_mode) return;\n")
-
-    f.write("  [[maybe_unused]] uint64_t end_time_host = 0;\n")
-    f.write("  end_time_host = utils::GetTime();\n")
-    f.write("  ze_instance_data.end_time_host = end_time_host;\n")
-    f.write("  ze_instance_data.callback_id_ = " + func + "_id;\n")
-
-    cb = get_kernel_tracing_callback("OnExit" + func[2:])
-
-    if (
-        (func in submission_func_list)
-        or (func in synchronize_func_list_on_enter)
-        or (func in synchronize_func_list_on_exit)
-    ):
-        f.write("  std::vector<uint64_t> kids;\n")
-
-    if (
-        func in synchronize_func_list_on_enter
-    ):  # enter callback pass the kids to exit callback
-        f.write("  if (ze_instance_data.kid != (uint64_t)(-1)) {\n")
-        f.write("      kids.push_back(ze_instance_data.kid);\n")
-        f.write("  }\n")
-
-    if func in synchronization_viewkind_api_list:
-        f.write("  uint64_t synch_corrid = UniCorrId::GetUniCorrId();\n")
-
-    if cb != "":
-        f.write(
-            "  if (collector->options_.kernel_tracing || collector->IsAnyCallbackSubscriberActive() ) { \n"
-        )
-        if (func in submission_func_list) or (func in synchronize_func_list_on_exit):
-            if func in synchronization_viewkind_api_list:
-                f.write(
-                    "    "
-                    + cb
-                    + "(params, result, global_data, instance_user_data, &kids, synch_corrid); \n"
-                )
-            else:
-                f.write(
-                    "    "
-                    + cb
-                    + "(params, result, global_data, instance_user_data, &kids); \n"
-                )
-        else:
-            if func in synchronization_viewkind_api_list:
-                f.write(
-                    "    "
-                    + cb
-                    + "(params, result, global_data, instance_user_data, synch_corrid); \n"
-                )
-            else:
-                f.write(
-                    "    "
-                    + cb
-                    + "(params, result, global_data, instance_user_data); \n"
-                )
-        f.write("  }\n")
-
-        f.write("\n")
-
-    f.write("\n")
-    f.write("  uint64_t start_time_host = ze_instance_data.start_time_host;\n")
-    f.write("\n")
-    f.write("  if (start_time_host == 0) {\n")
-    f.write("    return;\n")
-    f.write("  }\n")
-
-    if regen_api_files or (func + "_id" in existing_apiids):
-        # The following assert()'s are debug asserts and become noops in release builds
-        f.write("  [[maybe_unused]] const char* api_name = nullptr;\n")
-        f.write(
-            "  assert(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, "
-            + func
-            + "_id, &api_name) == pti_result::PTI_SUCCESS);\n"
-        )
-        f.write("  assert(std::strcmp(api_name, " + '"' + func + '") == 0);\n')
-        f.write("  uint32_t id_enabled=1;\n")
-        f.write("  {\n")
-        f.write(
-            "    const std::lock_guard<std::mutex> lock(levelzero_set_granularity_map_mtx);\n"
-        )
-        f.write("    id_enabled=pti_api_id_driver_levelzero_state[" + func + "_id];\n")
-        f.write("  }\n")
-        f.write(
-            "  if (collector->cb_enabled_.fcallback && collector->options_.lz_enabled_views.api_calls_enabled && collector->fcallback_ != nullptr) {\n"
-        )
-        f.write(
-            "    if ((collector->trace_all_env_value > 0) || ((collector->trace_all_env_value < 0) && id_enabled )) {\n"
-        )
-        f.write("       ZeKernelCommandExecutionRecord rec = {};\n")
-        f.write("       rec.start_time_ = start_time_host;\n")
-        f.write("       rec.end_time_ = end_time_host;\n")
-        f.write("       rec.callback_id_ = " + func + "_id;\n")
-        if func in km_rt_func_list:
-            f.write("       if (sycl_data_kview.cid_) {\n")
-            f.write("         rec.cid_ = sycl_data_kview.cid_;\n")
-            f.write("       } else if (sycl_data_mview.cid_) {\n")
-            f.write("         rec.cid_ = sycl_data_mview.cid_;\n")
-            f.write("       } else {\n")
-            f.write("          if (collector->options_.kernel_tracing) {\n")
-            f.write(
-                "           // UniCorrId was already incremented when GPU op was processed\n"
-            )
-            f.write(
-                "           // For correlation purposes PTI need to assign and report the same corr_id\n"
-            )
-            f.write("           // on the corresponding Driver API record\n")
-            f.write(
-                "           // TODO (PTI-289): ensure this works when only particular GPU ops (e.g. memory fill) requested for ptiView\n"
-            )
-            f.write(
-                "           //   this would require instead of one collector->options_.kernel_tracing option field - have several ones\n"
-            )
-            f.write("           if (*instance_user_data != nullptr) {\n")
-            f.write(
-                "             rec.cid_ = (static_cast<ZeKernelCommand*>(*instance_user_data))->corr_id_;\n"
-            )
-            f.write("           } else {\n")
-            f.write("             rec.cid_ = UniCorrId::GetUniCorrId();\n")
-            f.write("           }\n")
-            f.write("          } else {\n")
-            f.write("           rec.cid_ = UniCorrId::GetUniCorrId();\n")
-            f.write("          }\n")
-            f.write("       }\n")
-        else:
-            if func in synchronization_viewkind_api_list:
-                f.write("       rec.cid_ = synch_corrid;\n")
-            else:
-                f.write("       rec.cid_ = UniCorrId::GetUniCorrId();\n")
-        if func in km_rt_func_list:
-            f.write("       sycl_data_kview.cid_ = 0;\n")
-            f.write("       sycl_data_mview.cid_ = 0;\n")
-        # f.write("    sycl_data_kview.cid_ = 0;\n")
-        # f.write("    sycl_data_mview.cid_ = 0;\n")
-        f.write("       rec.pid_ = PidTidInfo::Get().pid;\n")
-        f.write("       rec.tid_ = PidTidInfo::Get().tid;\n")
-
-        if return_value.startswith("ze_result_t"):
-            f.write("       rec.result_ = result;\n")
-        else:
-            f.write("       rec.result_ = " + func + "ReturnStatus(result);\n")
-        f.write("       collector->fcallback_(collector->callback_data_, rec);\n")
-        f.write("    }\n")
-        f.write("  }\n")
-        f.write("\n")
-
-
-def gen_return_func(f, func):
-    if func in ["zeDriverGetDefaultContext"]:
-        f.write("static ze_result_t " + func + "ReturnStatus(\n")
-        f.write("    [[maybe_unused]]" + "ze_context_handle_t result) {\n")
-        f.write(
-            "  return (result != nullptr ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN);\n"
-        )
-        f.write("}\n")
-
-
-# Generate OnEnter and OnExit callbacks.
-def gen_callbacks(
-    f,
-    func_param_dict,
-    submission_func_list,
-    synchronize_func_list_on_enter,
-    synchronize_func_list_on_exit,
-    hybrid_mode_func_list,
-    km_rt_func_list,
-    ze_gen_func_list,
-    existing_apiid_dict,
-    regen_api_files,
-    synchronization_viewkind_api_list,
-    l0_apis_with_diff_return_status,
-):
-    for func in func_param_dict.keys():
-        # print ("+++ Function : ", func)
-        f.write("static void " + func + "OnEnter(\n")
-        f.write("    [[maybe_unused]]" + func_param_dict[func][0] + "\n")
-        f.write("    [[maybe_unused]]" + func_param_dict[func][1] + "\n")
-
-        f.write("    [[maybe_unused]]void* global_data,\n")
-        f.write("    [[maybe_unused]]void** instance_user_data) {\n")
-        gen_enter_callback(
-            f, func, synchronize_func_list_on_enter, hybrid_mode_func_list
-        )
-        f.write("}\n")
-        f.write("\n")
-        if func in l0_apis_with_diff_return_status:
-            gen_return_func(f, func)
-            f.write("\n")
-        f.write("static void " + func + "OnExit(\n")
-        f.write("    [[maybe_unused]]" + func_param_dict[func][0] + "\n")
-        f.write("    [[maybe_unused]]" + func_param_dict[func][1] + "\n")
-
-        f.write("    [[maybe_unused]]void* global_data,\n")
-        f.write("    [[maybe_unused]]void** instance_user_data) {\n")
-        gen_exit_callback(
-            f,
-            func,
-            func_param_dict[func][1],  # func return type
-            submission_func_list,
-            synchronize_func_list_on_enter,
-            synchronize_func_list_on_exit,
-            hybrid_mode_func_list,
-            km_rt_func_list,
-            ze_gen_func_list,
-            existing_apiid_dict,
-            regen_api_files,
-            synchronization_viewkind_api_list,
-        )
-        f.write("}\n")
-        f.write("\n")
-
-
-def append_undefined_functions(func_list, func_dictionary):
-    """
-    In Level-Zero 14 that PTI uses to build - these functions are not defined yet.
-    However, for Local profiling, PTI relies on these functions being present in the
-    L0 that is installed on the system.
-    We add these functions to the list of functions that are used to generate ApiId.
-    ApiIds are needed for overhead measurements.
-    We generate ApiIds for the tracing API functions as well. These functions also
-    contribute to the overhead.
-    """
-    additional_functions = [
-        "zeEventPoolGetFlags",
-        "zeCommandListGetDeviceHandle",
-        "zeCommandListGetContextHandle",
-        "zeCommandListIsImmediate",
-        "zeCommandListImmediateGetIndex",
-        "zeCommandListGetOrdinal",
-        "zeCommandQueueGetIndex",
-        "zeCommandQueueGetOrdinal",
-    ]
-
-    tracing_functions = [
-        "zelTracerSetEnabled",
-        "zelTracerCreate",
-    ]
-
-    for func in additional_functions:
-        if func not in func_dictionary.keys():
-            func_list.append(func)
-
-    for func in tracing_functions:
-        func_list.append(func)
-
-
-def main():
-    if len(sys.argv) < 6:
-        print(
-            "Usage: python gen_tracing_callbacks.py <output_include_path> <l0_include_path> <proj_bin_path> <pti_include_path> <ur_path> <regen_info> <regen_commit_hash>"
-        )
-        return
-
-    print(
-        "Using: python gen_tracing_callbacks.py",
-        sys.argv[1],
-        sys.argv[2],
-        sys.argv[3],
-        sys.argv[4],
-        sys.argv[5],
-        sys.argv[6],
-        sys.argv[7],
-    )
-
-    # TODO -- change the regen to take in a target L0 version to regenerate the api ids to.
-    dst_path = sys.argv[1]
-    if not os.path.exists(dst_path):
-        os.mkdir(dst_path)
-
-    dst_file_path = os.path.join(dst_path, "tracing.gen")
-    if os.path.isfile(dst_file_path):
-        os.remove(dst_file_path)
-    dst_file = open(dst_file_path, "wt", opener=default_file_opener)
-
-    dst_cb_api_file_path = os.path.join(dst_path, "tracing_cb_api.gen")
-    if os.path.isfile(dst_cb_api_file_path):
-        os.remove(dst_cb_api_file_path)
-    dst_cb_api_file = open(dst_cb_api_file_path, "wt", opener=default_file_opener)
-
-    dst_validation_file_with_path = os.path.join(
-        dst_path, "tracing_base_apiid_validation_file.gen"
-    )
-    if os.path.isfile(dst_validation_file_with_path):
-        os.remove(dst_validation_file_with_path)
-    dst_validation_file = open(
-        dst_validation_file_with_path, "wt", opener=default_file_opener
-    )
-
-    dst_api_dlsym_private_file_path = os.path.join(
-        dst_path, "tracing_api_dlsym_private.gen"
-    )
-    dst_api_dlsym_public_file_path = os.path.join(
-        dst_path, "tracing_api_dlsym_public.gen"
-    )
-    if os.path.isfile(dst_api_dlsym_private_file_path):
-        os.remove(dst_api_dlsym_private_file_path)
-        os.remove(dst_api_dlsym_public_file_path)
-    dst_api_dlsym_private_file = open(
-        dst_api_dlsym_private_file_path, "wt", opener=default_file_opener
-    )
-    dst_api_dlsym_public_file = open(
-        dst_api_dlsym_public_file_path, "wt", opener=default_file_opener
-    )
-
-    l0_path = sys.argv[2]
-
-    # Extract registerable apis from 2 headers (ze_api.h, layers/zel_tracing_register_cb.h)
-    # Both are complementary. One addresses APIs from v1.0(ze_api.h) the other v1.1+.
-    l0_file_path_api_1_0 = os.path.join(l0_path, "ze_api.h")
-    l0_file_path_api_1_1_plus = os.path.join(
-        l0_path, "layers", "zel_tracing_register_cb.h"
-    )
-
-    print("L0 files: ", l0_file_path_api_1_0, l0_file_path_api_1_1_plus)
-
-    proj_bin_path = sys.argv[3]
-    api_state_file_with_path = os.path.join(proj_bin_path, "pti_api_ids_state_maps.h")
-    if os.path.isfile(api_state_file_with_path):
-        os.remove(api_state_file_with_path)
-    api_state_file = open(api_state_file_with_path, "wt", opener=default_file_opener)
-
-    gen_apiid_header(api_state_file, "STATE_MAPS", ())
-    api_state_file.write("#include <unordered_map>\n")
-    api_state_file.write("#include <mutex>")
-    api_state_file.write("\n\n")
-    api_state_file.write('#include "pti/pti_driver_levelzero_api_ids.h"\n')
-    api_state_file.write('#include "pti/pti_runtime_sycl_api_ids.h"')
-    api_state_file.write("\n\n")
-
-    pti_inc_path = sys.argv[4]
-    ur_path = sys.argv[5]
-
-    ur_file_path = None
-    try:
-        ur_file_path = get_ur_api_file_path(ur_path)
-    except Exception as e:
-        print(f"Invalid path provided {ur_path}, defaulting to current API ids. {e}")
-
-    if ur_file_path:
-        print("Found UR Path: ", ur_file_path)
-
-    regen_api_files = False  # Should we regenerate and update API ID files as well?
-    if sys.argv[6] == "ON":
-        print("Regeneration of API files requested!")
-        regen_api_files = True  # Should we regenerate and update API ID files as well?
-
-    l0_loader_info = sys.argv[7]
-
-    # UNDO_WHEN_OCL ocl_api_list = get_ocl_api_list(ocl_path)
-    ocl_api_list = []
-
-    l0_api_files = [l0_file_path_api_1_0, l0_file_path_api_1_1_plus]
-    func_param_dictionary, l0_api_version = gen_func_param_dict(l0_api_files)
-    func_list = list(func_param_dictionary.keys())
-
-    kfunc_list = [
-        "zeEventCreate",
-        "zeEventDestroy",
-        "zeEventHostReset",
-        "zeEventPoolCreate",
-        "zeEventPoolDestroy",
-        "zeCommandListAppendLaunchKernel",
-        "zeCommandListAppendLaunchKernelWithArguments",
-        "zeCommandListAppendLaunchKernelWithParameters",
-        "zeCommandListAppendLaunchCooperativeKernel",
-        "zeCommandListAppendLaunchKernelIndirect",
-        "zeCommandListAppendMemoryCopy",
-        "zeCommandListAppendMemoryFill",
-        "zeCommandListAppendBarrier",
-        "zeCommandListAppendMemoryRangesBarrier",
-        # "zeContextSystemBarrier",
-        "zeCommandListAppendMemoryCopyRegion",
-        "zeCommandListAppendMemoryCopyFromContext",
-        "zeCommandListAppendImageCopy",
-        "zeCommandListAppendImageCopyRegion",
-        "zeCommandListAppendImageCopyToMemory",
-        "zeCommandListAppendImageCopyFromMemory",
-        "zeCommandQueueExecuteCommandLists",
-        "zeCommandListCreate",
-        "zeCommandListCreateImmediate",
-        "zeCommandListDestroy",
-        "zeCommandListReset",
-        "zeCommandQueueCreate",
-        "zeCommandQueueSynchronize",
-        "zeCommandQueueDestroy",
-        "zeImageCreate",
-        "zeImageDestroy",
-        "zeKernelSetGroupSize",
-        "zeKernelCreate",
-        "zeKernelDestroy",
-        "zeEventHostSynchronize",
-        "zeFenceCreate",
-        "zeFenceHostSynchronize",
-        "zeEventQueryStatus",
-        "zeCommandListHostSynchronize",
-        "zeDeviceSynchronize",
-        "zeContextDestroy",
-        "zeModuleCreate",
-        "zeModuleDestroy",
-    ]
-
-    ze_gen_func_list = [
-        "zeCommandListAppendLaunchKernel",
-        "zeCommandListAppendLaunchKernelWithArguments",
-        "zeCommandListAppendLaunchKernelWithParameters",
-    ]
-
-    km_rt_func_list = [
-        "zeCommandListAppendLaunchKernel",
-        "zeCommandListAppendLaunchKernelWithArguments",
-        "zeCommandListAppendLaunchKernelWithParameters",
-        "zeCommandListAppendLaunchCooperativeKernel",
-        "zeCommandListAppendLaunchKernelIndirect",
-        "zeCommandListAppendMemoryCopy",
-        "zeCommandListAppendMemoryFill",
-        "zeCommandListAppendMemoryCopyRegion",
-        "zeCommandListAppendMemoryCopyFromContext",
-        "zeCommandListAppendImageCopy",
-        "zeCommandListAppendImageCopyRegion",
-        "zeCommandListAppendImageCopyToMemory",
-        "zeCommandListAppendImageCopyFromMemory",
-    ]
-
-    hybrid_mode_func_list = ["zeEventPoolCreate"]
-
-    submission_func_list = [
-        "zeCommandQueueExecuteCommandLists",
-        "zeCommandListAppendLaunchKernel",
-        "zeCommandListAppendLaunchKernelWithArguments",
-        "zeCommandListAppendLaunchKernelWithParameters",
-        "zeCommandListAppendLaunchCooperativeKernel",
-        "zeCommandListAppendLaunchKernelIndirect",
-        "zeCommandListAppendMemoryCopy",
-        "zeCommandListAppendMemoryFill",
-        "zeCommandListAppendBarrier",
-        "zeCommandListAppendMemoryRangesBarrier",
-        "zeCommandListAppendMemoryCopyRegion",
-        "zeCommandListAppendMemoryCopyFromContext",
-        "zeCommandListAppendImageCopy",
-        "zeCommandListAppendImageCopyRegion",
-        "zeCommandListAppendImageCopyToMemory",
-        "zeCommandListAppendImageCopyFromMemory",
-    ]
-
-    synchronize_func_list_on_enter = ["zeEventDestroy", "zeEventHostReset"]
-
-    synchronize_func_list_on_exit = [
-        "zeCommandListHostSynchronize",
-        "zeEventHostSynchronize",
-        "zeEventQueryStatus",
-        "zeFenceHostSynchronize",
-        "zeCommandQueueSynchronize",
-    ]
-
-    synchronization_viewkind_api_list = [
-        "zeFenceHostSynchronize",
-        "zeCommandListAppendBarrier",
-        "zeCommandListAppendMemoryRangesBarrier",
-        # "zeContextSystemBarrier",
-        "zeEventHostSynchronize",
-        "zeCommandQueueSynchronize",
-        "zeCommandListHostSynchronize",
-        "zeDeviceSynchronize",
-    ]
-
-    #   There are few level zero APIs which do not return ze_result_t hence need special handling
-    l0_apis_with_diff_return_status = [
-        "zeDriverGetDefaultContext",
-    ]
-    exclude_from_epilogue_list = []
-
-    exclude_from_prologue_list = ["zeCommandListHostSynchronize"]
-
-    #######################################################
-    # Callbacks API api_group/category lists with apis within
-    # Max 64 categories can be supported
-    #######################################################
-
-    runtime_list = [
-        "zeCommandListAppendLaunchKernel",
-        "zeCommandListAppendLaunchKernelWithArguments",
-        "zeCommandListAppendLaunchKernelWithParameters",
-    ]
-
-    resource_list = []
-
-    if ur_file_path:
-        ur_func_list, ur_api_version = get_ur_api_list(ur_file_path)
-    else:
-        current_sycl_runtime_pti_file_path = os.path.join(
-            pti_inc_path, "pti_runtime_sycl_api_ids.h"
-        )
-        ur_func_list, ur_api_version = get_current_ur_api_list(
-            current_sycl_runtime_pti_file_path
-        )
-        ur_file_path = current_sycl_runtime_pti_file_path
-
-    # category_dict = {"runtime": ur_func_list, "driver": func_list}
-    # category_dict = {"runtime": ur_func_list, "driver": func_list + ocl_api_list}
-    # It is important to keep all categories(runtime,driver) together and maintain the order of api_groups(sycl, levelzero)
-    #    in the category.
-    category_dict = {
-        ("runtime", "sycl"): ur_func_list,
-        ("driver", "levelzero"): func_list,
-        # ("driver", "opencl"): ocl_api_list,
-    }
-
-    version_dict = {
-        "levelzero": (
-            l0_api_version,
-            l0_file_path_api_1_0.split("/")[-1],
-            "https://github.com/oneapi-src/level-zero.git",
-            l0_loader_info,
-        ),
-        "sycl": (
-            ur_api_version,
-            ur_file_path.split("/")[-1],
-            "https://github.com/oneapi-src/unified-runtime.git",
-            "",
-        ),
-    }
-
-    # append runtime apis aa well
-    existing_apiid_dict = get_apiids_per_category(pti_inc_path, category_dict)
-
-    # Instead of using ze_api.h directly to generate the internal maps and
-    # such, we will use the existing API files (unless regeneration is
-    # requested). This prevents the build from breaking on newer level zero
-    # versions than requested.
-    if not regen_api_files:
-        ze_existing_apiids = existing_apiid_dict.get(("driver", "levelzero"), {})
-        for function_name in list(func_param_dictionary.keys()):
-            if function_name + "_id" not in ze_existing_apiids:
-                print(
-                    f"Excluding {function_name} {func_param_dictionary.pop(function_name, None)}"
-                )
-
-        func_list = list(func_param_dictionary.keys())
-        # Overwrite category_dict to only include functions that are present in the
-        # PTI headers.
-        category_dict[("driver", "levelzero")] = func_list
-
-    gen_callbacks(
-        dst_file,
-        func_param_dictionary,
-        submission_func_list,
-        synchronize_func_list_on_enter,
-        synchronize_func_list_on_exit,
-        hybrid_mode_func_list,
-        km_rt_func_list,
-        ze_gen_func_list,
-        existing_apiid_dict,
-        regen_api_files,
-        synchronization_viewkind_api_list,
-        l0_apis_with_diff_return_status,
-    )
-    gen_api(
-        dst_file,
-        func_list,
-        kfunc_list,
-        exclude_from_epilogue_list,
-        exclude_from_prologue_list,
-        dst_api_dlsym_public_file,
-        dst_api_dlsym_private_file,
-        existing_apiid_dict,
-        regen_api_files,
-    )
-
-    # Add functions that may be undefined in the L0 header used to build PTI,
-    # but typically found in runtime (when using recent L0).
-    # They will be used from the list of appended undefined functions here
-    # to generate ApiIds for them. ApiIds are needed for overhead collection.
-    append_undefined_functions(
-        category_dict[("driver", "levelzero")], func_param_dictionary
-    )
-
-    gen_apiid_files_per_category(
-        pti_inc_path,
-        dst_cb_api_file,
-        category_dict,
-        existing_apiid_dict,
-        api_state_file,
-        dst_validation_file,
-        version_dict,
-        regen_api_files,
-    )
-    gen_apiid_terminate_header(api_state_file)
-
-    dst_file.close()
-    dst_cb_api_file.close()
-    dst_validation_file.close()
-    if not regen_api_files:
-        os.remove(dst_validation_file_with_path)
-    api_state_file.close()
-    dst_api_dlsym_private_file.close()
-    dst_api_dlsym_public_file.close()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/sdk/src/itt/itt_adapter.cc b/sdk/src/itt/itt_adapter.cc
deleted file mode 100644
index 62760bd5..00000000
--- a/sdk/src/itt/itt_adapter.cc
+++ /dev/null
@@ -1,351 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-#define ITTAPI_CDECL __attribute__((visibility("default")))
-#include <ittnotify.h>
-#include <ittnotify_config.h>
-#include <spdlog/spdlog.h>
-
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <utility>
-
-#include "itt/itt_lib_env.h"
-#include "pti_lib_handler.h"
-#include "utils/utils.h"
-
-namespace {
-
-struct LoadTimeIttConfig {
-  std::string pti_module_path_adapter_;
-  itt_lib_env::IttCollectorConfig config_adapter_ =
-      itt_lib_env::IttCollectorConfig::kConfigurationFailed;
-  std::string configured_collector_path_adapter_;
-};
-
-// Registers this module as ittnotify collector when no collector was supplied
-// externally. It must run before oneCCL makes its first ITT call.
-class GlobalIttInitializer {
- public:
-  static LoadTimeIttConfig Initialize() noexcept {
-    LoadTimeIttConfig result;
-    try {
-      result.pti_module_path_adapter_ = utils::GetPathToSharedObject(Initialize);
-      result.config_adapter_ = itt_lib_env::ConfigureIttCollector(result.pti_module_path_adapter_);
-      result.configured_collector_path_adapter_ = utils::GetEnv(itt_lib_env::kIttLibEnvVarName);
-    } catch (...) {
-      result.config_adapter_ = itt_lib_env::IttCollectorConfig::kConfigurationFailed;
-    }
-    return result;
-  }
-
-  inline static const LoadTimeIttConfig configuration_adapter_ = Initialize();
-};
-
-static std::atomic<__itt_global *> g_itt_global_of_ccl_domain{nullptr};
-static std::atomic<const __itt_domain *> g_ccl_domain_cached{nullptr};
-
-static const char *kNoIttGlobalOfCclDomainString = "No IttGlobalOfCclDomain available";
-static const char *const kCclDomainString = "oneCCL::API";
-
-inline const __itt_domain *GetCacheCclDomainAdapter(const __itt_domain *domain) {
-  const __itt_domain *cached = g_ccl_domain_cached.load(std::memory_order_relaxed);
-  if (cached != nullptr) return cached;
-  if (domain != nullptr && domain->nameA != nullptr &&
-      !std::strcmp(domain->nameA, kCclDomainString)) {
-    const __itt_domain *expected = nullptr;
-    g_ccl_domain_cached.compare_exchange_strong(expected, domain, std::memory_order_relaxed);
-    return domain;
-  }
-  return nullptr;
-}
-
-}  // namespace
-
-itt_lib_env::IttCollectorConfig itt_lib_env::GetIttCollectorConfig() {
-  return GlobalIttInitializer::configuration_adapter_.config_adapter_;
-}
-
-const std::string &itt_lib_env::GetSelectedIttCollectorPath() {
-  return GlobalIttInitializer::configuration_adapter_.configured_collector_path_adapter_;
-}
-
-const std::string &itt_lib_env::GetPtiIttCollectorPath() {
-  return GlobalIttInitializer::configuration_adapter_.pti_module_path_adapter_;
-}
-
-__itt_global *GetIttGlobalOfCclDomainAdapter() {
-  __itt_global *g = g_itt_global_of_ccl_domain.load(std::memory_order_acquire);
-  return g;
-}
-
-const __itt_domain *GetIttCclDomainAdapter() { return GetCacheCclDomainAdapter(nullptr); }
-
-// Helper template to forward ITT calls with domain check (only forwards oneCCL::API domain)
-template <typename Func, typename... Args>
-static void ForwardIttCallIfCclDomain(const __itt_domain *domain, Func handler_member_ptr,
-                                      Args &&...args) {
-  if (domain) {
-    if (GetCacheCclDomainAdapter(domain) == domain) {
-      if (pti::PtiLibHandler::IsSuccessfullyInitialized()) {
-        auto &handler = pti::PtiLibHandler::Instance();
-        auto func = handler.*handler_member_ptr;
-        if (func) {
-          func(std::forward<Args>(args)...);
-        }
-      }
-
-    } else {
-      SPDLOG_DEBUG(
-          "{}() Adapter Non-standard domain (global unknown): domain_name: {}, "
-          "domain ptr: {} - Apply domain->flags = 0 ",
-          __FUNCTION__, domain->nameA, static_cast<const void *>(domain));
-      // this is a data race - but we better shut down this domain, to avoid overhead
-      auto *mutable_domain = const_cast<__itt_domain *>(domain);
-      mutable_domain->flags = 0;
-    }
-  }
-}
-
-// Adapter functions that wrap handler calls
-static void ITTAPI itt_task_begin_adapter(const __itt_domain *domain, __itt_id taskid,
-                                          __itt_id parentid, __itt_string_handle *name) {
-  SPDLOG_DEBUG("{}() Adapter - domain_name: {}, domain ptr: {}, task_name: {}", __FUNCTION__,
-               domain ? domain->nameA : "NULL", static_cast<const void *>(domain),
-               name ? name->strA : "NULL");
-  ForwardIttCallIfCclDomain(domain, &pti::PtiLibHandler::itt_task_begin_, domain, taskid, parentid,
-                            name);
-}
-
-static void ITTAPI itt_task_end_adapter(const __itt_domain *domain) {
-  SPDLOG_DEBUG("{}() Adapter - domain_name: {}, domain ptr: {}", __FUNCTION__,
-               domain ? domain->nameA : "NULL", static_cast<const void *>(domain));
-  ForwardIttCallIfCclDomain(domain, &pti::PtiLibHandler::itt_task_end_, domain);
-}
-
-static void ITTAPI itt_metadata_add_adapter(const __itt_domain *domain, __itt_id id,
-                                            __itt_string_handle *key, __itt_metadata_type type,
-                                            size_t count, void *data) {
-  SPDLOG_DEBUG("{}() Adapter - domain: {}, key: {}", __FUNCTION__, domain ? domain->nameA : "NULL",
-               key ? key->strA : "NULL");
-  ForwardIttCallIfCclDomain(domain, &pti::PtiLibHandler::itt_metadata_add_, domain, id, key, type,
-                            count, data);
-}
-
-[[maybe_unused]] static std::string DumpIttStringHandlesOfCclDomainGlobal() {
-  __itt_global *g = g_itt_global_of_ccl_domain.load(std::memory_order_acquire);
-  if (g == nullptr) {
-    return kNoIttGlobalOfCclDomainString;
-  }
-
-  std::string result = "\nString handle list:\n";
-  __itt_mutex_lock(&(g->mutex));
-
-  int count = 0;
-  for (__itt_string_handle *h = g->string_list; h != nullptr; h = h->next) {
-    result += "  [" + std::to_string(count) + "] " + (h->strA ? h->strA : "NULL") + "\n";
-    count++;
-  }
-
-  if (count == 0) {
-    result += "  (empty string handle list)\n";
-  } else {
-    result += "  Total string handles: " + std::to_string(count);
-  }
-
-  __itt_mutex_unlock(&(g->mutex));
-  return result;
-}
-
-static __itt_string_handle *ITTAPI itt_string_handle_create_adapter(const char *name) {
-  SPDLOG_DEBUG("{}() - name: {}", __FUNCTION__, name ? name : "NULL");
-
-  __itt_global *g = g_itt_global_of_ccl_domain.load(std::memory_order_acquire);
-  if (g == nullptr || name == nullptr) {
-    return nullptr;
-  }
-
-  __itt_string_handle *h_tail = nullptr, *h = nullptr;
-
-  __itt_mutex_lock(&(g->mutex));
-  for (h_tail = nullptr, h = g->string_list; h != nullptr; h_tail = h, h = h->next) {
-    if (h->strA != nullptr && !__itt_fstrcmp(h->strA, name)) break;
-  }
-  if (h == nullptr) {
-    NEW_STRING_HANDLE_A(g, h, h_tail, name);
-
-    if (!__itt_fstrcmp(name, itt_metadata::kSendSizeString)) {
-      itt_metadata::GetSendSizeHandle().store(h);
-    } else if (!__itt_fstrcmp(name, itt_metadata::kRecvSizeString)) {
-      itt_metadata::GetRecvSizeHandle().store(h);
-    } else if (!__itt_fstrcmp(name, itt_metadata::kCommIdString)) {
-      itt_metadata::GetCommIdHandle().store(h);
-    }
-  }
-  __itt_mutex_unlock(&(g->mutex));
-
-  SPDLOG_DEBUG("{}() {}", __FUNCTION__, DumpIttStringHandlesOfCclDomainGlobal());
-  return h;
-}
-
-static void FillFuncPtrPerLib(__itt_global *p) {
-  SPDLOG_TRACE("{}() Adapter:", __FUNCTION__);
-  __itt_api_info *api_list = static_cast<__itt_api_info *>(p->api_list_ptr);
-
-  // Static lookup table for ITT function mappings to adapter functions
-  static const std::unordered_map<std::string_view, void *> itt_function_map = {
-      {"__itt_task_begin", reinterpret_cast<void *>(&itt_task_begin_adapter)},
-      {"__itt_task_end", reinterpret_cast<void *>(&itt_task_end_adapter)},
-      {"__itt_string_handle_create", reinterpret_cast<void *>(&itt_string_handle_create_adapter)},
-      {"__itt_metadata_add", reinterpret_cast<void *>(&itt_metadata_add_adapter)}};
-
-  for (int i = 0; api_list[i].name != NULL; i++) {
-    void *func_ptr = nullptr;
-
-    // Try to find in ITT function map first
-    auto it = itt_function_map.find(api_list[i].name);
-    if (it != itt_function_map.end()) {
-      func_ptr = it->second;
-    } else {
-      // Fallback to original behavior for non-ITT functions
-      func_ptr = static_cast<void *>(__itt_get_proc(p->lib, api_list[i].name));
-    }
-
-    // Use null_func if we didn't find a valid function pointer
-    if (!func_ptr) {
-      func_ptr = api_list[i].null_func;
-    }
-
-    *(api_list[i].func_ptr) = func_ptr;
-  }
-}
-
-//
-// Design note: how to capture the correct __itt_global for oneCCL::API.
-//
-// Every library that links ittnotify statically owns its own __itt_global.
-// We need the one belonging to libccl.so because its mutex is the correct
-// lock to use when toggling domain->flags, which is the switch that
-// enables and disables oneCCL ITT calls issued for that domain.
-//
-// Key invariant PTI relies on: ITT provider in shared library
-// creates all its domains before any other itt call issued, and the domains are present in
-// its __itt_global when __itt_api_init is called.
-// For oneCCL this should be always true:
-// "oneCCL::API" is ALWAYS present in p_ccl->domain_list
-// when __itt_api_init(p_ccl) is called oneCCL ITT initialization code.
-// The domain variable in oneCCL sched_timer.cpp (as of June 20'2026)
-// is a namespace-scope static, guaranteed by the C++ standard
-// to be initialized before any external caller can invoke a
-// function in libccl.so. domain_create's init stub does not trigger
-// init_ittlib — it only allocates the node in p_ccl->domain_list.
-// __itt_api_init is only triggered later by the first ITT_STUB call
-// (e.g. task_begin), which can only happen after libccl.so is fully
-// loaded. Therefore the domain node is always present when we walk
-// itt_global_of_ccl->domain_list inside IttGlobalInitAndCclIfPresent.
-//
-// Assuming the key invariant - we do not intercept itt_domain_create.
-//
-// Scenario 1 (simple case): oneCCL is the only ITT library.
-// The only __itt_global is the itt_global of ccl. We find the domain,
-// set g_itt_global_of_ccl_domain to itt_global of ccl.
-//
-// Scenario 2: oneCCL loads last (e.g. p_tbb initializes first).
-// p_tbb's __itt_api_init runs first:
-// no CCL domain found, g_itt_global_of_ccl_domain is not set (remains nullptr),
-// g_ccl_domain_cached is not set (remains nullptr).
-// p_ccl's __itt_api_init runs next:
-// CCL domain found, g_ccl_domain_cached CAS succeeds, g_itt_global_of_ccl_domain CAS succeeds also
-//
-// Scenario 3: oneCCL loads first (e.g. p_ccl initializes before p_tbb).
-// p_ccl's __itt_api_init runs first: CCL domain found, g_ccl_domain_cached
-// and g_itt_global both set to p_ccl. p_tbb's __itt_api_init runs later:
-// we check that there is no oneCCL domain and
-// do not attempt to overwrite g_itt_global_of_ccl_domain, and g_ccl_domain_cached
-// as it is already set to p_ccl.
-// The non-CCL domains in p_tbb get their flags zeroed out,
-// as they are not relevant for our collector
-//
-// Scenario 4: Some libraries might not follow the key invariant
-// (which assumes that all domains are present at __itt_api_init )
-// Then we might get such domains tasks and other calls (as domain->flags is non-zero).
-// In this case we make a data race and apply domain->flags = 0 to non-CCL domains,
-// which is not ideal, but should not cause correctness issues,
-// It helps avoid the overhead of the ITT calls issuing and processing.
-//
-static void ZeroAllDomainsFlagsAndStoreCclGlobalAndDomainIfSeeThem(__itt_global *p) {
-  [[maybe_unused]] int count = 0;
-
-  __itt_mutex_lock(&(p->mutex));
-
-  for (__itt_domain *h = p->domain_list; h != nullptr; h = h->next) {
-    h->flags = 0;
-    if (h->nameA != nullptr && !std::strcmp(h->nameA, kCclDomainString)) {
-      const __itt_domain *expected = nullptr;
-      g_ccl_domain_cached.compare_exchange_strong(expected, h, std::memory_order_relaxed);
-      __itt_global *expected_global = nullptr;
-      g_itt_global_of_ccl_domain.compare_exchange_strong(expected_global, p,
-                                                         std::memory_order_release);
-    }
-    count++;
-  }
-  __itt_mutex_unlock(&(p->mutex));
-  SPDLOG_DEBUG("{}() processed {} domains", __FUNCTION__, count);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_api_init(__itt_global *p,
-                                        [[maybe_unused]] __itt_group_id init_groups) {
-  SPDLOG_DEBUG("{}() Adapter: {}", __FUNCTION__, p ? "non-NULL" : "NULL");
-  if (p == nullptr) {
-    return;
-  }
-
-  switch (itt_lib_env::GetIttCollectorConfig()) {
-    case itt_lib_env::IttCollectorConfig::kConfigurationFailed:
-      SPDLOG_WARN("{}() Failed to configure {}; PTI oneCCL tracing is disabled", __FUNCTION__,
-                  itt_lib_env::kIttLibEnvVarName);
-      return;
-    case itt_lib_env::IttCollectorConfig::kExternalNotFound:
-    case itt_lib_env::IttCollectorConfig::kExternalLibrary:
-    case itt_lib_env::IttCollectorConfig::kUnresolvedLibraryName:
-      // ITT normally calls the selected external collector instead of PTI.
-      // Return defensively if PTI initializer is invoked directly.
-      return;
-    case itt_lib_env::IttCollectorConfig::kAlreadyPti:
-    case itt_lib_env::IttCollectorConfig::kSetByPti:
-      break;
-  }
-
-  FillFuncPtrPerLib(p);
-  ZeroAllDomainsFlagsAndStoreCclGlobalAndDomainIfSeeThem(p);
-
-  if (pti::PtiLibHandler::IsSuccessfullyInitialized()) {
-    SPDLOG_DEBUG("{}() PTI_LIB is successfully initialized, setting CCL Global {} and Domain {}",
-                 __FUNCTION__,
-                 static_cast<void *>(g_itt_global_of_ccl_domain.load(std::memory_order_acquire)),
-                 static_cast<const void *>(g_ccl_domain_cached.load(std::memory_order_acquire)));
-    auto &handler = pti::PtiLibHandler::Instance();
-
-    if (handler.IttCollectorSetCclGlobalAndDomain_ != nullptr) {
-      handler.IttCollectorSetCclGlobalAndDomain_(
-          g_itt_global_of_ccl_domain.load(std::memory_order_acquire),
-          g_ccl_domain_cached.load(std::memory_order_acquire));
-    } else {
-      SPDLOG_WARN(
-          "{}() IttCollectorSetCclGlobalAndDomain_ is NULL"
-          ", cannot set CCL global and domain in collector",
-          __FUNCTION__);
-    }
-  } else {
-    SPDLOG_DEBUG(
-        "{}() PTI_LIB is NOT initialized"
-        ", skipping setting CCL Global and Domain in collector",
-        __FUNCTION__);
-  }
-}
diff --git a/sdk/src/itt/itt_adapter.h b/sdk/src/itt/itt_adapter.h
deleted file mode 100644
index 975c5fd3..00000000
--- a/sdk/src/itt/itt_adapter.h
+++ /dev/null
@@ -1,16 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef __ITT_ADAPTER_H_
-#define __ITT_ADAPTER_H_
-
-#include <ittnotify.h>
-#include <ittnotify_config.h>
-
-__itt_global* GetIttGlobalOfCclDomainAdapter();
-const __itt_domain* GetIttCclDomainAdapter();
-
-#endif  // __ITT_ADAPTER_H_
diff --git a/sdk/src/itt/itt_collector.cc b/sdk/src/itt/itt_collector.cc
deleted file mode 100644
index b65c136c..00000000
--- a/sdk/src/itt/itt_collector.cc
+++ /dev/null
@@ -1,269 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "itt_collector.h"
-
-#include <ittnotify_config.h>
-#include <spdlog/spdlog.h>
-
-#include <cstddef>
-#include <cstdio>
-#include <stack>
-#include <string>
-#include <vector>
-
-#include "utils.h"
-
-namespace {
-static std::atomic<__itt_global *> g_itt_global_of_ccl_domain_adaptor{nullptr};
-static std::atomic<const __itt_domain *> g_ccl_domain_adaptor{nullptr};
-
-inline const __itt_domain *GetCacheCclDomainCollector(const __itt_domain *domain) {
-  static const char *const kCclDomain = "oneCCL::API";
-  const __itt_domain *cached = g_ccl_domain_adaptor.load(std::memory_order_relaxed);
-  if (cached != nullptr) return cached;
-  if (domain != nullptr && domain->nameA != nullptr && !std::strcmp(domain->nameA, kCclDomain)) {
-    g_ccl_domain_adaptor.store(domain, std::memory_order_relaxed);
-    return domain;
-  }
-  return nullptr;
-}
-}  // namespace
-
-ITT_EXTERN_C void ITTAPI IttCollectorSetConfiguration(itt_lib_env::IttCollectorConfig config,
-                                                      const char *selected_collector_path,
-                                                      const char *pti_module_path) {
-  IttCollector::Instance().SetConfiguration(config, selected_collector_path, pti_module_path);
-}
-
-bool IttCollector::IsAvailable() const {
-  std::lock_guard<std::mutex> lock(initialization_mutex_);
-  switch (config_collector_) {
-    case itt_lib_env::IttCollectorConfig::kSetByPti:
-    case itt_lib_env::IttCollectorConfig::kAlreadyPti:
-      return true;
-    case itt_lib_env::IttCollectorConfig::kExternalLibrary:
-      SPDLOG_WARN(
-          "Cannot enable communication tracing: {}='{}' selects another ITT collector; "
-          "PTI collector is '{}'.",
-          itt_lib_env::kIttLibEnvVarName, selected_collector_path_, pti_module_path_);
-      return false;
-    case itt_lib_env::IttCollectorConfig::kExternalNotFound:
-      SPDLOG_WARN(
-          "Cannot enable communication tracing: ITT collector path {}='{}' did not exist; "
-          "PTI collector is '{}'.",
-          itt_lib_env::kIttLibEnvVarName, selected_collector_path_, pti_module_path_);
-      return false;
-    case itt_lib_env::IttCollectorConfig::kUnresolvedLibraryName:
-      SPDLOG_WARN(
-          "Cannot enable communication tracing: ITT collector name {}='{}' could not be "
-          "identified among loaded modules; PTI collector is '{}'.",
-          itt_lib_env::kIttLibEnvVarName, selected_collector_path_, pti_module_path_);
-      return false;
-    case itt_lib_env::IttCollectorConfig::kConfigurationFailed:
-      SPDLOG_WARN(
-          "Cannot enable communication tracing: PTI could not configure its ITT collector "
-          "through {}='{}'; PTI collector is '{}'.",
-          itt_lib_env::kIttLibEnvVarName, selected_collector_path_, pti_module_path_);
-      return false;
-  }
-  // Never reached.
-  return false;
-}
-
-// Static method definitions
-std::string IttCollector::DumpTaskDescriptor() noexcept {
-  if (task_desc_.empty()) {
-    return "Task descriptor: (empty stack)";
-  }
-
-  std::string result = "\nTask descriptor stack:\n";
-  std::stack<ThreadTaskDescriptor> temp_stack = task_desc_;
-  std::vector<ThreadTaskDescriptor> elements;
-
-  // Extract all elements from the copy (this reverses the order)
-  while (!temp_stack.empty()) {
-    elements.push_back(temp_stack.top());
-    temp_stack.pop();
-  }
-
-  // Display elements in reverse order (original stack order: bottom to top)
-  for (size_t i = 0; i < elements.size(); ++i) {
-    const auto &desc = elements[elements.size() - 1 - i];
-    result += "  [" + std::to_string(i) + "] " +
-              (desc.domain_ && desc.domain_->nameA ? desc.domain_->nameA : "NULL") +
-              "::" + (desc.name_ && desc.name_->strA ? desc.name_->strA : "NULL") +
-              " start_time: " + std::to_string(desc.start_time_) + "\n";
-  }
-
-  result += "  Total task descriptors: " + std::to_string(elements.size()) + "\n";
-  return result;
-}
-
-ITT_EXTERN_C void ITTAPI IttCollectorSetCclGlobalAndDomain(__itt_global *g,
-                                                           const __itt_domain *domain) {
-  SPDLOG_DEBUG("{}() domain: {}", __FUNCTION__, static_cast<const void *>(domain));
-  std::lock_guard<std::mutex> lock(IttCollector::Instance().initialization_mutex_);
-
-  g_ccl_domain_adaptor.store(domain, std::memory_order_release);
-  g_itt_global_of_ccl_domain_adaptor.store(g, std::memory_order_release);
-  if (g != nullptr && domain != nullptr) {
-    auto *mutable_domain = const_cast<__itt_domain *>(domain);
-    __itt_mutex_lock(&(g->mutex));
-    mutable_domain->flags = IttCollector::Instance().IsCollectionEnabled() ? 1 : 0;
-    __itt_mutex_unlock(&(g->mutex));
-  }
-}
-
-ITT_EXTERN_C void ITTAPI itt_task_begin_collector(const __itt_domain *domain,
-                                                  [[maybe_unused]] __itt_id taskid,
-                                                  [[maybe_unused]] __itt_id parentid,
-                                                  __itt_string_handle *name) {
-  SPDLOG_DEBUG("{}() Collector - domain: {}, name: {}", __FUNCTION__,
-               domain ? domain->nameA : "NULL", name ? name->strA : "NULL");
-
-  if (!IttCollector::Instance().IsCollectionEnabled() || (domain == nullptr) ||
-      (GetCacheCclDomainCollector(domain) != domain)) {
-    return;
-  }
-
-  IttCollector::task_desc_.push(ThreadTaskDescriptor(domain, name, utils::GetTime()));
-
-  SPDLOG_DEBUG("{}() {}", __FUNCTION__, IttCollector::DumpTaskDescriptor());
-}
-
-ITT_EXTERN_C void ITTAPI itt_task_end_collector(const __itt_domain *domain) {
-  SPDLOG_DEBUG("{}() Collector - domain: {}", __FUNCTION__, domain ? domain->nameA : "NULL");
-
-  if (!IttCollector::Instance().IsCollectionEnabled() || (domain == nullptr) ||
-      (GetCacheCclDomainCollector(domain) != domain)) {
-    return;
-  }
-
-  auto end = utils::GetTime();
-
-  SPDLOG_DEBUG("{}() {}", __FUNCTION__, IttCollector::DumpTaskDescriptor());
-
-  if (IttCollector::task_desc_.empty()) {
-    return;
-  }
-
-  auto task = IttCollector::task_desc_.top();
-  IttCollector::task_desc_.pop();
-
-  SPDLOG_DEBUG("{}() line {} - {}::{}, start: {}, end: {}, send_size: {:#x}, recv_size: {:#x}",
-               __FUNCTION__, __LINE__, task.domain_ ? task.domain_->nameA : "NULL",
-               task.name_ ? task.name_->strA : "NULL", task.start_time_, end, task.send_size_,
-               task.recv_size_);
-
-  IttCollector::Instance().CallbackUser(task, end);
-}
-
-// Design note: why pointer-based caching of __itt_string_handle is safe here.
-//
-// Every .so that links ittnotify statically gets its own __itt_global. Our
-// collector's __itt_api_init is therefore called once per static part (p_sycl,
-// p_tbb, p_ccl, ...). Each library creates its domains and string handles
-// exclusively through its own p, so they accumulate in that p's lists.
-//
-// The key guarantee: __itt_metadata_add is always downstream of domain
-// creation. oneCCL must create "oneCCL::API" before it can annotate any
-// metadata. It also creates its metadata key strings ("send_size", "recv_size",
-// "comm_id") through the same p_ccl. All three therefore live in p_ccl's
-// string_list at the time we discover the domain in p_ccl->domain_list.
-//
-// Any other string handles from other libraries are irrelevant to our collector.
-// So there is no need to track them.
-//
-ITT_EXTERN_C void ITTAPI itt_metadata_add_collector(const __itt_domain *domain,
-                                                    [[maybe_unused]] __itt_id id,
-                                                    [[maybe_unused]] __itt_string_handle *key,
-                                                    __itt_metadata_type type, size_t count,
-                                                    void *data) {
-  if (!IttCollector::Instance().IsCollectionEnabled() || (domain == nullptr) ||
-      (GetCacheCclDomainCollector(domain) != domain)) {
-    return;
-  }
-
-  if (data == nullptr || type != __itt_metadata_u64 || count != 1) {
-    return;
-  }
-
-  SPDLOG_DEBUG("{}() Collector - domain: {}, key: {}, send_size: 0x{:#x}", __FUNCTION__,
-               domain ? domain->nameA : "NULL", key ? key->strA : "NULL",
-               *static_cast<uint64_t *>(data));
-
-  if (!IttCollector::task_desc_.empty() && IttCollector::task_desc_.top().domain_ == domain) {
-    SPDLOG_DEBUG("{}() Collector - FOUND!!", __FUNCTION__);
-
-    // Helper lambda to check and capture string handles
-    auto check_and_capture = [&](auto &handle, const char *target_string) -> bool {
-      __itt_string_handle *current_handle = handle.load();
-      if (current_handle == key) return true;  // Fast path
-      if (key == nullptr) return false;
-      if (current_handle == nullptr && key->strA != nullptr &&
-          !__itt_fstrcmp(key->strA, target_string)) {
-        // Attempt atomic capture - use compare_exchange to avoid races
-        __itt_string_handle *expected = nullptr;
-        if (handle.compare_exchange_strong(expected, key)) {
-          return true;  // Successfully captured
-        }
-        // Another thread captured it, check if it matches our key
-        return handle.load() == key;
-      }
-      return false;
-    };
-
-    if (check_and_capture(itt_metadata::GetSendSizeHandle(), itt_metadata::kSendSizeString)) {
-      IttCollector::task_desc_.top().send_size_ = *static_cast<uint64_t *>(data);
-    } else if (check_and_capture(itt_metadata::GetRecvSizeHandle(),
-                                 itt_metadata::kRecvSizeString)) {
-      IttCollector::task_desc_.top().recv_size_ = *static_cast<uint64_t *>(data);
-    } else if (check_and_capture(itt_metadata::GetCommIdHandle(), itt_metadata::kCommIdString)) {
-      IttCollector::task_desc_.top().communicator_id_ = *static_cast<uint64_t *>(data);
-    }
-    return;
-  }
-  SPDLOG_DEBUG("{}() Collector - NOT FOUND!!", __FUNCTION__);
-}
-
-void IttCollector::EnableCollection() {
-  SPDLOG_DEBUG("{}() Collector", __FUNCTION__);
-
-  auto *domain = const_cast<__itt_domain *>(GetCacheCclDomainCollector(nullptr));
-  if (domain == nullptr) {
-    SPDLOG_DEBUG("{}() Collector: oneCCL domain not yet cached", __FUNCTION__);
-  } else {
-    auto *g = g_itt_global_of_ccl_domain_adaptor.load(std::memory_order_acquire);
-    if (g != nullptr) {
-      __itt_mutex_lock(&(g->mutex));
-      domain->flags = 1;
-      __itt_mutex_unlock(&(g->mutex));
-    }  // else - don't know global for Ccl domain -
-       // so rely only on collection_state_ flag to enable collection
-  }
-
-  collection_state_.store(CollectionState::kEnabled, std::memory_order_release);
-}
-
-void IttCollector::DisableCollection() {
-  SPDLOG_DEBUG("{}() Collector", __FUNCTION__);
-
-  collection_state_.store(CollectionState::kDisabled, std::memory_order_release);
-
-  auto *domain = const_cast<__itt_domain *>(GetCacheCclDomainCollector(nullptr));
-  if (domain == nullptr) {
-    SPDLOG_DEBUG("{}() Collector: oneCCL domain not yet cached", __FUNCTION__);
-    return;
-  }
-  auto *g = g_itt_global_of_ccl_domain_adaptor.load(std::memory_order_acquire);
-  if (g != nullptr) {
-    __itt_mutex_lock(&(g->mutex));
-    domain->flags = 0;
-    __itt_mutex_unlock(&(g->mutex));
-  }  // else - don't know global for Ccl domain -
-     // so rely only on collection_state_ flag to disable collection
-}
diff --git a/sdk/src/itt/itt_collector.h b/sdk/src/itt/itt_collector.h
deleted file mode 100644
index 1c616acf..00000000
--- a/sdk/src/itt/itt_collector.h
+++ /dev/null
@@ -1,160 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef ITT_ITT_COLLECTOR_H_
-#define ITT_ITT_COLLECTOR_H_
-
-#include <spdlog/spdlog.h>
-
-#include <atomic>
-#include <cstdint>
-#include <mutex>
-#include <stack>
-#include <string>
-
-#include "itt_lib_env.h"
-#include "pti_assert.h"
-#include "unikernel.h"
-
-using OnIttLoggingCallback = void (*)(void* data, CommunicationRecord& rec);
-
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-
-#if defined(PTI_CCL_ITT_COMPILE)
-#define ITTAPI_CDECL __attribute__((visibility("default")))
-#else
-#define ITTAPI_CDECL
-#endif  // PTI_CCL_ITT_COMPILE
-
-#include "itt_metadata.h"
-
-struct ThreadTaskDescriptor {
-  __itt_domain* domain_;
-  __itt_string_handle* name_;
-
-  uint64_t start_time_;
-  uint64_t send_size_;
-  uint64_t recv_size_;
-  uint64_t communicator_id_;
-
-  explicit ThreadTaskDescriptor(const __itt_domain* d = nullptr,
-                                const __itt_string_handle* n = nullptr, uint64_t start = 0)
-      : domain_(const_cast<__itt_domain*>(d)),
-        name_(const_cast<__itt_string_handle*>(n)),
-        start_time_(start),
-        send_size_(0),
-        recv_size_(0),
-        communicator_id_(0) {}
-};
-
-class IttCollector {
- public:  // Interface
-  inline static auto& Instance(OnIttLoggingCallback callback_ = nullptr) {
-    static IttCollector itt_collector{callback_};
-    return itt_collector;
-  }
-
-  IttCollector(const IttCollector& copy) = delete;
-  IttCollector& operator=(const IttCollector& copy) = delete;
-  IttCollector(IttCollector&&) = delete;
-  IttCollector& operator=(IttCollector&&) = delete;
-
-  void SetConfiguration(itt_lib_env::IttCollectorConfig config, const char* selected_collector_path,
-                        const char* pti_module_path) {
-    std::lock_guard<std::mutex> lock(initialization_mutex_);
-    selected_collector_path_ = selected_collector_path != nullptr ? selected_collector_path : "";
-    pti_module_path_ = pti_module_path != nullptr ? pti_module_path : "";
-    config_collector_ = config;
-  }
-
-  // Returns whether the saved load-time configuration permits PTI communication
-  // tracing; logs a warning explaining why it is unavailable.
-  bool IsAvailable() const;
-
-  void EnableTrace() {
-    SPDLOG_DEBUG("{}(): TID: {}", PTI_FUNCTION_NAME, utils::GetTid());
-
-    // Clear any stale stack state for clean start
-    if (!task_desc_.empty()) {
-      SPDLOG_DEBUG("Clearing {} stale tasks on EnableTrace", task_desc_.size());
-      std::stack<ThreadTaskDescriptor> empty_stack;
-      task_desc_.swap(empty_stack);
-    }
-
-    EnableCollection();
-  }
-  void DisableTrace() {
-    SPDLOG_DEBUG("{}(): TID: {}", PTI_FUNCTION_NAME, utils::GetTid());
-
-    DisableCollection();
-
-    if (!task_desc_.empty()) {
-      SPDLOG_DEBUG("Purging {} incomplete tasks from thread-local stack", task_desc_.size());
-      std::stack<ThreadTaskDescriptor> empty_stack;
-      task_desc_.swap(empty_stack);
-    }
-  }
-
-  bool IsCollectionEnabled() const {
-    return collection_state_.load(std::memory_order_acquire) == CollectionState::kEnabled;
-  }
-
-  void SetCallback(const OnIttLoggingCallback callback) {
-    record_dispatcher_.store(callback, std::memory_order_relaxed);
-  }
-
-  // Debug utility for dumping thread-local task stack
-  static std::string DumpTaskDescriptor() noexcept;
-
-  // Thread-local task stack - public for implementation functions access
-  inline static thread_local std::stack<ThreadTaskDescriptor> task_desc_;
-
-  ~IttCollector() {}
-
-  void CallbackUser(ThreadTaskDescriptor& rec, uint64_t end) {
-    SPDLOG_DEBUG("{}() - name: {}, start_ts: {}, end_ts: {}, send_size: {:#x}, recv_size: {:#x}",
-                 __FUNCTION__, rec.name_ ? rec.name_->strA : "NULL", rec.start_time_, end,
-                 rec.send_size_, rec.recv_size_);
-
-    // Single atomic load with relaxed ordering
-    auto itt_cb = record_dispatcher_.load(std::memory_order_relaxed);
-    if (itt_cb) {
-      itt_runtime_rec_.pid_ = PidTidInfo::Get().pid;
-      itt_runtime_rec_.tid_ = PidTidInfo::Get().tid;
-      itt_runtime_rec_.start_time_ = rec.start_time_;
-      itt_runtime_rec_.end_time_ = end;
-      itt_runtime_rec_.send_size_ = rec.send_size_;
-      itt_runtime_rec_.recv_size_ = rec.recv_size_;
-      itt_runtime_rec_.communicator_id_ = rec.communicator_id_;
-      itt_runtime_rec_.name_ = rec.name_ ? rec.name_->strA : nullptr;
-
-      itt_cb(nullptr, itt_runtime_rec_);
-    }
-  }
-
-  mutable std::mutex initialization_mutex_;
-
- private:  // Implementation
-  enum class CollectionState : int { kDisabled = 0, kEnabled = 1 };
-
-  void EnableCollection();
-  void DisableCollection();
-
-  inline static thread_local CommunicationRecord itt_runtime_rec_;
-  explicit IttCollector(OnIttLoggingCallback callback) : record_dispatcher_(callback) {}
-
-  // Data
-  // Set once from the interface library; protected by initialization_mutex_.
-  itt_lib_env::IttCollectorConfig config_collector_ =
-      itt_lib_env::IttCollectorConfig::kConfigurationFailed;
-  std::string selected_collector_path_;
-  std::string pti_module_path_;
-
-  std::atomic<OnIttLoggingCallback> record_dispatcher_ = nullptr;
-  std::atomic<CollectionState> collection_state_{CollectionState::kDisabled};
-};
-
-#endif  // ITT_ITT_COLLECTOR_H_
diff --git a/sdk/src/itt/itt_lib_env.cc b/sdk/src/itt/itt_lib_env.cc
deleted file mode 100644
index 76e94cff..00000000
--- a/sdk/src/itt/itt_lib_env.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "itt_lib_env.h"
-
-#include <dlfcn.h>
-
-#include <memory>
-#include <string>
-#include <system_error>
-
-#include "utils/library_loader.h"
-#include "utils/pti_filesystem.h"
-#include "utils/utils.h"
-
-namespace itt_lib_env {
-
-IttCollectorConfig ConfigureIttCollector(const std::string& this_module_path) {
-  if (this_module_path.empty()) {
-    return IttCollectorConfig::kConfigurationFailed;
-  }
-
-  const std::string env_value = ::utils::GetEnv(kIttLibEnvVarName);
-
-  if (env_value.empty()) {
-    // Preserve the module actually mapped into this process, but make its path
-    // independent of the working directory inherited by child processes.
-    std::error_code error;
-    const auto absolute_path = pti::utils::AbsolutePath(this_module_path, error);
-    if (error || absolute_path.empty()) {
-      return IttCollectorConfig::kConfigurationFailed;
-    }
-    ::utils::SetEnv(kIttLibEnvVarName, absolute_path.c_str());
-    return IttCollectorConfig::kSetByPti;
-  }
-
-  if (env_value.find('/') == std::string::npos) {
-    // ITT resolves bare names through the dynamic loader, not the working
-    // directory. Observe loaded modules without loading a foreign collector.
-    auto selected_module = LibraryLoader::Probe(env_value);
-    if (!selected_module) {
-      return IttCollectorConfig::kUnresolvedLibraryName;
-    }
-    auto pti_module = LibraryLoader::Probe(this_module_path);
-    if (!pti_module) {
-      return IttCollectorConfig::kConfigurationFailed;
-    }
-    return selected_module->LibraryHandle() == pti_module->LibraryHandle()
-               ? IttCollectorConfig::kAlreadyPti
-               : IttCollectorConfig::kExternalLibrary;
-  }
-
-  std::error_code error;
-  const bool exists = pti::utils::filesystem::exists(env_value, error);
-  if (error) {
-    return IttCollectorConfig::kConfigurationFailed;
-  }
-  if (!exists) {
-    return IttCollectorConfig::kExternalNotFound;
-  }
-
-  // Compare file identity so symlinks and alternate paths to this module match.
-  const bool is_this_module =
-      pti::utils::filesystem::equivalent(env_value, this_module_path, error);
-  if (error) {
-    return IttCollectorConfig::kConfigurationFailed;
-  }
-  if (is_this_module) {
-    return IttCollectorConfig::kAlreadyPti;
-  }
-
-  return IttCollectorConfig::kExternalLibrary;
-}
-
-}  // namespace itt_lib_env
diff --git a/sdk/src/itt/itt_lib_env.h b/sdk/src/itt/itt_lib_env.h
deleted file mode 100644
index 10752bd7..00000000
--- a/sdk/src/itt/itt_lib_env.h
+++ /dev/null
@@ -1,55 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_ITT_ITT_LIB_ENV_H_
-#define PTI_ITT_ITT_LIB_ENV_H_
-
-#include <string>
-
-//
-// Helpers around INTEL_LIBITTNOTIFY64, the variable ittnotify uses to pick its
-// collector.
-//
-// ittnotify reads it once per provider library, on that library's first ITT
-// call, and latches collector-present-or-absent for the rest of the process.
-// libpti_view.so therefore registers itself at load time, from
-// GlobalIttInitializer in itt_adapter.cc, which runs before main() and so
-// before oneCCL's first ITT call. A late dlopen of libpti_view.so is not
-// covered: once a provider has latched, nothing here can undo it.
-//
-namespace itt_lib_env {
-
-// PTI is 64-bit only, so the 32-bit spelling of this variable is not handled.
-inline constexpr const char* kIttLibEnvVarName = "INTEL_LIBITTNOTIFY64";
-
-enum class IttCollectorConfig {
-  kSetByPti,
-  kAlreadyPti,
-  kExternalLibrary,
-  kExternalNotFound,
-  kConfigurationFailed,
-  kUnresolvedLibraryName,
-};
-
-// Return the decision and diagnostic paths saved when the PTI interface library
-// loaded. These getters do not load the core or inspect the environment again.
-IttCollectorConfig GetIttCollectorConfig();
-const std::string& GetSelectedIttCollectorPath();
-const std::string& GetPtiIttCollectorPath();
-
-// Point ittnotify at this module unless a collector was already chosen.
-//
-// This may call setenv; callers loading PTI after startup must prevent
-// concurrent environment access. The XPTI initializer has the same constraint.
-//
-// Logs nothing itself; the caller reports the returned value.
-// Bare library names are identified only among modules already loaded into the
-// process. A name that cannot be identified is preserved and reported unresolved.
-IttCollectorConfig ConfigureIttCollector(const std::string& this_module_path);
-
-}  // namespace itt_lib_env
-
-#endif  // PTI_ITT_ITT_LIB_ENV_H_
diff --git a/sdk/src/itt/itt_metadata.h b/sdk/src/itt/itt_metadata.h
deleted file mode 100644
index 558613ee..00000000
--- a/sdk/src/itt/itt_metadata.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef SRC_ITT_ITT_METADATA_H_
-#define SRC_ITT_ITT_METADATA_H_
-
-#include <ittnotify.h>
-
-#include <atomic>
-
-namespace itt_metadata {
-
-// String constants for metadata identification
-constexpr const char *kSendSizeString = "send_size";
-constexpr const char *kRecvSizeString = "recv_size";
-constexpr const char *kCommIdString = "comm_id";
-
-// Singleton accessor functions for atomic string handles
-// Using functions ensures single definition across translation units
-inline std::atomic<__itt_string_handle *> &GetSendSizeHandle() {
-  static std::atomic<__itt_string_handle *> handle{nullptr};
-  return handle;
-}
-
-inline std::atomic<__itt_string_handle *> &GetRecvSizeHandle() {
-  static std::atomic<__itt_string_handle *> handle{nullptr};
-  return handle;
-}
-
-inline std::atomic<__itt_string_handle *> &GetCommIdHandle() {
-  static std::atomic<__itt_string_handle *> handle{nullptr};
-  return handle;
-}
-
-}  // namespace itt_metadata
-
-#endif  // SRC_ITT_ITT_METADATA_H_
diff --git a/sdk/src/itt/itt_stubs.cc b/sdk/src/itt/itt_stubs.cc
deleted file mode 100644
index a3b7993e..00000000
--- a/sdk/src/itt/itt_stubs.cc
+++ /dev/null
@@ -1,705 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-
-#if defined(PTI_CCL_ITT_COMPILE)
-#define ITTAPI_CDECL __attribute__((visibility("default")))
-#else
-#define ITTAPI_CDECL
-#endif  // PTI_CCL_ITT_COMPILE
-
-#include <ittnotify.h>
-#include <ittnotify_config.h>
-#include <spdlog/spdlog.h>
-
-// ITT API stub functions for libpti_view
-// These provide symbol resolution without actual implementation
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_internal_callback_info(const __itt_domain *domain
-                                                               [[maybe_unused]],
-                                                               int64_t mpi_counter [[maybe_unused]],
-                                                               size_t src_size [[maybe_unused]],
-                                                               size_t dst_size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_event ITTAPI __itt_event_create(const char *name [[maybe_unused]],
-                                                   int namelen [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return -1;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_event_start(__itt_event event [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return __itt_error_no_symbol;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_pause(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C void ITTAPI __itt_pause_scoped(__itt_collection_scope scope [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_resume(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C void ITTAPI __itt_resume_scoped(__itt_collection_scope scope [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_marker(const __itt_domain *domain [[maybe_unused]],
-                                      __itt_id id [[maybe_unused]],
-                                      __itt_string_handle *name [[maybe_unused]],
-                                      __itt_scope scope [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_detach(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C __itt_pt_region ITTAPI __itt_pt_region_create(const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_thread_set_name(const char *name [[maybe_unused]]) {
-  SPDLOG_DEBUG("{}(): {}", __FUNCTION__, name);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_thread_ignore(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_push(unsigned int mask [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_pop(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t mode [[maybe_unused]],
-                                                   unsigned int mask [[maybe_unused]],
-                                                   void *address [[maybe_unused]],
-                                                   size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t mode [[maybe_unused]],
-                                                    unsigned int mask [[maybe_unused]],
-                                                    void *address [[maybe_unused]],
-                                                    size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_create(void *addr [[maybe_unused]],
-                                           const char *objtype [[maybe_unused]],
-                                           const char *objname [[maybe_unused]],
-                                           int attribute [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_rename(void *addr [[maybe_unused]],
-                                           const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_destroy(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_prepare(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_cancel(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_acquired(void *addr [[maybe_unused]]) {
-  // NOTE: Logging disabled to prevent race condition between sync tracking
-  // and spdlog's internal synchronization mechanisms.
-  // SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_releasing(void *addr [[maybe_unused]]) {
-  // NOTE: Logging disabled to prevent race condition between sync release tracking
-  // and spdlog's internal synchronization mechanisms.
-  // SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_prepare(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_cancel(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_acquired(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_releasing(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_begin(__itt_model_site *site [[maybe_unused]],
-                                                __itt_model_site_instance *instance
-                                                [[maybe_unused]],
-                                                const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_beginA(const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_beginAL(const char *name [[maybe_unused]],
-                                                  size_t siteNameLen [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_end(__itt_model_site *site [[maybe_unused]],
-                                              __itt_model_site_instance *instance
-                                              [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_end_2(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_begin(__itt_model_task *task [[maybe_unused]],
-                                                __itt_model_task_instance *instance
-                                                [[maybe_unused]],
-                                                const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_beginA(const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_beginAL(const char *name [[maybe_unused]],
-                                                  size_t taskNameLen [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_iteration_taskA(const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_iteration_taskAL(const char *name [[maybe_unused]],
-                                                      size_t taskNameLen [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_end(__itt_model_task *task [[maybe_unused]],
-                                              __itt_model_task_instance *instance
-                                              [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_end_2(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_acquire(void *lock [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_acquire_2(void *lock [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_release(void *lock [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_release_2(void *lock [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_record_allocation(void *addr [[maybe_unused]],
-                                                       size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_record_deallocation(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_induction_uses(void *addr [[maybe_unused]],
-                                                    size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_reduction_uses(void *addr [[maybe_unused]],
-                                                    size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_observe_uses(void *addr [[maybe_unused]],
-                                                  size_t size [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_clear_uses(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_disable_push(__itt_model_disable x [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_disable_pop(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_aggregate_task(size_t x [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_heap_function ITTAPI __itt_heap_function_create(const char *name
-                                                                   [[maybe_unused]],
-                                                                   const char *domain
-                                                                   [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_allocate_begin(__itt_heap_function h [[maybe_unused]],
-                                                   size_t size [[maybe_unused]],
-                                                   int initialized [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_allocate_end(__itt_heap_function h [[maybe_unused]],
-                                                 void **addr [[maybe_unused]],
-                                                 size_t size [[maybe_unused]],
-                                                 int initialized [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_free_begin(__itt_heap_function h [[maybe_unused]],
-                                               void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_free_end(__itt_heap_function h [[maybe_unused]],
-                                             void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function h [[maybe_unused]],
-                                                     void *addr [[maybe_unused]],
-                                                     size_t new_size [[maybe_unused]],
-                                                     int initialized [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reallocate_end(__itt_heap_function h [[maybe_unused]],
-                                                   void *addr [[maybe_unused]],
-                                                   void **new_addr [[maybe_unused]],
-                                                   size_t new_size [[maybe_unused]],
-                                                   int initialized [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_internal_access_begin(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_internal_access_end(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record_memory_growth_begin(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record_memory_growth_end(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reset_detection(unsigned int reset_mask [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record(unsigned int record_mask [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_create(const __itt_domain *domain [[maybe_unused]],
-                                         __itt_id id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_destroy(const __itt_domain *domain [[maybe_unused]],
-                                          __itt_id id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_timestamp ITTAPI __itt_get_timestamp(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_region_begin(const __itt_domain *domain [[maybe_unused]],
-                                            __itt_id id [[maybe_unused]],
-                                            __itt_id parentid [[maybe_unused]],
-                                            __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_region_end(const __itt_domain *domain [[maybe_unused]],
-                                          __itt_id id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_begin_v3(const __itt_domain *domain [[maybe_unused]],
-                                              __itt_id *id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_end_v3(const __itt_domain *domain [[maybe_unused]],
-                                            __itt_id *id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_submit_v3(const __itt_domain *domain [[maybe_unused]],
-                                               __itt_id *id [[maybe_unused]],
-                                               __itt_timestamp begin [[maybe_unused]],
-                                               __itt_timestamp end [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_group(const __itt_domain *domain [[maybe_unused]],
-                                          __itt_id id [[maybe_unused]],
-                                          __itt_id parentid [[maybe_unused]],
-                                          __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_fn(const __itt_domain *domain [[maybe_unused]],
-                                             __itt_id taskid [[maybe_unused]],
-                                             __itt_id parentid [[maybe_unused]],
-                                             void *fn [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_overlapped(const __itt_domain *domain [[maybe_unused]],
-                                                     __itt_id taskid [[maybe_unused]],
-                                                     __itt_id parentid [[maybe_unused]],
-                                                     __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_overlapped(const __itt_domain *domain [[maybe_unused]],
-                                                   __itt_id taskid [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_str_add(const __itt_domain *domain [[maybe_unused]],
-                                                __itt_id id [[maybe_unused]],
-                                                __itt_string_handle *key [[maybe_unused]],
-                                                const char *data [[maybe_unused]],
-                                                size_t length [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_add_with_scope(const __itt_domain *domain [[maybe_unused]],
-                                                       __itt_scope scope [[maybe_unused]],
-                                                       __itt_string_handle *key [[maybe_unused]],
-                                                       __itt_metadata_type type [[maybe_unused]],
-                                                       size_t count [[maybe_unused]],
-                                                       void *data [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_str_add_with_scope(
-    const __itt_domain *domain [[maybe_unused]], __itt_scope scope [[maybe_unused]],
-    __itt_string_handle *key [[maybe_unused]], const char *data [[maybe_unused]],
-    size_t length [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_to_current(const __itt_domain *domain [[maybe_unused]],
-                                                       __itt_relation relation [[maybe_unused]],
-                                                       __itt_id tail [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add(const __itt_domain *domain [[maybe_unused]],
-                                            __itt_id head [[maybe_unused]],
-                                            __itt_relation relation [[maybe_unused]],
-                                            __itt_id tail [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_clock_domain *ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn fn
-                                                                  [[maybe_unused]],
-                                                                  void *fn_data [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_clock_domain_reset(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_create_ex(const __itt_domain *domain [[maybe_unused]],
-                                            __itt_clock_domain *clock_domain [[maybe_unused]],
-                                            unsigned long long timestamp [[maybe_unused]],
-                                            __itt_id id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_destroy_ex(const __itt_domain *domain [[maybe_unused]],
-                                             __itt_clock_domain *clock_domain [[maybe_unused]],
-                                             unsigned long long timestamp [[maybe_unused]],
-                                             __itt_id id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_ex(const __itt_domain *domain [[maybe_unused]],
-                                             __itt_clock_domain *clock_domain [[maybe_unused]],
-                                             unsigned long long timestamp [[maybe_unused]],
-                                             __itt_id taskid [[maybe_unused]],
-                                             __itt_id parentid [[maybe_unused]],
-                                             __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_fn_ex(const __itt_domain *domain [[maybe_unused]],
-                                                __itt_clock_domain *clock_domain [[maybe_unused]],
-                                                unsigned long long timestamp [[maybe_unused]],
-                                                __itt_id taskid [[maybe_unused]],
-                                                __itt_id parentid [[maybe_unused]],
-                                                void *fn [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_ex(const __itt_domain *domain [[maybe_unused]],
-                                           __itt_clock_domain *clock_domain [[maybe_unused]],
-                                           unsigned long long timestamp [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_counter ITTAPI __itt_counter_create(const char *name [[maybe_unused]],
-                                                       const char *domain [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc(__itt_counter id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_delta(__itt_counter id [[maybe_unused]],
-                                                 unsigned long long value [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec(__itt_counter id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_delta(__itt_counter id [[maybe_unused]],
-                                                 unsigned long long value [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_v3(const __itt_domain *domain [[maybe_unused]],
-                                              __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain *domain [[maybe_unused]],
-                                                    __itt_string_handle *name [[maybe_unused]],
-                                                    unsigned long long delta [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_v3(const __itt_domain *domain [[maybe_unused]],
-                                              __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain *domain [[maybe_unused]],
-                                                    __itt_string_handle *name [[maybe_unused]],
-                                                    unsigned long long delta [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_set_value(__itt_counter id [[maybe_unused]],
-                                                 void *value_ptr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_set_value_ex(__itt_counter id [[maybe_unused]],
-                                                    __itt_clock_domain *clock_domain
-                                                    [[maybe_unused]],
-                                                    unsigned long long timestamp [[maybe_unused]],
-                                                    void *value_ptr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_counter ITTAPI __itt_counter_create_typed(const char *name [[maybe_unused]],
-                                                             const char *domain [[maybe_unused]],
-                                                             __itt_metadata_type type
-                                                             [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_destroy(__itt_counter id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_marker_ex(const __itt_domain *domain [[maybe_unused]],
-                                         __itt_clock_domain *clock_domain [[maybe_unused]],
-                                         unsigned long long timestamp [[maybe_unused]],
-                                         __itt_id id [[maybe_unused]],
-                                         __itt_string_handle *name [[maybe_unused]],
-                                         __itt_scope scope [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_to_current_ex(
-    const __itt_domain *domain [[maybe_unused]], __itt_clock_domain *clock_domain [[maybe_unused]],
-    unsigned long long timestamp [[maybe_unused]], __itt_relation relation [[maybe_unused]],
-    __itt_id tail [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_ex(const __itt_domain *domain [[maybe_unused]],
-                                               __itt_clock_domain *clock_domain [[maybe_unused]],
-                                               unsigned long long timestamp [[maybe_unused]],
-                                               __itt_id head [[maybe_unused]],
-                                               __itt_relation relation [[maybe_unused]],
-                                               __itt_id tail [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_track_group *ITTAPI
-__itt_track_group_create(__itt_string_handle *name [[maybe_unused]],
-                         __itt_track_group_type track_group_type [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C __itt_track *ITTAPI __itt_track_create(__itt_track_group *track_group [[maybe_unused]],
-                                                    __itt_string_handle *name [[maybe_unused]],
-                                                    __itt_track_type track_type [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_set_track(__itt_track *track [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C int ITTAPI __itt_av_save(void *data [[maybe_unused]], int rank [[maybe_unused]],
-                                      const int *dimensions [[maybe_unused]],
-                                      int type [[maybe_unused]],
-                                      const char *filePath [[maybe_unused]],
-                                      int columnOrder [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_enable_attach(void) { SPDLOG_TRACE("{}() Adapter", __FUNCTION__); }
-
-ITT_EXTERN_C void ITTAPI __itt_module_load(void *start_addr [[maybe_unused]],
-                                           void *end_addr [[maybe_unused]],
-                                           const char *path [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_unload(void *addr [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_load_with_sections(__itt_module_object *module_obj
-                                                         [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_unload_with_sections(__itt_module_object *module_obj
-                                                           [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_histogram *ITTAPI __itt_histogram_create(
-    const __itt_domain *domain [[maybe_unused]], const char *name [[maybe_unused]],
-    __itt_metadata_type x_type [[maybe_unused]], __itt_metadata_type y_type [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_histogram_submit(__itt_histogram *hist [[maybe_unused]],
-                                                size_t length [[maybe_unused]],
-                                                void *x_data [[maybe_unused]],
-                                                void *y_data [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_overlapped_ex(
-    const __itt_domain *domain [[maybe_unused]], __itt_clock_domain *clock_domain [[maybe_unused]],
-    unsigned long long timestamp [[maybe_unused]], __itt_id taskid [[maybe_unused]],
-    __itt_id parentid [[maybe_unused]], __itt_string_handle *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain *domain [[maybe_unused]],
-                                                      __itt_clock_domain *clock_domain
-                                                      [[maybe_unused]],
-                                                      unsigned long long timestamp [[maybe_unused]],
-                                                      __itt_id taskid [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C __itt_mark_type ITTAPI __itt_mark_create(const char *name [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark(__itt_mark_type mt [[maybe_unused]],
-                                   const char *parameter [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_global(__itt_mark_type mt [[maybe_unused]],
-                                          const char *parameter [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_off(__itt_mark_type mt [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_global_off(__itt_mark_type mt [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C __itt_caller ITTAPI __itt_stack_caller_create(void) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_caller_destroy(__itt_caller id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_callee_enter(__itt_caller id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_callee_leave(__itt_caller id [[maybe_unused]]) {
-  SPDLOG_TRACE("{}() Adapter", __FUNCTION__);
-}
diff --git a/sdk/src/levelzero/collector_options.h b/sdk/src/levelzero/collector_options.h
deleted file mode 100644
index d87f68e8..00000000
--- a/sdk/src/levelzero/collector_options.h
+++ /dev/null
@@ -1,46 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef SDK_SRC_COLLECTOR_OPTIONS_
-#define SDK_SRC_COLLECTOR_OPTIONS_
-
-#include <atomic>
-
-// Structure holds flags that convey to collector that the associated viewKind is enabled by user.
-//    Enabled flags trigger callbacks to view_handler to issue buffer record.
-struct ViewsBufferable {
-  std::atomic<bool> synch_enabled = false;      // is synchronization viewkind enabled by user.
-  std::atomic<bool> api_calls_enabled = false;  // are driver api calls enabled by user.
-
-  ViewsBufferable() = default;
-
-  // to copy atomics
-  ViewsBufferable(const ViewsBufferable& other)
-      : synch_enabled(other.synch_enabled.load()),
-        api_calls_enabled(other.api_calls_enabled.load()) {}
-
-  ViewsBufferable& operator=(const ViewsBufferable&) = delete;  // Not used.
-  ViewsBufferable(ViewsBufferable&&) = delete;
-  ViewsBufferable& operator=(ViewsBufferable&&) = delete;
-  ~ViewsBufferable() = default;
-};
-
-struct CollectorOptions {
-  // collector present in the process but does nothing, ready to start
-  bool disabled_mode = true;
-  // collector shifts to this mode only when introspection apis available and only when user forces
-  // to be so.
-  bool hybrid_mode = false;
-
-  bool kernel_tracing = false;
-  bool api_tracing = false;
-
-  const bool demangle = true;
-
-  ViewsBufferable lz_enabled_views;
-};
-
-#endif  // SDK_SRC_COLLECTOR_OPTIONS_
diff --git a/sdk/src/levelzero/ze_collector.h b/sdk/src/levelzero/ze_collector.h
deleted file mode 100644
index e20d4f2b..00000000
--- a/sdk/src/levelzero/ze_collector.h
+++ /dev/null
@@ -1,4029 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_PTI_LEVEL_ZERO_COLLECTOR_H_
-#define PTI_TOOLS_PTI_LEVEL_ZERO_COLLECTOR_H_
-
-/*
- * Level zero collection methods:  hook into the level zero api to capture
- * kernel/memory movement, collect relevant timing and handles key structures
- * and issue callbacks to buffer,etc interfaces to capture this data in view
- * records.
- */
-
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/layers/zel_tracing_register_cb.h>
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-#include <pti/pti_driver_levelzero_api_ids.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <new>
-#include <optional>
-#include <shared_mutex>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <variant>
-#include <vector>
-
-#include "collector_options.h"
-#include "lz_api_tracing_api_loader.h"
-#include "overhead_kinds.h"
-#include "pti/pti_view.h"
-#include "pti_api_ids_state_maps.h"
-#include "pti_memory_route.h"
-#include "unikernel.h"
-#include "utils.h"
-#include "ze_collector_cb_helpers.h"
-#include "ze_command_visitor.h"
-#include "ze_driver_init.h"
-#include "ze_event_cache.h"
-#include "ze_event_managers.h"
-#include "ze_events_and_pools_observer.h"
-#include "ze_gpu_command.h"
-#include "ze_graph_storage.h"
-#include "ze_kernel_name_cache.h"
-#include "ze_local_collection_helpers.h"
-#include "ze_timer_helper.h"
-#include "ze_utils.h"
-#include "ze_wrappers.h"
-
-#if defined(PTI_TRACE_SYCL)
-#include "sycl_collector.h"
-#endif
-
-struct CallbacksEnabled {
-  std::atomic<bool> acallback = false;
-  std::atomic<bool> fcallback = false;
-};
-
-inline std::atomic<uint64_t> global_ref_count =
-    0;  // Keeps track of zelEnable/zelDisable TracingLayer()
-        // calls issued. 0 => truly disabled tracing.
-
-struct ZeInstanceData {
-  uint64_t start_time_host;
-  uint64_t timestamp_host;    // in ns
-  uint64_t timestamp_device;  // in ticks
-  uint64_t end_time_host;
-  uint64_t kid;  // passing kid from enter callback to exit callback
-  uint32_t callback_id_;
-};
-
-inline thread_local ZeInstanceData ze_instance_data;
-
-// Used for CPU/GPU sync points. See description to ZeCollector::GetDeviceTimestamps function
-inline thread_local std::map<ze_device_handle_t, std::unique_ptr<CPUGPUTimeInterpolationHelper>>
-    timer_helpers;
-
-using ZeKernelGroupSizeMap = std::map<ze_kernel_handle_t, ZeKernelGroupSize>;
-using ZeCommandListMap = std::map<ze_command_list_handle_t, ZeCommandListInfo>;
-using ZeImageSizeMap = std::map<ze_image_handle_t, size_t>;
-using ZeDeviceMap = std::map<ze_device_handle_t, std::vector<ze_device_handle_t>>;
-
-using OnZeKernelFinishCallback = void (*)(void*, std::vector<ZeKernelCommandExecutionRecord>&);
-using OnZeApiCallsFinishCallback = void (*)(void*, ZeKernelCommandExecutionRecord&);
-
-class ZeCollector {
- public:  // Interface
-  ZeCollector(const ZeCollector&) = delete;
-  ZeCollector& operator=(const ZeCollector&) = delete;
-  ZeCollector(ZeCollector&&) = delete;
-  ZeCollector& operator=(ZeCollector&&) = delete;
-
-  static std::unique_ptr<ZeCollector> Create(std::atomic<pti_result>* pti_state,
-                                             CollectorOptions options,
-                                             OnZeKernelFinishCallback acallback = nullptr,
-                                             OnZeApiCallsFinishCallback fcallback = nullptr,
-                                             void* callback_data = nullptr) {
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-    PTI_ASSERT(nullptr != pti_state);
-    ZeDriverInit driver_init{};
-    if (!driver_init.Success()) {
-      SPDLOG_ERROR("Unable to initialize Level Zero driver(s)");
-      *pti_state = pti_result::PTI_ERROR_DRIVER;
-      return nullptr;
-    }
-
-    auto collector = std::unique_ptr<ZeCollector>(
-        new ZeCollector(options, acallback, fcallback, callback_data, driver_init));
-
-    PTI_ASSERT(collector != nullptr);
-    collector->parent_state_ = pti_state;
-
-    zel_tracer_desc_t tracer_desc = {ZEL_STRUCTURE_TYPE_TRACER_EXP_DESC, nullptr, collector.get()};
-    zel_tracer_handle_t tracer = nullptr;
-    overhead::Init();
-    auto status = zelTracerCreate(&tracer_desc, &tracer);
-    overhead_fini(zelTracerCreate_id);
-
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_CRITICAL(
-          "Unable to create Level Zero tracer, error code {0:#x}\n"
-          "It could be due to old driver installed where tracing enabled with "
-          "setting env variable ZE_ENABLE_TRACING_LAYER to 1.",
-          static_cast<std::size_t>(status));
-      *pti_state = pti_result::PTI_ERROR_TRACING_NOT_INITIALIZED;
-      return nullptr;
-    }
-
-    collector->collection_mode_ =
-        SelectZeCollectionMode(collector->driver_introspection_capable_,
-                               collector->options_.disabled_mode, collector->options_.hybrid_mode);
-    SPDLOG_DEBUG("\tCollection_mode: {}", (uint32_t)collector->collection_mode_);
-
-    collector->options_.api_tracing = true;
-    collector->EnableTracer(tracer);
-
-    status = collector->l0_wrapper_.w_zelEnableTracingLayer();
-    if (ZE_RESULT_SUCCESS == status) {
-      global_ref_count++;
-    }
-
-    if (collector->options_.disabled_mode) {
-      SPDLOG_DEBUG("\tRunning in disabled mode");
-      status = collector->l0_wrapper_.w_zelDisableTracingLayer();
-      if (ZE_RESULT_SUCCESS == status) {
-        global_ref_count--;
-      }
-    } else {
-      SPDLOG_DEBUG("\tRunning in enabled mode");
-    }
-
-    collector->tracer_ = tracer;
-    return collector;
-  }
-
-  ~ZeCollector() {
-    if (tracer_ != nullptr) {
-      // TODO(PTI): Right now, if called from a singleton, this will crash on Windows due to DLL
-      // unload order. Leak the collector on Windows.
-      [[maybe_unused]] auto status = zelTracerSetEnabled(tracer_, static_cast<ze_bool_t>(false));
-      status = zelTracerDestroy(tracer_);
-      tracer_ = nullptr;
-    }
-  }
-  enum class ZeCollectionMode { kFull = 0, kHybrid = 1, kLocal = 2 };
-  enum class ZeCollectionState { kNormal = 0, kAbnormal = 1 };
-
-  /**
-   * \internal
-   * \brief Returns the current device timestamps, CPU in nanoseconds and GPU in ticks
-   *
-   * \param [in] device - the device to get the timestamps from
-   * \param [out] host_time - the CPU time in nanoseconds
-   * \param [out] device_time - the GPU time in ticks
-   * \return ZE_RESULT_SUCCESS on success, ZE_RESULT_ERROR on failure
-   *
-   * Previously, zeDeviceGetGlobalTimestamps was called every time CPU and GPU timestamps
-   * needed to be synced (via utils::ze::GetDeviceTimestamps(device, host_time, device_time);)
-   * GPU cycles were then converted to CPU (aka host) timescale.
-   * However, zeDeviceGetGlobalTimestamps has a high latency,
-   * so it is not suitable for frequent calls (e.g. each dozen of micro-secs),
-   * especially in profiler
-   *
-   * The current implementation calls zeDeviceGetGlobalTimestamp less often:
-   * once in  ~ hundreds of microseconds (and maybe even less often...)
-   * (see CPUGPUTimeInterpolationHelper.delta) - for sync CPU/GPU point
-   * per thread per device. (per thread - to avoid any synchronization between threads)
-   * The delta between sync points is selected  empirically, but it is important to keep in mind
-   * that on systems with 32-bit GPU time counter - this counter would wrap around every few
-   * seconds. The delta should be less than this wrap around time.
-   *
-   * Another change - the GPU timer frequency is not interpolated anymore but rather
-   * taken from the device descriptor. This assumes that it is constant.
-   *
-   * The function is called synchronously in a profiled thread, once per device.
-   *
-   * InterpolationHelper keeps the sync point from some recent past.
-   * If CPU time, from the recent sync point, exceeded delta - makes a new sync point.
-   * The sync point data are returned to a caller. The caller uses the sync point data
-   * to convert GPU cycles to CPU time or do other ops with them.
-   */
-  ze_result_t GetDeviceTimestamps(ze_device_handle_t device, uint64_t* host_time,
-                                  uint64_t* device_time) {
-    // PTI-336 talks about Interpolation approach.
-    // At the moment of this change - all tests on real devices are passing.
-    // If any issues - they need to be carefully investigated prior to disabling this pass.
-    //
-    // Frequent calls of high latency zeDeviceGetGlobalTimestamps()
-    // not only introduce CPU overhead, but also skews the workload behaviour,
-    // so that PTI ends up profiling a different workload than the original one.
-    // This is especially true when a workload submits many short running kernels with high density.
-    //
-    // If this solution doesn't work for simulator - the suggested change should not harm
-    // the profiling workloads running on real silicon.
-    PTI_ASSERT(device != nullptr);
-    PTI_ASSERT(host_time != nullptr);
-    PTI_ASSERT(device_time != nullptr);
-
-    if (device_descriptors_.find(device) != device_descriptors_.end()) {
-      if (timer_helpers.find(device) == timer_helpers.end()) {
-        SPDLOG_DEBUG(
-            "Creating new CPUGPUTimeInterpolationHelper for device {}, "
-            "device_timer_frequency: {}, device_timer_mask: {}, device_sync_delta: {}",
-            static_cast<void*>(device), device_descriptors_[device].device_timer_frequency,
-            device_descriptors_[device].device_timer_mask,
-            device_descriptors_[device].device_sync_delta);
-
-        timer_helpers[device] = std::make_unique<CPUGPUTimeInterpolationHelper>(
-            device, device_descriptors_[device].device_timer_frequency,
-            device_descriptors_[device].device_timer_mask,
-            device_descriptors_[device].device_sync_delta);
-      }
-
-      uint64_t anchor_host_time = 0;
-      uint64_t anchor_device_time = 0;
-
-      auto helper = timer_helpers[device].get();
-      uint64_t current_host_time = utils::GetTime();
-
-      // Why integer arithmetic below:
-      // 1. Avoids any precision issues with floating point arithmetic,
-      //    as here dealing with large numbers (nanoseconds and GPU ticks) - conversion to/from FP
-      //    can cause significant precision loss in the last decimal digits, we care about
-      // 2. Avoids any performance issues with floating point arithmetic,
-      //    (this is in the critical path)
-      //    especially, denormals etc. - which are costly from a performance perspective,
-      // 3. Reproducibility - with FP can get different results on different runs
-      //    + dependence on what FP instructions code compiled - x87, SSE, AVX..
-      //    can contribute to issues with reproducibility and precision.
-
-      if (current_host_time - helper->cpu_timestamp_ > helper->delta_) {
-        auto res = utils::ze::GetDeviceTimestamps(device, &anchor_host_time, &anchor_device_time);
-        PTI_ASSERT(res == ZE_RESULT_SUCCESS);
-        helper->cpu_timestamp_ = anchor_host_time;
-        helper->gpu_timestamp_ = anchor_device_time;
-      } else {
-        anchor_host_time = helper->cpu_timestamp_;
-        anchor_device_time = helper->gpu_timestamp_;
-      }
-      current_host_time = utils::GetTime();
-
-      uint64_t current_device_time = anchor_device_time + ((current_host_time - anchor_host_time) /
-                                                           helper->GetNsecInGPUTimerTick());
-
-      *host_time = current_host_time;
-      *device_time = current_device_time;
-    } else {
-      SPDLOG_WARN("Device {} not found in device_descriptors. Fallback to old GPU timing method.",
-                  static_cast<void*>(device));
-      auto res = utils::ze::GetDeviceTimestamps(device, host_time, device_time);
-      PTI_ASSERT(res == ZE_RESULT_SUCCESS);
-    }
-    return ZE_RESULT_SUCCESS;
-  }
-
-  static ZeCollectionMode SelectZeCollectionMode(bool introspection_capable, bool& disabled_mode,
-                                                 bool& hybrid_mode) {
-    ZeCollector::ZeCollectionMode mode = ZeCollectionMode::kFull;
-    disabled_mode = false;
-    hybrid_mode = false;
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-
-    SPDLOG_INFO("\tIntrospectable?: {}", introspection_capable);
-    SPDLOG_INFO("\tChecking if the mode enforced by PTI_COLLECTION_MODE environment variable");
-    try {
-      std::string env_string = utils::GetEnv("PTI_COLLECTION_MODE");
-      int32_t env_value = -1;
-      if (!env_string.empty()) {
-        env_value = std::stoi(env_string);
-        SPDLOG_INFO("\tDetected var: {}", env_value);
-        switch (env_value) {
-          case 0:  // FullAPI collection mode
-            SPDLOG_INFO("\tForced Full collection");
-            disabled_mode = false;
-            hybrid_mode = false;
-            mode = ZeCollectionMode::kFull;
-            break;
-          case 1:  // Asking for Hybrid collection mode
-            if (introspection_capable) {
-              SPDLOG_INFO(
-                  "\tLevel-Zero Introspection API available: Forced fallback to hybrid mode.");
-              disabled_mode = false;
-              hybrid_mode = true;
-              mode = ZeCollectionMode::kHybrid;
-              break;
-            } else {
-              SPDLOG_WARN("\tLevel-Zero Introspection API not available: Cannot do Hybrid mode.");
-            }
-            break;
-          case 2:  // Asking for Local collection mode
-            if (introspection_capable) {
-              SPDLOG_INFO("\tForced fallback to Local mode.");
-              disabled_mode = true;
-              hybrid_mode = false;
-              mode = ZeCollectionMode::kLocal;
-            } else {
-              SPDLOG_WARN("\tLevel-Zero Introspection API not available: Cannot do Local mode.");
-            }
-            break;
-        }
-      } else {
-        if (introspection_capable) {
-          mode = ZeCollectionMode::kLocal;
-          disabled_mode = true;
-          hybrid_mode = false;
-        }
-      }
-    } catch (std::invalid_argument const& /*ex*/) {
-      hybrid_mode = false;
-      disabled_mode = false;
-      mode = ZeCollectionMode::kFull;
-    } catch (std::out_of_range const& /*ex*/) {
-      hybrid_mode = false;
-      disabled_mode = false;
-      mode = ZeCollectionMode::kFull;
-    }
-    return mode;
-  }
-
-  bool IsIntrospectionCapable() const { return driver_introspection_capable_; }
-
-  bool IsDynamicTracingCapable() const { return loader_dynamic_tracing_capable_; }
-
-  // We get here on StartTracing/enable of L0 related view kinds.
-  // The caller needs to ensure duplicated enable of view_kinds do not happen on a per thread basis.
-  void EnableTracing() {
-    // switches to full/hybrid api mode - only if we are not already in full/hybrid api mode.  Else
-    // records another view_kind active in region.
-    startstop_mode_changer.ToStartTracing();
-  }
-
-  // We get here on StopTracing/disable of L0 related view kinds.
-  // The caller needs to ensure duplicated disables of view_kinds do not happen on a per thread
-  // basis.
-  void DisableTracing() {
-    // disables full/hybrid api mode - only if all previously active view_kinds are disabled
-    // across all threads. Else records another view_kind deactivated in region.
-    startstop_mode_changer.ToStopTracing();
-  }
-
-  /**
-   * @brief Stop Tracing if in case of any abnormal collection situation
-   *
-   * this could be no L0 Introspection API while dynamic tracing enabled
-   * so application called PTI after context, or queue created
-   */
-  void AbnormalStopTracing() {
-    ze_result_t status = l0_wrapper_.w_zelDisableTracingLayer();
-    if (ZE_RESULT_SUCCESS == status) {
-      global_ref_count--;
-      collection_state_ = ZeCollectionState::kAbnormal;
-
-      PTI_ASSERT(global_ref_count == 0);
-      SPDLOG_DEBUG("In {}, L0 Tracing OFF, tid: {}", __FUNCTION__, PidTidInfo::Get().tid);
-      return;
-    }
-    SPDLOG_CRITICAL("In {}, Cannot stop L0 Tracing, tid: {}", __FUNCTION__, PidTidInfo::Get().tid);
-    PTI_ASSERT(false);
-  }
-
-  void DisableTracer() {
-    // In the past: pre- oneAPI 2025.2 and old L0, on Windows due to not specified DLLs unload order
-    // we had issues here.
-    // Now this works and prevents from receiving L0 Callbacks when the process is winding down.
-    overhead::ScopedOverheadCollector overhead_fini(zelTracerSetEnabled_id);
-    [[maybe_unused]] const auto status =
-        zelTracerSetEnabled(tracer_, static_cast<ze_bool_t>(false));
-    SPDLOG_DEBUG("In {}, zelTracerSetEnabled(.., false) returns: {:x}", __func__,
-                 static_cast<uint32_t>(status));
-  }
-
-  const CollectorOptions& GetCollectorOptions() const { return options_; }
-  bool IsTracingOn() const { return startstop_mode_changer.IsTracingOn(); }
-  void SetKernelTracing(bool enable) { options_.kernel_tracing = enable; }
-
-  void SetCollectorOptionSynchronization() { options_.lz_enabled_views.synch_enabled = true; }
-  void SetCollectorOptionApiCalls() { options_.lz_enabled_views.api_calls_enabled = true; }
-
-  void UnSetCollectorOptionSynchronization() { options_.lz_enabled_views.synch_enabled = false; }
-  void UnSetCollectorOptionApiCalls() { options_.lz_enabled_views.api_calls_enabled = false; }
-
-  // Multiple subscribers support with handle-based management
-  pti_callback_subscriber_handle AddCallbackSubscriber(pti_callback_function callback,
-                                                       void* user_data) {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    auto subscriber = std::make_unique<ZeCollectorCBSubscriber>();
-    subscriber->SetUserData(user_data);
-    subscriber->SetCallback(callback);
-    return cb_subscribers_collection_.AddExternalSubscriber(std::move(subscriber));
-  }
-
-  pti_result RemoveCallbackSubscriber(pti_callback_subscriber_handle subscriber_handle) {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    if (cb_subscribers_collection_.RemoveExternalSubscriber(subscriber_handle)) {
-      return pti_result::PTI_SUCCESS;
-    }
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  std::vector<pti_callback_subscriber_handle> GetAllSubscriberHandles() const {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    return cb_subscribers_collection_.GetAllSubscriberHandles();
-  }
-
-  pti_result EnableCallbackDomain(pti_callback_subscriber_handle handle, pti_callback_domain domain,
-                                  uint32_t enter_cb, uint32_t exit_cb) {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    return cb_subscribers_collection_.EnableCallbackDomain(handle, domain, enter_cb, exit_cb);
-  }
-
-  pti_result DisableCallbackDomain(pti_callback_subscriber_handle handle,
-                                   pti_callback_domain domain) {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    return cb_subscribers_collection_.DisableCallbackDomain(handle, domain);
-  }
-
-  pti_result DisableAllCallbackDomains(pti_callback_subscriber_handle handle) {
-    std::unique_lock<std::shared_mutex> lock(subscribers_mutex_);
-    return cb_subscribers_collection_.DisableAllCallbackDomains(handle);
-  }
-
-  // Check if any subscriber has the given domain enabled
-  bool IsCallbackDomainEnabled(pti_callback_domain domain, uint32_t cb_type) {
-    std::shared_lock<std::shared_mutex> lock(subscribers_mutex_);
-    for (auto& subscriber_handle : cb_subscribers_collection_) {
-      auto subscriber = cb_subscribers_collection_.GetSubscriber(subscriber_handle);
-      PTI_ASSERT(subscriber != nullptr);
-      if (subscriber->IsEnabled(domain, cb_type)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool IsAnyCallbackSubscriberActive() {
-    std::shared_lock<std::shared_mutex> lock(subscribers_mutex_);
-    return cb_subscribers_collection_.IsAnySubscriberActive();
-  }
-
- private:
-  pti_gpu_op_details MakeGPUOpDetails(const ZeKernelCommand& command) {
-    return pti_gpu_op_details{
-        ZeCollectorCBSubscriber::GetGPUOperationKind(command.props.type), command.kernel_id,
-        INVALID_KERNEL_HANDLE,  // temp, until modules & kernels in them supported
-        command.props.name.c_str()};
-  }
-
-  pti_callback_gpu_op_data MakeGPUOpData(const ZeKernelCommand& command, pti_callback_phase phase,
-                                         ze_result_t return_code, pti_gpu_op_details* op_details) {
-    pti_backend_command_list_type cmd_list_props = IsCommandListImmediate(command.command_list)
-                                                       ? PTI_BACKEND_COMMAND_LIST_TYPE_IMMEDIATE
-                                                       : PTI_BACKEND_COMMAND_LIST_TYPE_UNKNOWN;
-    pti_backend_queue_t queue_handle =
-        (IsCommandListImmediate(command.command_list)) ? command.command_list : nullptr;
-    return pti_callback_gpu_op_data{PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    cmd_list_props,
-                                    command.command_list,
-                                    queue_handle,
-                                    command.device,
-                                    phase,
-                                    static_cast<uint32_t>(return_code),
-                                    command.corr_id_,
-                                    1,
-                                    op_details};
-  }
-
-  void DoCallbackOnGPUOperationCompletion(
-      const std::vector<ZeKernelCommandExecutionRecord>& kcexecrec) {
-    SPDLOG_TRACE("In {} on {} commands: {}", __func__,
-                 ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED),
-                 kcexecrec.size());
-    if (IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1) &&
-        kcexecrec.size() > 0) {
-      ExecRecordsMap record_map;
-      ZeCollectorCBSubscriber::MapRecordsByContextAndDevice(kcexecrec, record_map);
-      SPDLOG_TRACE("\trecord map size: {}", record_map.size());
-      // For each context/device pair, make a callback
-      for (const auto& [key, records] : record_map) {
-        const auto& [context, device_handle] = key;
-        SPDLOG_TRACE("\tGPU op records: {}", records.size());
-        // all records in this group have same context and device
-        std::vector<pti_gpu_op_details> op_details(records.size());
-        ZeCollectorCBSubscriber::MakeGPUOpDetailsArray(records, op_details);
-
-        pti_callback_gpu_op_data callback_data = {
-            PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-            // as operations from many cmd lists and queues comes in one completion callback
-            PTI_BACKEND_COMMAND_LIST_TYPE_UNKNOWN, nullptr, nullptr, device_handle,
-            PTI_CB_PHASE_API_EXIT, 0, 0, static_cast<uint32_t>(op_details.size()),
-            op_details.data()};
-
-        InvokeCallbacksForSubscribers(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-                                      PTI_CB_PHASE_API_EXIT, ze_instance_data.callback_id_, context,
-                                      &callback_data);
-      }
-    }
-  }
-
-  void DoCallbackOnGPUOperationAppended(const ZeKernelCommand* command, pti_callback_phase phase,
-                                        ze_result_t return_code) {
-    SPDLOG_TRACE("On {}", __func__);
-    if (IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, phase)) {
-      pti_gpu_op_details op_details = MakeGPUOpDetails(*command);
-      pti_callback_gpu_op_data callback_data =
-          MakeGPUOpData(*command, phase, return_code, &op_details);
-
-      // Invoke callbacks for all subscribers with this domain enabled
-      // TODO: Make correct order for different phases:
-      // ENTER - forward, EXIT -> backward
-      InvokeCallbacksForSubscribers(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, phase,
-                                    ze_instance_data.callback_id_, command->context,
-                                    &callback_data);
-    }
-    SPDLOG_TRACE(
-        "\tCallback calls completed in domain: "
-        "PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED");
-  }
-
-  void InvokeCallbacksForSubscribers(pti_callback_domain domain, pti_callback_phase phase,
-                                     uint32_t api_id, pti_backend_ctx_t context,
-                                     void* callback_data) {
-    std::shared_lock<std::shared_mutex> lock(subscribers_mutex_);
-    for (const auto& subscriber_handle : cb_subscribers_collection_) {
-      auto subscriber = cb_subscribers_collection_.GetSubscriber(subscriber_handle);
-      PTI_ASSERT(subscriber != nullptr);
-      if (subscriber->IsEnabled(domain, phase) && subscriber->GetCallback()) {
-        thread_local_is_within_subscriber_callback = true;
-        subscriber->GetCallback()(domain, PTI_API_GROUP_LEVELZERO, api_id, context, callback_data,
-                                  subscriber->GetUserData(),
-                                  subscriber->GetPtrForInstanceUserData());
-        thread_local_is_within_subscriber_callback = false;
-      }
-    }
-  }
-
-  void DoCallbackOnKernelLifecycle(pti_callback_domain domain, pti_callback_phase phase,
-                                   ze_context_handle_t context, ze_kernel_handle_t kernel_handle,
-                                   ze_module_handle_t module_handle,
-                                   ze_device_handle_t device_handle, const char* kernel_name,
-                                   ze_result_t return_code, uint32_t api_id) {
-    SPDLOG_TRACE("In {} domain {} phase {}", __func__, static_cast<uint32_t>(domain),
-                 static_cast<uint32_t>(phase));
-    if (domain != PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED &&
-        domain != PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED) {
-      return;
-    }
-    if (!IsCallbackDomainEnabled(domain, phase)) {
-      return;
-    }
-    pti_callback_kernel_data callback_data = {};
-    callback_data._domain = domain;
-    callback_data._phase = phase;
-    callback_data._return_code =
-        (phase == PTI_CB_PHASE_API_EXIT) ? static_cast<uint32_t>(return_code) : 0u;
-    callback_data._device_kernel_handle = static_cast<pti_backend_kernel_t>(kernel_handle);
-    callback_data._module_handle = static_cast<pti_backend_module_t>(module_handle);
-    callback_data._name = kernel_name;
-    callback_data._device_handle = static_cast<pti_device_handle_t>(device_handle);
-
-    InvokeCallbacksForSubscribers(domain, phase, api_id, context, &callback_data);
-  }
-
- private:  // Implementation
-  ZeCollector(CollectorOptions options, OnZeKernelFinishCallback acallback,
-              OnZeApiCallsFinishCallback fcallback, void* callback_data,
-              const ZeDriverInit& driver_init)
-      : options_(options),
-        acallback_(acallback),
-        fcallback_(fcallback),
-        callback_data_(callback_data),
-        l0_wrapper_(),
-        graph_storage_(&l0_wrapper_),
-        event_cache_(ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP),
-        event_pools_observer_(l0_wrapper_),
-        startstop_mode_changer(this) {
-    CreateDeviceMap(driver_init);
-    DetermineIfCounterEventsPossible(driver_init);
-    DetermineIfVisitorExtensionIsAvailable(driver_init);
-    UpdateDeviceSyncDelta();
-    ze_result_t res = l0_wrapper_.InitDynamicTracingWrappers();
-    if (ZE_RESULT_SUCCESS == res) {
-      loader_dynamic_tracing_capable_ = true;
-      MarkIntrospection(driver_init);
-    }
-  }
-
-  int32_t trace_all_env_value = utils::IsSetEnv("PTI_VIEW_DRIVER_API");
-
-  ze_result_t DetectIntrospectionApis(const ze_driver_handle_t& driver) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-
-    ze_result_t res = l0_wrapper_.InitIntrospectionWrappers();
-    if (ZE_RESULT_SUCCESS != res) {
-      return res;
-    }
-
-    // Create Context
-    ze_context_handle_t context = nullptr;
-    ze_context_desc_t cdesc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-    overhead::Init();
-    ze_result_t status = zeContextCreate(driver, &cdesc, &context);
-    overhead_fini(zeContextCreate_id);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    // Create Event Pool
-    ze_event_pool_handle_t event_pool = nullptr;
-    ze_event_pool_desc_t event_pool_desc = {
-        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-        ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-
-    overhead::Init();
-    status = zeEventPoolCreate(context, &event_pool_desc, 0, nullptr, &event_pool);
-    overhead_fini(zeEventPoolCreate_id);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    // IntrospectionAPI --- return status determines if api's available on this driver.
-    ze_event_pool_flags_t event_pool_flags;
-    overhead::Init();
-    status = l0_wrapper_.w_zeEventPoolGetFlags(event_pool, &event_pool_flags);
-    overhead_fini(zeEventPoolGetFlags_id);
-
-    // Cleanup
-    overhead::Init();
-    ze_result_t status1 = zeEventPoolDestroy(event_pool);
-    overhead_fini(zeEventPoolDestroy_id);
-    PTI_ASSERT(status1 == ZE_RESULT_SUCCESS);
-
-    overhead::Init();
-    status1 = zeContextDestroy(context);
-    overhead_fini(zeContextDestroy_id);
-    PTI_ASSERT(status1 == ZE_RESULT_SUCCESS);
-
-    return status;
-  }
-
-  void CreateDeviceMap(const ZeDriverInit& driver_init) {
-    for (auto* const driver : driver_init.Drivers()) {
-      const auto visit = driver_init.GetExtension<ZeExts::Visit>(driver);
-      const auto cmdlist_introspection =
-          driver_init.GetExtension<ZeExts::CmdListIntrospection>(driver);
-      const auto graph_ext = driver_init.GetExtension<ZeExts::GraphExt>(driver);
-      const auto devices = utils::ze::GetDeviceList(driver);
-      for (auto* const device : devices) {
-        device_descriptors_[device] = GetZeDeviceDescriptor(device);
-        device_descriptors_[device].visit = visit;
-        device_descriptors_[device].cmdlist_introspection = cmdlist_introspection;
-        device_descriptors_[device].graph_exp = graph_ext;
-        SPDLOG_DEBUG("\tdevice: {}", static_cast<const void*>(device));
-        const auto sub_devices = utils::ze::GetSubDeviceList(device);
-        device_map_[device] = sub_devices;
-        for (auto* const sub_device : sub_devices) {
-          SPDLOG_DEBUG("\tsub-device: {}", static_cast<const void*>(sub_device));
-          device_descriptors_[sub_device] = GetZeDeviceDescriptor(sub_device);
-          device_descriptors_[sub_device].visit = visit;
-          device_descriptors_[sub_device].cmdlist_introspection = cmdlist_introspection;
-          device_descriptors_[sub_device].graph_exp = graph_ext;
-        }
-      }
-    }
-  }
-
-  void UpdateDeviceSyncDelta() {
-    // in future we can try make it per device
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-    uint64_t delta = 0;
-    auto env_string = utils::GetEnv("PTI_DEVICE_SYNC_DELTA");
-    SPDLOG_INFO("Checking DeviceSyncDelta by PTI_DEVICE_SYNC_DELTA environment variable");
-    if (!env_string.empty()) {
-      try {
-        delta = std::stoll(env_string);
-        SPDLOG_INFO("\tPTI_DEVICE_SYNC_DELTA is {} ns, will use it in device tracing", delta);
-      } catch (std::invalid_argument const& /*ex*/) {
-        delta = CPUGPUTimeInterpolationHelper::kSyncDeltaDefault;  // fallback to default
-      } catch (std::out_of_range const& /*ex*/) {
-        delta = CPUGPUTimeInterpolationHelper::kSyncDeltaDefault;  // fallback to default
-      }
-    }
-    for (auto& [device, descriptor] : device_descriptors_) {
-      descriptor.device_sync_delta = delta;
-    }
-  }
-  void MarkIntrospection(const ZeDriverInit& drivers) {
-    for (auto* const driver : drivers.Drivers()) {
-      const auto devices = utils::ze::GetDeviceList(driver);
-      for (auto* const device : devices) {
-        ze_device_properties_t device_properties = {};
-        device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-        device_properties.pNext = nullptr;
-        overhead::Init();
-        ze_result_t status = zeDeviceGetProperties(device, &device_properties);
-        overhead_fini(zeDeviceGetProperties_id);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        // Checking only on one driver for GPU device
-        if (device_properties.type == ZE_DEVICE_TYPE_GPU) {
-          // Issue api call here and detect if introspection apis are supported by underlying
-          // rolling driver.
-          status = DetectIntrospectionApis(driver);
-          if (status == ze_result_t::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
-            driver_introspection_capable_ = false;
-          } else if (status == ze_result_t::ZE_RESULT_SUCCESS) {
-            driver_introspection_capable_ = true;
-          }
-          break;
-        }
-      }
-    }
-  }
-
-  void DetermineIfCounterEventsPossible(const ZeDriverInit& drivers) {
-    driver_supports_counter_events_ = std::any_of(
-        drivers.Drivers().cbegin(), drivers.Drivers().cend(), [&](ze_driver_handle_t driver) {
-          return drivers.GetExtension<ZeExts::CounterBasedEvents>(driver).has_value();
-        });
-    SPDLOG_TRACE("Driver supports counter events: {}", driver_supports_counter_events_);
-  }
-
-  void DetermineIfVisitorExtensionIsAvailable(const ZeDriverInit& drivers) {
-    if (std::any_of(drivers.Drivers().cbegin(), drivers.Drivers().cend(),
-                    [&](ze_driver_handle_t driver) {
-                      return drivers.GetExtension<ZeExts::Visit>(driver).has_value();
-                    })) {
-      swap_cmd_lists_func_ = &ZeCollector::SwapCommandListsWithInstrumentedCommandLists;
-    }
-  }
-
-  static ZeDeviceDescriptor GetZeDeviceDescriptor(const ze_device_handle_t device) {
-    ZeDeviceDescriptor desc = {};
-
-    bool ret = utils::ze::GetDeviceTimerFrequency_TimestampMask_UUID(
-        device, desc.device_timer_frequency, desc.device_timer_mask, desc.uuid);
-    PTI_ASSERT(ret);
-
-    ze_pci_ext_properties_t pci_device_properties{};
-    pci_device_properties.pNext = nullptr;
-    pci_device_properties.stype = ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
-
-    overhead::Init();
-    ze_result_t status = zeDevicePciGetPropertiesExt(device, &pci_device_properties);
-    overhead_fini(zeDevicePciGetPropertiesExt_id);
-
-    if (status != ZE_RESULT_SUCCESS) {
-      // Not critical to have PCI properties. User might have an idea about the device topology,
-      // so just log the info and continue. This is not 'core' functionality.
-      SPDLOG_INFO("Unable to get PCI properties for device {} driver returned 0x{:x}",
-                  static_cast<const void*>(device), static_cast<std::size_t>(status));
-      std::memset(&pci_device_properties.address, 0, sizeof(pci_device_properties.address));
-      std::memset(&pci_device_properties.maxSpeed, 0, sizeof(pci_device_properties.maxSpeed));
-    }
-    desc.pci_properties = pci_device_properties;
-
-    auto ip_version = utils::ze::GetGpuDeviceIpVersion(device);
-
-    if (!ip_version.has_value()) {
-      SPDLOG_INFO(
-          "Failed to get IP version for device {}. For newer GPUs (e.g., BMG, IP version >= "
-          "{:#x}), this may cause instability on versions of SYCL in Intel(R) oneAPI 2025.3 and "
-          "newer or Level Zero workloads using counter-based events.",
-          static_cast<const void*>(device), utils::ze::kBmgIpVersion);
-    }
-
-    desc.ip_version = ip_version.value_or(0);
-    SPDLOG_TRACE("Device IP Version: {:#x}", desc.ip_version);
-
-    return desc;
-  }
-
-  ze_result_t RebuildCommandListInfo(ze_command_list_handle_t command_list) {
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    ze_bool_t is_immediate = true;
-    ze_context_handle_t ctx_handle = nullptr;
-    ze_device_handle_t device_handle = nullptr;
-    auto ordinal = static_cast<uint32_t>(-1);
-    auto index = static_cast<uint32_t>(-1);
-
-    status = l0_wrapper_.w_zeCommandListGetDeviceHandle(command_list, &device_handle);
-
-    if (ZE_RESULT_SUCCESS != status) {
-      // as this function is called from many places - makes sense to communicate an issue here
-      SPDLOG_WARN(
-          "Level-Zero Introspection API is not present. Local Collection not possible."
-          " Disabling Level-Zero Tracing.");
-      if (nullptr != parent_state_) {
-        *(parent_state_) = pti_result::PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED;
-      }
-      return status;
-    }
-
-    status = l0_wrapper_.w_zeCommandListGetContextHandle(command_list, &ctx_handle);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    status = l0_wrapper_.w_zeCommandListIsImmediate(command_list, &is_immediate);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    SPDLOG_DEBUG("\tIs CmdList immediate?  {}", is_immediate);
-    if (is_immediate) {
-      status = l0_wrapper_.w_zeCommandListImmediateGetIndex(command_list, &index);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      status = l0_wrapper_.w_zeCommandListGetOrdinal(command_list, &ordinal);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-
-    std::pair<uint32_t, uint32_t> ordinal_index(ordinal, index);
-    CreateCommandListInfo(command_list, ctx_handle, device_handle, ordinal_index,
-                          static_cast<bool>(is_immediate));
-
-    return status;
-  }
-
-  bool CommandListInfoExists(ze_command_list_handle_t clist_handle) {
-    std::shared_lock lock(command_list_map_mutex_);
-    return command_list_map_.find(clist_handle) != command_list_map_.end();
-  }
-
-  const ZeCommandListInfo& GetCommandListInfoConst(ze_command_list_handle_t clist_handle) {
-    if (!CommandListInfoExists(clist_handle)) {
-      auto result = RebuildCommandListInfo(clist_handle);
-      PTI_ASSERT(result == ZE_RESULT_SUCCESS);  // Can't happen - unsupported mode (non-local).
-    }
-
-    std::shared_lock lock(command_list_map_mutex_);
-    return command_list_map_[clist_handle];
-  }
-
-  ZeCommandListInfo& GetCommandListInfo(ze_command_list_handle_t clist_handle) {
-    if (!CommandListInfoExists(clist_handle)) {
-      auto result = RebuildCommandListInfo(clist_handle);
-      PTI_ASSERT(result == ZE_RESULT_SUCCESS);  // Can't happen - unsupported mode (non-local).
-    }
-
-    std::shared_lock lock(command_list_map_mutex_);
-    return command_list_map_[clist_handle];
-  }
-
-  auto FindCommandListInfo(ze_command_list_handle_t clist_handle) {
-    std::shared_lock lock(command_list_map_mutex_);
-    return command_list_map_.find(clist_handle);
-  }
-
-  void CopyDeviceUuid(ze_device_handle_t device_handle, uint8_t* ptr) {
-    SPDLOG_TRACE("In {} device_handle: {}", __FUNCTION__, (void*)device_handle);
-    if (device_descriptors_.find(device_handle) != device_descriptors_.end()) {
-      std::copy_n(device_descriptors_[device_handle].uuid.id, ZE_MAX_DEVICE_UUID_SIZE, ptr);
-      return;
-    }
-    // in some cases for CCL Copy GetMemoryAllocProperties returns new,
-    // not seen so far, device handle that looks like a parent device to two tile devices
-    // TODO: this is not a good solution, need to investigate why this happens
-    // and how to handle it properly
-    // Specifically - bad that here write to device_descriptors_ without lock
-    SPDLOG_DEBUG("In {} detected new device: device_handle: {}", __FUNCTION__,
-                 (void*)device_handle);
-    device_descriptors_[device_handle] = GetZeDeviceDescriptor(device_handle);
-    std::copy_n(device_descriptors_[device_handle].uuid.id, ZE_MAX_DEVICE_UUID_SIZE, ptr);
-  }
-
-  void CollectOrdinalAndIndex(ze_command_queue_handle_t queue) {
-    uint32_t ordinal = static_cast<uint32_t>(-1);
-    uint32_t index = static_cast<uint32_t>(-1);
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (queue_ordinal_index_map_.count(queue) == 0) {
-      ze_result_t res = l0_wrapper_.w_zeCommandQueueGetIndex(queue, &index);
-      ze_result_t res2 = l0_wrapper_.w_zeCommandQueueGetOrdinal(queue, &ordinal);
-      if (ZE_RESULT_SUCCESS != res || ZE_RESULT_SUCCESS != res2) {
-        if (nullptr != parent_state_) {
-          *(parent_state_) = pti_result::PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED;
-        }
-        SPDLOG_WARN("Failed to get queue ordinal and index, disabling Level Zero Tracing.");
-        AbnormalStopTracing();
-      }
-      queue_ordinal_index_map_[queue] = std::make_pair(ordinal, index);
-    }
-  }
-
-  void CollectOrdinalAndIndex(ze_command_list_handle_t command_list) {
-    // Ordinal and index will be acquired regardless
-    auto ordinal_index = GetCommandListInfoConst(command_list).oi_pair;
-    // Immediate command lists ordinal and indexes are stored as queues so we
-    // can cast. This is done in a few places.
-    const auto queue = reinterpret_cast<ze_command_queue_handle_t>(command_list);
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (queue_ordinal_index_map_.count(queue) == 0) {
-      queue_ordinal_index_map_[queue] = std::move(ordinal_index);
-    }
-  }
-
-  /**
-   *  \internal
-   *  \warning lock to be acquired in caller chain
-   */
-  ze_result_t QueryEventStatusUnlessDestroyed(ze_event_handle_t event) const {
-    const bool destroyed = destroyed_events_.find(event) != destroyed_events_.end();
-    SPDLOG_TRACE("\tPrior checking event status event: {}, destroyed: {} ",
-                 static_cast<const void*>(event), destroyed);
-    if (destroyed) {
-      return ZE_RESULT_SUCCESS;
-    }
-    overhead::ScopedOverheadCollector overhead_collector{zeEventQueryStatus_id};
-    return zeEventQueryStatus(event);
-  }
-
-  std::vector<ZeKernelCommandExecutionRecord> CollectCommandExecutionRecordsProcessingEvent(
-      ze_event_handle_t event, std::vector<uint64_t>* kids) {
-    std::vector<ZeKernelCommandExecutionRecord> kcexecrec;
-    {
-      const std::lock_guard<std::mutex> lock(lock_);
-      ProcessCallEvent(event, kids, &kcexecrec);
-    }
-    return kcexecrec;
-  }
-
-  void ProcessEventAndReturnCommandExecutionsRecordsToUser(ze_event_handle_t event,
-                                                           std::vector<uint64_t>* kids) {
-    auto cmd_records = CollectCommandExecutionRecordsProcessingEvent(event, kids);
-    if (cb_enabled_.acallback && acallback_ != nullptr) {
-      acallback_(callback_data_, cmd_records);
-    }
-    DoCallbackOnGPUOperationCompletion(cmd_records);
-  }
-
-  void ProcessCommandsAndReturnCommandExecutionsRecordsToUser(
-      std::vector<uint64_t>* kids, ze_event_handle_t event_ready_to_process) {
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    {
-      const std::lock_guard<std::mutex> lock(lock_);
-      ProcessCalls(kids, &kcexec, event_ready_to_process);
-    }
-    if (cb_enabled_.acallback && acallback_ != nullptr) {
-      acallback_(callback_data_, kcexec);
-    }
-    DoCallbackOnGPUOperationCompletion(kcexec);
-  }
-
-  // Heavy handed operation - only call if the user's event is signaled and we have to wait for
-  // kernel timestamps to be available.
-  static bool EnsureTimestampsAvailable(const ZeKernelCommand* command) {
-    static constexpr auto kTimeout =
-        std::chrono::nanoseconds(std::chrono::microseconds(50)).count();
-
-    bool timestamps_available = true;  // since event is signaled, no need to
-                                       // sync unless timestamp query event exists.
-    if (!command->timestamp_query_event.Empty() && !command->timestamp_query_event.Ready()) {
-      overhead::ScopedOverheadCollector overhead_collector{zeEventHostSynchronize_id};
-      auto result = zeEventHostSynchronize(command->timestamp_query_event.Get(), kTimeout);
-      timestamps_available = (result == ZE_RESULT_SUCCESS);
-      if (!timestamps_available) {
-        if (result == ZE_RESULT_NOT_READY) {
-          SPDLOG_INFO(
-              "Reached timeout of {} ns while trying to synchronize device timestamp event. Data "
-              "might be lost.",
-              kTimeout);
-        }
-        SPDLOG_INFO("Unable to synchronize timestamp query event for command {}",
-                    static_cast<const void*>(command));
-      }
-    }
-    return timestamps_available;
-  }
-
-  bool AbleToProcessCommand(const ZeKernelCommand* command) {
-    const bool event_signaled =
-        (QueryEventStatusUnlessDestroyed(command->event_self) == ZE_RESULT_SUCCESS);
-    //  event_signaled could be the event was reset on device, so check the
-    //  timestamp query event if not signaled.
-    return event_signaled ? EnsureTimestampsAvailable(command)
-                          : command->timestamp_query_event.Ready();
-  }
-
-  // Return true if the graph execution was processed (ready and commands processed) or
-  // empty/invalid. Helper function to determine whether to skip processing of a graph in the
-  // submission list.
-  bool TryToProcessBatchedSubmission(
-      ZeBatchedExecution* graph_execution, std::vector<uint64_t>* kernel_ids,
-      std::vector<ZeKernelCommandExecutionRecord>* kernel_execution_command_records,
-      ze_event_handle_t ready_event = nullptr) {
-    if (!graph_execution || !graph_execution->completion_event ||
-        graph_execution->completion_event->Empty()) {
-      SPDLOG_DEBUG(
-          "\tInvalid graph execution. Null graph execution or empty/missing completion event. "
-          "Command processing skipped.");
-      return true;
-    }
-
-    // ready_event avoids unnecessary zeEventQueryStatus calls when we know the event is already
-    // signaled. Otherwise, check the event status.
-    const bool is_signaled =
-        (ready_event != nullptr) && (graph_execution->completion_event->Get() == ready_event ||
-                                     graph_execution->user_completion_event == ready_event);
-    if (is_signaled || graph_execution->completion_event->Ready()) {
-      for (const auto& command : graph_execution->commands) {
-        if (command) {
-          ProcessCallCommand(command.get(), kernel_ids, kernel_execution_command_records,
-                             graph_execution);
-        } else {
-          SPDLOG_DEBUG("\tIgnoring unexpected null command in graph execution.");
-        }
-      }
-      return true;
-    }
-    return false;
-  }
-
-  void ProcessCallEvent(ze_event_handle_t event, std::vector<uint64_t>* kids,
-                        std::vector<ZeKernelCommandExecutionRecord>* kcexecrec) {
-    // lock is acquired in caller
-    // const std::lock_guard<std::mutex> lock(lock_);
-    SPDLOG_TRACE("In {}, event: {}", __FUNCTION__, static_cast<const void*>(event));
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    {
-      overhead::ScopedOverheadCollector overhead_collector{zeEventQueryStatus_id};
-      status = zeEventQueryStatus(event);
-    }
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("\tIn {} EventQueryStatus returned: {}, Returning...", __FUNCTION__,
-                   static_cast<uint32_t>(status));
-      return;
-    }
-
-    for (auto it = submitted_commands_.begin(); it != submitted_commands_.end();) {
-      if (auto* cmd_ptr = std::get_if<std::shared_ptr<ZeKernelCommand>>(&(*it))) {
-        ZeKernelCommand* command = cmd_ptr->get();
-
-        if (!command || !command->event_self) {
-          SPDLOG_DEBUG("\tDeleting of unexpected command {} containing zero event.",
-                       static_cast<const void*>(command));
-          it = submitted_commands_.erase(it);
-          continue;
-        }
-
-        const bool is_target_event = (command->event_self == event);
-        auto ready_to_process_command =
-            is_target_event ? EnsureTimestampsAvailable(command) : AbleToProcessCommand(command);
-
-        if (ready_to_process_command) {
-          ProcessCallCommand(command, kids, kcexecrec);
-          it = submitted_commands_.erase(it);
-        } else {
-          it++;
-        }
-      } else if (auto* graph_execution_ptr =
-                     std::get_if<std::unique_ptr<ZeBatchedExecution>>(&(*it))) {
-        if (TryToProcessBatchedSubmission(graph_execution_ptr->get(), kids, kcexecrec, event)) {
-          it = submitted_commands_.erase(it);
-        } else {
-          ++it;
-        }
-      } else {
-        SPDLOG_WARN("\tUnhandled type of submitted command, deleting it.");
-        it = submitted_commands_.erase(it);
-      }
-    }
-  }
-
-  void ProcessCallFence(ze_fence_handle_t fence, std::vector<uint64_t>* kids,
-                        std::vector<ZeKernelCommandExecutionRecord>* kcexecrec) {
-    // lock is acquired in the caller
-    // const std::lock_guard<std::mutex> lock(lock_);
-    SPDLOG_TRACE("In {}, fence: {}", __FUNCTION__, static_cast<const void*>(fence));
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    overhead::Init();
-    status = zeFenceQueryStatus(fence);
-    overhead_fini(zeFenceQueryStatus_id);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_WARN("\tFence Query Status unsuccessful.");
-      return;
-    }
-
-    for (auto it = submitted_commands_.begin(); it != submitted_commands_.end();) {
-      if (auto* cmd_ptr = std::get_if<std::shared_ptr<ZeKernelCommand>>(&(*it))) {
-        ZeKernelCommand* command = cmd_ptr->get();
-        if (!command) {
-          SPDLOG_DEBUG("\tDeleting unexpected null command.");
-          it = submitted_commands_.erase(it);
-          continue;
-        }
-
-        SPDLOG_TRACE("\tFence Query: {} - {}.", static_cast<const void*>(command),
-                     static_cast<const void*>(fence));
-
-        if ((command->fence != nullptr) && (command->fence == fence)) {
-          SPDLOG_TRACE("\tFound current fence query {} - {}.", static_cast<const void*>(command),
-                       static_cast<const void*>(fence));
-          ProcessCallCommand(command, kids, kcexecrec);
-          // TODO - check if we need to clean up the fence event
-          it = submitted_commands_.erase(it);
-          return;
-        }
-        if (command->event_self != nullptr) {
-          if (AbleToProcessCommand(command)) {
-            ProcessCallCommand(command, kids, kcexecrec);
-            it = submitted_commands_.erase(it);
-          } else {
-            it++;
-          }
-        } else {
-          SPDLOG_WARN("\tDeleting of unexpected command {} containing zero event.",
-                      static_cast<const void*>(command));
-          it = submitted_commands_.erase(it);
-        }
-      } else if (auto* graph_execution_ptr =
-                     std::get_if<std::unique_ptr<ZeBatchedExecution>>(&(*it))) {
-        if (TryToProcessBatchedSubmission(graph_execution_ptr->get(), kids, kcexecrec)) {
-          it = submitted_commands_.erase(it);
-        } else {
-          ++it;
-        }
-      } else {
-        SPDLOG_WARN("\tUnhandled type of submitted command, deleting it.");
-        it = submitted_commands_.erase(it);
-      }
-    }
-  }
-
-  constexpr uint64_t ComputeDuration(uint64_t start, uint64_t end, uint64_t freq, uint64_t mask) {
-    uint64_t duration = 0;
-    if (start <= end) {
-      duration = (end - start) * static_cast<uint64_t>(NSEC_IN_SEC) / freq;
-    } else {  // Timer Overflow
-      duration = ((mask + 1ULL) + end - start) * static_cast<uint64_t>(NSEC_IN_SEC) / freq;
-    }
-    return duration;
-  }
-
-  inline void GetHostTime(const ZeKernelCommand* command, const ze_kernel_timestamp_result_t& ts,
-                          uint64_t& start, uint64_t& end,
-                          ZeBatchedExecution* batched_execution = nullptr) {
-    uint64_t device_freq = command->device_timer_frequency_;
-    uint64_t device_mask = command->device_timer_mask_;
-
-    uint64_t device_start = ts.global.kernelStart & device_mask;
-    uint64_t device_end = ts.global.kernelEnd & device_mask;
-    SPDLOG_TRACE(
-        "In {}\nBefore applying mask.\nGPU op device time start: {}\n"
-        "                     end: {}\n"
-        "After applying mask.\nGPU op device time start: {}\n"
-        "                     end: {}",
-        __func__, utils::AposFormat(ts.global.kernelStart), utils::AposFormat(ts.global.kernelEnd),
-        utils::AposFormat(device_start), utils::AposFormat(device_end));
-
-    // Why submit_time_device_ and time_shift ?
-    //
-    // - All times reported by PTI_VIEW in CPU (aka Host) timescale
-    // - However GPU "commands" (kernel & memory transfers) start/end reported in GPU timescale
-    // - There is significant time drift between CPU and GPU, so to cope with it, we need to
-    // "sync" often calling zeDeviceGetGlobalTimestamps,
-    //  where command->submit_time_device_ comes with GPU time
-    //        command->submit_time         comes with CPU time
-    //
-    // "sync" points are made around "command(s)" submit to GPU:
-    // - at Enter to CommandListAppendLaunch<...>  time for an Immediate Command List
-    // - at Enter to CommandQueueExecuteCommandLists for not Immediate CommandLists
-
-    //  GPU time mask applied to the GPU time to remove some spurious bits (in case they made
-    //  there)
-    uint64_t raw_device_time = 0;
-    uint64_t raw_submit_time = 0;
-
-    if (batched_execution) {
-      raw_device_time = batched_execution->submit_time_device;
-      raw_submit_time = batched_execution->submit_time_host;
-    } else {
-      raw_device_time = command->submit_time_device_;
-      raw_submit_time = command->submit_time;
-    }
-
-    uint64_t device_submit_time = (raw_device_time & device_mask);
-
-    if (device_start != 0ULL || device_end != 0ULL) {
-      // typically both stamps are non-zero, but could be [rare] a case when one of them is zero
-      // due to timer overflow
-
-      // time_shift calculated in GPU scale between sync point and GPU command start,
-      // then it recalculated to CPU timescale units
-      uint64_t time_shift = 0;
-
-      // TODO - investigate more and submit bug to driver
-      if (device_start <= device_submit_time && device_mask == 0xFFFFFFFFFFFFFFFFULL &&  // 64 bits
-          device_submit_time - device_start < CPUGPUTimeInterpolationHelper::kThresholdForMissync) {
-        SPDLOG_DEBUG("In {} detected suspicious case, device_start: {}, device_submit_time: {}",
-                     __func__, utils::AposFormat(device_start),
-                     utils::AposFormat(device_submit_time));
-        // to avoid negative time_shift and wrong start/end times in CPU timescale
-        if (device_start > 2) {
-          device_submit_time = device_start - 2;
-        }
-      }
-
-      if (device_start > device_submit_time) {
-        time_shift = (device_start - device_submit_time) * NSEC_IN_SEC / device_freq;
-      } else {
-        // overflow
-        SPDLOG_DEBUG("In {} detected overflow case, device_start: {}, device_submit_time: {}",
-                     __func__, utils::AposFormat(device_start),
-                     utils::AposFormat(device_submit_time));
-        time_shift =
-            (device_mask - device_submit_time + 1 + device_start) * NSEC_IN_SEC / device_freq;
-      }
-
-      // GPU command duration recalculated to CPU time scale units
-      uint64_t duration = ComputeDuration(device_start, device_end, device_freq, device_mask);
-
-      // here GPU command start and end (on GPU) are calculated in CPU timescale
-      start = raw_submit_time + time_shift;
-      end = start + duration;
-    } else {
-      // This processes the case when for some reason a profiling event was not ready (not signaled)
-      // and we have not received GPU timestamps - so we zeroed them out.
-      // Such "pathological" GPU op records could be easily spotted in the result trace.
-      start = raw_submit_time;
-      end = raw_submit_time;
-    }
-  }
-
-  void ProcessCallTimestamp(const ZeKernelCommand* command,
-                            const ze_kernel_timestamp_result_t& timestamp, int tile,
-                            bool /*in_summary*/,
-                            std::vector<ZeKernelCommandExecutionRecord>* kcexecrec,
-                            ZeBatchedExecution* batched_execution = nullptr) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    uint64_t host_start = 0;
-    uint64_t host_end = 0;
-    GetHostTime(command, timestamp, host_start, host_end, batched_execution);
-    PTI_ASSERT(host_start <= host_end);
-
-    std::string name = command->props.name;
-
-    PTI_ASSERT(!name.empty());
-
-    if (kcexecrec && acallback_) {
-      SPDLOG_TRACE("Processing callback rec: {}", name);
-      ZeKernelCommandExecutionRecord rec = {};
-
-      rec.kid_ = command->kernel_id;
-      rec.tid_ = command->tid;
-
-      rec.cid_ = batched_execution && batched_execution->graph_correlation_id
-                     ? static_cast<uint32_t>(batched_execution->graph_correlation_id)
-                     : command->corr_id_;
-      rec.callback_id_ = command->callback_id_;
-      rec.append_time_ = command->append_time;
-      rec.submit_time_ =
-          batched_execution ? batched_execution->submit_time_host : command->submit_time;
-      rec.start_time_ = host_start;
-      rec.end_time_ = host_end;
-      auto oi = std::make_pair(static_cast<uint32_t>(-1), static_cast<uint32_t>(-1));
-      const auto oi_it = queue_ordinal_index_map_.find(command->queue);
-      if (oi_it != queue_ordinal_index_map_.end()) {
-        oi = oi_it->second;
-      } else {
-        SPDLOG_DEBUG("In {} no engine ordinal/index known for queue: {}, command: {}", __FUNCTION__,
-                     static_cast<const void*>(command->queue), name);
-      }
-      rec.engine_ordinal_ = oi.first;
-      rec.engine_index_ = oi.second;
-      rec.tile_ = tile;
-      auto it = device_descriptors_.find(command->device);
-      PTI_ASSERT(it != device_descriptors_.end());
-      rec.pci_prop_ = it->second.pci_properties;
-      rec.name_ = std::move(name);
-      rec.queue_ = command->queue;
-      rec.device_ = command->device;
-      rec.memory_route_ = command->props.route;
-      rec.num_wait_events_ = command->num_wait_events;
-      rec.result_ = static_cast<uint32_t>(command->result_);
-      if (command->props.src_device != nullptr) {
-        CopyDeviceUuid(command->props.src_device, static_cast<uint8_t*>(rec.src_device_uuid));
-      }
-      if (command->props.dst_device != nullptr) {
-        CopyDeviceUuid(command->props.dst_device, static_cast<uint8_t*>(rec.dst_device_uuid));
-      }
-
-      if ((tile >= 0) && (device_map_.count(command->device) == 1) &&
-          !device_map_[command->device].empty()) {  // Implicit Scaling
-        rec.implicit_scaling_ = true;
-      } else {
-        rec.implicit_scaling_ = false;
-      }
-
-      rec.command_type_ = command->props.type;
-      if (command->props.type == KernelCommandType::kMemory) {
-        rec.device_ = command->props.src_device;
-        rec.dst_device_ = command->props.dst_device;
-        if (command->props.src_device != nullptr) {
-          auto dev_it = device_descriptors_.find(command->props.src_device);
-          PTI_ASSERT(dev_it != device_descriptors_.end());
-          rec.pci_prop_ = dev_it->second.pci_properties;
-        }
-        if (command->props.dst_device != nullptr) {
-          auto dev_it = device_descriptors_.find(command->props.dst_device);
-          PTI_ASSERT(dev_it != device_descriptors_.end());
-          rec.dst_pci_prop_ = dev_it->second.pci_properties;
-        }
-        if (command->props.bytes_transferred > 0) {
-          rec.bytes_xfered_ = command->props.bytes_transferred;
-        } else if (command->props.value_size > 0) {
-          rec.value_set_ = command->props.value_size;
-        }
-      }
-
-      rec.context_ = command->context;
-
-      if (command->props.type == KernelCommandType::kKernel) {
-        rec.sycl_node_id_ = command->sycl_node_id_;
-        rec.sycl_queue_id_ = command->sycl_queue_id_;
-        rec.sycl_invocation_id_ = command->sycl_invocation_id_;
-        rec.sycl_task_begin_time_ = command->sycl_task_begin_time_;
-        // rec.sycl_task_end_time_ = command->sycl_task_end_time_;
-        rec.sycl_enqk_begin_time_ = command->sycl_enqk_begin_time_;
-
-        // rec.sycl_enqk_end_time_ = sycl_data_kview.sycl_enqk_end_time_;
-
-        rec.source_file_name_ = command->source_file_name_;
-        rec.source_line_number_ = command->source_line_number_;
-        if (command->device != nullptr) {
-          CopyDeviceUuid(command->device, static_cast<uint8_t*>(rec.src_device_uuid));
-        }
-      }
-      if (command->props.type == KernelCommandType::kMemory) {
-        rec.sycl_node_id_ = command->sycl_node_id_;
-        rec.sycl_queue_id_ = command->sycl_queue_id_;
-        rec.sycl_invocation_id_ = command->sycl_invocation_id_;
-        rec.sycl_task_begin_time_ = command->sycl_task_begin_time_;
-        // rec.sycl_task_end_time_ = command->sycl_task_end_time_;
-        rec.source_file_name_ = command->source_file_name_;
-        rec.source_line_number_ = command->source_line_number_;
-      }
-
-      kcexecrec->push_back(std::move(rec));
-    }
-  }
-
-  void ProcessCallCommand(ZeKernelCommand* command, std::vector<uint64_t>* kids,
-                          std::vector<ZeKernelCommandExecutionRecord>* kcexecrec,
-                          ZeBatchedExecution* batched_execution = nullptr) {
-    SPDLOG_TRACE("In {} command kid: {}", __FUNCTION__, command->kernel_id);
-    if (kids) {
-      kids->push_back(command->kernel_id);
-    }
-
-    ze_kernel_timestamp_result_t timestamp{};
-
-    ze_event_handle_t event_to_query = command->event_self;
-    // In most cases event_swap present for Local collection,
-    // but since introduction UR V2, where UR uses counter-based events by default
-    // - for all modes PTI uses the same event_swap flow
-    const bool using_swap_event = (command->event_swap.Get() != nullptr);
-    if (using_swap_event) {
-      event_to_query = command->event_swap.Get();
-    }
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    SPDLOG_TRACE("\tQuery KernelTimestamp on event: {}", static_cast<const void*>(event_to_query));
-    if (!command->timestamp) {
-      overhead::ScopedOverheadCollector overhead_collector{zeEventQueryKernelTimestamp_id};
-      status = zeEventQueryKernelTimestamp(event_to_query, &timestamp);
-    } else {
-      timestamp = *command->timestamp;
-    }
-
-    if (status != ZE_RESULT_SUCCESS) {
-      // sporadic - smth wrong with event from time to time
-      // TODO: watch for it and investigate
-      SPDLOG_WARN("In {}, zeEventQueryKernelTimestamp returned: {} for event: {} command type: {}",
-                  __FUNCTION__, static_cast<uint32_t>(status),
-                  static_cast<const void*>(event_to_query),
-                  static_cast<uint32_t>(command->props.type));
-      // zero-ing timestamp (although test shows that when Query failed - it not changed,
-      // so stays zero in this code - but to make sure)
-      // then later in ProcessCallTimestamp - Zero timestamp signals about this issue
-      // and further if GPU record has Zero duration - it tells that PTI was not able to capture
-      // GPU duration
-      timestamp = {{0ULL, 0ULL}, {0ULL, 0ULL}};
-    }
-
-    ProcessCallTimestamp(command, timestamp, -1, true, kcexecrec, batched_execution);
-
-    // Reset events that signal timestamp availability, but don't allow them to be re-issued until
-    // the command list is reset or destroyed.
-    bool reset_result = command->event_swap.ResetSignal();
-
-    if (!reset_result) {
-      SPDLOG_WARN("Failed to reset swap event for command {}, event: {}",
-                  static_cast<const void*>(command),
-                  static_cast<const void*>(command->event_swap.Get()));
-    }
-
-    if (!using_swap_event) {
-      event_cache_.ResetEvent(command->event_self);
-    }
-    reset_result = command->timestamp_query_event.ResetSignal();
-    if (!reset_result) {
-      SPDLOG_WARN("Failed to reset timestamp event for command {}, event: {}",
-                  static_cast<const void*>(command),
-                  static_cast<const void*>(command->timestamp_query_event.Get()));
-    }
-  }
-
-  void ProcessCalls(std::vector<uint64_t>* kids,
-                    std::vector<ZeKernelCommandExecutionRecord>* kcexecrec,
-                    ze_event_handle_t event_ready_to_process) {
-    SPDLOG_TRACE("In {} Kernel command list size: {}", __FUNCTION__, submitted_commands_.size());
-    // lock is acquired in the caller
-    // const std::lock_guard<std::mutex> lock(lock_);
-    //
-    auto it = submitted_commands_.begin();
-    while (it != submitted_commands_.end()) {
-      if (auto* cmd_ptr = std::get_if<std::shared_ptr<ZeKernelCommand>>(&(*it))) {
-        auto* command = cmd_ptr->get();
-        if (!command || !command->event_self) {
-          SPDLOG_DEBUG("\tDeleting of unexpected command {} containing zero event.",
-                       static_cast<const void*>(command));
-          it = submitted_commands_.erase(it);
-          continue;
-        }
-
-        if (AbleToProcessCommand(command)) {
-          ProcessCallCommand(command, kids, kcexecrec);
-          it = submitted_commands_.erase(it);
-        } else {
-          ++it;
-        }
-      } else if (auto* graph_execution_ptr =
-                     std::get_if<std::unique_ptr<ZeBatchedExecution>>(&(*it))) {
-        if (TryToProcessBatchedSubmission(graph_execution_ptr->get(), kids, kcexecrec,
-                                          event_ready_to_process)) {
-          it = submitted_commands_.erase(it);
-        } else {
-          ++it;
-        }
-      } else {
-        SPDLOG_WARN("\tUnhandled type of submitted command, deleting it.");
-        it = submitted_commands_.erase(it);
-      }
-    }
-  }
-
-  void CreateCommandListInfo(ze_command_list_handle_t command_list, ze_context_handle_t context,
-                             ze_device_handle_t device, std::pair<uint32_t, uint32_t>& oi_pair,
-                             bool immediate) {
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    // exclusive lock of command_list_map_   as we are changing it ("writing" to it)
-    // all other accesses to it ("reading") would be protected by shared_lock
-    {
-      const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-      if (command_list_map_.count(command_list)) {
-        ZeCommandListInfo& command_list_info = command_list_map_[command_list];
-        if (command_list_info.immediate) {
-          queue_ordinal_index_map_.erase(reinterpret_cast<ze_command_queue_handle_t>(command_list));
-        }
-        ReleaseInstrumentedCommandList(command_list_info);
-        command_list_map_.erase(command_list);
-      }
-
-      PTI_ASSERT(device_descriptors_.count(device) != 0);
-      auto cmdlist_intro = device_descriptors_[device].cmdlist_introspection;
-
-      ze_command_list_flags_t command_list_info_flags = ZE_COMMAND_LIST_FLAG_FORCE_UINT32;
-      {
-        overhead::ScopedOverheadCollector overhead_collector{zeCommandListGetFlags_id};
-        auto flag_result =
-            l0_wrapper_.w_zeCommandListGetFlags(command_list, &command_list_info_flags);
-
-        if (cmdlist_intro.has_value() && flag_result != ZE_RESULT_SUCCESS) {
-          flag_result =
-              cmdlist_intro->ze_command_list_get_flags(command_list, &command_list_info_flags);
-          if (flag_result != ZE_RESULT_SUCCESS) {
-            SPDLOG_DEBUG("Failed to get command list flags for command list {}, status: {:x}",
-                         static_cast<const void*>(command_list),
-                         static_cast<uint32_t>(flag_result));
-            command_list_info_flags = ZE_COMMAND_LIST_FLAG_FORCE_UINT32;
-          }
-        }
-      }
-
-      ze_command_queue_flags_t immediate_command_list_flags = ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32;
-      if (immediate) {
-        overhead::ScopedOverheadCollector overhead_collector2{zeCommandListImmediateGetFlags_id};
-        const auto immediate_result = l0_wrapper_.w_zeCommandListImmediateGetFlags(
-            command_list, &immediate_command_list_flags);
-        if (immediate_result != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG(
-              "Failed to get immediate command list flags for command list {}, status: {:x}",
-              static_cast<const void*>(command_list), static_cast<uint32_t>(immediate_result));
-          immediate_command_list_flags = ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32;
-        }
-      }
-
-      command_list_map_[command_list] = {std::vector<std::shared_ptr<ZeKernelCommand>>(),
-                                         context,
-                                         device,
-                                         immediate,
-                                         false,
-                                         oi_pair,
-                                         command_list_info_flags,
-                                         immediate_command_list_flags,
-                                         command_list,
-                                         nullptr};
-    }
-
-    if (immediate) {
-      if (queue_ordinal_index_map_.count(
-              reinterpret_cast<ze_command_queue_handle_t>(command_list)) == 0) {
-        queue_ordinal_index_map_[reinterpret_cast<ze_command_queue_handle_t>(command_list)] =
-            oi_pair;
-      }
-    }
-  }
-
-  void CleanEventsAssociatedWithCommandsInList(
-      std::vector<std::shared_ptr<ZeKernelCommand>>& commands) {
-    for (auto& cmd : commands) {
-      if (collection_mode_ != ZeCollectionMode::kLocal) {
-        event_cache_.ReleaseEvent(cmd->event_self);
-      }
-    }
-  }
-
-  static void ReleaseCommandList(ze_command_list_handle_t command_list) {
-    if (!command_list) {
-      return;
-    }
-    overhead::ScopedOverheadCollector overhead_collector{zeCommandListDestroy_id};
-    auto status = zeCommandListDestroy(command_list);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_WARN("Failed to destroy command list {}, status: {:x}",
-                  static_cast<const void*>(command_list), static_cast<uint32_t>(status));
-    }
-  }
-
-  static void ReleaseInstrumentedCommandList(ZeCommandListInfo& command_list_info) {
-    ReleaseCommandList(command_list_info.instrumented_command_list);
-    command_list_info.instrumented_command_list = nullptr;
-  }
-
-  void ResetCommandListInfo(ZeCommandListInfo& command_list_info) {
-    CleanEventsAssociatedWithCommandsInList(command_list_info.appended_commands);
-    command_list_info.appended_commands.clear();
-    command_list_info.closed = false;
-    ReleaseInstrumentedCommandList(command_list_info);
-  }
-
-  void ResetCommandList(ze_command_list_handle_t command_list) {
-    const std::lock_guard<std::mutex> lock(lock_);
-    const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-    auto cmd_list_iter = command_list_map_.find(command_list);
-    if (cmd_list_iter != command_list_map_.end()) {
-      ResetCommandListInfo(cmd_list_iter->second);
-    }
-  }
-
-  void DestroyCommandList(ze_command_list_handle_t command_list) {
-    const std::lock_guard<std::mutex> lock(lock_);
-    const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-    auto cmd_list_iter = command_list_map_.find(command_list);
-    if (cmd_list_iter != command_list_map_.end()) {
-      if (cmd_list_iter->second.immediate) {
-        auto queue_ordinal_index_map_iter = queue_ordinal_index_map_.find(
-            reinterpret_cast<ze_command_queue_handle_t>(command_list));
-        if (queue_ordinal_index_map_iter != queue_ordinal_index_map_.end()) {
-          queue_ordinal_index_map_.erase(queue_ordinal_index_map_iter);
-        }
-      }
-      CleanEventsAssociatedWithCommandsInList(cmd_list_iter->second.appended_commands);
-      ReleaseInstrumentedCommandList(cmd_list_iter->second);
-      command_list_map_.erase(cmd_list_iter);
-    }
-  }
-
-  void ClearCommandListMap() {
-    const std::lock_guard<std::mutex> lock(lock_);
-    const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-    for (auto& [command_list, info] : command_list_map_) {
-      if (info.immediate) {
-        queue_ordinal_index_map_.erase(reinterpret_cast<ze_command_queue_handle_t>(command_list));
-      }
-      CleanEventsAssociatedWithCommandsInList(info.appended_commands);
-      ReleaseInstrumentedCommandList(info);
-    }
-    command_list_map_.clear();
-  }
-
-  void PrepareToExecuteCommandLists(ze_command_list_handle_t* command_lists,
-                                    uint32_t command_list_count, ze_command_queue_handle_t queue,
-                                    ze_fence_handle_t fence) {
-    uint64_t host_time_sync = 0;
-    uint64_t device_time_sync = 0;
-
-    // TODO Consider taking only one Timestamp for all command lists
-    // as all those are in one queue and on one device
-    /*
-        auto it = command_queues_.find(queue);
-        PTI_ASSERT(it != command_queues_.end());
-        ze_device_handle_t device = it->second.device_;
-        PTI_ASSERT(nullptr != device);
-        ze_result_t status = zeDeviceGetGlobalTimestamps(device, &host_time_sync,
-       &device_time_sync); PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    */
-
-    for (uint32_t i = 0; i < command_list_count; ++i) {
-      ze_command_list_handle_t clist = command_lists[i];
-      PTI_ASSERT(clist != nullptr);
-
-      auto& info = GetCommandListInfo(clist);
-      std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-      auto dev_it = device_descriptors_.find(info.device);
-      const auto visitor_extension_available =
-          (dev_it != device_descriptors_.end() && dev_it->second.visit.has_value());
-      if (visitor_extension_available && info.appended_commands.empty()) {
-        if (!info.instrumented_command_list) {
-          ze_command_list_handle_t clist_for_visit = nullptr;
-          ze_command_list_desc_t desc{};
-          desc.stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC;
-          desc.pNext = nullptr;
-
-          uint32_t ordinal = 0;
-          ze_result_t ord_status = ZE_RESULT_SUCCESS;
-
-          {
-            overhead::ScopedOverheadCollector overhead_coll{zeCommandListGetOrdinal_id};
-            ord_status = l0_wrapper_.w_zeCommandListGetOrdinal(clist, &ordinal);
-          }
-          if (ord_status != ZE_RESULT_SUCCESS) {
-            SPDLOG_WARN("Failed to query ordinal for command list {}, status: {}, skipping visit",
-                        static_cast<const void*>(clist), static_cast<uint32_t>(ord_status));
-          } else {
-            desc.commandQueueGroupOrdinal = ordinal;
-            desc.flags = (info.flags == ZE_COMMAND_LIST_FLAG_FORCE_UINT32)
-                             ? ze_command_list_flags_t{0}
-                             : info.flags;
-            overhead::ScopedOverheadCollector overhead_collector{zeCommandListCreate_id};
-            auto create_status =
-                zeCommandListCreate(info.context, info.device, &desc, &clist_for_visit);
-            if (create_status != ZE_RESULT_SUCCESS || clist_for_visit == nullptr) {
-              SPDLOG_WARN(
-                  "Failed to create command list for visit, status: {}, skipping visit for "
-                  "this command list. Flags {}",
-                  static_cast<uint32_t>(create_status), desc.flags);
-            } else {
-              info.instrumented_command_list = clist_for_visit;
-            }
-          }
-        }
-        try {
-          if (info.instrumented_command_list && info.appended_commands.empty()) {
-            auto visitor = ZeCommandVisitor{*dev_it->second.visit, &event_pool_manager_};
-            auto [commands, result] =
-                visitor.Visit(dev_it->second, info, clist, info.instrumented_command_list);
-            if (result == ZE_RESULT_SUCCESS) {
-              SPDLOG_TRACE(
-                  "Found {} commands in command list {} during visit. Instrumented Command List {}",
-                  commands.size(), static_cast<const void*>(clist),
-                  static_cast<const void*>(info.instrumented_command_list));
-              ze_result_t close_status = ZE_RESULT_SUCCESS;
-              {
-                overhead::ScopedOverheadCollector overhead_collector{zeCommandListClose_id};
-                close_status = zeCommandListClose(info.instrumented_command_list);
-              }
-              if (close_status == ZE_RESULT_SUCCESS) {
-                info.appended_commands = std::move(commands);
-              } else {
-                SPDLOG_INFO("Failed to close instrumented command list {}, status: {:x}",
-                            static_cast<const void*>(info.instrumented_command_list),
-                            static_cast<uint32_t>(close_status));
-                ZeCollector::ReleaseInstrumentedCommandList(info);
-              }
-            } else {
-              SPDLOG_INFO(
-                  "Failed to visit command list {}, status: {:x}, skipping visit for this "
-                  "command list.",
-                  static_cast<const void*>(clist), static_cast<uint32_t>(result));
-              ZeCollector::ReleaseInstrumentedCommandList(info);
-            }
-          }
-        } catch (const std::exception& e) {
-          SPDLOG_ERROR("Exception occurred during command list visit for command list {}: {}",
-                       static_cast<const void*>(clist), e.what());
-          ZeCollector::ReleaseInstrumentedCommandList(info);
-        } catch (...) {
-          SPDLOG_ERROR("Unknown exception occurred during command list visit for command list {}",
-                       static_cast<const void*>(clist));
-          ZeCollector::ReleaseInstrumentedCommandList(info);
-        }
-      }
-
-      if (info.appended_commands.empty() && !visitor_extension_available) {
-        SPDLOG_INFO(
-            "Command list {} submitted with no PTI tracking: visitor extension "
-            "unavailable and no commands captured via tracer.",
-            static_cast<const void*>(clist));
-      }
-
-      // as all command lists submitted to the execution into queue - they are not immediate
-      PTI_ASSERT(!info.immediate);
-      PTI_ASSERT(info.device != nullptr);
-      ze_result_t status = GetDeviceTimestamps(info.device, &host_time_sync, &device_time_sync);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      for (auto it = info.appended_commands.begin(); it != info.appended_commands.end(); it++) {
-        ZeKernelCommand* command = (*it).get();
-        if (!command->tid) {
-          command->tid = PidTidInfo::Get().tid;
-        }
-        command->queue = queue;
-        command->submit_time = host_time_sync;
-        command->submit_time_device_ = device_time_sync;
-
-        PTI_ASSERT(command->append_time <= command->submit_time);
-        command->fence = fence;
-      }
-    }
-  }
-
-  void SwapCommandListsWithInstrumentedCommandLists(
-      ze_command_list_handle_t* old_command_lists, uint32_t command_list_count,
-      void** instance_data, ze_command_list_handle_t** executed_command_lists) {
-    auto* new_command_lists = new ze_command_list_handle_t[command_list_count];
-    bool any_swapped = false;
-    {
-      std::shared_lock<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-      for (uint32_t i = 0; i < command_list_count; ++i) {
-        auto info_it = command_list_map_.find(old_command_lists[i]);
-        if (info_it != command_list_map_.end() &&
-            info_it->second.instrumented_command_list != nullptr) {
-          new_command_lists[i] = info_it->second.instrumented_command_list;
-          any_swapped = true;
-        } else {
-          new_command_lists[i] = old_command_lists[i];
-        }
-      }
-    }
-
-    if (any_swapped) {
-      *instance_data = old_command_lists;
-      *executed_command_lists = new_command_lists;
-    } else {
-      *instance_data = nullptr;
-      delete[] new_command_lists;
-    }
-  }
-
-  void DisabledSwapCommandListsWithInstrumentedCommandLists(ze_command_list_handle_t*, uint32_t,
-                                                            void**, ze_command_list_handle_t**) {
-    return;
-  }
-
-  void PostSubmitKernelCommands(ze_command_list_handle_t* command_lists,
-                                uint32_t command_list_count, std::vector<uint64_t>* kids) {
-    for (uint32_t i = 0; i < command_list_count; ++i) {
-      ze_command_list_handle_t clist = command_lists[i];
-      PTI_ASSERT(clist != nullptr);
-      ZeCommandListInfo& info = GetCommandListInfo(clist);
-
-      // Needs to go after GetCommandListInfo and before cl_list_lock to avoid deadlocks.
-      const std::lock_guard<std::mutex> lock(lock_);
-
-      // info is a reference to an element in this map, which we're modifying here.
-      const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-      // as all command lists submitted to the execution into queue - they are not immediate
-      PTI_ASSERT(!info.immediate);
-      for (auto it = info.appended_commands.begin(); it != info.appended_commands.end(); it++) {
-        ZeKernelCommand* command = (*it).get();
-        if (kids) {
-          kids->push_back(command->kernel_id);
-        }
-        submitted_commands_.push_back(*it);
-      }
-    }
-  }
-
-  ze_context_handle_t GetCommandListContext(ze_command_list_handle_t command_list) {
-    PTI_ASSERT(command_list != nullptr);
-    const ZeCommandListInfo& command_list_info = GetCommandListInfoConst(command_list);
-    return command_list_info.context;
-  }
-
-  ze_device_handle_t GetCommandListDevice(ze_command_list_handle_t command_list) {
-    PTI_ASSERT(command_list != nullptr);
-    const ZeCommandListInfo& command_list_info = GetCommandListInfoConst(command_list);
-    return command_list_info.device;
-  }
-
-  bool IsCommandListImmediate(ze_command_list_handle_t command_list) {
-    const ZeCommandListInfo& command_list_info = GetCommandListInfoConst(command_list);
-    return command_list_info.immediate;
-  }
-
-  bool IsCommandListInOrder(ze_command_list_handle_t command_list) {
-    {
-      std::shared_lock lock1(command_list_map_mutex_);
-      auto cmd_list_it = command_list_map_.find(command_list);
-      if (cmd_list_it != command_list_map_.end()) {
-        return IsInOrder(cmd_list_it->second);
-      }
-    }
-    if (RebuildCommandListInfo(command_list) != ZE_RESULT_SUCCESS) {
-      return false;
-    }
-    std::shared_lock lock2(command_list_map_mutex_);
-    auto new_cmd_list_it = command_list_map_.find(command_list);
-    if (new_cmd_list_it == command_list_map_.end()) {
-      return false;  // extremely rare case, the entry should be rebuilt.
-    }
-    return IsInOrder(new_cmd_list_it->second);
-  }
-
-  void AddImage(ze_image_handle_t image, size_t size) {
-    // PTI_ASSERT(image != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    PTI_ASSERT(image_size_map_.count(image) == 0);
-    image_size_map_[image] = size;
-  }
-
-  void RemoveImage(ze_image_handle_t image) {
-    // PTI_ASSERT(image != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    PTI_ASSERT(image_size_map_.count(image) == 1);
-    image_size_map_.erase(image);
-  }
-
-  size_t GetImageSize(ze_image_handle_t image) {
-    // PTI_ASSERT(image != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (image_size_map_.count(image) == 1) {
-      return image_size_map_[image];
-    }
-    return 0;
-  }
-
-  void AddKernelGroupSize(ze_kernel_handle_t kernel, const ZeKernelGroupSize& group_size) {
-    // PTI_ASSERT(kernel != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    kernel_group_size_map_[kernel] = group_size;
-  }
-
-  void RemoveKernelGroupSize(ze_kernel_handle_t kernel) {
-    // PTI_ASSERT(kernel != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    kernel_group_size_map_.erase(kernel);
-  }
-
-  ZeKernelGroupSize GetKernelGroupSize(ze_kernel_handle_t kernel) {
-    // PTI_ASSERT(kernel != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (kernel_group_size_map_.count(kernel) == 0) {
-      return {0, 0, 0};
-    }
-    return kernel_group_size_map_[kernel];
-  }
-
-  template <pti_api_id_driver_levelzero E>
-  ZeKernelCommandExecutionRecord MakeSyncRecord(
-      std::string_view name, ze_event_pool_handle_t event_pool, ze_event_handle_t event,
-      ze_context_handle_t context, ze_command_queue_handle_t queue,
-      ze_command_list_handle_t command_list, uint64_t corr_id, ze_result_t result) {
-    ZeKernelCommandExecutionRecord rec = {};
-    if (IsIntrospectionCapable()) {
-      if (event && event_pool == nullptr) {
-        // TODO(PTI): Counter-based events no longer need an event pool, it may be a good idea to
-        // check if the event is counter-based and skip this call in that case.
-        auto status = l0_wrapper_.w_zeEventGetEventPool(event, &event_pool);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG("Failed to get event pool for event {}, result: {:x}",
-                       static_cast<const void*>(event), static_cast<uint32_t>(status));
-          event_pool = nullptr;
-        }
-      }
-      if (event_pool && context == nullptr) {
-        auto status = l0_wrapper_.w_zeEventPoolGetContextHandle(event_pool, &context);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG("Failed to get context for event pool {}, result: {:x}",
-                       static_cast<const void*>(event_pool), static_cast<uint32_t>(status));
-          context = nullptr;
-        }
-      }
-      if (command_list && context == nullptr) {
-        auto status = l0_wrapper_.w_zeCommandListGetContextHandle(command_list, &context);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG("Failed to get context for command list {}, result: {:x}",
-                       static_cast<const void*>(command_list), static_cast<uint32_t>(status));
-          context = nullptr;
-        }
-      }
-    }
-    rec.name_ = name;
-    rec.tid_ = PidTidInfo::Get().tid;
-    rec.start_time_ = ze_instance_data.start_time_host;
-    rec.end_time_ = ze_instance_data.end_time_host;
-    rec.context_ = context;
-    rec.queue_ = queue;
-    rec.event_ = event;
-    rec.cid_ = corr_id;
-    rec.result_ = static_cast<uint32_t>(result);
-    rec.callback_id_ = E;
-    rec.command_type_ = KernelCommandType::kCommand;
-    return rec;
-  }
-
-  // Callbacks
-  static void OnEnterEventPoolCreate(ze_event_pool_create_params_t* params, void* global_data,
-                                     void** instance_data) {
-    const ze_event_pool_desc_t* desc = *(params->pdesc);
-    if (desc == nullptr) {
-      return;
-    }
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    if (collector->collection_mode_ == ZeCollectionMode::kLocal) {
-      return;
-    }
-
-    if (desc->flags & ZE_EVENT_POOL_FLAG_IPC) {
-      // TODO Might need special processing of such pool
-      SPDLOG_DEBUG("In {} skipping IPC event pool", __func__);
-      return;
-    }
-
-    ze_event_pool_desc_t* profiling_desc = nullptr;
-
-    // Creating timestamp enabled description only for non-counter-based event pool
-    // where pNext == nullptr
-    if (desc->pNext == nullptr) {
-      profiling_desc = new ze_event_pool_desc_t;
-      PTI_ASSERT(profiling_desc != nullptr);
-      profiling_desc->stype = desc->stype;
-      // PTI_ASSERT(profiling_desc->stype == ZE_STRUCTURE_TYPE_EVENT_POOL_DESC);
-      profiling_desc->pNext = desc->pNext;
-      profiling_desc->flags = desc->flags;
-
-      profiling_desc->flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
-      profiling_desc->flags |= ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
-      profiling_desc->count = desc->count;
-      *(params->pdesc) = profiling_desc;
-      SPDLOG_DEBUG("In {} overwrote pool description", __func__);
-    }
-
-    *instance_data = profiling_desc;
-  }
-
-  static void OnExitEventPoolCreate(ze_event_pool_create_params_t* params, ze_result_t /*result*/,
-                                    void* global_data, void** instance_data) {
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-    // this might be original desc or desc that we created
-    const ze_event_pool_desc_t* passed_desc = *(params->pdesc);
-
-    ze_event_pool_desc_t* desc = static_cast<ze_event_pool_desc_t*>(*instance_data);
-
-    const ze_event_pool_handle_t pool = **(params->pphEventPool);
-    SPDLOG_DEBUG("In {} pool: {}\n\tcleaned up the profiling_desc", __func__,
-                 static_cast<const void*>(pool));
-
-    // A non-null pNext indicates that this event pool uses an extension
-    // structure for counter-based profiling (implementation-specific
-    // convention used as a proxy here).
-    collector->event_pools_observer_.Add(
-        pool, *(params->phContext), passed_desc->flags,
-        (passed_desc->pNext != nullptr) ? EventPoolType::kCounterBased : EventPoolType::kRegular);
-
-    if (desc != nullptr) {
-      delete desc;
-    }
-  }
-
-  static void OnExitEventPoolDestroy(ze_event_pool_destroy_params_t* params, ze_result_t /*result*/,
-                                     void* global_data, void** /*instance_data*/) {
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-    const ze_event_pool_handle_t pool = *(params->phEventPool);
-    SPDLOG_DEBUG("In {} pool: {}\n\tcleaned up the profiling_desc", __func__,
-                 static_cast<const void*>(pool));
-
-    collector->event_pools_observer_.ClearPool(pool);
-  }
-
-  static void OnEnterEventDestroy(ze_event_destroy_params_t* params, void* global_data,
-                                  void** /*instance_data*/, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {} event: {}", __FUNCTION__, static_cast<const void*>(*(params->phEvent)));
-    if (*params->phEvent == nullptr) {
-      return;
-    }
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    collector->ProcessEventAndReturnCommandExecutionsRecordsToUser(*params->phEvent, kids);
-
-    // only events that managed by collector should be taken care
-    if (ZeCollectionMode::kLocal == collector->collection_mode_) {
-      const std::lock_guard<std::mutex> lock(collector->lock_);
-      collector->destroyed_events_.insert(*params->phEvent);
-    }
-  }
-
-  static void OnExitEventCreate(ze_event_create_params_t* params, ze_result_t result,
-                                void* global_data, void** /*instance_data*/) {
-    if (result != ZE_RESULT_SUCCESS || *params->pphEvent == nullptr) {
-      return;
-    }
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    if (ZeCollectionMode::kLocal == collector->collection_mode_) {
-      const std::lock_guard<std::mutex> lock(collector->lock_);
-      collector->destroyed_events_.erase(*(*params->pphEvent));
-    }
-  }
-
-  static void OnEnterEventHostReset(ze_event_host_reset_params_t* params, void* global_data,
-                                    void** /*instance_data*/, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {} event: {}", __FUNCTION__, static_cast<const void*>(*(params->phEvent)));
-    if (*params->phEvent == nullptr) {
-      return;
-    }
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    collector->ProcessEventAndReturnCommandExecutionsRecordsToUser(*(params->phEvent), kids);
-  }
-
-  static void OnExitEventHostSynchronize(ze_event_host_synchronize_params_t* params,
-                                         ze_result_t result, void* global_data,
-                                         void** /*instance_data*/, std::vector<uint64_t>* kids,
-                                         uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {} event: {}", __FUNCTION__, (void*)*(params->phEvent));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      collector->ProcessEventAndReturnCommandExecutionsRecordsToUser(*(params->phEvent), kids);
-    }
-    // Process generation of synch record even if result is not successful.
-    if (collector->cb_enabled_.acallback && collector->options_.lz_enabled_views.synch_enabled &&
-        collector->acallback_ != nullptr) {
-      std::vector<ZeKernelCommandExecutionRecord> kcexec;
-      ze_event_handle_t event_h = *params->phEvent;
-      auto rec = collector->MakeSyncRecord<zeEventHostSynchronize_id>(
-          "zeEventHostSynchronize", nullptr, event_h, nullptr, nullptr, nullptr, synch_corrid,
-          result);
-      kcexec.push_back(std::move(rec));
-      collector->acallback_(collector->callback_data_, kcexec);
-    }
-  }
-
-  static void OnExitCommandListHostSynchronize(
-      [[maybe_unused]] ze_command_list_host_synchronize_params_t* params, ze_result_t result,
-      void* global_data, void** /*instance_data*/, std::vector<uint64_t>* kids,
-      [[maybe_unused]] uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    {
-      const std::lock_guard<std::mutex> lock(collector->lock_);
-      if (result == ZE_RESULT_SUCCESS) {
-        collector->ProcessCalls(kids, &kcexec, nullptr);
-        if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-          collector->acallback_(collector->callback_data_, kcexec);
-        }
-      }
-    }
-
-    // Process generation of synch record even if result is not successful.
-    if (collector->cb_enabled_.acallback && collector->options_.lz_enabled_views.synch_enabled &&
-        collector->acallback_ != nullptr) {
-      std::vector<ZeKernelCommandExecutionRecord> kcexec1;
-      auto rec = collector->MakeSyncRecord<zeCommandListHostSynchronize_id>(
-          "zeCommandListHostSynchronize", nullptr, nullptr, nullptr, nullptr,
-          *params->phCommandList, synch_corrid, result);
-      kcexec1.push_back(std::move(rec));
-      collector->acallback_(collector->callback_data_, kcexec1);
-    }
-
-    collector->DoCallbackOnGPUOperationCompletion(kcexec);
-  }
-
-  static void OnExitCommandListClose(ze_command_list_close_params_t* params, ze_result_t result,
-                                     void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result {} ", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      auto* collector = static_cast<ZeCollector*>(global_data);
-      ze_command_list_handle_t command_list = *(params->phCommandList);
-      auto& info = collector->GetCommandListInfo(command_list);
-      const std::lock_guard<std::shared_mutex> cl_list_lock(collector->command_list_map_mutex_);
-      info.closed = true;
-    }
-  }
-
-  static void OnExitEventQueryStatus(ze_event_query_status_params_t* params, ze_result_t result,
-                                     void* global_data, void** /*instance_data*/,
-                                     std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result {} event: {}", __FUNCTION__, static_cast<uint32_t>(result),
-                 static_cast<const void*>(*(params->phEvent)));
-
-    // this call-back is useful to see if we are re-entering to it via Tracing level
-    // this should not happen when we are inside of Tracing layer..
-    // but things can get weird..
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      collector->ProcessEventAndReturnCommandExecutionsRecordsToUser(*(params->phEvent), kids);
-    }
-  }
-
-  static void OnExitFenceCreate(ze_fence_create_params_t* params,
-                                [[maybe_unused]] ze_result_t result, void* global_data,
-                                void** /*instance_data*/) {
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    const std::lock_guard<std::mutex> lock(collector->lock_);
-    ze_command_queue_handle_t fence_queue = *(params->phCommandQueue);
-    ze_fence_handle_t* fence_h = *params->pphFence;
-    collector->fence_queue_map_.insert({*fence_h, fence_queue});
-    SPDLOG_TRACE("In {}, fence_h {}, queue_h {}", __FUNCTION__, static_cast<void*>(*fence_h),
-                 static_cast<void*>(fence_queue));
-  }
-
-  static void OnExitFenceHostSynchronize(ze_fence_host_synchronize_params_t* params,
-                                         ze_result_t result, void* global_data,
-                                         void** /*instance_data*/, std::vector<uint64_t>* kids,
-                                         uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {}, result {} ", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    if (result == ZE_RESULT_SUCCESS) {
-      const std::lock_guard<std::mutex> lock(collector->lock_);
-      PTI_ASSERT(*(params->phFence) != nullptr);
-      collector->ProcessCallFence(*(params->phFence), kids, &kcexec);
-
-      if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-        collector->acallback_(collector->callback_data_, kcexec);
-      }
-    }
-    // Process generation of synch record even if result is not successful.
-    if (collector->cb_enabled_.acallback && collector->options_.lz_enabled_views.synch_enabled &&
-        collector->acallback_ != nullptr) {
-      std::vector<ZeKernelCommandExecutionRecord> kcexec1;
-      ze_fence_handle_t fence_h = *params->phFence;
-      ze_context_handle_t ctxt_h = nullptr;
-      ze_command_queue_handle_t queue_h = nullptr;
-      auto it_fence = collector->fence_queue_map_.find(fence_h);
-      if (it_fence != collector->fence_queue_map_.end()) {
-        queue_h = it_fence->second;
-        auto it = collector->command_queues_.find(it_fence->second);
-        if (it != collector->command_queues_.end()) {
-          ctxt_h = it->second.context_;
-        }
-      }
-      auto rec = collector->MakeSyncRecord<zeFenceHostSynchronize_id>(
-          "zeFenceHostSynchronize", nullptr, nullptr, ctxt_h, queue_h, nullptr, synch_corrid,
-          result);
-      kcexec1.push_back(std::move(rec));
-      collector->acallback_(collector->callback_data_, kcexec1);
-    }
-    collector->DoCallbackOnGPUOperationCompletion(kcexec);
-  }
-
-  static void OnExitImageCreate(ze_image_create_params_t* params, ze_result_t result,
-                                void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result {} ", __FUNCTION__, (uint32_t)result);
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-      ze_image_desc_t image_desc = **(params->pdesc);
-      size_t image_size = image_desc.width;
-      switch (image_desc.type) {
-        case ZE_IMAGE_TYPE_2D:
-        case ZE_IMAGE_TYPE_2DARRAY:
-          image_size *= image_desc.height;
-          break;
-        case ZE_IMAGE_TYPE_3D:
-          image_size *= image_desc.height * image_desc.depth;
-          break;
-        default:
-          break;
-      }
-
-      switch (image_desc.format.type) {
-        case ZE_IMAGE_FORMAT_TYPE_UINT:
-        case ZE_IMAGE_FORMAT_TYPE_UNORM:
-        case ZE_IMAGE_FORMAT_TYPE_FORCE_UINT32:
-          image_size *= sizeof(unsigned int);
-          break;
-        case ZE_IMAGE_FORMAT_TYPE_SINT:
-        case ZE_IMAGE_FORMAT_TYPE_SNORM:
-          image_size *= sizeof(int);
-          break;
-        case ZE_IMAGE_FORMAT_TYPE_FLOAT:
-          image_size *= sizeof(float);
-          break;
-        default:
-          break;
-      }
-
-      collector->AddImage(**(params->pphImage), image_size);
-    }
-  }
-
-  static void OnExitImageDestroy(ze_image_destroy_params_t* params, ze_result_t result,
-                                 void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result {} ", __FUNCTION__, (uint32_t)result);
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      collector->RemoveImage(*(params->phImage));
-    }
-  }
-
-  static void PrepareToAppendKernelCommand(ZeCollector* collector,
-                                           ze_command_list_handle_t command_list,
-                                           KernelCommandType kernel_type,
-                                           ze_event_handle_t& signal_event, void** instance_data) {
-    PTI_ASSERT(command_list != nullptr);
-    PTI_ASSERT(instance_data != nullptr);
-    SPDLOG_TRACE("In {} Collection mode: {}, Cmdl: {}, signal_event: {}, kernel_type: {}",
-                 __FUNCTION__, static_cast<uint32_t>(collector->collection_mode_),
-                 static_cast<const void*>(command_list), static_cast<const void*>(signal_event),
-                 static_cast<uint32_t>(kernel_type));
-
-    auto& info = collector->GetCommandListInfo(command_list);
-    {
-      const std::lock_guard<std::shared_mutex> cl_list_lock(collector->command_list_map_mutex_);
-      // we may have missed a call to CommandListReset.
-      if (info.closed && !info.immediate) {
-        collector->ResetCommandListInfo(info);
-      }
-    }
-
-    ze_context_handle_t context = collector->GetCommandListContext(command_list);
-    ze_device_handle_t device = collector->GetCommandListDevice(command_list);
-
-    ZeKernelCommand* command = nullptr;
-
-    try {
-      command = new ZeKernelCommand;
-    } catch (const std::exception&) {
-      SPDLOG_ERROR("In {} failed to allocate ZeKernelCommand", __func__);
-      collector->AbnormalStopTracing();
-      return;
-    }
-
-    SPDLOG_TRACE("\tCreated New ZeKernelCommand: {}, passes via instance data",
-                 static_cast<const void*>(command));
-    PTI_ASSERT(command != nullptr);
-
-    *instance_data = command;
-
-    command->props.type = kernel_type;
-    command->command_list = command_list;
-    command->device = device;
-    command->context = context;
-    // Need kernel_id on Enter as it might be needed for Callback API
-    command->kernel_id = UniKernelId::GetKernelId();
-    if (command->props.type == KernelCommandType::kKernel) {
-      if (sycl_data_kview.cid_) {
-        command->corr_id_ = sycl_data_kview.cid_;
-      } else {
-        command->corr_id_ = UniCorrId::GetUniCorrId();
-#if defined(PTI_TRACE_SYCL)
-        if (SyclCollector::Instance().Enabled()) {
-          sycl_data_kview.cid_ = command->corr_id_;
-        }
-#endif
-      }
-    } else if (command->props.type == KernelCommandType::kMemory) {
-      if (sycl_data_mview.cid_) {
-        command->corr_id_ = sycl_data_mview.cid_;
-      } else {
-        command->corr_id_ = UniCorrId::GetUniCorrId();
-#if defined(PTI_TRACE_SYCL)
-        if (SyclCollector::Instance().Enabled()) {
-          sycl_data_mview.cid_ = command->corr_id_;
-        }
-#endif
-      }
-    }
-    SPDLOG_TRACE("\tcontext: {}, device: {}", static_cast<const void*>(context),
-                 static_cast<const void*>(device));
-
-    if (signal_event == nullptr) {
-      signal_event = collector->event_cache_.GetEvent(context);
-      PTI_ASSERT(signal_event != nullptr);
-      SPDLOG_DEBUG("\tIn {} No incoming Signal event, creating Signal event from Event_cache",
-                   __func__);
-      command->event_self = signal_event;
-    } else {
-      auto properties_opt = collector->event_pools_observer_.GetEventProperties(signal_event);
-
-      bool event_regular =
-          properties_opt.has_value() && properties_opt->type == EventPoolType::kRegular;
-      bool event_timestamped =
-          properties_opt && (properties_opt->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-      bool event_host_visible =
-          properties_opt && (properties_opt->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE);
-      SPDLOG_DEBUG(
-          "\tIncoming Event properties: properties found: {}, regular: {},"
-          " timestamped: {}, host_visible: {}",
-          properties_opt.has_value(), event_regular ? "true" : "false (counter-based or unknown)",
-          event_timestamped, event_host_visible);
-
-      if (!event_regular || !event_timestamped || !event_host_visible) {
-        // Make a swap event that takes the role of initial signal event.
-        // While for the signal event - create regular event with Timestamped property,
-        // so it can be requested on the GPU operation timing
-        command->event_self = signal_event;  // save signal event
-        if (command->event_swap.Empty()) {
-          command->event_swap = collector->event_pool_manager_.AcquireEvent(context);
-        }
-        signal_event = command->event_swap.Get();
-
-        SPDLOG_DEBUG(
-            "\tIn {} Created Swap event from Event_pool_manager"
-            " swap event: {}, self_event: {}",
-            __func__, static_cast<const void*>(command->event_swap.Get()),
-            static_cast<const void*>(command->event_self));
-      } else {
-        command->event_self = signal_event;
-        SPDLOG_DEBUG("\tIn {} using Incoming Signal event as is", __func__);
-      }
-    }
-
-    // Subscriber callback
-    collector->DoCallbackOnGPUOperationAppended(command, PTI_CB_PHASE_API_ENTER, ZE_RESULT_SUCCESS);
-
-    uint64_t host_timestamp = 0;
-    uint64_t device_timestamp = 0;  // in ticks
-    ze_result_t status = collector->GetDeviceTimestamps(device, &host_timestamp, &device_timestamp);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_instance_data.timestamp_host = host_timestamp;
-    ze_instance_data.timestamp_device = device_timestamp;
-  }
-
-  void PostAppendKernelCommandCommon(ZeKernelCommand* command, ze_event_handle_t& signal_event,
-                                     ZeCommandListInfo& command_list_info,
-                                     std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, command: {}, kernel name {}", __FUNCTION__,
-                 static_cast<const void*>(command), command->props.name.c_str());
-    if (ZeCollectionState::kAbnormal == collection_state_) {
-      return;
-    }
-    PTI_ASSERT(command != nullptr);
-
-    PTI_ASSERT(signal_event != nullptr);
-    command->tid = PidTidInfo::Get().tid;
-    uint64_t host_timestamp = ze_instance_data.timestamp_host;
-    command->append_time = host_timestamp;
-    command->device_timer_frequency_ = device_descriptors_[command->device].device_timer_frequency;
-    command->device_timer_mask_ = device_descriptors_[command->device].device_timer_mask;
-    if (command->props.type == KernelCommandType::kKernel) {
-      command->sycl_node_id_ = std::exchange(sycl_data_kview.sycl_node_id_, 0);
-      command->sycl_queue_id_ = std::exchange(sycl_data_kview.sycl_queue_id_, PTI_INVALID_QUEUE_ID);
-      command->sycl_invocation_id_ = std::exchange(sycl_data_kview.sycl_invocation_id_, 0);
-      command->sycl_task_begin_time_ = std::exchange(sycl_data_kview.sycl_task_begin_time_, 0);
-      command->sycl_enqk_begin_time_ = std::exchange(sycl_data_kview.sycl_enqk_begin_time_, 0);
-      sycl_data_kview.kid_ = command->kernel_id;
-      sycl_data_kview.tid_ = command->tid;
-      command->source_file_name_ = sycl_data_kview.source_file_name_;
-      command->source_line_number_ = sycl_data_kview.source_line_number_;
-    } else if (command->props.type == KernelCommandType::kMemory) {
-      sycl_data_mview.kid_ = command->kernel_id;
-      sycl_data_mview.tid_ = command->tid;
-      command->sycl_node_id_ = std::exchange(sycl_data_mview.sycl_node_id_, 0);
-      command->sycl_invocation_id_ = std::exchange(sycl_data_mview.sycl_invocation_id_, 0);
-      command->sycl_task_begin_time_ = std::exchange(sycl_data_mview.sycl_task_begin_time_, 0);
-      command->sycl_queue_id_ = std::exchange(sycl_data_mview.sycl_queue_id_, PTI_INVALID_QUEUE_ID);
-
-      // Some memory operations come in as kernel ops from XPTI.
-      // TODO: Work with XPTI team and investigate
-      if (command->sycl_queue_id_ == PTI_INVALID_QUEUE_ID) {
-        SPDLOG_TRACE("Missing SYCL queue id. Taking from kernel view.");
-        command->sycl_queue_id_ =
-            std::exchange(sycl_data_kview.sycl_queue_id_, PTI_INVALID_QUEUE_ID);
-      }
-      command->source_file_name_ = sycl_data_mview.source_file_name_;
-      command->source_line_number_ = sycl_data_mview.source_line_number_;
-    } else {
-      if (!command
-               ->corr_id_) {  // for synchronization activity commands the corrid is the api corrid.
-        command->corr_id_ =
-            UniCorrId::GetUniCorrId();  // setting here for non-synchronization activity corr_id.
-      }
-    }
-
-    SPDLOG_TRACE("\tcorr_id: {}", command->corr_id_);
-
-    // In most cases event_swap present for Local collection,
-    // but with UR V2 in presence of counter-based events
-    // - for Full and Hybrid modes the same event_swap mechanism is used
-    if (command->event_swap.Get() != nullptr) {
-      bool append_result = false;
-      bool in_order = false;
-      {
-        std::shared_lock<std::shared_mutex> cl_lock(command_list_map_mutex_);
-        in_order = IsInOrder(command_list_info);
-      }
-      if (in_order) {
-        SPDLOG_DEBUG("Appending Signal event to command list {}, event: {}",
-                     static_cast<const void*>(command->command_list),
-                     static_cast<const void*>(command->event_self));
-        append_result = A2AppendSignalEvent(command->command_list, command->event_self);
-      } else {
-        SPDLOG_DEBUG(
-            "Appending Wait and Signal event to command list {}, signal event: {}, wait event: {}",
-            static_cast<const void*>(command->command_list),
-            static_cast<const void*>(command->event_self),
-            static_cast<const void*>(command->event_swap.Get()));
-        append_result = A2AppendWaitAndSignalEvent(command->command_list, command->event_self,
-                                                   command->event_swap.Get());
-      }
-      PTI_ASSERT(append_result);
-    }
-
-    // A shared pointer is being created here because the lifetime of this GPU execution command is
-    // shared between the command list info (append commands) and the submitted commands for
-    // non-immediate command lists. For immediate command lists, the command will free itself after
-    // querying timestamps. There is a refactoring opportunity here to use a unique_ptr and a
-    // non-owning raw pointer. However, using a shared pointer requires fewer changes.
-
-    std::shared_ptr<ZeKernelCommand> p_command(command);
-    {
-      // We need to keep this lock order (lock, cl_list_lock).
-      // lock: protects submitted_commands_.
-      // cl_list_lock: protects command_list_info (reference, locked in other places)
-      const std::lock_guard<std::mutex> lock(lock_);  // submitted_commands_ lock
-      const std::lock_guard<std::shared_mutex> cl_list_lock(command_list_map_mutex_);
-      if (command_list_info.immediate) {
-        command->submit_time = command->append_time;
-        command->submit_time_device_ =
-            ze_instance_data.timestamp_device;  // append time and submit time are the same
-                                                //
-        auto dev_desc = device_descriptors_.find(command_list_info.device);
-        if (dev_desc != device_descriptors_.end()) {
-          if (dev_desc->second.graph_exp.has_value()) {
-            const auto capture_enabled_result =
-                l0_wrapper_.w_zeCommandListIsGraphCaptureEnabledExt(command_list_info.command_list);
-            // Drop the command if graph capture is enabled - avoids clashes with visitor extension.
-            // The command will be picked up by the graph visitor extension and will be processed
-            // there. Level Zero started returning ZE_RESULT_QUERY_TRUE for this API, however, older
-            // versions (e.g., 26.27.39122.11) returned 0x7fff0000. This is vestigial from the
-            // experimental API.
-            constexpr static uint32_t kFormerZeResultQueryTrue = 0x7fff0000;
-            if (capture_enabled_result == ZE_RESULT_QUERY_TRUE ||
-                static_cast<uint32_t>(capture_enabled_result) == kFormerZeResultQueryTrue) {
-              SPDLOG_DEBUG(
-                  "In {} Graph capture is enabled for command list {}, skipping kernel command "
-                  "creation",
-                  __func__, static_cast<const void*>(command_list_info.command_list));
-              return;
-            }
-          }
-        }
-
-        command->queue = reinterpret_cast<ze_command_queue_handle_t>(command->command_list);
-        submitted_commands_.push_back(std::move(p_command));
-        SPDLOG_TRACE("\tImmediate CmdList, command: {} pushed to submitted_commands_, queue: {}",
-                     static_cast<void*>(command), static_cast<const void*>(command->queue));
-        kids->push_back(command->kernel_id);
-      } else {
-        // Note: Since we're using the user's command list, we cannot guarantee it isn't constructed
-        // using the copy engine. However, in that case, AppendQueryKernelTimestamps will crash.
-        // Therefore, we only append the timestamp query for kernel operations (compute command
-        // lists).
-        if (command->props.type == KernelCommandType::kKernel) {
-          if (command->timestamp_query_event.Empty()) {
-            command->timestamp_query_event = event_pool_manager_.AcquireEvent(command->context);
-          }
-          if (!command->timestamp) {
-            // TODO(PTI-362): Should we create a memory pool for timestamps instead?
-            command->timestamp = utils::ze::MakeTimestampBuffer(command->context, 1);
-          }
-          ze_result_t result = ZE_RESULT_FORCE_UINT32;
-          if (command->timestamp && !command_list_info.closed) {
-            auto* event_to_query =
-                command->event_swap.Empty() ? command->event_self : command->event_swap.Get();
-            overhead::ScopedOverheadCollector overhead_collector(
-                zeCommandListAppendQueryKernelTimestamps_id);
-            result = zeCommandListAppendQueryKernelTimestamps(
-                command->command_list, 1, &event_to_query, command->timestamp.get(), nullptr,
-                command->timestamp_query_event.Get(), 1, &event_to_query);
-          }
-          if (result != ZE_RESULT_SUCCESS) {
-            command->timestamp_query_event = ZeEventView<ZeEventPool>();
-            command->timestamp.reset(nullptr);
-            SPDLOG_DEBUG(
-                "Failed to append query kernel timestamps {:x}. Falling back to event timestamps.",
-                static_cast<uint32_t>(result));
-          }
-        }
-        command_list_info.appended_commands.push_back(std::move(p_command));
-        SPDLOG_TRACE("\tcommand: {} pushed to command_list_info",
-                     static_cast<const void*>(command));
-      }
-    }
-  }
-
-  void PostAppendKernel(ZeCollector* collector, ze_kernel_handle_t kernel,
-                        const ze_group_count_t* group_count, ze_event_handle_t& signal_event,
-                        ze_command_list_handle_t command_list, ze_result_t result,
-                        void** instance_data, std::vector<uint64_t>* kids) {
-    PTI_ASSERT(command_list != nullptr);
-    PTI_ASSERT(kernel != nullptr);
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-
-    ZeKernelCommand* command = static_cast<ZeKernelCommand*>(*instance_data);
-
-    command->props.name = kernel_name_cache_.GetKernelName(kernel, options_.demangle);
-    command->props.type = KernelCommandType::kKernel;
-    command->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(kernel);
-    command->props.bytes_transferred = 0;
-
-    ZeKernelGroupSize group_size{};
-    {
-      const std::lock_guard<std::mutex> lock(lock_);
-      if (kernel_group_size_map_.count(kernel) == 0) {
-        group_size = {0, 0, 0};
-      } else {
-        group_size = kernel_group_size_map_[kernel];
-      }
-    }
-
-    command->props.group_size[0] = group_size.x;
-    command->props.group_size[1] = group_size.y;
-    command->props.group_size[2] = group_size.z;
-
-    if (group_count != nullptr) {
-      command->props.group_count[0] = group_count->groupCountX;
-      command->props.group_count[1] = group_count->groupCountY;
-      command->props.group_count[2] = group_count->groupCountZ;
-    }
-
-    ZeCommandListInfo& command_list_info = GetCommandListInfo(command_list);
-
-    // Subscriber callback
-    collector->DoCallbackOnGPUOperationAppended(command, PTI_CB_PHASE_API_EXIT, result);
-
-    if (result == ZE_RESULT_SUCCESS) {
-      PostAppendKernelCommandCommon(command, signal_event, command_list_info, kids);
-    }
-  }
-
-  void PostAppendMemoryCommand(ZeCollector* collector, std::string_view command_name,
-                               size_t bytes_transferred, const void* src, const void* dst,
-                               ze_event_handle_t& signal_event,
-                               ze_command_list_handle_t command_list, ze_result_t result,
-                               void** instance_data, std::vector<uint64_t>* kids,
-                               size_t pattern_size = 0) {
-    SPDLOG_TRACE(
-        "In: {}, CmdList: {}, Signal event: {}, dst: {}, src: {}, \
-                 bytes_transferred: {}, pattern_size: {}",
-        __FUNCTION__, (void*)command_list, (void*)signal_event, dst, src, bytes_transferred,
-        pattern_size);
-    if (ZeCollectionState::kAbnormal == collection_state_) {
-      return;
-    }
-    PTI_ASSERT(command_list != nullptr);
-
-    ZeCommandListInfo& command_list_info = GetCommandListInfo(command_list);
-
-    ze_context_handle_t context = command_list_info.context;
-    PTI_ASSERT(context != nullptr);
-
-    ZeKernelCommand* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->props = GetTransferProps(command_name, bytes_transferred, (src ? context : nullptr),
-                                      src, (dst ? context : nullptr), dst, pattern_size);
-
-    // Subscriber callback
-    collector->DoCallbackOnGPUOperationAppended(command, PTI_CB_PHASE_API_EXIT, result);
-
-    PostAppendKernelCommandCommon(command, signal_event, command_list_info, kids);
-  }
-
-  void AppendMemoryCommandContext(std::string_view command_name, size_t bytes_transferred,
-                                  ze_context_handle_t src_context, const void* src,
-                                  ze_context_handle_t dst_context, const void* dst,
-                                  ze_event_handle_t& signal_event,
-                                  ze_command_list_handle_t command_list, void** instance_data,
-                                  std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    PTI_ASSERT(command_list != nullptr);
-    // TODO: How to protect command_list_info reference?
-    ZeCommandListInfo& command_list_info = GetCommandListInfo(command_list);
-
-    ze_context_handle_t context = command_list_info.context;
-    PTI_ASSERT(context != nullptr);
-
-    ZeKernelCommand* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->props = GetTransferProps(command_name, bytes_transferred, src_context, src,
-                                      (dst_context ? dst_context : context), dst);
-
-    PostAppendKernelCommandCommon(command, signal_event, command_list_info, kids);
-  }
-
-  void AppendImageMemoryCopyCommand(std::string_view command_name, ze_image_handle_t image,
-                                    const void* src, const void* dst,
-                                    ze_event_handle_t& signal_event,
-                                    ze_command_list_handle_t command_list, void** instance_data,
-                                    std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    PTI_ASSERT(command_list != nullptr);
-
-    ZeCommandListInfo& command_list_info = GetCommandListInfo(command_list);
-    ze_context_handle_t context = command_list_info.context;
-    PTI_ASSERT(context != nullptr);
-
-    size_t bytes_transferred = GetImageSize(image);
-
-    ZeKernelCommand* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->props = GetTransferProps(command_name, bytes_transferred, context, src, context, dst);
-
-    // TODO implement image copy support in Local collection model
-    if (collection_mode_ != ZeCollectionMode::kLocal) {
-      PostAppendKernelCommandCommon(command, signal_event, command_list_info, kids);
-    }
-  }
-
-  void PostAppendCommand(std::string command_name, ze_event_handle_t& signal_event,
-                         ze_command_list_handle_t command_list, void** instance_data,
-                         std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    if (ZeCollectionState::kAbnormal == collection_state_) {
-      return;
-    }
-    PTI_ASSERT(command_list != nullptr);
-
-    ZeCommandListInfo& command_list_info = GetCommandListInfo(command_list);
-
-    ze_context_handle_t context = command_list_info.context;
-    PTI_ASSERT(context != nullptr);
-
-    ZeKernelCommand* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->props.name = std::move(command_name);
-    command->props.type = KernelCommandType::kCommand;
-
-    PostAppendKernelCommandCommon(command, signal_event, command_list_info, kids);
-  }
-
-  static void OnEnterCommandListAppendLaunchKernel(
-      ze_command_list_append_launch_kernel_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kKernel,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendLaunchKernel(
-      ze_command_list_append_launch_kernel_params_t* params, ze_result_t result, void* global_data,
-      void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->callback_id_ = zeCommandListAppendLaunchKernel_id;
-    collector->PostAppendKernel(collector, *(params->phKernel), *(params->ppLaunchFuncArgs),
-                                *(params->phSignalEvent), *(params->phCommandList), result,
-                                instance_data, kids);
-    if (result != ZE_RESULT_SUCCESS) {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchCooperativeKernel(
-      ze_command_list_append_launch_cooperative_kernel_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kKernel,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendLaunchCooperativeKernel(
-      ze_command_list_append_launch_cooperative_kernel_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->callback_id_ = zeCommandListAppendLaunchCooperativeKernel_id;
-    collector->PostAppendKernel(collector, *(params->phKernel), *(params->ppLaunchFuncArgs),
-                                *(params->phSignalEvent), *(params->phCommandList), result,
-                                instance_data, kids);
-    if (result != ZE_RESULT_SUCCESS) {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelIndirect(
-      ze_command_list_append_launch_kernel_indirect_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kKernel,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendLaunchKernelIndirect(
-      ze_command_list_append_launch_kernel_indirect_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->callback_id_ = zeCommandListAppendLaunchKernelIndirect_id;
-    collector->PostAppendKernel(collector, *(params->phKernel), *(params->ppLaunchArgumentsBuffer),
-                                *(params->phSignalEvent), *(params->phCommandList), result,
-                                instance_data, kids);
-    if (result != ZE_RESULT_SUCCESS) {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelWithArguments(
-      ze_command_list_append_launch_kernel_with_arguments_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kKernel,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendLaunchKernelWithArguments(
-      ze_command_list_append_launch_kernel_with_arguments_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->callback_id_ = zeCommandListAppendLaunchKernelWithArguments_id;
-    collector->PostAppendKernel(collector, *(params->phKernel), params->pgroupCounts,
-                                *(params->phSignalEvent), *(params->phCommandList), result,
-                                instance_data, kids);
-    if (result != ZE_RESULT_SUCCESS) {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelWithParameters(
-      ze_command_list_append_launch_kernel_with_parameters_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kKernel,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendLaunchKernelWithParameters(
-      ze_command_list_append_launch_kernel_with_parameters_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    command->callback_id_ = zeCommandListAppendLaunchKernelWithParameters_id;
-    collector->PostAppendKernel(collector, *(params->phKernel), *(params->ppGroupCounts),
-                                *(params->phSignalEvent), *(params->phCommandList), result,
-                                instance_data, kids);
-    if (result != ZE_RESULT_SUCCESS) {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryCopy(
-      ze_command_list_append_memory_copy_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-    SPDLOG_TRACE("In {}, new (swapped)  signal event: {}", __FUNCTION__,
-                 (void*)(*(params->phSignalEvent)));
-  }
-
-  static void OnExitCommandListAppendMemoryCopy(ze_command_list_append_memory_copy_params_t* params,
-                                                ze_result_t result, void* global_data,
-                                                void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      command->callback_id_ = zeCommandListAppendMemoryCopy_id;
-      collector->PostAppendMemoryCommand(collector, "zeCommandListAppendMemoryCopy",
-                                         *(params->psize), *(params->psrcptr), *(params->pdstptr),
-                                         *(params->phSignalEvent), *(params->phCommandList), result,
-                                         instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryFill(
-      ze_command_list_append_memory_fill_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendMemoryFill(ze_command_list_append_memory_fill_params_t* params,
-                                                ze_result_t result, void* global_data,
-                                                void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      command->callback_id_ = zeCommandListAppendMemoryFill_id;
-      collector->PostAppendMemoryCommand(collector, "zeCommandListAppendMemoryFill",
-                                         *(params->psize), *(params->ppattern), *(params->pptr),
-                                         *(params->phSignalEvent), *(params->phCommandList), result,
-                                         instance_data, kids, *(params->ppattern_size));
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendBarrier(ze_command_list_append_barrier_params_t* params,
-                                              void* global_data, void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kCommand,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendBarrier(ze_command_list_append_barrier_params_t* params,
-                                             ze_result_t result, void* global_data,
-                                             void** instance_data, std::vector<uint64_t>* kids,
-                                             uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, (uint32_t)result);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      command->corr_id_ = synch_corrid;
-      command->num_wait_events = *params->pnumWaitEvents;
-      command->callback_id_ = zeCommandListAppendBarrier_id;
-      command->result_ = result;
-      collector->PostAppendCommand("zeCommandListAppendBarrier", *(params->phSignalEvent),
-                                   *(params->phCommandList), instance_data, kids);
-    } else {
-      // Process generation of synch record even if result is not successful.
-      // TODO barrier sync based on api start/end times here if needed.  For now no gen if result
-      // shows unsuccessful. rec.name_ = "zeCommandListAppendBarrier";
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryRangesBarrier(
-      ze_command_list_append_memory_ranges_barrier_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kCommand,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendMemoryRangesBarrier(
-      ze_command_list_append_memory_ranges_barrier_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids, uint64_t synch_corrid) {
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      command->corr_id_ = synch_corrid;
-      command->num_wait_events = *params->pnumWaitEvents;
-      command->callback_id_ = zeCommandListAppendMemoryRangesBarrier_id;
-      command->result_ = result;
-      collector->PostAppendCommand("zeCommandListAppendMemoryRangesBarrier",
-                                   *(params->phSignalEvent), *(params->phCommandList),
-                                   instance_data, kids);
-    } else {
-      // Process generation of synch record even if result is not successful.
-      // TODO barrier sync based on api start/end times here if needed.  For now no gen if result
-      // shows unsuccessful. rec.name_ = "zeCommandListAppendMemoryRangesBarrier";
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  // TODO -- uncomment this method and corresponding gen portion, for support of context barriers.
-  /*
-    static void OnExitContextTodoSystemBarrier(ze_context_system_barrier_params_t* params,
-                                           ze_result_t result, void* global_data,
-                                           void** instance_data, uint64_t synch_corrid) {
-      SPDLOG_TRACE("In {}, result {} ", __FUNCTION__, static_cast<uint32_t>(result));
-      if (result == ZE_RESULT_SUCCESS) {
-        PTI_ASSERT(*(params->phContext) != nullptr);
-        ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-        std::vector<ZeKernelCommandExecutionRecord> kcexec;
-
-        if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-          ZeKernelCommandExecutionRecord rec = {};
-          ze_context_handle_t ctxt = *params->phContext;
-          rec.name_ = "zeContextSystemBarrier";
-          rec.tid_ = PidTidInfo::Get().tid;
-          rec.start_time_ = ze_instance_data.start_time_host;
-          rec.end_time_ = ze_instance_data.end_time_host;
-          rec.context_ = ctxt;
-          rec.cid_ = synch_corrid;
-          rec.callback_id_ = zeContextSystemBarrier_id;
-          SPDLOG_TRACE("In {}, context_h {}, corrId {}", __FUNCTION__, static_cast<void*>(ctxt),
-                       rec.cid_);
-          kcexec.push_back(rec);
-          collector->acallback_(collector->callback_data_, kcexec);
-        }
-      }
-    }
-  */
-
-  static void OnEnterCommandListAppendMemoryCopyRegion(
-      ze_command_list_append_memory_copy_region_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendMemoryCopyRegion(
-      ze_command_list_append_memory_copy_region_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      size_t bytes_transferred = 0;
-      const ze_copy_region_t* region = *(params->psrcRegion);
-
-      if (region != nullptr) {
-        bytes_transferred = region->width * region->height * (*(params->psrcPitch));
-        if (region->depth != 0) {
-          bytes_transferred *= region->depth;
-        }
-      }
-      command->callback_id_ = zeCommandListAppendMemoryCopyRegion_id;
-      collector->PostAppendMemoryCommand(collector, "zeCommandListAppendMemoryCopyRegion",
-                                         bytes_transferred, *(params->psrcptr), *(params->pdstptr),
-                                         *(params->phSignalEvent), *(params->phCommandList), result,
-                                         instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryCopyFromContext(
-      ze_command_list_append_memory_copy_from_context_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendMemoryCopyFromContext(
-      ze_command_list_append_memory_copy_from_context_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    auto* command = static_cast<ZeKernelCommand*>(*instance_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      ze_context_handle_t src_context = *(params->phContextSrc);
-      // ze_context_handle_t dst_context = nullptr;
-      command->callback_id_ = zeCommandListAppendMemoryCopyFromContext_id;
-      collector->AppendMemoryCommandContext("zeCommandListAppendMemoryCopyFromContext",
-                                            *(params->psize), src_context, *(params->psrcptr),
-                                            nullptr, *(params->pdstptr), *(params->phSignalEvent),
-                                            *(params->phCommandList), instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopy(ze_command_list_append_image_copy_params_t* params,
-                                                void* global_data, void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendImageCopy(ze_command_list_append_image_copy_params_t* params,
-                                               ze_result_t result, void* global_data,
-                                               void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      collector->AppendImageMemoryCopyCommand("zeCommandListAppendImageCopy", *(params->phSrcImage),
-                                              nullptr, nullptr, *(params->phSignalEvent),
-                                              *(params->phCommandList), instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyRegion(
-      ze_command_list_append_image_copy_region_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendImageCopyRegion(
-      ze_command_list_append_image_copy_region_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      collector->AppendImageMemoryCopyCommand(
-          "zeCommandListAppendImageCopyRegion", *(params->phSrcImage), nullptr, nullptr,
-          *(params->phSignalEvent), *(params->phCommandList), instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyToMemory(
-      ze_command_list_append_image_copy_to_memory_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendImageCopyToMemory(
-      ze_command_list_append_image_copy_to_memory_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      collector->AppendImageMemoryCopyCommand(
-          "zeCommandListAppendImageCopyRegion", *(params->phSrcImage), nullptr, *(params->pdstptr),
-          *(params->phSignalEvent), *(params->phCommandList), instance_data, kids);
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyFromMemory(
-      ze_command_list_append_image_copy_from_memory_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {} --->", __FUNCTION__);
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    PrepareToAppendKernelCommand(collector, *(params->phCommandList), KernelCommandType::kMemory,
-                                 *(params->phSignalEvent), instance_data);
-  }
-
-  static void OnExitCommandListAppendImageCopyFromMemory(
-      ze_command_list_append_image_copy_from_memory_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      size_t bytes_transferred = 0;
-      const ze_image_region_t* region = *(params->ppDstRegion);
-
-      if (region != nullptr) {
-        bytes_transferred = region->width * region->height;
-        if (region->depth != 0) {
-          bytes_transferred *= region->depth;
-        }
-      }
-
-      // TODO implement image copy support in Local collection model
-      if (collector->collection_mode_ != ZeCollectionMode::kLocal) {
-        collector->PostAppendMemoryCommand(collector, "zeCommandListAppendImageCopyFromMemory",
-                                           bytes_transferred, *(params->psrcptr), nullptr,
-                                           *(params->phSignalEvent), *(params->phCommandList),
-                                           result, instance_data, kids);
-      }
-    } else {
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnExitCommandListCreate(ze_command_list_create_params_t* params, ze_result_t result,
-                                      void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      PTI_ASSERT(**params->pphCommandList != nullptr);
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-      // dummy pair
-      std::pair<uint32_t, uint32_t> oi(-1, -1);
-      collector->CreateCommandListInfo(**(params->pphCommandList), *(params->phContext),
-                                       *(params->phDevice), oi, false);
-    }
-  }
-
-  static void OnExitCommandListCreateImmediate(ze_command_list_create_immediate_params_t* params,
-                                               ze_result_t result, void* global_data,
-                                               void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      PTI_ASSERT(**params->pphCommandList != nullptr);
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      ze_device_handle_t* device_handle = params->phDevice;
-      if (device_handle == nullptr) {
-        return;
-      }
-
-      const ze_command_queue_desc_t* clq_desc = *params->paltdesc;
-      if (clq_desc == nullptr) {
-        return;
-      }
-
-      ze_command_list_handle_t* command_list = *params->pphCommandList;
-      if (command_list == nullptr) {
-        return;
-      }
-
-      std::pair<uint32_t, uint32_t> oi(clq_desc->ordinal, clq_desc->index);
-
-      collector->CreateCommandListInfo(**(params->pphCommandList), *(params->phContext),
-                                       *(params->phDevice), oi, true);
-    }
-  }
-
-  static void OnExitCommandListDestroy(ze_command_list_destroy_params_t* params, ze_result_t result,
-                                       void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      PTI_ASSERT(*params->phCommandList != nullptr);
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      std::vector<ZeKernelCommandExecutionRecord> kcexec;
-      {
-        const std::lock_guard<std::mutex> lock(collector->lock_);
-        collector->ProcessCalls(nullptr, &kcexec, nullptr);
-      }
-
-      if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-        collector->acallback_(collector->callback_data_, kcexec);
-      }
-      collector->DestroyCommandList(*params->phCommandList);
-    }
-  }
-
-  static void OnExitCommandListReset(ze_command_list_reset_params_t* params, ze_result_t result,
-                                     void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {:x}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result != ZE_RESULT_SUCCESS) {
-      return;
-    }
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    {
-      // collector->ResetCommandList(*params->phCommandList);
-      const std::lock_guard<std::mutex> lock(collector->lock_);
-      collector->ProcessCalls(nullptr, &kcexec, nullptr);
-    }
-
-    if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-      collector->acallback_(collector->callback_data_, kcexec);
-    }
-    collector->DoCallbackOnGPUOperationCompletion(kcexec);
-    collector->ResetCommandList(*params->phCommandList);
-  }
-
-  static void OnEnterCommandQueueExecuteCommandLists(
-      ze_command_queue_execute_command_lists_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-    uint32_t command_list_count = *params->pnumCommandLists;
-    if (command_list_count == 0) {
-      return;
-    }
-
-    ze_command_list_handle_t* command_lists = *params->pphCommandLists;
-    if (command_lists == nullptr) {
-      return;
-    }
-    collector->CollectOrdinalAndIndex(*(params->phCommandQueue));
-    collector->PrepareToExecuteCommandLists(command_lists, command_list_count,
-                                            *(params->phCommandQueue), *(params->phFence));
-    (collector->*collector->swap_cmd_lists_func_)(*params->pphCommandLists, command_list_count,
-                                                  instance_data, params->pphCommandLists);
-  }
-
-  static void OnExitCommandQueueExecuteCommandLists(
-      ze_command_queue_execute_command_lists_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data, std::vector<uint64_t>* kids) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-
-    // Restore the original command list array (if we swapped it on enter) so
-    // downstream tracking uses the user's handles.
-    ze_command_list_handle_t* swapped_lists = nullptr;
-    if (*instance_data != nullptr) {
-      swapped_lists = *params->pphCommandLists;
-      *params->pphCommandLists = static_cast<ze_command_list_handle_t*>(*instance_data);
-    }
-
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      uint32_t command_list_count = *params->pnumCommandLists;
-      if (command_list_count != 0) {
-        ze_command_list_handle_t* command_lists = *params->pphCommandLists;
-        if (command_lists != nullptr) {
-          collector->PostSubmitKernelCommands(command_lists, command_list_count, kids);
-        }
-      }
-    }
-
-    delete[] swapped_lists;
-  }
-
-  static void OnExitCommandQueueSynchronize(
-      [[maybe_unused]] ze_command_queue_synchronize_params_t* params, ze_result_t result,
-      void* global_data, void** /*instance_data*/, std::vector<uint64_t>* kids,
-      [[maybe_unused]] uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    {
-      if (result == ZE_RESULT_SUCCESS) {
-        {
-          const std::lock_guard<std::mutex> lock(collector->lock_);
-          collector->ProcessCalls(kids, &kcexec, nullptr);
-        }
-        if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-          collector->acallback_(collector->callback_data_, kcexec);
-        }
-      }
-
-      // Process generation of synch record even if result is not successful.
-      if (collector->cb_enabled_.acallback && collector->options_.lz_enabled_views.synch_enabled &&
-          collector->acallback_ != nullptr) {
-        std::vector<ZeKernelCommandExecutionRecord> kcexec1;
-        ze_command_queue_handle_t queue_h = *params->phCommandQueue;
-        ze_context_handle_t ctxt_h = nullptr;
-        auto it = collector->command_queues_.find(queue_h);
-        if (it != collector->command_queues_.end()) {
-          ctxt_h = it->second.context_;
-        }
-        auto rec = collector->MakeSyncRecord<zeCommandQueueSynchronize_id>(
-            "zeCommandQueueSynchronize", nullptr, nullptr, ctxt_h, queue_h, nullptr, synch_corrid,
-            result);
-        kcexec1.push_back(std::move(rec));
-        collector->acallback_(collector->callback_data_, kcexec1);
-      }
-    }
-    collector->DoCallbackOnGPUOperationCompletion(kcexec);
-  }
-
-  static void OnExitDeviceSynchronize([[maybe_unused]] ze_device_synchronize_params_t* params,
-                                      ze_result_t result, void* global_data,
-                                      void** /*instance_data*/, uint64_t synch_corrid) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    std::vector<ZeKernelCommandExecutionRecord> kcexec;
-    if (result == ZE_RESULT_SUCCESS) {
-      {
-        const std::lock_guard<std::mutex> lock(collector->lock_);
-        collector->ProcessCalls(nullptr, &kcexec, nullptr);
-      }
-      if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-        collector->acallback_(collector->callback_data_, kcexec);
-      }
-    }
-    if (collector->cb_enabled_.acallback && collector->options_.lz_enabled_views.synch_enabled &&
-        collector->acallback_ != nullptr) {
-      std::vector<ZeKernelCommandExecutionRecord> kcexec1{
-          collector->MakeSyncRecord<zeDeviceSynchronize_id>("zeDeviceSynchronize", nullptr, nullptr,
-                                                            nullptr, nullptr, nullptr, synch_corrid,
-                                                            result)};
-      collector->acallback_(collector->callback_data_, kcexec1);
-    }
-    collector->DoCallbackOnGPUOperationCompletion(kcexec);
-  }
-
-  static void OnExitCommandQueueCreate(ze_command_queue_create_params_t* params,
-                                       [[maybe_unused]] ze_result_t result, void* global_data,
-                                       void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    ze_device_handle_t* device = params->phDevice;
-    if (device == nullptr) {
-      return;
-    }
-    const ze_command_queue_desc_t* queue_desc = *params->pdesc;
-    if (queue_desc == nullptr) {
-      return;
-    }
-    ze_command_queue_handle_t* command_queue = *params->pphCommandQueue;
-    if (command_queue == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::mutex> lock(collector->lock_);
-    if (collector->queue_ordinal_index_map_.count(*command_queue) == 0) {
-      collector->queue_ordinal_index_map_[*command_queue] =
-          std::make_pair(queue_desc->ordinal, queue_desc->index);
-    }
-
-    ZeCommandQueue desc{};
-    desc.queue_ = *command_queue;
-    desc.context_ = *(params->phContext);
-    desc.device_ = *device;
-    desc.engine_ordinal_ = queue_desc->ordinal;
-    desc.engine_index_ = queue_desc->index;
-
-    collector->command_queues_.erase(*command_queue);
-    collector->command_queues_.insert({*command_queue, std::move(desc)});
-  }
-
-  static void OnExitCommandQueueDestroy(ze_command_queue_destroy_params_t* params,
-                                        ze_result_t result, void* global_data,
-                                        void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      std::vector<ZeKernelCommandExecutionRecord> kcexec;
-      {
-        const std::lock_guard<std::mutex> lock(collector->lock_);
-        collector->ProcessCalls(nullptr, &kcexec, nullptr);
-        collector->queue_ordinal_index_map_.erase(*params->phCommandQueue);
-        collector->command_queues_.erase(*params->phCommandQueue);
-      }
-
-      if (collector->cb_enabled_.acallback && collector->acallback_ != nullptr) {
-        collector->acallback_(collector->callback_data_, kcexec);
-      }
-      collector->DoCallbackOnGPUOperationCompletion(kcexec);
-    }
-  }
-
-  static void OnEnterExecutableGraphDestroyExt(ze_executable_graph_destroy_ext_params_t* params,
-                                               void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    collector->ProcessCommandsAndReturnCommandExecutionsRecordsToUser(nullptr, nullptr);
-    auto removed_instrumented_graph = collector->graph_storage_.Remove(*params->phGraph);
-    if (removed_instrumented_graph) {
-      collector->ReleaseInstrumentedGraph(*removed_instrumented_graph);
-    }
-  }
-
-  static void OnExitKernelSetGroupSize(ze_kernel_set_group_size_params_t* params,
-                                       ze_result_t result, void* global_data,
-                                       void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      ZeKernelGroupSize group_size{*(params->pgroupSizeX), *(params->pgroupSizeY),
-                                   *(params->pgroupSizeZ)};
-      collector->AddKernelGroupSize(*(params->phKernel), group_size);
-    }
-  }
-
-  static void OnEnterModuleCreate([[maybe_unused]] ze_module_create_params_t* params,
-                                  [[maybe_unused]] void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    // No need to do anything here now
-  }
-
-  static void OnExitModuleCreate(ze_module_create_params_t* params, ze_result_t result,
-                                 void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result != ZE_RESULT_SUCCESS) {
-      return;
-    }
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    ze_module_handle_t module_handle =
-        (params && params->pphModule && *(params->pphModule)) ? **(params->pphModule) : nullptr;
-    ze_device_handle_t device = (params && params->phDevice) ? *(params->phDevice) : nullptr;
-    if (module_handle != nullptr && device != nullptr) {
-      std::unique_lock<std::shared_mutex> lock(collector->module_to_device_map_lock_);
-      collector->module_to_device_map_[module_handle] = device;
-    }
-  }
-
-  static void OnEnterModuleDestroy([[maybe_unused]] ze_module_destroy_params_t* params,
-                                   void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    ze_module_handle_t module_handle = (params && params->phModule) ? *(params->phModule) : nullptr;
-    if (module_handle != nullptr) {
-      std::unique_lock<std::shared_mutex> lock(collector->module_to_device_map_lock_);
-      collector->module_to_device_map_.erase(module_handle);
-    }
-  }
-
-  static void OnExitModuleDestroy([[maybe_unused]] ze_module_destroy_params_t* params,
-                                  [[maybe_unused]] ze_result_t result,
-                                  [[maybe_unused]] void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-  }
-
-  static void OnEnterKernelCreate(ze_kernel_create_params_t* params, void* global_data,
-                                  void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    ze_device_handle_t device = nullptr;
-    if (collector->IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED,
-                                           PTI_CB_PHASE_API_ENTER)) {
-      const ze_kernel_desc_t* desc = (params && params->pdesc) ? *(params->pdesc) : nullptr;
-      const char* kname = (desc != nullptr) ? desc->pKernelName : nullptr;
-      ze_module_handle_t module_handle =
-          (params && params->phModule) ? *(params->phModule) : nullptr;
-      {
-        std::shared_lock<std::shared_mutex> lock(collector->module_to_device_map_lock_);
-        auto device_handle_it = collector->module_to_device_map_.find(module_handle);
-        if (device_handle_it != collector->module_to_device_map_.end()) {
-          device = device_handle_it->second;
-        }
-      }
-      collector->DoCallbackOnKernelLifecycle(
-          PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, PTI_CB_PHASE_API_ENTER,
-          /*context*/ nullptr,
-          /*kernel*/ nullptr, module_handle, device, kname, ZE_RESULT_SUCCESS, zeKernelCreate_id);
-    }
-  }
-
-  static void OnExitKernelCreate(ze_kernel_create_params_t* params, ze_result_t result,
-                                 void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    if (collector->IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED,
-                                           PTI_CB_PHASE_API_EXIT)) {
-      const ze_kernel_desc_t* desc = (params && params->pdesc) ? *(params->pdesc) : nullptr;
-      const char* kname = (desc != nullptr) ? desc->pKernelName : nullptr;
-      ze_module_handle_t module_handle =
-          (params && params->phModule) ? *(params->phModule) : nullptr;
-      ze_kernel_handle_t kernel = nullptr;
-      if (result == ZE_RESULT_SUCCESS && params && params->pphKernel && *(params->pphKernel)) {
-        kernel = **(params->pphKernel);
-      }
-      ze_device_handle_t device = nullptr;
-      {
-        std::shared_lock<std::shared_mutex> lock(collector->module_to_device_map_lock_);
-        auto device_handle_it = collector->module_to_device_map_.find(module_handle);
-        if (device_handle_it != collector->module_to_device_map_.end()) {
-          device = device_handle_it->second;
-        }
-      }
-      collector->DoCallbackOnKernelLifecycle(
-          PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, PTI_CB_PHASE_API_EXIT,
-          /*context*/ nullptr, kernel, module_handle, device, kname, result, zeKernelCreate_id);
-    }
-  }
-
-  static void OnEnterKernelDestroy(ze_kernel_destroy_params_t* params, void* global_data,
-                                   void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    if (collector->IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED,
-                                           PTI_CB_PHASE_API_ENTER)) {
-      ze_kernel_handle_t kernel = (params && params->phKernel) ? *(params->phKernel) : nullptr;
-      collector->DoCallbackOnKernelLifecycle(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED,
-                                             PTI_CB_PHASE_API_ENTER,
-                                             /*context*/ nullptr, kernel, nullptr, nullptr, nullptr,
-                                             ZE_RESULT_SUCCESS, zeKernelDestroy_id);
-    }
-  }
-
-  static void OnExitKernelDestroy(ze_kernel_destroy_params_t* params, ze_result_t result,
-                                  void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-    if (result == ZE_RESULT_SUCCESS) {
-      collector->RemoveKernelGroupSize(*(params->phKernel));
-      collector->kernel_name_cache_.RemoveKernel(*(params->phKernel));
-    }
-    if (collector->IsCallbackDomainEnabled(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED,
-                                           PTI_CB_PHASE_API_EXIT)) {
-      ze_kernel_handle_t kernel = (params && params->phKernel) ? *(params->phKernel) : nullptr;
-      collector->DoCallbackOnKernelLifecycle(
-          PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED, PTI_CB_PHASE_API_EXIT,
-          /*context*/ nullptr, kernel, nullptr, nullptr, nullptr, result, zeKernelDestroy_id);
-    }
-  }
-
-  static void OnEnterContextDestroy(ze_context_destroy_params_t* params, void* global_data,
-                                    void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    auto* const ctx = *(params->phContext);
-    if (!ctx) {
-      return;
-    }
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    for (const auto& graph_info : collector->graph_storage_.RemoveContext(ctx)) {
-      collector->ReleaseInstrumentedGraph(*graph_info);
-    }
-    collector->ProcessCommandsAndReturnCommandExecutionsRecordsToUser(nullptr, nullptr);
-    collector->event_cache_.ReleaseContext(*(params->phContext));
-    collector->event_pool_manager_.Clear(*(params->phContext));
-  }
-
-  static void OnExitContextDestroy(ze_context_destroy_params_t* params, ze_result_t result,
-                                   void* global_data, void** /*instance_data*/) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-      collector->event_pools_observer_.ClearContext(*(params->phContext));
-    }
-  }
-
-  static void OnEnterCommandListImmediateAppendCommandListsExp(
-      ze_command_list_immediate_append_command_lists_exp_params_t* params, void* global_data,
-      void** instance_data) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    ZeCollector* collector = static_cast<ZeCollector*>(global_data);
-
-    auto command_list_count = *params->pnumCommandLists;
-    if (command_list_count == 0) {
-      return;
-    }
-
-    auto* command_lists = *params->pphCommandLists;
-    if (command_lists == nullptr) {
-      return;
-    }
-
-    auto imm_command_list = *(params->phCommandListImmediate);
-
-    collector->CollectOrdinalAndIndex(imm_command_list);
-    collector->PrepareToExecuteCommandLists(
-        command_lists, command_list_count,
-        reinterpret_cast<ze_command_queue_handle_t>(imm_command_list), nullptr);
-    (collector->*collector->swap_cmd_lists_func_)(command_lists, command_list_count, instance_data,
-                                                  params->pphCommandLists);
-  }
-
-  static void OnExitCommandListImmediateAppendCommandListsExp(
-      ze_command_list_immediate_append_command_lists_exp_params_t* params, ze_result_t result,
-      void* global_data, void** instance_data) {
-    SPDLOG_TRACE("In {}, result: {}", __FUNCTION__, static_cast<uint32_t>(result));
-
-    ze_command_list_handle_t* swapped_lists = nullptr;
-    if (*instance_data != nullptr) {
-      swapped_lists = *params->pphCommandLists;
-      *params->pphCommandLists = static_cast<ze_command_list_handle_t*>(*instance_data);
-    }
-
-    if (result == ZE_RESULT_SUCCESS) {
-      auto* collector = static_cast<ZeCollector*>(global_data);
-      uint32_t command_list_count = *params->pnumCommandLists;
-      if (command_list_count == 0) {
-        delete[] swapped_lists;
-        return;
-      }
-
-      ze_command_list_handle_t* command_lists = *params->pphCommandLists;
-      if (command_lists == nullptr) {
-        delete[] swapped_lists;
-        return;
-      }
-
-      if (command_lists != nullptr) {
-        collector->PostSubmitKernelCommands(command_lists, command_list_count, nullptr);
-      }
-    }
-    delete[] swapped_lists;
-  }
-
-  std::pair<ze_event_handle_t, bool> SynchronizePreviousExecution(ZeGraphInfo* graph_info) {
-    static constexpr auto kExecutionTimeout =
-        std::chrono::nanoseconds(std::chrono::milliseconds(250)).count();
-    auto& execution = graph_info->execution;
-    if (!execution.graph_execution_event || execution.graph_execution_event->Empty()) {
-      SPDLOG_TRACE("No previous execution of graph {} to synchronize",
-                   static_cast<const void*>(graph_info->graph));
-      return {nullptr, true};
-    }
-
-    if (!execution.graph_execution_event->Ready()) {
-      if (execution.sync_timeout) {
-        SPDLOG_WARN(
-            "Previous execution of graph {} has already timed out. Skipping synchronization.",
-            static_cast<const void*>(graph_info->graph));
-        return {execution.graph_execution_event->Get(), false};
-      }
-      SPDLOG_INFO("Waiting for completion of previous execution of graph {}",
-                  static_cast<const void*>(graph_info->graph));
-      overhead::ScopedOverheadCollector overhead_collector{zeEventHostSynchronize_id};
-      const auto result =
-          zeEventHostSynchronize(execution.graph_execution_event->Get(), kExecutionTimeout);
-      if (result != ZE_RESULT_SUCCESS) {
-        execution.sync_timeout = true;
-        SPDLOG_ERROR(
-            "Failed to synchronize completion event {} for graph {}, result: {:x}. Timeout {} ns",
-            static_cast<const void*>(execution.graph_execution_event->Get()),
-            static_cast<const void*>(graph_info->graph), static_cast<uint32_t>(result),
-            kExecutionTimeout);
-        return {execution.graph_execution_event->Get(), false};
-      }
-    }
-    execution.sync_timeout = false;
-    return {execution.graph_execution_event->Get(), true};
-  }
-
-  bool InstrumentGraph(ZeGraphInfo& graph_info) {
-    if (graph_info.execution.instrumented_executable_graph != nullptr) {
-      return true;
-    }
-
-    auto dev_it = device_descriptors_.find(graph_info.device);
-    if (dev_it == device_descriptors_.end() || !dev_it->second.visit.has_value()) {
-      return false;
-    }
-
-    if (graph_info.execution.instrumented_graph == nullptr) {
-      overhead::ScopedOverheadCollector overhead_collector{zeGraphCreateExt_id};
-      auto result = l0_wrapper_.w_zeGraphCreateExt(graph_info.context, nullptr,
-                                                   &graph_info.execution.instrumented_graph);
-      if (result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to create instrumented graph for graph {}, result: {:x}",
-                     static_cast<const void*>(graph_info.graph), static_cast<uint32_t>(result));
-        return false;
-      }
-    }
-
-    // Record a new "instrumented" graph into the primary command list with the visitor feature.
-    // This enables us to clone a graph and insert our own instrumentation.
-    {
-      overhead::ScopedOverheadCollector overhead_collector{
-          zeCommandListBeginCaptureIntoGraphExt_id};
-      auto result = l0_wrapper_.w_zeCommandListBeginCaptureIntoGraphExt(
-          graph_info.primary_command_list, graph_info.execution.instrumented_graph, nullptr);
-      if (result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to begin capture into instrumented graph for graph {}, result: {:x}",
-                     static_cast<const void*>(graph_info.graph), static_cast<uint32_t>(result));
-        return false;
-      }
-    }
-
-    std::vector<std::shared_ptr<ZeKernelCommand>> commands;
-    auto visit_result = ZE_RESULT_SUCCESS;
-    try {
-      auto visitor = ZeCommandVisitor{*dev_it->second.visit, &event_pool_manager_};
-      std::tie(commands, visit_result) =
-          visitor.GraphVisit(dev_it->second, graph_info, graph_info.graph);
-    } catch (const std::exception& e) {
-      SPDLOG_ERROR("Exception occurred during graph visit for graph {}: {}",
-                   static_cast<const void*>(graph_info.graph), e.what());
-      visit_result = ZE_RESULT_ERROR_UNKNOWN;
-    } catch (...) {
-      SPDLOG_ERROR("Unknown exception occurred during graph visit for graph {}",
-                   static_cast<const void*>(graph_info.graph));
-      visit_result = ZE_RESULT_ERROR_UNKNOWN;
-    }
-
-    ze_graph_handle_t captured_graph = nullptr;
-    {
-      overhead::ScopedOverheadCollector overhead_collector{zeCommandListEndGraphCaptureExt_id};
-      auto end_result = l0_wrapper_.w_zeCommandListEndGraphCaptureExt(
-          graph_info.primary_command_list, nullptr, &captured_graph);
-      if (end_result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to end capture into instrumented graph for graph {}, result: {:x}",
-                     static_cast<const void*>(graph_info.graph), static_cast<uint32_t>(end_result));
-        return false;
-      }
-    }
-
-    if (visit_result != ZE_RESULT_SUCCESS) {
-      SPDLOG_ERROR("Failed to visit graph {}, result: {:x}",
-                   static_cast<const void*>(graph_info.graph), static_cast<uint32_t>(visit_result));
-      return false;
-    }
-
-    PTI_ASSERT(captured_graph == graph_info.execution.instrumented_graph);
-    SPDLOG_INFO(
-        "Capturing graph {} into instrumented graph {} is done. This graph contains {} commands.",
-        static_cast<const void*>(graph_info.graph),
-        static_cast<const void*>(graph_info.execution.instrumented_graph), commands.size());
-
-    {
-      overhead::ScopedOverheadCollector overhead_collector{zeGraphInstantiateExt_id};
-      auto inst_result =
-          l0_wrapper_.w_zeGraphInstantiateExt(graph_info.execution.instrumented_graph, nullptr,
-                                              &graph_info.execution.instrumented_executable_graph);
-      if (inst_result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to instantiate instrumented graph for graph {}, result: {:x}",
-                     static_cast<const void*>(graph_info.graph),
-                     static_cast<uint32_t>(inst_result));
-        return false;
-      }
-    }
-    SPDLOG_INFO("Finished generating instrumented executable graph {} from instrumented graph {}",
-                static_cast<const void*>(graph_info.execution.instrumented_executable_graph),
-                static_cast<const void*>(graph_info.execution.instrumented_graph));
-
-    graph_info.execution.graph_commands = std::move(commands);
-    return true;
-  }
-
-  void ReleaseInstrumentedGraph(ZeGraphInfo& graph_info) {
-    const std::lock_guard<std::mutex> lock(graph_info.execution_mutex);
-    auto& execution = graph_info.execution;
-    if (!execution.instrumented_graph && !execution.instrumented_executable_graph) {
-      return;
-    }
-
-    if (!SynchronizePreviousExecution(&graph_info).second) {
-      SPDLOG_WARN("Leaking instrumented graphs of graph {}: previous execution did not complete",
-                  static_cast<const void*>(graph_info.graph));
-      return;
-    }
-
-    if (execution.instrumented_executable_graph) {
-      overhead::ScopedOverheadCollector overhead_collector{zeExecutableGraphDestroyExt_id};
-      auto result =
-          l0_wrapper_.w_zeExecutableGraphDestroyExt(execution.instrumented_executable_graph);
-      if (result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to destroy instrumented executable graph {}, result: {:x}",
-                     static_cast<const void*>(execution.instrumented_executable_graph),
-                     static_cast<uint32_t>(result));
-        return;
-      }
-      execution.instrumented_executable_graph = nullptr;
-    }
-
-    if (execution.instrumented_graph) {
-      overhead::ScopedOverheadCollector overhead_collector{zeGraphDestroyExt_id};
-      auto result = l0_wrapper_.w_zeGraphDestroyExt(execution.instrumented_graph);
-      if (result != ZE_RESULT_SUCCESS) {
-        SPDLOG_ERROR("Failed to destroy instrumented graph {}, result: {:x}",
-                     static_cast<const void*>(execution.instrumented_graph),
-                     static_cast<uint32_t>(result));
-        return;
-      }
-      execution.instrumented_graph = nullptr;
-    }
-  }
-
-  static void OnEnterCommandListAppendGraphExt(ze_command_list_append_graph_ext_params_t* params,
-                                               void* global_data, void** instance_data) {
-    SPDLOG_TRACE("In {}", __FUNCTION__);
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-
-    const auto graph_info = collector->graph_storage_.GetInfo(*params->phGraph);
-    if (!graph_info) {
-      SPDLOG_ERROR("Failed to get graph info");
-      return;
-    }
-
-    auto* const app_signal_event = *params->phSignalEvent;
-    ze_event_handle_t completion_event = nullptr;
-
-    const std::lock_guard<std::mutex> replay_lock(graph_info->execution_mutex);
-    // TODO(PTI): We are serializing graph execution to simplify the
-    // implementation. We should consider parallelizing this in the future e.g., create another
-    // instrumented graph for overlapping executions. Executions records should be processed again
-    // to make sure all timestamps are collected.
-    // Check graph
-    auto [graph_completion_event, success] =
-        collector->SynchronizePreviousExecution(graph_info.get());
-    if (!success) {
-      SPDLOG_WARN(
-          "Skipping replay trace due to failed synchronization of previous execution of graph {} "
-          "with completion event {}",
-          static_cast<const void*>(graph_info->graph),
-          static_cast<const void*>(graph_completion_event));
-      return;
-    }
-    collector->ProcessCommandsAndReturnCommandExecutionsRecordsToUser(nullptr,
-                                                                      graph_completion_event);
-    if (!collector->InstrumentGraph(*graph_info)) {
-      return;
-    }
-    if (!graph_info->execution.graph_execution_event ||
-        graph_info->execution.graph_execution_event->Empty()) {
-      graph_info->execution.graph_execution_event = std::make_shared<ZeEventView<ZeEventPool>>(
-          collector->event_pool_manager_.AcquireEvent(graph_info->context));
-    }
-    graph_info->execution.graph_execution_event->ResetSignal();
-    completion_event = graph_info->execution.graph_execution_event->Get();
-
-    uint64_t host_timestamp = 0;
-    uint64_t device_timestamp = 0;  // in ticks
-    auto status =
-        collector->GetDeviceTimestamps(graph_info->device, &host_timestamp, &device_timestamp);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    ze_instance_data.timestamp_host = host_timestamp;
-    ze_instance_data.timestamp_device = device_timestamp;
-
-    // Correlation between urEnqueueGraphExp and graph commands.
-#if defined(PTI_TRACE_SYCL)
-    const uint64_t graph_cid = sycl_data_kview.cid_ ? sycl_data_kview.cid_ : sycl_data_mview.cid_;
-#else
-    const uint64_t graph_cid = 0;
-#endif
-    *params->phGraph = graph_info->execution.instrumented_executable_graph;
-    *params->phSignalEvent = completion_event;
-    SPDLOG_TRACE(
-        "Replacing user graph {} with instrumented graph {} and user event {} with swap event {}",
-        static_cast<const void*>(graph_info->graph),
-        static_cast<const void*>(graph_info->execution.instrumented_executable_graph),
-        static_cast<const void*>(app_signal_event), static_cast<const void*>(completion_event));
-    try {
-      auto graph_data = std::make_unique<ZeGraphAppendInstanceData>(
-          ZeGraphAppendInstanceData{graph_info, app_signal_event, completion_event, host_timestamp,
-                                    device_timestamp, graph_cid});
-      *instance_data = graph_data.release();
-    } catch (const std::bad_alloc&) {
-      SPDLOG_ERROR("Failed to allocate ZeGraphAppendInstanceData");
-      *instance_data = nullptr;
-    }
-  }
-  static void OnExitCommandListAppendGraphExt(ze_command_list_append_graph_ext_params_t* params,
-                                              ze_result_t result, void* global_data,
-                                              void** instance_data) {
-    SPDLOG_TRACE("In {}, result: {:x}", __FUNCTION__, static_cast<uint32_t>(result));
-    auto* const graph_append_data = static_cast<ZeGraphAppendInstanceData*>(*instance_data);
-    if (!graph_append_data) {
-      return;
-    }
-    std::unique_ptr<ZeGraphAppendInstanceData> graph_data(graph_append_data);
-    if (result != ZE_RESULT_SUCCESS) {
-      const std::lock_guard<std::mutex> exec_lock(graph_data->graph_info->execution_mutex);
-      graph_append_data->graph_info->execution.sync_timeout = false;
-      graph_append_data->graph_info->execution.graph_execution_event.reset();
-      SPDLOG_WARN("User graph append failed: {:x}", static_cast<uint32_t>(result));
-      return;
-    }
-    auto* const collector = static_cast<ZeCollector*>(global_data);
-    if (graph_append_data->user_graph_signal_event) {
-      SPDLOG_TRACE("Chaining user graph completion signal {} with swap event {}",
-                   static_cast<const void*>(graph_append_data->user_graph_signal_event),
-                   static_cast<const void*>(graph_append_data->graph_completion_event));
-      auto cmd_list = *params->phCommandList;
-      const bool success =
-          collector->IsCommandListInOrder(cmd_list)
-              ? A2AppendSignalEvent(cmd_list, graph_append_data->user_graph_signal_event)
-              : A2AppendWaitAndSignalEvent(cmd_list, graph_append_data->user_graph_signal_event,
-                                           graph_append_data->graph_completion_event);
-      if (!success) {
-        SPDLOG_ERROR("Failed to chain user graph completion signal with user's events");
-      }
-    }
-
-    {
-      const std::lock_guard<std::mutex> graph_lock(graph_data->graph_info->execution_mutex);
-      const std::lock_guard<std::mutex> collector_lock(collector->lock_);
-      collector->submitted_commands_.emplace_back(
-          std::make_unique<ZeBatchedExecution>(ZeBatchedExecution{
-              graph_append_data->graph_info->execution.graph_execution_event,
-              graph_append_data->user_graph_signal_event,
-              graph_append_data->submit_time_host,
-              graph_append_data->submit_time_device,
-              graph_append_data->graph_correlation_id,
-              graph_data->graph_info->execution.graph_commands,
-          }));
-    }
-  }
-
-  using SwapCmdListsFn = void (ZeCollector::*)(ze_command_list_handle_t* old_command_lists,
-                                               uint32_t command_list_count, void** instance_data,
-                                               ze_command_list_handle_t** executed_command_lists);
-
-  using DeviceSubmission =
-      std::variant<std::shared_ptr<ZeKernelCommand>, std::unique_ptr<ZeBatchedExecution>>;
-
-  zel_tracer_handle_t tracer_ = nullptr;
-  CollectorOptions options_ = {};
-  bool driver_introspection_capable_ = false;
-  bool driver_supports_counter_events_ = false;
-  // Enabled if any driver on the system supports the visitor extension. In that case, we can
-  // support swapping the user's command list with an instrumented command list to capture all GPU
-  // activity.
-  SwapCmdListsFn swap_cmd_lists_func_ =
-      &ZeCollector::DisabledSwapCommandListsWithInstrumentedCommandLists;
-  bool loader_dynamic_tracing_capable_ = false;
-  CallbacksEnabled cb_enabled_ = {};
-  OnZeKernelFinishCallback acallback_ = nullptr;
-  OnZeApiCallsFinishCallback fcallback_ = nullptr;
-  void* callback_data_ = nullptr;
-  std::mutex lock_;
-
-#include <tracing.gen>  // Auto-generated callbacks
-
-  // mode=0 implies full apis; mode=1 implies hybrid apis only (eventpool); mode=2 is Local
-  ZeCollectionMode collection_mode_ = ZeCollectionMode::kFull;
-
-  // Owns swap events. To ensure proper destruction order, event_pool_manager_ should be declared
-  // before other members that may use it, so they can release the events
-  // event_pool_manager_ owns.
-  ZeEventPoolManager event_pool_manager_;
-
-  Level0Wrapper l0_wrapper_;
-
-  ZeGraphStorage graph_storage_;
-
-  // ZeKernelCommand objects are shared w/ ZeCommandListInfo
-  std::list<DeviceSubmission> submitted_commands_;
-  // keep track of destroyed events, not request their status
-  // CCL workloads often destroy events
-  std::unordered_set<ze_event_handle_t> destroyed_events_;
-
-  mutable std::shared_mutex command_list_map_mutex_;
-  ZeCommandListMap command_list_map_;
-  ZeImageSizeMap image_size_map_;
-  ZeKernelGroupSizeMap kernel_group_size_map_;
-  ZeKernelNameCache<> kernel_name_cache_;
-  ZeDeviceMap device_map_;
-  std::unordered_map<ze_device_handle_t, ZeDeviceDescriptor> device_descriptors_;
-  std::unordered_map<ze_module_handle_t, ze_device_handle_t> module_to_device_map_;
-  std::shared_mutex module_to_device_map_lock_;
-
-  ZeEventCache event_cache_;
-
-  std::map<ze_command_queue_handle_t, std::pair<uint32_t, uint32_t>> queue_ordinal_index_map_;
-
-  std::map<ze_command_queue_handle_t, ZeCommandQueue> command_queues_;
-  std::map<ze_fence_handle_t, ze_command_queue_handle_t> fence_queue_map_;
-
-  // Keeps track of EventPools in Full & Hybrid collection modes,
-  // queries event pools in Local mode -
-  // all is to find out if GPU operation event is regular or counter-based, and
-  // if regular - may be already has timestamp property
-  ZeEventPoolsObserver event_pools_observer_;
-
-  // Multiple subscribers support with subscriber handle-based access
-  // important that container is ordered, callbacks should be called in an order
-
-  SubscribersCollection cb_subscribers_collection_;
-  mutable std::shared_mutex subscribers_mutex_;
-
-  std::atomic<ZeCollectionState> collection_state_ = ZeCollectionState::kNormal;
-
-  // pointer to state of an object that created ZeCollector
-  // a way to communicate abnormal situations
-  std::atomic<pti_result>* parent_state_ = nullptr;
-
-  class ZeStartStopModeChanger {
-   public:
-    explicit ZeStartStopModeChanger(ZeCollector* collector)
-        : ref_count(0), parent_collector_(collector) {}
-
-    // switches to fully start tracing mode - only if we are not already in start mode.  Else
-    // records another view_kind active in region.
-    inline uint64_t ToStartTracing() {
-      const std::lock_guard<std::mutex> lock(ss_lock_);
-      if (ref_count) {
-        ref_count++;
-        return ref_count;
-      }
-      if (parent_collector_->options_.disabled_mode) {
-        ze_result_t status = parent_collector_->l0_wrapper_.w_zelEnableTracingLayer();
-        if (ZE_RESULT_SUCCESS == status) {
-          PTI_ASSERT(global_ref_count == 0);
-          global_ref_count++;
-          SPDLOG_DEBUG(" --- In {}, Tracing ON, tid: {}", __FUNCTION__, PidTidInfo::Get().tid);
-        }
-      }
-      parent_collector_->cb_enabled_.acallback = true;
-      parent_collector_->cb_enabled_.fcallback = true;
-      if (ZeCollectionMode::kHybrid == parent_collector_->collection_mode_)
-        parent_collector_->options_.hybrid_mode = false;
-      ref_count++;
-      return ref_count;
-    }
-
-    // switches to fully stopped tracing mode - only if all previously active view_kinds are
-    // disabled across all threads(ref_count drops to 0). Else records another view_kind deactivated
-    // in region.
-    inline uint64_t ToStopTracing() {
-      SPDLOG_TRACE("In {}", __FUNCTION__);
-      const std::lock_guard<std::mutex> lock(ss_lock_);
-      if (ref_count > 0) ref_count--;
-      if (ref_count) {
-        return ref_count;
-      }
-
-      // ref_count hit 0 -- we need to ensure tracing is fully disabled
-      if (parent_collector_->options_.disabled_mode) {
-        // no any collector ProcessCalls or similar here -
-        // all finished tasks data should be captured and handled by proper callbacks by this point
-        ze_result_t status = parent_collector_->l0_wrapper_.w_zelDisableTracingLayer();
-        // Clear observed event pools info as tracing is being disabled
-        // even it will be further enabled - collector is blind to what happen in-between
-        parent_collector_->event_pools_observer_.ClearAll();
-
-        if (ZE_RESULT_SUCCESS == status) {
-          global_ref_count--;
-          PTI_ASSERT(global_ref_count == 0);
-          SPDLOG_DEBUG(" --- In {}, Tracing OFF, tid: {}", __FUNCTION__, PidTidInfo::Get().tid);
-        }
-      }
-      parent_collector_->cb_enabled_.fcallback = false;
-      if (ZeCollectionMode::kHybrid == parent_collector_->collection_mode_)
-        parent_collector_->options_.hybrid_mode = true;
-      if (ZeCollectionMode::kFull != parent_collector_->collection_mode_) {
-        // On Hybrid and Local modes, there's a chance that the graph will be destroyed and the
-        // handle re-used while tracing is off. This alleviates this issue by
-        // clearing the stored commands to prevents to prevent stale command
-        // list and graph handles from being used.
-        parent_collector_->ClearCommandListMap();
-        for (const auto& [executable_graph, graph_info] :
-             parent_collector_->graph_storage_.RemoveAll()) {
-          parent_collector_->ReleaseInstrumentedGraph(*graph_info);
-        }
-      }
-      return ref_count;
-    }
-
-    inline bool IsTracingOn() const { return (ref_count > 0); }
-
-   private:
-    // Track enable/disable tracing layer calls on a global basis - in order to swap apis.
-    // zelEnableTracingLayer and zelDisableTracingLayer are not thread specific -- and act globally.
-    //      We use ref_count to track how many L0 view_kinds are enabled/disabled on a global basis.
-
-    std::atomic<uint64_t> ref_count = 0;
-    ZeCollector* parent_collector_;
-    std::mutex ss_lock_;
-  };
-  ZeStartStopModeChanger startstop_mode_changer;
-};
-
-#endif  // PTI_TOOLS_PTI_LEVEL_ZERO_COLLECTOR_H_
diff --git a/sdk/src/levelzero/ze_collector_cb_helpers.h b/sdk/src/levelzero/ze_collector_cb_helpers.h
deleted file mode 100644
index 0831b19d..00000000
--- a/sdk/src/levelzero/ze_collector_cb_helpers.h
+++ /dev/null
@@ -1,354 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef ZE_COLLECTOR_CB_HELPERS_H_
-#define ZE_COLLECTOR_CB_HELPERS_H_
-
-#include <spdlog/spdlog.h>
-
-#include <cstdint>
-#include <list>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "unikernel.h"
-
-#define CB_SUBSCRIBER_HANDLE_INVALID nullptr
-
-struct pair_hash {
-  std::size_t operator()(const std::pair<pti_backend_ctx_t, pti_device_handle_t>& p) const {
-    uintptr_t a1 = reinterpret_cast<uintptr_t>(p.first);
-    uintptr_t a2 = reinterpret_cast<uintptr_t>(p.second);
-    auto h1 = std::hash<uintptr_t>{}(a1);
-    auto h2 = std::hash<uintptr_t>{}(a2);
-    // Combine the two hashes
-    return h1 ^ (h2 << 1);
-  }
-};
-
-// Not copy Records but store their pointers
-using ExecRecordsMap =
-    std::unordered_map<std::pair<pti_backend_ctx_t, pti_device_handle_t>,
-                       std::vector<const ZeKernelCommandExecutionRecord*>, pair_hash>;
-
-#define INVALID_KERNEL_HANDLE 0
-
-struct CbDomainProperties {
-  pti_callback_domain domain;
-  // serve for ENTER/EXIT to API, THREAD_START/THREAD_END to THREAD or other "events" that
-  // come in a pair
-  bool is_enter_enabled;
-  bool is_exit_enabled;
-};
-
-struct _pti_callback_subscriber {
-  _pti_callback_subscriber(pti_callback_function callback, void* user_data)
-      : callback_(callback), user_data_(user_data), instance_user_data_(nullptr) {}
-
-  _pti_callback_subscriber(const _pti_callback_subscriber&) = delete;
-  _pti_callback_subscriber& operator=(const _pti_callback_subscriber&) = delete;
-  _pti_callback_subscriber(_pti_callback_subscriber&&) = delete;
-  _pti_callback_subscriber& operator=(_pti_callback_subscriber&&) = delete;
-  ~_pti_callback_subscriber() {}  // To satisfy Coverity with user-defined destructor
-  pti_callback_function callback_ = nullptr;
-  std::unordered_map<pti_callback_domain, CbDomainProperties> domains_;
-  mutable void* user_data_ = nullptr;
-  mutable void* instance_user_data_ = nullptr;
-};
-
-class ZeCollectorCBSubscriber {
- public:
-  ZeCollectorCBSubscriber() : subscriber_info_(nullptr, nullptr) {}
-
-  ZeCollectorCBSubscriber(const ZeCollectorCBSubscriber&) = delete;
-  ZeCollectorCBSubscriber& operator=(const ZeCollectorCBSubscriber&) = delete;
-  ZeCollectorCBSubscriber(ZeCollectorCBSubscriber&&) = delete;
-  ZeCollectorCBSubscriber& operator=(ZeCollectorCBSubscriber&&) = delete;
-
-  // Virtual destructor for proper cleanup in derived classes
-  virtual ~ZeCollectorCBSubscriber() = default;
-
-  _pti_callback_subscriber* GetHandle() { return &subscriber_info_; }
-
-  pti_result EnableDomain(pti_callback_domain domain, uint32_t enter_cb, uint32_t exit_cb) {
-    // for now only few specific domains supported
-    if (domain != PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED &&
-        domain != PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED &&
-        domain != PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED &&
-        domain != PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED) {
-      return PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (enter_cb == 0 && exit_cb == 0 && domain != PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED) {
-      return PTI_ERROR_BAD_ARGUMENT;  // at least one should be non-zero
-    }
-    if (subscriber_info_.domains_.find(domain) != subscriber_info_.domains_.end()) {
-      subscriber_info_.domains_[domain].is_enter_enabled = static_cast<bool>(enter_cb);
-      subscriber_info_.domains_[domain].is_exit_enabled = static_cast<bool>(exit_cb);
-      // Domain already enabled, return success
-      return PTI_SUCCESS;
-    }
-    CbDomainProperties properties = {domain, static_cast<bool>(enter_cb),
-                                     static_cast<bool>(exit_cb)};
-    subscriber_info_.domains_[domain] = properties;
-    return PTI_SUCCESS;
-  }
-
-  pti_result DisableDomain(pti_callback_domain domain) {
-    auto it = subscriber_info_.domains_.find(domain);
-    if (it != subscriber_info_.domains_.end()) {
-      subscriber_info_.domains_.erase(it);
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_BAD_ARGUMENT;  // Domain not found
-  }
-
-  pti_result DisableAllDomains() {
-    SPDLOG_TRACE("In {}", __func__);
-    subscriber_info_.domains_.clear();
-    return PTI_SUCCESS;
-  }
-
-  pti_result SetCallback(pti_callback_function callback) {
-    if (callback == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    subscriber_info_.callback_ = callback;
-    return PTI_SUCCESS;
-  }
-
-  pti_callback_function GetCallback() const { return subscriber_info_.callback_; }
-
-  bool IsActive() const {
-    return !subscriber_info_.domains_.empty() && subscriber_info_.callback_ != nullptr;
-  }
-
-  void* GetUserData() const { return subscriber_info_.user_data_; }
-
-  void SetUserData(void* user_data) { subscriber_info_.user_data_ = user_data; }
-
-  void** GetPtrForInstanceUserData() const { return &(subscriber_info_.instance_user_data_); }
-
-  pti_result Clean() {
-    subscriber_info_.callback_ = nullptr;
-    subscriber_info_.user_data_ = nullptr;
-    return DisableAllDomains();
-  }
-
-  bool IsEnabled(pti_callback_domain domain, uint32_t cb_type) const {
-    auto it = subscriber_info_.domains_.find(domain);
-    if (it != subscriber_info_.domains_.end()) {
-      if (cb_type == PTI_CB_PHASE_API_ENTER) {
-        return it->second.is_enter_enabled;
-      } else if (cb_type == PTI_CB_PHASE_API_EXIT) {
-        return it->second.is_exit_enabled;
-      }
-    }
-    return false;
-  }
-
-  static void MapRecordsByContextAndDevice(
-      const std::vector<ZeKernelCommandExecutionRecord>& records, ExecRecordsMap& record_map) {
-    for (const auto& record : records) {
-      // for memory ops device is tricky -- it could be source or destination,
-      // or for D2D - both source and destination - so ask route object who is "main" device
-      auto device_in_memory_op =
-          (record.memory_route_.IsMainDeviceSrc()) ? record.device_ : record.dst_device_;
-      auto key = (record.command_type_ == KernelCommandType::kMemory)
-                     ? std::make_pair(record.context_, device_in_memory_op)
-                     : std::make_pair(record.context_, record.device_);
-      record_map[key].push_back(&record);
-    }
-  }
-
-  static void MakeGPUOpDetailsArray(
-      const std::vector<const ZeKernelCommandExecutionRecord*>& records,
-      std::vector<pti_gpu_op_details>& op_details) {
-    PTI_ASSERT(records.size() == op_details.size());
-
-    for (size_t i = 0; i < records.size(); ++i) {
-      op_details[i]._operation_kind = GetGPUOperationKind(records[i]->command_type_);
-      op_details[i]._operation_id = records[i]->kid_;
-      // temp, until modules & kernels in them supported
-      op_details[i]._kernel_handle = INVALID_KERNEL_HANDLE;
-      op_details[i]._name = records[i]->name_.c_str();
-    }
-  }
-
-  static pti_gpu_operation_kind GetGPUOperationKind(const KernelCommandType& type) {
-    // Map KernelCommandType to pti_gpu_operation_kind
-    // TODO: consider to use the same enum, make it external and then this function not needed
-    switch (type) {
-      case KernelCommandType::kKernel:
-        return PTI_GPU_OPERATION_KIND_KERNEL;
-      case KernelCommandType::kMemory:
-        return PTI_GPU_OPERATION_KIND_MEMORY;
-      case KernelCommandType::kCommand:
-        return PTI_GPU_OPERATION_KIND_OTHER;
-      default:
-        return PTI_GPU_OPERATION_KIND_INVALID;
-    }
-  }
-
- private:
-  _pti_callback_subscriber subscriber_info_;
-};
-
-class SubscribersCollection {
- public:
-  SubscribersCollection() {}
-  SubscribersCollection(const SubscribersCollection&) = delete;
-  SubscribersCollection& operator=(const SubscribersCollection&) = delete;
-  SubscribersCollection(SubscribersCollection&&) = delete;
-  SubscribersCollection& operator=(SubscribersCollection&&) = delete;
-
-  virtual ~SubscribersCollection() {}  // To satisfy Coverity with user-defined destructor
-
-  pti_callback_subscriber_handle AddExternalSubscriber(
-      std::unique_ptr<ZeCollectorCBSubscriber> subscriber) {
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-    bool is_internal = false;
-    return AddSubscriber(std::move(subscriber), is_internal);
-  }
-
-  pti_callback_subscriber_handle AddInternalSubscriber(
-      std::unique_ptr<ZeCollectorCBSubscriber> subscriber) {
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-    bool is_internal = true;
-    return AddSubscriber(std::move(subscriber), is_internal);
-  }
-
-  bool RemoveExternalSubscriber(pti_callback_subscriber_handle handle) {
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-    return RemoveSubscriber(handle);
-  }
-
-  bool RemoveInternalSubscriber(pti_callback_subscriber_handle handle) {
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-    return RemoveSubscriber(handle);
-  }
-
-  const ZeCollectorCBSubscriber* GetSubscriber(pti_callback_subscriber_handle handle) const {
-    const std::shared_lock<std::shared_mutex> lock(lock_);
-    auto it = subscribers_map_.find(handle);
-    if (it != subscribers_map_.end()) {
-      return it->second.get();
-    }
-    return nullptr;
-  }
-
-  std::vector<pti_callback_subscriber_handle> GetAllSubscriberHandles() const {
-    std::shared_lock<std::shared_mutex> lock(lock_);
-    std::vector<pti_callback_subscriber_handle> handles;
-    handles.reserve(subscribers_map_.size());
-    for (const auto& [handle, subscriber] : subscribers_map_) {
-      handles.push_back(handle);
-    }
-    return handles;
-  }
-
-  bool IsAnySubscriberActive() const {
-    std::shared_lock<std::shared_mutex> lock(lock_);
-    for (const auto& kv : subscribers_map_) {
-      if (kv.second && kv.second->IsActive()) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  pti_result EnableCallbackDomain(pti_callback_subscriber_handle handle, pti_callback_domain domain,
-                                  uint32_t enter_cb, uint32_t exit_cb) {
-    std::lock_guard<std::shared_mutex> lock(lock_);
-    if (subscribers_map_.find(handle) != subscribers_map_.end()) {
-      auto subscriber = subscribers_map_[handle].get();
-      PTI_ASSERT(subscriber != nullptr);
-      return subscriber->EnableDomain(domain, enter_cb, exit_cb);
-    }
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;  // Subscriber not found
-  }
-
-  pti_result DisableCallbackDomain(pti_callback_subscriber_handle handle,
-                                   pti_callback_domain domain) {
-    std::lock_guard<std::shared_mutex> lock(lock_);
-    if (subscribers_map_.find(handle) != subscribers_map_.end()) {
-      auto subscriber = subscribers_map_[handle].get();
-      PTI_ASSERT(subscriber != nullptr);
-      return subscriber->DisableDomain(domain);
-    }
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;  // Subscriber not found
-  }
-
-  pti_result DisableAllCallbackDomains(pti_callback_subscriber_handle handle) {
-    std::lock_guard<std::shared_mutex> lock(lock_);
-    if (subscribers_map_.find(handle) != subscribers_map_.end()) {
-      auto subscriber = subscribers_map_[handle].get();
-      PTI_ASSERT(subscriber != nullptr);
-      return subscriber->DisableAllDomains();
-    }
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;  // Subscriber not found
-  }
-
-  size_t GetSubscriberCount() const {
-    const std::shared_lock<std::shared_mutex> lock(lock_);
-    return subscribers_map_.size();
-  }
-
-  auto begin() { return subscribers_list_.begin(); }
-  auto end() { return subscribers_list_.end(); }
-
- private:
-  pti_callback_subscriber_handle AddSubscriber(std::unique_ptr<ZeCollectorCBSubscriber> subscriber,
-                                               bool is_internal) {
-    // lock in a caller
-    if (subscriber == nullptr) {
-      return CB_SUBSCRIBER_HANDLE_INVALID;
-    }
-    auto handle = subscriber->GetHandle();
-    auto it = std::find(subscribers_list_.begin(), subscribers_list_.end(), handle);
-    if (it != subscribers_list_.end()) {
-      // something wrong, subscriber already in the list
-      PTI_ASSERT(subscribers_map_.find(handle) != subscribers_map_.end());
-      return CB_SUBSCRIBER_HANDLE_INVALID;  // Subscriber already exists
-    }
-    PTI_ASSERT(subscribers_map_.find(handle) == subscribers_map_.end());
-    if (is_internal) {
-      subscribers_list_.push_back(handle);
-    } else {
-      subscribers_list_.push_front(handle);
-    }
-    subscribers_map_.insert({handle, std::move(subscriber)});
-    return handle;
-  }
-
-  bool RemoveSubscriber(pti_callback_subscriber_handle handle) {
-    // lock in a caller
-    auto it = std::find(subscribers_list_.begin(), subscribers_list_.end(), handle);
-    if (it != subscribers_list_.end()) {
-      PTI_ASSERT(subscribers_map_.find(handle) != subscribers_map_.end());
-      subscribers_list_.erase(it);
-      subscribers_map_.erase(handle);
-      return true;
-    }
-    PTI_ASSERT(subscribers_map_.find(handle) == subscribers_map_.end());
-    return false;
-  }
-
-  //  PTI subscribers
-  // list ensures subscribers will be called in an order they were added
-  std::list<pti_callback_subscriber_handle> subscribers_list_;
-
-  std::unordered_map<pti_callback_subscriber_handle, std::unique_ptr<ZeCollectorCBSubscriber>>
-      subscribers_map_;
-  mutable std::shared_mutex lock_;
-};
-
-#endif
diff --git a/sdk/src/levelzero/ze_command_visitor.cc b/sdk/src/levelzero/ze_command_visitor.cc
deleted file mode 100644
index e2961d93..00000000
--- a/sdk/src/levelzero/ze_command_visitor.cc
+++ /dev/null
@@ -1,915 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "ze_command_visitor.h"
-
-#include <level_zero/driver_experimental/zex_visit.h>
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <array>
-#include <stdexcept>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#include "lz_api_tracing_api_loader.h"
-#include "unikernel.h"
-#include "utils.h"
-#include "ze_driver_init.h"
-#include "ze_event_managers.h"
-#include "ze_gpu_command.h"
-#include "ze_local_collection_helpers.h"
-#include "ze_utils.h"
-
-#if defined(PTI_TRACE_SYCL)
-#include "sycl_collector.h"
-#endif
-
-namespace {
-#define ZE_COMMAND(visitor, fn, ...)                 \
-  do {                                               \
-    (visitor)->ZeCommand<fn##_id>(&fn, __VA_ARGS__); \
-  } while (0)
-
-// If the symbol is not found, record internal_error_ and skip re-appending this command; we
-// cannot re-append it to the target command list without the symbol. This makes the visit no longer
-// valid.
-#define ZE_VISITOR_COMMAND(visitor, fn, ...)                 \
-  do {                                                       \
-    auto* symbol = pti::PtiLzTracerLoader::Instance().fn##_; \
-    if (!symbol) {                                           \
-      visitor->internal_error_ = ZE_RESULT_ERROR_UNKNOWN;    \
-      return;                                                \
-    }                                                        \
-    (visitor)->ZeCommand<fn##_id>(symbol, __VA_ARGS__);      \
-  } while (0)
-
-#define APPEND_COMMAND(append_name)                                 \
-  std::make_pair(                                                   \
-      std::string_view{TOSTRING(zeCommandListAppend##append_name)}, \
-      reinterpret_cast<void*>(&ZeCommandVisitor::VisitCommandListAppend##append_name)),  // NOLINT
-
-/* clang-format off */
-auto& GetVisitorTable() {
-  static std::array visitor_table = {
-#include "ze_visitor_commands.inc"
-  };  // NOLINT
-  return visitor_table;
-}
-/* clang-format on */
-#undef APPEND_COMMAND
-
-// Static table of visitors. My thinking is that this should be generated at compile time and treat
-// it like a configuration. Eventually, we can support new configurations with different static
-// tables of visitors. This cannot be compile-time generated yet due to reinterpret_casts (fn ptr ->
-// void*).
-auto* MakeVisitors() {
-  using VisitorTableType = std::decay_t<decltype(GetVisitorTable())>;
-  static auto visitors = []() {
-    std::array<ze_concrete_visitor_ext_desc_t, std::tuple_size_v<VisitorTableType>> visitors_temp =
-        {};
-    std::transform(GetVisitorTable().begin(), GetVisitorTable().end(), visitors_temp.begin(),
-                   [](const auto& str_func) {
-                     return ze_concrete_visitor_ext_desc_t{
-                         ZEX_STRUCTURE_TYPE_CONCRETE_VISITOR_EXT_DESC, nullptr,
-                         str_func.first.data(), str_func.second};
-                   });
-    return visitors_temp;
-  }();
-
-  // repair pNext pointers.
-  [[maybe_unused]] static const bool linked = []() {
-    for (size_t i = 0; i < visitors.size() - 1; ++i) {
-      visitors[i].pNext = visitors.data() + (i + 1);  // NOLINT
-    }
-    return true;
-  }();
-
-  return visitors.data();
-}
-
-template <KernelCommandType CommandType,
-          typename = std::enable_if_t<CommandType != KernelCommandType::kInvalid>>
-inline void GetSyclCollectorData(ZeKernelCommand* command) {
-  if constexpr (CommandType == KernelCommandType::kKernel) {
-    if (sycl_data_kview.cid_) {
-      command->corr_id_ = sycl_data_kview.cid_;
-    } else {
-      command->corr_id_ = UniCorrId::GetUniCorrId();
-#if defined(PTI_TRACE_SYCL)
-      if (SyclCollector::Instance().Enabled()) {
-        sycl_data_kview.cid_ = command->corr_id_;
-      }
-#endif
-    }
-    sycl_data_kview.kid_ = command->kernel_id;
-    sycl_data_kview.tid_ = command->tid;
-    command->sycl_node_id_ = sycl_data_kview.sycl_node_id_;
-    command->sycl_queue_id_ = sycl_data_kview.sycl_queue_id_;
-    command->sycl_invocation_id_ = sycl_data_kview.sycl_invocation_id_;
-    command->sycl_task_begin_time_ = sycl_data_kview.sycl_task_begin_time_;
-    command->sycl_enqk_begin_time_ = sycl_data_kview.sycl_enqk_begin_time_;
-    command->source_file_name_ = sycl_data_kview.source_file_name_;
-    command->source_line_number_ = sycl_data_kview.source_line_number_;
-  } else if constexpr (CommandType == KernelCommandType::kMemory) {
-    if (sycl_data_mview.cid_) {
-      command->corr_id_ = sycl_data_mview.cid_;
-    } else {
-      command->corr_id_ = UniCorrId::GetUniCorrId();
-#if defined(PTI_TRACE_SYCL)
-      if (SyclCollector::Instance().Enabled()) {
-        sycl_data_mview.cid_ = command->corr_id_;
-      }
-#endif
-    }
-
-    sycl_data_mview.kid_ = command->kernel_id;
-    sycl_data_mview.tid_ = command->tid;
-    command->sycl_node_id_ = sycl_data_mview.sycl_node_id_;
-    command->sycl_invocation_id_ = sycl_data_mview.sycl_invocation_id_;
-    command->sycl_task_begin_time_ = sycl_data_mview.sycl_task_begin_time_;
-    command->sycl_queue_id_ = sycl_data_mview.sycl_queue_id_;
-
-    // Some memory operations come in as kernel ops from XPTI.
-    // TODO: Work with XPTI team and investigate
-    if (command->sycl_queue_id_ == PTI_INVALID_QUEUE_ID) {
-      SPDLOG_TRACE("Missing SYCL queue id. Taking from kernel view.");
-      command->sycl_queue_id_ = std::exchange(sycl_data_kview.sycl_queue_id_, PTI_INVALID_QUEUE_ID);
-    }
-    command->source_file_name_ = sycl_data_mview.source_file_name_;
-    command->source_line_number_ = sycl_data_mview.source_line_number_;
-  } else {
-    if (!command
-             ->corr_id_) {  // for synchronization activity commands the corrid is the api corrid.
-      command->corr_id_ =
-          UniCorrId::GetUniCorrId();  // setting here for non-synchronization activity corr_id.
-    }
-  }
-}
-
-template <KernelCommandType CommandType,
-          typename = std::enable_if_t<CommandType != KernelCommandType::kInvalid>>
-[[nodiscard]] auto MakeCommand(ze_command_list_handle_t user_command_list,
-                               const ZeCommandListInfo& command_list_info,
-                               const ZeDeviceDescriptor& device_desc) {
-  auto command = std::make_shared<ZeKernelCommand>();
-  command->props.type = CommandType;
-  command->tid = PidTidInfo::Get().tid;
-  command->kernel_id = UniKernelId::GetKernelId();
-  command->result_ = ZE_RESULT_SUCCESS;
-  command->append_time = ::utils::GetTime();
-  GetSyclCollectorData<CommandType>(command.get());
-  if constexpr (CommandType == KernelCommandType::kKernel) {
-    command->callback_id_ = zeCommandListAppendLaunchKernel_id;
-  } else if constexpr (CommandType == KernelCommandType::kMemory) {
-    command->callback_id_ = zeCommandListAppendMemoryCopy_id;
-  } else if constexpr (CommandType == KernelCommandType::kCommand) {
-    command->callback_id_ = zeCommandListAppendBarrier_id;
-  }
-  command->command_list = user_command_list;
-  command->device = command_list_info.device;
-  command->context = command_list_info.context;
-  command->device_timer_frequency_ = device_desc.device_timer_frequency;
-  command->device_timer_mask_ = device_desc.device_timer_mask;
-  return command;
-}
-
-template <pti_api_id_driver_levelzero OverheadId, typename T, typename Fn>
-std::optional<T> GetCommandListProperty(Fn func, ze_command_list_handle_t command_list) {
-  if (!func) {
-    return std::nullopt;
-  }
-  overhead::ScopedOverheadCollector scoped(OverheadId);
-  T value{};
-  if (func(command_list, &value) != ZE_RESULT_SUCCESS) {
-    return std::nullopt;
-  }
-  return value;
-}
-
-[[nodiscard]] ZeCommandListImmutableInfo GetCommandListImmutableInfo(
-    ze_command_list_handle_t command_list) {
-  auto& loader = pti::PtiLzTracerLoader::Instance();
-  ZeCommandListImmutableInfo info;
-
-  auto immediate = GetCommandListProperty<zeCommandListIsImmediate_id, ze_bool_t>(
-      loader.zeCommandListIsImmediate_, command_list);
-  if (!immediate) {
-    return info;
-  }
-
-  info.immediate = static_cast<bool>(*immediate);
-  if (info.immediate) {
-    info.immediate_flags =
-        GetCommandListProperty<zeCommandListImmediateGetFlags_id, ze_command_queue_flags_t>(
-            loader.zeCommandListImmediateGetFlags_, command_list)
-            .value_or(ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32);
-  } else {
-    info.flags = GetCommandListProperty<zeCommandListGetFlags_id, ze_command_list_flags_t>(
-                     loader.zeCommandListGetFlags_, command_list)
-                     .value_or(ZE_COMMAND_LIST_FLAG_FORCE_UINT32);
-  }
-  return info;
-}
-
-}  // namespace
-
-ZeCommandVisitor::ZeCommandVisitor(ZeExts::Visit visitor_extension,
-                                   ZeEventPoolManager* event_pool_manager)
-    : visitor_extension_(visitor_extension),
-      event_pool_manager_(event_pool_manager),
-      visit_desc_({ZEX_STRUCTURE_TYPE_COMMAND_VISIT_EXT_DESC, MakeVisitors(), this, nullptr,
-                   nullptr, ZE_VISIT_EXT_DEFAULT_OP_REAPPEND, nullptr}),
-      internal_error_(ZE_RESULT_SUCCESS) {
-  if (!event_pool_manager_) {
-    throw std::invalid_argument("Event pool manager cannot be null");
-  }
-  if (!visitor_extension_.ze_command_list_visit || !visitor_extension_.ze_graph_visit) {
-    throw std::invalid_argument("Visitor extension function pointers cannot be null");
-  }
-}
-
-ZeCommandVisitor::Result ZeCommandVisitor::CollectResultAndReset() {
-  visit_desc_.hReappendTargetCmdList = nullptr;
-  current_device_desc_ = {};
-  current_command_list_info_ = {};
-  Result result;
-  result.first = std::exchange(commands_, {});
-  result.second = std::exchange(internal_error_, ZE_RESULT_SUCCESS);
-  if (internal_exception_) {
-    auto internal_exception = std::exchange(internal_exception_, nullptr);
-    std::rethrow_exception(internal_exception);
-  }
-  command_list_info_map_.clear();
-  return result;
-}
-
-bool ZeCommandVisitor::VisitingNativeGraph() const {
-  return visit_desc_.hReappendTargetCmdList == nullptr;
-}
-
-std::optional<ZeCommandVisitor::TimestampInfo> ZeCommandVisitor::AppendQueryTimestamp(
-    ze_command_list_handle_t command_list, ze_event_handle_t event_to_query) {
-  // Avoid `zeCommandListAppendQueryKernelTimestamps` on native graph workloads.
-  if (VisitingNativeGraph()) {
-    return std::make_pair(ZeEventView<ZeEventPool>{}, utils::ze::TimestampBuffer{nullptr});
-  }
-
-  auto buf = utils::ze::MakeTimestampBuffer(current_command_list_info_.context, 1);
-  if (!buf) {
-    SPDLOG_INFO("Failed to create timestamp buffer");
-    internal_error_ = ZE_RESULT_ERROR_UNKNOWN;
-    return std::nullopt;
-  }
-
-  auto timestamp_event = event_pool_manager_->AcquireEvent(current_command_list_info_.context);
-
-  ZE_COMMAND(this, zeCommandListAppendQueryKernelTimestamps, command_list, 1, &event_to_query,
-             buf.get(), nullptr, timestamp_event.Get(), 1, &event_to_query);
-
-  return std::make_pair(std::move(timestamp_event), std::move(buf));
-}
-
-void ZeCommandVisitor::AppendSignalEvent(ze_command_list_handle_t command_list,
-                                         ze_event_handle_t event_to_signal,
-                                         ze_event_handle_t wait_event) {
-  if (!event_to_signal) {
-    return;
-  }
-
-  auto command_list_info_it = command_list_info_map_.find(command_list);
-  if (command_list_info_it == command_list_info_map_.end()) {
-    command_list_info_it =
-        command_list_info_map_.emplace(command_list, GetCommandListImmutableInfo(command_list))
-            .first;
-  }
-
-  bool res = false;
-  if (IsInOrder(command_list_info_it->second)) {
-    res = A2AppendSignalEvent(command_list, event_to_signal);
-  } else {
-    res = A2AppendWaitAndSignalEvent(command_list, event_to_signal, wait_event);
-  }
-
-  if (!res) {
-    SPDLOG_INFO("Failed to append wait and signal for event: {}",
-                static_cast<const void*>(event_to_signal));
-    internal_error_ = ZE_RESULT_ERROR_UNKNOWN;
-  }
-}
-
-ZeCommandVisitor::Result ZeCommandVisitor::Visit(
-    const ZeDeviceDescriptor& device_desc, const ZeCommandListInfo& info,
-    ze_command_list_handle_t command_list, ze_command_list_handle_t instrumented_command_list) {
-  current_device_desc_ = device_desc;
-  current_command_list_info_ = info;
-  visit_desc_.hReappendTargetCmdList = instrumented_command_list;
-  auto result = visitor_extension_.ze_command_list_visit(command_list, &visit_desc_);
-  SPDLOG_TRACE("Visit result: {:x}", static_cast<std::uint32_t>(result));
-  if (HasError() || result != ZE_RESULT_SUCCESS) {
-    SPDLOG_INFO("Failed to visit command list: {:x}",
-                static_cast<std::uint32_t>(result == ZE_RESULT_SUCCESS ? internal_error_ : result));
-    if (internal_error_ == ZE_RESULT_SUCCESS && result != ZE_RESULT_SUCCESS) {
-      internal_error_ = result;
-    }
-    // clear commands to avoid returning partial/corrupted data. However, we still want the result
-    // propagated to the user, so refrain from returning.
-    commands_.clear();
-  }
-  return CollectResultAndReset();
-}
-
-ZeCommandVisitor::Result ZeCommandVisitor::GraphVisit(const ZeDeviceDescriptor& device_desc,
-                                                      const ZeGraphInfo& graph_info,
-                                                      ze_graph_handle_t graph) {
-  current_device_desc_ = device_desc;
-  // Convert graph_info to command list info. For now, its easier to use the graph information for
-  // graphs. This is the relevant information between the two.
-  current_command_list_info_.context = graph_info.context;
-  current_command_list_info_.device = graph_info.device;
-  auto result = visitor_extension_.ze_graph_visit(graph, &visit_desc_);
-  SPDLOG_TRACE("GraphVisit result: {:x}", static_cast<std::uint32_t>(result));
-  if (HasError() || result != ZE_RESULT_SUCCESS) {
-    SPDLOG_INFO("Failed to visit graph: {:x}",
-                static_cast<std::uint32_t>(result == ZE_RESULT_SUCCESS ? internal_error_ : result));
-    if (internal_error_ == ZE_RESULT_SUCCESS && result != ZE_RESULT_SUCCESS) {
-      internal_error_ = result;
-    }
-    // clear commands to avoid returning partial/corrupted data. However, we still want the result
-    // propagated to the user, so refrain from returning.
-    commands_.clear();
-  }
-  return CollectResultAndReset();
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendLaunchKernel(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendLaunchKernel, target_command_list, hKernel,
-               pLaunchFuncArgs, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    auto timestamp_query = visitor->AppendQueryTimestamp(target_command_list, event.Get());
-    if (!timestamp_query) {
-      return;
-    }
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kKernel>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->timestamp_query_event = std::move(timestamp_query->first);
-    visitor->commands_.back()->timestamp = std::move(timestamp_query->second);
-
-    visitor->commands_.back()->props.name = utils::ze::GetKernelName(hKernel, true);
-    visitor->commands_.back()->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(hKernel);
-    if (pLaunchFuncArgs != nullptr) {
-      visitor->commands_.back()->props.group_count[0] = pLaunchFuncArgs->groupCountX;
-      visitor->commands_.back()->props.group_count[1] = pLaunchFuncArgs->groupCountY;
-      visitor->commands_.back()->props.group_count[2] = pLaunchFuncArgs->groupCountZ;
-    }
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendLaunchKernelWithArguments(
-    ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel,
-    const ze_group_count_t groupCounts, const ze_group_size_t groupSizes, void** pArguments,
-    const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-    ze_event_handle_t* phWaitEvents, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_VISITOR_COMMAND(visitor, zeCommandListAppendLaunchKernelWithArguments, target_command_list,
-                       hKernel, groupCounts, groupSizes, pArguments, pNext, event.Get(),
-                       numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    auto timestamp_query = visitor->AppendQueryTimestamp(target_command_list, event.Get());
-    if (!timestamp_query) {
-      return;
-    }
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kKernel>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->timestamp_query_event = std::move(timestamp_query->first);
-    visitor->commands_.back()->timestamp = std::move(timestamp_query->second);
-    visitor->commands_.back()->props.name = utils::ze::GetKernelName(hKernel, true);
-    visitor->commands_.back()->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(hKernel);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendLaunchKernelWithParameters(
-    ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel,
-    const ze_group_count_t* pGroupCounts, const void* pNext, ze_event_handle_t hSignalEvent,
-    uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_VISITOR_COMMAND(visitor, zeCommandListAppendLaunchKernelWithParameters, target_command_list,
-                       hKernel, pGroupCounts, pNext, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    auto timestamp_query = visitor->AppendQueryTimestamp(target_command_list, event.Get());
-    if (!timestamp_query) {
-      return;
-    }
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kKernel>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->timestamp_query_event = std::move(timestamp_query->first);
-    visitor->commands_.back()->timestamp = std::move(timestamp_query->second);
-    visitor->commands_.back()->props.name = utils::ze::GetKernelName(hKernel, true);
-    visitor->commands_.back()->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(hKernel);
-    if (pGroupCounts != nullptr) {
-      visitor->commands_.back()->props.group_count[0] = pGroupCounts->groupCountX;
-      visitor->commands_.back()->props.group_count[1] = pGroupCounts->groupCountY;
-      visitor->commands_.back()->props.group_count[2] = pGroupCounts->groupCountZ;
-    }
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendLaunchCooperativeKernel(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendLaunchCooperativeKernel, target_command_list, hKernel,
-               pLaunchFuncArgs, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    auto timestamp_query = visitor->AppendQueryTimestamp(target_command_list, event.Get());
-    if (!timestamp_query) {
-      return;
-    }
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kKernel>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->timestamp_query_event = std::move(timestamp_query->first);
-    visitor->commands_.back()->timestamp = std::move(timestamp_query->second);
-    visitor->commands_.back()->props.name = utils::ze::GetKernelName(hKernel, true);
-    visitor->commands_.back()->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(hKernel);
-    if (pLaunchFuncArgs != nullptr) {
-      visitor->commands_.back()->props.group_count[0] = pLaunchFuncArgs->groupCountX;
-      visitor->commands_.back()->props.group_count[1] = pLaunchFuncArgs->groupCountY;
-      visitor->commands_.back()->props.group_count[2] = pLaunchFuncArgs->groupCountZ;
-    }
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendLaunchKernelIndirect(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendLaunchKernelIndirect, target_command_list, hKernel,
-               pLaunchArgumentsBuffer, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    auto timestamp_query = visitor->AppendQueryTimestamp(target_command_list, event.Get());
-    if (!timestamp_query) {
-      return;
-    }
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kKernel>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->timestamp_query_event = std::move(timestamp_query->first);
-    visitor->commands_.back()->timestamp = std::move(timestamp_query->second);
-    visitor->commands_.back()->props.name = utils::ze::GetKernelName(hKernel, true);
-    visitor->commands_.back()->props.simd_width = utils::ze::GetKernelMaxSubgroupSize(hKernel);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendMemoryCopy(
-    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,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendMemoryCopy, target_command_list, dstptr, srcptr, size,
-               event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props =
-        GetTransferProps("zeCommandListAppendMemoryCopy", size, (srcptr ? context : nullptr),
-                         srcptr, (dstptr ? context : nullptr), dstptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendMemoryFill(
-    ze_command_list_handle_t hCommandList, void* ptr, const void* pattern, size_t pattern_size,
-    size_t size, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-    ze_event_handle_t* phWaitEvents, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendMemoryFill, target_command_list, ptr, pattern,
-               pattern_size, size, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props =
-        GetTransferProps("zeCommandListAppendMemoryFill", size, (pattern ? context : nullptr),
-                         pattern, (ptr ? context : nullptr), ptr, pattern_size);
-    visitor->commands_.back()->callback_id_ = zeCommandListAppendMemoryFill_id;
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendMemoryCopyRegion(
-    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,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendMemoryCopyRegion, target_command_list, dstptr, dstRegion,
-               dstPitch, dstSlicePitch, srcptr, srcRegion, srcPitch, srcSlicePitch, event.Get(),
-               numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    size_t bytes_transferred = 0;
-    if (srcRegion != nullptr) {
-      bytes_transferred = srcRegion->width * srcRegion->height * srcPitch;
-      if (srcRegion->depth != 0) {
-        bytes_transferred *= srcRegion->depth;
-      }
-    }
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props = GetTransferProps(
-        "zeCommandListAppendMemoryCopyRegion", bytes_transferred, (srcptr ? context : nullptr),
-        srcptr, (dstptr ? context : nullptr), dstptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendMemoryCopyFromContext(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendMemoryCopyFromContext, target_command_list, dstptr,
-               hContextSrc, srcptr, size, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props = GetTransferProps("zeCommandListAppendMemoryCopyFromContext",
-                                                        size, hContextSrc, srcptr, context, dstptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopy(
-    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,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendImageCopy, target_command_list, hDstImage, hSrcImage,
-               event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    // Image size lives in the collector's image_size_map_, which the visitor cannot reach,
-    // so bytes_transferred stays 0 (see ze_command_visitor_todo.md). GetTransferProps still
-    // derives the route/device info from any host pointers (none here for image-to-image).
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props =
-        GetTransferProps("zeCommandListAppendImageCopy", 0, context, nullptr, context, nullptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopyRegion(
-    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,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendImageCopyRegion, target_command_list, hDstImage,
-               hSrcImage, pDstRegion, pSrcRegion, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    // bytes_transferred requires the collector's image_size_map_ (unavailable here); leave 0.
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props = GetTransferProps("zeCommandListAppendImageCopyRegion", 0,
-                                                        context, nullptr, context, nullptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopyToMemory(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendImageCopyToMemory, target_command_list, dstptr,
-               hSrcImage, pSrcRegion, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    // Source image size lives in the collector's image_size_map_ (unavailable here); leave
-    // bytes_transferred 0. The route/dst device are still derived from the host dst pointer.
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props = GetTransferProps("zeCommandListAppendImageCopyToMemory", 0,
-                                                        context, nullptr, context, dstptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopyFromMemory(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendImageCopyFromMemory, target_command_list, hDstImage,
-               srcptr, pDstRegion, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    size_t bytes_transferred = 0;
-    if (pDstRegion != nullptr) {
-      bytes_transferred = pDstRegion->width * pDstRegion->height;
-      if (pDstRegion->depth != 0) {
-        bytes_transferred *= pDstRegion->depth;
-      }
-    }
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props =
-        GetTransferProps("zeCommandListAppendImageCopyFromMemory", bytes_transferred,
-                         (srcptr ? context : nullptr), srcptr, context, nullptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopyToMemoryExt(
-    ze_command_list_handle_t hCommandList, void* dstptr, ze_image_handle_t hSrcImage,
-    const ze_image_region_t* pSrcRegion, uint32_t destRowPitch, uint32_t destSlicePitch,
-    ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_VISITOR_COMMAND(visitor, zeCommandListAppendImageCopyToMemoryExt, target_command_list,
-                       dstptr, hSrcImage, pSrcRegion, destRowPitch, destSlicePitch, event.Get(),
-                       numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    // Mirrors zeCommandListAppendImageCopyToMemory: source image size lives in the collector's
-    // image_size_map_ (unavailable here), so bytes_transferred stays 0; route/dst device are
-    // still derived from the host dst pointer.
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props = GetTransferProps("zeCommandListAppendImageCopyToMemoryExt",
-                                                        0, context, nullptr, context, dstptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendImageCopyFromMemoryExt(
-    ze_command_list_handle_t hCommandList, ze_image_handle_t hDstImage, const void* srcptr,
-    const ze_image_region_t* pDstRegion, uint32_t srcRowPitch, uint32_t srcSlicePitch,
-    ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents,
-    void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_VISITOR_COMMAND(visitor, zeCommandListAppendImageCopyFromMemoryExt, target_command_list,
-                       hDstImage, srcptr, pDstRegion, srcRowPitch, srcSlicePitch, event.Get(),
-                       numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kMemory>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    // Mirrors zeCommandListAppendImageCopyFromMemory: bytes from the destination region geometry.
-    size_t bytes_transferred = 0;
-    if (pDstRegion != nullptr) {
-      bytes_transferred = pDstRegion->width * pDstRegion->height;
-      if (pDstRegion->depth != 0) {
-        bytes_transferred *= pDstRegion->depth;
-      }
-    }
-    const auto context = visitor->current_command_list_info_.context;
-    visitor->commands_.back()->props =
-        GetTransferProps("zeCommandListAppendImageCopyFromMemoryExt", bytes_transferred,
-                         (srcptr ? context : nullptr), srcptr, context, nullptr);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendEventReset(
-    ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendEventReset, target_command_list, hEvent);
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendBarrier(
-    ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-    ze_event_handle_t* phWaitEvents, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendBarrier, target_command_list, event.Get(), numWaitEvents,
-               phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kCommand>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->props.name = "zeCommandListAppendBarrier";
-    visitor->commands_.back()->num_wait_events = numWaitEvents;
-    visitor->commands_.back()->callback_id_ = zeCommandListAppendBarrier_id;
-  });
-}
-
-ze_result_t VISITOR_CCONV ZeCommandVisitor::VisitCommandListAppendMemoryRangesBarrier(
-    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, void* userData) {
-  auto* visitor = static_cast<ZeCommandVisitor*>(userData);
-  return ExceptionHandler(visitor, __func__, [&] {
-    auto event =
-        visitor->event_pool_manager_->AcquireEvent(visitor->current_command_list_info_.context);
-
-    auto* target_command_list = visitor->visit_desc_.hReappendTargetCmdList
-                                    ? visitor->visit_desc_.hReappendTargetCmdList
-                                    : hCommandList;
-
-    ZE_COMMAND(visitor, zeCommandListAppendMemoryRangesBarrier, target_command_list, numRanges,
-               pRangeSizes, pRanges, event.Get(), numWaitEvents, phWaitEvents);
-    visitor->AppendSignalEvent(target_command_list, hSignalEvent, event.Get());
-
-    visitor->commands_.emplace_back(MakeCommand<KernelCommandType::kCommand>(
-        hCommandList, visitor->current_command_list_info_, visitor->current_device_desc_));
-    visitor->commands_.back()->event_self = hSignalEvent ? hSignalEvent : event.Get();
-    visitor->commands_.back()->event_swap = std::move(event);
-    visitor->commands_.back()->props.name = "zeCommandListAppendMemoryRangesBarrier";
-    visitor->commands_.back()->num_wait_events = numWaitEvents;
-    visitor->commands_.back()->callback_id_ = zeCommandListAppendMemoryRangesBarrier_id;
-  });
-}
-
-#undef ZE_VISITOR_COMMAND
-#undef ZE_COMMAND
diff --git a/sdk/src/levelzero/ze_command_visitor.h b/sdk/src/levelzero/ze_command_visitor.h
deleted file mode 100644
index 8c9bc4d4..00000000
--- a/sdk/src/levelzero/ze_command_visitor.h
+++ /dev/null
@@ -1,196 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_LEVELZERO_ZE_COMMAND_VISITOR_H_
-#define PTI_LEVELZERO_ZE_COMMAND_VISITOR_H_
-
-#include <level_zero/driver_experimental/zex_visit.h>
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <exception>
-#include <memory>
-#include <optional>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "overhead_kinds.h"
-#include "pti_assert.h"
-#include "ze_driver_init.h"
-#include "ze_event_managers.h"
-#include "ze_gpu_command.h"
-
-struct ZeCommandListImmutableInfo {
-  bool immediate = false;
-  ze_command_list_flags_t flags = ZE_COMMAND_LIST_FLAG_FORCE_UINT32;
-  ze_command_queue_flags_t immediate_flags = ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32;
-};
-
-class ZeCommandVisitor {
- public:
-  using Self = ZeCommandVisitor;
-  using Command = std::shared_ptr<ZeKernelCommand>;
-  using Commands = std::vector<Command>;
-  using Result = std::pair<Commands, ze_result_t>;
-  // Timestamp event & buffer
-  using TimestampInfo = std::pair<ZeEventView<ZeEventPool>, utils::ze::TimestampBuffer>;
-
-  ZeCommandVisitor(ZeExts::Visit visitor_extension, ZeEventPoolManager* event_pool_manager);
-
-  [[nodiscard]] Result Visit(const ZeDeviceDescriptor& device_desc,
-                             const ZeCommandListInfo& command_list_info,
-                             ze_command_list_handle_t command_list,
-                             ze_command_list_handle_t instrumented_command_list);
-
-  [[nodiscard]] Result GraphVisit(const ZeDeviceDescriptor& device_desc,
-                                  const ZeGraphInfo& graph_info, ze_graph_handle_t graph);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendLaunchKernel(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendLaunchKernelWithArguments(
-      ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel,
-      const ze_group_count_t groupCounts, const ze_group_size_t groupSizes, void** pArguments,
-      const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-      ze_event_handle_t* phWaitEvents, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendLaunchKernelWithParameters(
-      ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel,
-      const ze_group_count_t* pGroupCounts, const void* pNext, ze_event_handle_t hSignalEvent,
-      uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendLaunchCooperativeKernel(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendLaunchKernelIndirect(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendMemoryCopy(
-      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,
-      void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendMemoryFill(
-      ze_command_list_handle_t hCommandList, void* ptr, const void* pattern, size_t pattern_size,
-      size_t size, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-      ze_event_handle_t* phWaitEvents, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendMemoryCopyRegion(
-      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,
-      void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendMemoryCopyFromContext(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopy(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopyRegion(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopyToMemory(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopyFromMemory(
-      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, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopyToMemoryExt(
-      ze_command_list_handle_t hCommandList, void* dstptr, ze_image_handle_t hSrcImage,
-      const ze_image_region_t* pSrcRegion, uint32_t destRowPitch, uint32_t destSlicePitch,
-      ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents,
-      void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendImageCopyFromMemoryExt(
-      ze_command_list_handle_t hCommandList, ze_image_handle_t hDstImage, const void* srcptr,
-      const ze_image_region_t* pDstRegion, uint32_t srcRowPitch, uint32_t srcSlicePitch,
-      ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents,
-      void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendEventReset(
-      ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendBarrier(
-      ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-      ze_event_handle_t* phWaitEvents, void* userData);
-
-  static ze_result_t VISITOR_CCONV VisitCommandListAppendMemoryRangesBarrier(
-      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, void* userData);
-
-  constexpr bool HasError() const { return internal_error_ != ZE_RESULT_SUCCESS; }
-
- private:
-  bool VisitingNativeGraph() const;
-
-  Result CollectResultAndReset();
-
-  template <pti_api_id_driver_levelzero OverheadId, typename Fn, typename... Args>
-  void ZeCommand(Fn func, Args&&... args) {
-    overhead::ScopedOverheadCollector scoped(OverheadId);
-    auto result = func(std::forward<Args>(args)...);
-    if (result != ZE_RESULT_SUCCESS) {
-      SPDLOG_ERROR("Command {} failed with result: {:x}", PTI_FUNCTION_NAME,
-                   static_cast<std::uint32_t>(result));
-      internal_error_ = result;
-    }
-  }
-
-  template <typename T>
-  static ze_result_t ExceptionHandler(Self* visitor, const char* function_name, T&& function) {
-    try {
-      std::forward<T>(function)();
-      return ZE_RESULT_SUCCESS;
-    } catch (const std::exception& ex) {
-      SPDLOG_ERROR("Exception in {} : {}", function_name, ex.what());
-    } catch (...) {
-      SPDLOG_ERROR("Unknown Exception in {}", function_name);
-    }
-    visitor->internal_error_ = ZE_RESULT_ERROR_UNKNOWN;
-    visitor->internal_exception_ = std::current_exception();
-    return ZE_RESULT_SUCCESS;  // This return value is the return value of the callback, passed to
-                               // the driver. Afaik, its unused.
-  }
-
-  std::optional<TimestampInfo> AppendQueryTimestamp(ze_command_list_handle_t command_list,
-                                                    ze_event_handle_t event_to_query);
-
-  void AppendSignalEvent(ze_command_list_handle_t command_list, ze_event_handle_t event_to_signal,
-                         ze_event_handle_t wait_event);
-
-  ZeExts::Visit visitor_extension_;
-  ZeEventPoolManager* event_pool_manager_;
-  ze_visit_ext_desc_t visit_desc_;
-  ze_result_t internal_error_;
-  std::exception_ptr internal_exception_ = nullptr;
-  Commands commands_;
-  ZeCommandListInfo current_command_list_info_;
-  ZeDeviceDescriptor current_device_desc_;
-  std::unordered_map<ze_command_list_handle_t, ZeCommandListImmutableInfo> command_list_info_map_;
-};
-
-#endif  // PTI_LEVELZERO_ZE_COMMAND_VISITOR_H_
diff --git a/sdk/src/levelzero/ze_driver_init.cc b/sdk/src/levelzero/ze_driver_init.cc
deleted file mode 100644
index e385a565..00000000
--- a/sdk/src/levelzero/ze_driver_init.cc
+++ /dev/null
@@ -1,205 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "ze_driver_init.h"
-
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <optional>
-#include <tuple>
-#include <vector>
-
-#include "lz_api_tracing_api_loader.h"
-#include "overhead_kinds.h"
-#include "pti_assert.h"
-#include "utils.h"
-#include "ze_utils.h"
-
-namespace {
-// The Level Zero Loader version with a fully functional zeInitDrivers.
-// Versions prior to this one have bugs (or don't have it at all).
-// zeInitDrivers is the preferred method for initializing drivers from this point on.
-constexpr zel_version_t kProperLoaderVersionForZeInitDrivers = {1, 19, 2};
-
-// Environment variable that determines whether to call zesInit.
-//
-// This is needed to allow users to disable zesInit if they want or if oneAPI changes the default
-// behavior in the future, we can still have a way to fix it.
-//
-// PTI_SYSMAN_ZESINIT=0 not not call zesInit.
-// PTI_SYSMAN_ZESINIT=1 call zesInit.
-// unset - default to oneAPI behavior, calling it on BMG and later platforms.
-constexpr const char* const kCallZesInitEnv = "PTI_SYSMAN_ZESINIT";
-
-std::optional<bool> GetZesInitEnv() {
-  auto env_value = utils::GetEnv(kCallZesInitEnv);
-  if (env_value.empty()) {
-    return std::nullopt;
-  }
-  if (env_value == "1") {
-    return true;
-  }
-  if (env_value == "0") {
-    return false;
-  }
-  return std::nullopt;
-}
-
-inline bool operator>=(const zel_version_t& left, const zel_version_t& right) {
-  bool same_major_version = left.major == right.major;
-  return (same_major_version && left.minor > right.minor) ||
-         (same_major_version && left.minor == right.minor && left.patch >= right.patch) ||
-         (left.major > right.major);
-}
-
-ze_result_t ZeInitDrivers(uint32_t* driver_count, ze_driver_handle_t* drivers,
-                          ze_init_driver_type_desc_t* desc) {
-  if (pti::PtiLzTracerLoader::Instance().zeInitDrivers_) {
-    overhead::ScopedOverheadCollector scoped_collector(zeInitDrivers_id);
-    return pti::PtiLzTracerLoader::Instance().zeInitDrivers_(driver_count, drivers, desc);
-  }
-  return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-bool ProperLoaderforZeInitDrivers() {
-  auto loader_version = utils::ze::GetLoaderVersion();
-  if (!loader_version) {
-    return false;
-  }
-  SPDLOG_DEBUG("Loader version: {}.{}.{}.", loader_version->major, loader_version->minor,
-               loader_version->patch);
-  return *loader_version >= kProperLoaderVersionForZeInitDrivers;
-}
-
-void CheckLegacyDriverVersion(const std::vector<ze_driver_handle_t>& drivers) {
-  auto version = utils::ze::GetVersion(drivers);
-  SPDLOG_INFO("Driver version major: {}, minor: {}", ZE_MAJOR_VERSION(version),
-              ZE_MINOR_VERSION(version));
-  PTI_ASSERT(ZE_MAJOR_VERSION(version) > 1 ||
-             (ZE_MAJOR_VERSION(version) == 1 && ZE_MINOR_VERSION(version) >= 3));
-}
-
-bool InitLegacyDrivers() {
-  overhead::Init();
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-  overhead_fini(zeInit_id);
-  bool result = (status == ZE_RESULT_SUCCESS);
-  if (!result) {
-    SPDLOG_WARN("zeInit returned: {}.", static_cast<uint32_t>(status));
-    return false;
-  }
-  return result;
-}
-}  // namespace
-
-ZeDriverInit::ZeDriverInit() : init_success_(InitLegacyDrivers()) {
-  CollectLegacyDrivers();
-  CheckLegacyDriverVersion(drivers_);
-  if (ProperLoaderforZeInitDrivers()) {
-    // If legacy driver initialization failed, the current way. Don't immediately fail.
-    if (InitDrivers()) {
-      init_success_ = true;
-    }
-  }
-  if (init_success_) {
-    InitSysmanDrivers();
-  }
-  CollectExtensions(drivers_);
-}
-
-bool ZeDriverInit::Success() const { return init_success_; }
-
-const std::vector<ze_driver_handle_t>& ZeDriverInit::Drivers() const { return drivers_; }
-
-std::vector<ze_driver_handle_t>& ZeDriverInit::Drivers() { return drivers_; }
-
-bool ZeDriverInit::InitDrivers() {
-  std::uint32_t drv_cnt = 0;
-  ze_init_driver_type_desc_t desc{};
-  desc.stype = ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC;
-  desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU;
-  desc.pNext = nullptr;
-  auto status = ZeInitDrivers(&drv_cnt, nullptr, &desc);
-
-  bool result = (status == ZE_RESULT_SUCCESS);
-
-  if (!result) {
-    SPDLOG_INFO("ZeInitDrivers returned: {}.", static_cast<uint32_t>(status));
-    return result;
-  }
-
-  std::vector<ze_driver_handle_t> driver_list(static_cast<size_t>(drv_cnt));
-
-  status = ZeInitDrivers(&drv_cnt, driver_list.data(), &desc);
-  result = (status == ZE_RESULT_SUCCESS);
-
-  if (!result) {
-    SPDLOG_INFO("ZeInitDrivers returned: {}.", static_cast<uint32_t>(status));
-    return result;
-  }
-
-  for (auto* driver : driver_list) {
-    drivers_.push_back(driver);
-  }
-
-  return result;
-}
-
-void ZeDriverInit::CollectLegacyDrivers() { drivers_ = utils::ze::GetDriverList(); }
-
-void ZeDriverInit::InitSysmanDrivers() {
-  auto call_zesinit_env = GetZesInitEnv();
-
-  // As of oneAPI 2025.1, zesInit will be called for BMG/LNL and later platforms. Until now,
-  // pti_view has not required the Sysman API. However, without this, subsequent calls to zesInit
-  // will disable tracing for users.
-  // The SYCL runtime will call zesInit on BMG and later platforms if zesDriverGetDeviceByUuid
-  // symbol is available. We will mirror this behavior due to potential compatibility issues with
-  // other oneAPI components.
-  //
-  // zesInit is only supported on platforms newer than PVC.
-  //
-  // See specifics regarding Sysman / zes* compatibility below:
-  // https://github.com/intel/compute-runtime/blob/master/programmers-guide/SYSMAN.md
-  bool call_zesinit = false;
-  if (!call_zesinit_env) {
-    if (pti::PtiLzTracerLoader::Instance().zesDriverGetDeviceByUuidExp_) {
-      if (utils::ze::ContainsDeviceWithAtLeastIpVersion(drivers_, utils::ze::kBmgIpVersion)) {
-        call_zesinit = true;
-      }
-    }
-  } else {
-    call_zesinit = *call_zesinit_env;
-  }
-  if (call_zesinit) {
-    constexpr zes_init_flags_t kZesInitFlags = 0;
-    if (zesInit(kZesInitFlags) != ZE_RESULT_SUCCESS) {
-      // If this fails, likely zesInit is not supported by the platform. However, logging it is
-      // useful for debugging (exploring the scenario mentioned).
-      SPDLOG_INFO(
-          "zesInit failed, tracing state might be disabled after another call to a oneAPI "
-          "component or driver");
-    }
-  }
-}
-
-template <typename T>
-void ProcessExt(ze_driver_handle_t driver, T& ext) {
-  ext = T::value_type::Load(driver);
-}
-
-void ZeDriverInit::CollectExtensions(const std::vector<ze_driver_handle_t>& drivers) {
-  for (auto* driver : drivers) {
-    ZeExts exts{};
-    std::apply([driver](auto&... args) { (ProcessExt(driver, args), ...); }, exts.extensions);
-
-    driver_extension_fns_[driver] = exts;
-  }
-}
diff --git a/sdk/src/levelzero/ze_driver_init.h b/sdk/src/levelzero/ze_driver_init.h
deleted file mode 100644
index 3f5baed9..00000000
--- a/sdk/src/levelzero/ze_driver_init.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef LEVEL_ZERO_ZE_DRIVER_INIT_H_
-#define LEVEL_ZERO_ZE_DRIVER_INIT_H_
-
-#include <level_zero/ze_api.h>
-
-#include <optional>
-#include <unordered_map>
-#include <vector>
-
-#include "ze_extensions.h"
-
-class ZeDriverInit {
- public:
-  ZeDriverInit();
-
-  bool Success() const;
-
-  const std::vector<ze_driver_handle_t>& Drivers() const;
-
-  std::vector<ze_driver_handle_t>& Drivers();
-
-  template <typename T>
-  std::optional<T> GetExtension(ze_driver_handle_t driver) const {
-    auto ext_it = driver_extension_fns_.find(driver);
-    if (ext_it == driver_extension_fns_.end()) {
-      return std::nullopt;
-    }
-    return std::get<std::optional<T>>(ext_it->second.extensions);
-  }
-
- private:
-  bool InitDrivers();
-  void CollectLegacyDrivers();
-  void InitSysmanDrivers();
-  void CollectExtensions(const std::vector<ze_driver_handle_t>& drivers);
-
-  bool init_success_ = false;
-  std::vector<ze_driver_handle_t> drivers_;
-  std::unordered_map<ze_driver_handle_t, ZeExts> driver_extension_fns_;
-};
-
-#endif  // LEVEL_ZERO_ZE_DRIVER_INIT_H_
diff --git a/sdk/src/levelzero/ze_event_cache.h b/sdk/src/levelzero/ze_event_cache.h
deleted file mode 100644
index d4739200..00000000
--- a/sdk/src/levelzero/ze_event_cache.h
+++ /dev/null
@@ -1,212 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
-#define PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
-
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <map>
-#include <mutex>
-#include <vector>
-
-#include "overhead_kinds.h"
-#include "pti_assert.h"
-
-#define EVENT_POOL_SIZE 1024
-
-struct ZeEventInfo {
-  ze_event_pool_handle_t pool;
-  ze_context_handle_t context;
-};
-
-class ZeEventCache {
- public:
-  explicit ZeEventCache(ze_event_pool_flags_t flags) : flags_(flags) {}
-
-  ZeEventCache(const ZeEventCache&) = delete;
-  ZeEventCache& operator=(const ZeEventCache&) = delete;
-  ZeEventCache(ZeEventCache&&) = delete;
-  ZeEventCache& operator=(ZeEventCache&&) = delete;
-
-  virtual ~ZeEventCache() {
-    const std::lock_guard<std::mutex> lock(lock_);
-    for (auto& value : event_map_) {
-      for (auto* event : value.second) {
-        ze_result_t status = ZE_RESULT_SUCCESS;
-        overhead::Init();
-        status = zeEventDestroy(event);
-        overhead_fini(zeEventDestroy_id);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_INFO("zeEventDestroy failed with status: {:x}", static_cast<uint32_t>(status));
-        }
-      }
-    }
-    for (auto& value : event_pools_) {
-      for (auto* pool : value.second) {
-        overhead::Init();
-        ze_result_t status = zeEventPoolDestroy(pool);
-        overhead_fini(zeEventPoolDestroy_id);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_INFO("zeEventPoolDestroy failed with status: {:x}", static_cast<uint32_t>(status));
-        }
-      }
-    }
-  }
-
-  bool QueryEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return false;
-    }
-
-    const std::lock_guard<std::mutex> lock(lock_);
-    auto info = event_info_map_.find(event);
-    if (info == event_info_map_.end()) {
-      return false;
-    }
-
-    return true;
-  }
-
-  ze_event_handle_t GetEvent(ze_context_handle_t context) {
-    PTI_ASSERT(context != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-    ze_event_handle_t event = nullptr;
-
-    auto result = event_map_.find(context);
-    if (result == event_map_.end()) {
-      result = event_map_.emplace(std::make_pair(context, std::vector<ze_event_handle_t>())).first;
-    }
-
-    if (result->second.empty()) {
-      ze_result_t status = ZE_RESULT_SUCCESS;
-
-      ze_event_pool_flags_t flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | flags_;
-      ze_event_pool_desc_t pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr, flags,
-                                        EVENT_POOL_SIZE};
-      ze_event_pool_handle_t pool = nullptr;
-      overhead::Init();
-      status = zeEventPoolCreate(context, &pool_desc, 0, nullptr, &pool);
-      overhead_fini(zeEventPoolCreate_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      auto pool_iter = event_pools_.find(context);
-      if (pool_iter == event_pools_.end()) {
-        pool_iter =
-            event_pools_.emplace(std::make_pair(context, std::vector<ze_event_pool_handle_t>()))
-                .first;
-      }
-      pool_iter->second.push_back(pool);
-
-      for (uint32_t i = 0; i < EVENT_POOL_SIZE; i++) {
-        ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, i,
-                                      ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-        overhead::Init();
-        status = zeEventCreate(pool, &event_desc, &event);
-        overhead_fini(zeEventCreate_id);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        PTI_ASSERT(event_info_map_.count(event) == 0);
-        event_info_map_[event] = context;
-        result->second.push_back(event);
-      }
-    }
-
-    event = result->second.back();
-    result->second.pop_back();
-    /* on Windows with oneAPI 2025.3.1 zeEventQueryStatus returned ZE_SUCCESS - not sure why,
-    // although this check is redundant and could be omitted
-    overhead::Init();
-    PTI_ASSERT(zeEventQueryStatus(event) == ZE_RESULT_NOT_READY);
-    overhead_fini(zeEventQueryStatus_id);
-    */
-    return event;
-  }
-
-  void ResetEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return;
-    }
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    auto info = event_info_map_.find(event);
-    if (info != event_info_map_.end()) {
-      overhead::Init();
-      ze_result_t status = zeEventHostReset(event);
-      overhead_fini(zeEventHostReset_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-  }
-
-  void ReleaseEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return;
-    }
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    // get context by event
-    auto info = event_info_map_.find(event);
-    if (info == event_info_map_.end()) {
-      return;
-    }
-
-    // event vector by the context
-    auto result = event_map_.find(info->second);
-    PTI_ASSERT(result != event_map_.end());
-    if (result != event_map_.end()) {
-      overhead::Init();
-      ze_result_t status = zeEventHostReset(event);
-      overhead_fini(zeEventHostReset_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      // returning event to vector of available events
-      result->second.push_back(event);
-    }
-  }
-
-  void ReleaseContext(ze_context_handle_t context) {
-    PTI_ASSERT(context != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    // all events in the context should already be released
-    auto result = event_map_.find(context);
-    if (result != event_map_.end()) {
-      auto iter = event_pools_.find(context);
-      if (iter != event_pools_.end()) {
-        if (result->second.size() == (EVENT_POOL_SIZE * iter->second.size())) {
-          for (auto* event : result->second) {
-            ze_result_t status = ZE_RESULT_SUCCESS;
-            overhead::Init();
-            status = zeEventDestroy(event);
-            overhead_fini(zeEventDestroy_id);
-            PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-            event_info_map_.erase(event);
-          }
-
-          event_map_.erase(result);
-
-          for (auto* pool : iter->second) {
-            ze_result_t status = ZE_RESULT_SUCCESS;
-            overhead::Init();
-            status = zeEventPoolDestroy(pool);
-            overhead_fini(zeEventPoolDestroy_id);
-            PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-          }
-          event_pools_.erase(iter);
-        }
-      }
-    }
-  }
-
- private:
-  ze_event_pool_flags_t flags_ = 0;
-  std::map<ze_context_handle_t, std::vector<ze_event_handle_t> > event_map_;
-  std::map<ze_event_handle_t, ze_context_handle_t> event_info_map_;
-  std::map<ze_context_handle_t, std::vector<ze_event_pool_handle_t> > event_pools_;
-  std::mutex lock_;
-};
-
-#endif  // PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
diff --git a/sdk/src/levelzero/ze_event_managers.h b/sdk/src/levelzero/ze_event_managers.h
deleted file mode 100644
index 779cae96..00000000
--- a/sdk/src/levelzero/ze_event_managers.h
+++ /dev/null
@@ -1,251 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef LEVELZERO_ZE_EVENT_MANAGERS_H_
-#define LEVELZERO_ZE_EVENT_MANAGERS_H_
-
-#include <assert.h>
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-
-#include "overhead_kinds.h"
-#include "pti/pti_driver_levelzero_api_ids.h"
-#include "pti_assert.h"
-
-template <typename T>
-class ZeEventView {
- public:
-  ZeEventView() : event_(nullptr), event_pool_(nullptr), index_(0) {}
-
-  ZeEventView(ze_event_handle_t event, T* event_pool, uint32_t idx)
-      : event_(event), event_pool_(event_pool), index_(idx) {}
-
-  explicit ZeEventView(ze_event_handle_t event) : event_(event), event_pool_(nullptr), index_(0) {}
-
-  ZeEventView(const ZeEventView&) = delete;
-  ZeEventView(ZeEventView&& other) noexcept
-      : event_(std::exchange(other.event_, nullptr)),
-        event_pool_(std::exchange(other.event_pool_, nullptr)),
-        index_(std::exchange(other.index_, 0)) {}
-  ZeEventView& operator=(const ZeEventView&) = delete;
-  ZeEventView& operator=(ZeEventView&& other) noexcept {
-    if (this != &other) {
-      if (event_) {
-        Release();
-      }
-      event_ = std::exchange(other.event_, nullptr);
-      event_pool_ = std::exchange(other.event_pool_, nullptr);
-      index_ = std::exchange(other.index_, 0);
-    }
-    return *this;
-  }
-
-  constexpr ze_event_handle_t Get() const { return event_; }
-  constexpr uint32_t Idx() const { return index_; }
-  constexpr bool Empty() const { return event_ == nullptr; }
-
-  bool ResetSignal() {
-    auto result = ZE_RESULT_SUCCESS;
-    if (event_) {
-      overhead::ScopedOverheadCollector overhead(zeEventHostReset_id);
-      result = zeEventHostReset(event_);
-    }
-    return result == ZE_RESULT_SUCCESS;
-  }
-
-  bool Ready() const {
-    if (Empty()) {
-      return false;
-    }
-    overhead::ScopedOverheadCollector overhead(zeEventQueryStatus_id);
-    return zeEventQueryStatus(event_) == ZE_RESULT_SUCCESS;
-  }
-
-  void Unlink() { event_pool_ = nullptr; }
-
-  ~ZeEventView() noexcept {
-    if (event_) {
-      Release();
-    }
-  }
-
- private:
-  void Release() {
-    if (event_pool_) {
-      event_pool_->ResetEvent(this);
-    }
-  }
-
-  ze_event_handle_t event_;
-  T* event_pool_;
-  uint32_t index_;
-};
-
-class ZeEventPool {
- public:
-  ZeEventPool(ze_context_handle_t ctx, uint32_t count) : events_(count) {
-    assert(ctx != nullptr);
-    assert(count != 0);
-    ze_event_pool_desc_t event_pool_desc = {
-        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-        ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, count};
-
-    ze_result_t result = ZE_RESULT_SUCCESS;
-    {
-      overhead::ScopedOverheadCollector overhead(zeEventPoolCreate_id);
-      result = zeEventPoolCreate(ctx, &event_pool_desc, 0, nullptr, &event_pool_);
-    }
-    HandleIrrecoverableZeError(result, "zeEventPoolCreate");
-
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0,
-                                  ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-
-    for (uint32_t i = 0; i < count; ++i) {
-      event_desc.index = i;
-      ze_event_handle_t event = nullptr;
-      {
-        overhead::ScopedOverheadCollector overhead(zeEventCreate_id);
-        result = zeEventCreate(event_pool_, &event_desc, &event);
-      }
-      HandleIrrecoverableZeError(result, "zeEventCreate");
-      events_[i] = ZeEventView{event, this, i};
-    }
-  }
-
-  ZeEventPool(const ZeEventPool&) = delete;
-
-  ZeEventPool(ZeEventPool&& other) noexcept = delete;
-  ZeEventPool& operator=(const ZeEventPool&) = delete;
-  ZeEventPool& operator=(ZeEventPool&& other) noexcept = delete;
-
-  [[nodiscard]] ZeEventView<ZeEventPool> AcquireEvent() {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    auto event = std::move(events_[current_event_index_]);
-    current_event_index_ = (current_event_index_ + 1) % events_.size();
-    ++outstanding_events_;
-    return event;
-  }
-
-  [[nodiscard]] bool IsExhausted() const {
-    // The pool is exhausted if the next event to be acquired is not available
-    // (i.e., its handle is null because it was moved out and not returned
-    // yet).
-    const std::lock_guard<std::mutex> lock(mutex_);
-    return events_[current_event_index_].Get() == nullptr;
-  }
-
-  void ResetEvent(ZeEventView<ZeEventPool>* event) {
-    if (event) {
-      const std::lock_guard<std::mutex> lock(mutex_);  // avoid race between pool destroy and reset
-      if (destroyed_) {
-        return;
-      }
-      auto* ze_event = event->Get();
-      if (ze_event) {
-        overhead::ScopedOverheadCollector overhead(zeEventHostReset_id);
-        auto result = zeEventHostReset(ze_event);
-        HandleIrrecoverableZeError(result, "zeEventHostReset");
-      }
-      events_[event->Idx()] = std::move(*event);
-      --outstanding_events_;
-    }
-  }
-
-  [[nodiscard]] bool IsCompletelyAvailable() const {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    return outstanding_events_ == 0;
-  }
-
-  ~ZeEventPool() noexcept {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    destroyed_ = true;
-    DestroyResources();
-  }
-
- private:
-  static void HandleIrrecoverableZeError(ze_result_t result, const char* function_name) {
-    if (result != ZE_RESULT_SUCCESS) {
-      SPDLOG_CRITICAL("{} irrecoverable error: {:x}", function_name, static_cast<uint32_t>(result));
-      PTI_ASSERT(false);  // NOLINT
-    }
-  }
-
-  static void HandleZeError(ze_result_t result, const char* function_name) {
-    if (result != ZE_RESULT_SUCCESS) {
-      SPDLOG_INFO("{} failed with result: {:x}", function_name, static_cast<uint32_t>(result));
-    }
-  }
-
-  void DestroyResources() noexcept {
-    // call lock before calling this function
-    for (auto& event : events_) {
-      auto finished_event = std::move(event);
-      finished_event.Unlink();  // prevent deadlock
-      if (finished_event.Get()) {
-        overhead::ScopedOverheadCollector overhead(zeEventDestroy_id);
-        auto result = zeEventDestroy(finished_event.Get());
-        HandleZeError(result, "zeEventDestroy");
-      }
-    }
-    if (event_pool_) {
-      overhead::ScopedOverheadCollector overhead(zeEventPoolDestroy_id);
-      auto result = zeEventPoolDestroy(event_pool_);
-      HandleZeError(result, "zeEventPoolDestroy");
-      event_pool_ = nullptr;
-    }
-  }
-
-  mutable std::mutex mutex_;
-  std::vector<ZeEventView<ZeEventPool>> events_;
-  uint32_t current_event_index_ = 0;
-  uint32_t outstanding_events_ = 0;
-  bool destroyed_ = false;
-  ze_event_pool_handle_t event_pool_ = nullptr;
-};
-
-class ZeEventPoolManager {
- public:
-  static constexpr uint32_t kDefaultPoolSize = 256U;
-
-  [[nodiscard]] ZeEventView<ZeEventPool> AcquireEvent(ze_context_handle_t context) {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    auto& pools = event_pools_[context];
-    if (pools.empty()) {
-      pools.emplace_back(std::make_unique<ZeEventPool>(context, kDefaultPoolSize));
-    } else if (pools.back()->IsExhausted()) {
-      auto last_unchecked_pool_it = pools.end() - 1;
-      auto reusable_pool_it =
-          std::find_if(pools.begin(), last_unchecked_pool_it,
-                       [](const auto& pool) { return pool->IsCompletelyAvailable(); });
-      if (reusable_pool_it != last_unchecked_pool_it) {
-        std::iter_swap(reusable_pool_it, last_unchecked_pool_it);
-      } else {
-        pools.emplace_back(std::make_unique<ZeEventPool>(context, kDefaultPoolSize));
-      }
-    }
-    assert(pools.back()->IsExhausted() == false);
-    return pools.back()->AcquireEvent();
-  }
-
-  void Clear(ze_context_handle_t context) {
-    const std::lock_guard<std::mutex> lock(mutex_);
-    event_pools_.erase(context);
-  }
-
- private:
-  using PoolStorage = std::vector<std::unique_ptr<ZeEventPool>>;
-
-  mutable std::mutex mutex_;
-  std::unordered_map<ze_context_handle_t, PoolStorage> event_pools_;
-};
-
-#endif  // LEVELZERO_ZE_EVENT_MANAGERS_H_
diff --git a/sdk/src/levelzero/ze_events_and_pools_observer.h b/sdk/src/levelzero/ze_events_and_pools_observer.h
deleted file mode 100644
index 50cef650..00000000
--- a/sdk/src/levelzero/ze_events_and_pools_observer.h
+++ /dev/null
@@ -1,142 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef LEVELZERO_EVENTS_AND_POOLS_OBSERVER_H_
-#define LEVELZERO_EVENTS_AND_POOLS_OBSERVER_H_
-
-// Events in PTI are primary objects through which GPU timing information is collected.
-// However there could be different types of events in Level-Zero:
-// 1) Regular events created by zeEventPoolCreate and zeEventCreate
-// 2) Counter-based events, so far also created from special event pools and zeEventCreate
-//    but which behave differently vs. regular events
-// https://oneapi-src.github.io/level-zero-spec/level-zero/latest/core/EXT_Exp_CounterBasedEventPools.html#counter-based-event-pools-extension
-// Moreover, on some platforms (starting from BMG and newer in 2025.3)
-// counter-based events are used by default in UR, while regular events still supported
-
-// With that in mind, this file provides API to query events and pools.
-// For this purpose it maintains the cache of pools that collector sees when tracing Level-Zero
-// application. If Level-Zero loader/layers provide APIs to query event properties/flags directly
-// and easy - this code can be removed.
-
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <optional>
-#include <shared_mutex>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "overhead_kinds.h"
-#include "pti/pti_driver_levelzero_api_ids.h"
-#include "ze_wrappers.h"
-
-enum class EventPoolType { kUnknown, kRegular, kCounterBased };
-struct EventPoolProperties {
-  EventPoolType type = EventPoolType::kUnknown;
-  ze_event_pool_flags_t flags = 0;
-};
-
-class ZeEventPoolsObserver {
- public:
-  explicit ZeEventPoolsObserver(Level0Wrapper& wrapper) : wrapper_(wrapper) {}
-
-  bool Add(ze_event_pool_handle_t pool, ze_context_handle_t context, ze_event_pool_flags_t flags,
-           EventPoolType pool_type) {
-    std::unique_lock lock(event_pool_mutex_);
-    SPDLOG_TRACE("In {} pool: {}, context: {}, type: {}", __func__, static_cast<const void*>(pool),
-                 static_cast<const void*>(context), static_cast<int>(pool_type));
-    bool added = false;
-    if (event_pool_properties_.find(pool) == event_pool_properties_.end()) {
-      event_pool_properties_[pool] = {context, EventPoolProperties{pool_type, flags}};
-      context_to_pools_[context].insert(pool);
-      added = true;
-    }
-    return added;
-  }
-
-  void ClearPool(ze_event_pool_handle_t pool) {
-    std::unique_lock lock(event_pool_mutex_);
-    SPDLOG_TRACE("In {} pool: {}", __func__, static_cast<const void*>(pool));
-
-    auto pool_it = event_pool_properties_.find(pool);
-    if (pool_it != event_pool_properties_.end()) {
-      ze_context_handle_t context = pool_it->second.first;
-      event_pool_properties_.erase(pool_it);
-
-      // Remove from context tracking
-      auto ctx_it = context_to_pools_.find(context);
-      if (ctx_it != context_to_pools_.end()) {
-        ctx_it->second.erase(pool);
-        if (ctx_it->second.empty()) {
-          context_to_pools_.erase(ctx_it);
-        }
-      }
-    }
-  }
-
-  void ClearContext(ze_context_handle_t context) {
-    std::unique_lock lock(event_pool_mutex_);
-    SPDLOG_TRACE("In {} context: {}", __func__, static_cast<const void*>(context));
-
-    auto ctx_it = context_to_pools_.find(context);
-    if (ctx_it != context_to_pools_.end()) {
-      // Remove all pools associated with this context
-      for (auto pool : ctx_it->second) {
-        event_pool_properties_.erase(pool);
-      }
-      context_to_pools_.erase(ctx_it);
-    }
-  }
-
-  void ClearAll() {
-    std::unique_lock lock(event_pool_mutex_);
-    SPDLOG_TRACE("In {} remove all pools", __func__);
-    event_pool_properties_.clear();
-    context_to_pools_.clear();
-  }
-
-  std::optional<EventPoolProperties> GetPoolProperties(ze_event_pool_handle_t pool) {
-    // Until counter-based events are created via Event Pool -
-    // calling EventPoolGetFlag for not-traced Pool doesn't tell the diff between
-    // regular and counter-based events.
-    // But when counter-based events created w/o Pool or have a special flag in Pool
-    // - asking Pool flags might be helpful and then this fragment could be changed, e.g.
-    // wrapper_.w_zeEventPoolGetFlags(pool, &flags);
-
-    std::shared_lock lock(event_pool_mutex_);
-    SPDLOG_TRACE("In {} pool: {}", __func__, static_cast<const void*>(pool));
-    auto iter = event_pool_properties_.find(pool);
-    if (iter != event_pool_properties_.end()) {
-      return iter->second.second;
-    }
-    return std::nullopt;
-  }
-
-  std::optional<EventPoolProperties> GetEventProperties(ze_event_handle_t event) {
-    ze_event_pool_handle_t pool;
-    ze_result_t res = ZE_RESULT_SUCCESS;
-    {
-      overhead::ScopedOverheadCollector overhead(zeEventGetEventPool_id);
-      res = wrapper_.w_zeEventGetEventPool(event, &pool);
-    }
-    if (res != ZE_RESULT_SUCCESS || pool == nullptr) {
-      SPDLOG_DEBUG("In {}, zeEventGetEventPool failed with code {:x}, pool: {}", __func__,
-                   static_cast<uint32_t>(res), static_cast<const void*>(pool));
-      return std::nullopt;
-    }
-    return GetPoolProperties(pool);
-  }
-
- private:
-  std::unordered_map<ze_event_pool_handle_t, std::pair<ze_context_handle_t, EventPoolProperties>>
-      event_pool_properties_;
-  std::unordered_map<ze_context_handle_t, std::unordered_set<ze_event_pool_handle_t>>
-      context_to_pools_;
-  mutable std::shared_mutex event_pool_mutex_;
-  Level0Wrapper& wrapper_;
-};
-
-#endif  // LEVELZERO_EVENTS_AND_POOLS_OBSERVER_H_
diff --git a/sdk/src/levelzero/ze_extensions.h b/sdk/src/levelzero/ze_extensions.h
deleted file mode 100644
index 2600c78e..00000000
--- a/sdk/src/levelzero/ze_extensions.h
+++ /dev/null
@@ -1,95 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef LEVEL_ZERO_ZE_EXTENSIONS_H_
-#define LEVEL_ZERO_ZE_EXTENSIONS_H_
-
-#include <level_zero/driver_experimental/zex_visit.h>
-#include <level_zero/ze_intel_gpu.h>
-#include <spdlog/spdlog.h>
-
-#include "ze_utils.h"
-
-struct ZeExts {
-  template <typename Extension>
-  [[nodiscard]] static bool IsSupported(ze_driver_handle_t driver) {
-    return utils::ze::IsDriverExtensionSupported(driver, Extension::kExtName);
-  }
-
-  template <typename FnPtr>
-  static bool LoadFunction(ze_driver_handle_t driver, std::string_view fn_name, FnPtr& fn_ptr) {
-    auto* ptr = utils::ze::GetExtensionFunctionAddr(driver, fn_name.data());
-    if (!ptr) {
-      return false;
-    }
-    fn_ptr = reinterpret_cast<FnPtr>(ptr);
-    return true;
-  }
-
-  struct Visit {
-    static constexpr std::string_view kExtName = ZE_COMMAND_VISIT_EXT_NAME;
-
-    decltype(&zeCommandListVisitExt) ze_command_list_visit = nullptr;
-    decltype(&zeGraphVisitExt) ze_graph_visit = nullptr;
-
-    [[nodiscard]] static std::optional<Visit> Load(ze_driver_handle_t driver) {
-      if (!IsSupported<Visit>(driver)) {
-        return std::nullopt;
-      }
-
-      Visit visit{};
-
-      if (LoadFunction(driver, "zeCommandListVisitExt", visit.ze_command_list_visit) &&
-          LoadFunction(driver, "zeGraphVisitExt", visit.ze_graph_visit)) {
-        return visit;
-      }
-
-      return std::nullopt;
-    }
-  };
-
-  struct CounterBasedEvents {
-    static constexpr std::string_view kExtName = ZE_EVENT_POOL_COUNTER_BASED_EXP_NAME;
-    static std::optional<CounterBasedEvents> Load(ze_driver_handle_t driver) {
-      if (!IsSupported<CounterBasedEvents>(driver)) {
-        return std::nullopt;
-      }
-      return CounterBasedEvents{};
-    }
-  };
-
-  struct CmdListIntrospection {
-    static constexpr std::string_view kCmdListGetFlagsFunctionName = "zeCommandListGetFlags";
-    decltype(&zeCommandListGetFlags) ze_command_list_get_flags = nullptr;
-    static std::optional<CmdListIntrospection> Load(ze_driver_handle_t driver) {
-      CmdListIntrospection cmd_list_introspection{};
-
-      if (LoadFunction(driver, kCmdListGetFlagsFunctionName,
-                       cmd_list_introspection.ze_command_list_get_flags)) {
-        return cmd_list_introspection;
-      }
-
-      return std::nullopt;
-    }
-  };
-
-  struct GraphExt {
-    static constexpr std::string_view kExtName = ZE_RECORD_REPLAY_GRAPH_EXT_NAME;
-
-    static std::optional<GraphExt> Load(ze_driver_handle_t driver) {
-      if (!IsSupported<GraphExt>(driver)) {
-        return std::nullopt;
-      }
-      return GraphExt{};
-    }
-  };
-
-  using Extensions = std::tuple<std::optional<Visit>, std::optional<CounterBasedEvents>,
-                                std::optional<CmdListIntrospection>, std::optional<GraphExt>>;
-  Extensions extensions;
-};
-
-#endif  // LEVEL_ZERO_ZE_EXTENSIONS_H_
diff --git a/sdk/src/levelzero/ze_gpu_command.h b/sdk/src/levelzero/ze_gpu_command.h
deleted file mode 100644
index 6e1f6f05..00000000
--- a/sdk/src/levelzero/ze_gpu_command.h
+++ /dev/null
@@ -1,307 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_LEVELZERO_ZE_GPU_COMMAND_H_
-#define PTI_LEVELZERO_ZE_GPU_COMMAND_H_
-
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/layers/zel_tracing_register_cb.h>
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-#include <pti/pti_driver_levelzero_api_ids.h>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "pti_memory_route.h"
-#include "unikernel.h"
-#include "utils.h"
-#include "ze_driver_init.h"
-#include "ze_event_managers.h"
-#include "ze_timer_helper.h"
-#include "ze_utils.h"
-
-#if defined(PTI_TRACE_SYCL)
-#include "sycl_collector.h"
-#endif
-
-struct ZeKernelGroupSize {
-  uint32_t x;
-  uint32_t y;
-  uint32_t z;
-};
-
-struct ZeKernelCommandProps {
-  std::string name;
-  KernelCommandType type = KernelCommandType::kInvalid;
-  PtiMemoryCommandRoute route;
-  size_t simd_width;
-  size_t bytes_transferred;
-  std::array<uint32_t, 3> group_count;
-  std::array<uint32_t, 3> group_size;
-  size_t value_size;
-  std::byte* value_array;
-  ze_device_handle_t src_device = nullptr;  // Device for p2p memcpy, source of copy data
-  ze_device_handle_t dst_device = nullptr;  // Device for p2p memcpy, destination of copy data
-  void* dst = nullptr;                      // Addresses for MemoryCopy or Fill
-  void* src = nullptr;
-};
-
-struct ZeMemoryInfo {
-  ze_device_handle_t device = nullptr;
-  pti_view_memory_type type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY;
-  bool is_p2p_capable = false;
-};
-
-struct ZeKernelCommand {
-  ZeKernelCommandProps props;
-  uint64_t device_timer_frequency_;
-  uint64_t device_timer_mask_;
-  ze_event_handle_t event_self = nullptr;  // in Local mode this event goes after traced GPU op
-  ZeEventView<ZeEventPool> event_swap;     // event created in Local collection mode
-  ze_device_handle_t device =
-      nullptr;  // Device where the operation is submitted, associated with command list
-  uint64_t kernel_id = 0;
-  uint64_t append_time = 0;
-  ze_context_handle_t context = nullptr;
-  ze_command_list_handle_t command_list = nullptr;
-  ze_command_queue_handle_t queue = nullptr;
-  ze_fence_handle_t fence;
-  uint64_t submit_time = 0;          // in ns
-  uint64_t submit_time_device_ = 0;  // in ticks
-  uint32_t tid = 0;
-  uint64_t sycl_node_id_ = 0;
-  uint64_t sycl_queue_id_ =
-      PTI_INVALID_QUEUE_ID;  // default to invalid till we determine otherwise.
-  uint32_t sycl_invocation_id_ = 0;
-  uint64_t sycl_task_begin_time_ = 0;
-  uint64_t sycl_enqk_begin_time_ = 0;
-  std::string source_file_name_;
-  uint32_t source_line_number_ = 0;
-  uint32_t corr_id_ = 0;
-  uint32_t callback_id_ = 0;
-  uint64_t api_start_time_ = 0;  // in ns
-  uint64_t api_end_time_ = 0;    // in ns
-  uint64_t num_wait_events = 0;  // tracks wait event count for synchronization activity commands
-  ze_result_t result_ = ZE_RESULT_SUCCESS;
-  utils::ze::TimestampBuffer timestamp = nullptr;
-  ZeEventView<ZeEventPool> timestamp_query_event;
-};
-
-struct ZeCommandQueue {
-  ze_command_queue_handle_t queue_;
-  ze_context_handle_t context_;
-  ze_device_handle_t device_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-};
-
-struct ZeCommandListInfo {
-  std::vector<std::shared_ptr<ZeKernelCommand>> appended_commands;
-  ze_context_handle_t context = nullptr;
-  ze_device_handle_t device = nullptr;
-  bool immediate = false;
-  bool closed = false;
-  std::pair<uint32_t, uint32_t> oi_pair;
-  ze_command_list_flags_t flags = ZE_COMMAND_LIST_FLAG_FORCE_UINT32;
-  ze_command_queue_flags_t immediate_flags = ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32;
-  ze_command_list_handle_t command_list = nullptr;
-  ze_command_list_handle_t instrumented_command_list = nullptr;
-};
-
-// Structure represents a batch of commands submitted to the device for which checking each
-// command's completion event individually is not efficient.
-struct ZeBatchedExecution {
-  std::shared_ptr<ZeEventView<ZeEventPool>> completion_event = nullptr;
-  ze_event_handle_t user_completion_event =
-      nullptr;  // User's event they passed to the submit call.
-  uint64_t submit_time_host = 0;
-  uint64_t submit_time_device = 0;
-  uint64_t graph_correlation_id = 0;
-  std::vector<std::shared_ptr<ZeKernelCommand>> commands;
-};
-
-struct ZeGraphExecutionInfo {
-  ze_graph_handle_t instrumented_graph = nullptr;  // The graph handle PTI creates and
-                                                   // swaps the user's graph handle with.
-  ze_executable_graph_handle_t instrumented_executable_graph =
-      nullptr;  // The executable graph handle PTI creates and swaps the user's executable graph
-                // handle with.
-  std::vector<std::shared_ptr<ZeKernelCommand>> graph_commands;  // List of commands associated with
-                                                                 // the graph execution. Gets
-                                                                 // drained into same list as
-                                                                 // command list commands.
-  std::shared_ptr<ZeEventView<ZeEventPool>> graph_execution_event;  // PTI's event used to track the
-                                                                    // graph execution completion.
-  bool sync_timeout = false;  // PTI checked the exec event and it timed out. It's likely not being
-                              // signaled so don't wait on it again.
-};
-
-struct ZeGraphInfo {
-  ze_graph_handle_t graph = nullptr;  // User's Level Zero native graph handle
-  ze_executable_graph_handle_t executable_graph =
-      nullptr;  // User's Level Zero native executable graph handle
-  ze_command_list_handle_t primary_command_list = nullptr;  // The command list used to start the
-                                                            // graph capture
-  ze_device_handle_t device = nullptr;                      // Device handle associated with primary
-                                                            // command list
-  ze_context_handle_t context = nullptr;  // Context handle associated with primary command list
-  ZeGraphExecutionInfo execution;         // Represents an execution of the graph
-                                          // (not static properties of the graph).
-  std::mutex execution_mutex;
-};
-
-struct ZeGraphAppendInstanceData {
-  std::shared_ptr<ZeGraphInfo> graph_info;
-  ze_event_handle_t user_graph_signal_event = nullptr;  // User's signal event they passed to the
-                                                        // graph append call.
-  ze_event_handle_t graph_completion_event =
-      nullptr;  // PTI's event we use to track the graph
-                // execution completion. We swap the user's
-                // event with this event if the user already
-                // passed an signal event to the graph append call.
-  uint64_t submit_time_host = 0;
-  uint64_t submit_time_device = 0;
-  uint64_t graph_correlation_id = 0;
-};
-
-struct ZeDeviceDescriptor {
-  uint64_t host_time_origin = 0;
-  uint64_t device_time_origin = 0;
-  uint64_t device_timer_frequency = 0;
-  uint64_t device_timer_mask = 0;
-  uint64_t device_sync_delta = CPUGPUTimeInterpolationHelper::kSyncDeltaDefault;
-  ze_driver_handle_t driver = nullptr;
-  ze_context_handle_t context = nullptr;
-  ze_pci_ext_properties_t pci_properties{};
-  ze_device_uuid_t uuid{};
-  uint32_t ip_version = 0;
-  std::optional<ZeExts::Visit> visit = std::nullopt;
-  std::optional<ZeExts::CmdListIntrospection> cmdlist_introspection = std::nullopt;
-  std::optional<ZeExts::GraphExt> graph_exp = std::nullopt;
-};
-
-[[nodiscard]] inline ZeMemoryInfo GetMemoryInfo(ze_context_handle_t ctx, const void* ptr) {
-  ZeMemoryInfo mem_info{};
-  if (ctx == nullptr || ptr == nullptr) {
-    return mem_info;
-  }
-
-  ze_memory_allocation_properties_t props{};
-  props.stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;
-  auto status = ZE_RESULT_SUCCESS;
-  ze_device_handle_t device = nullptr;
-  {
-    overhead::ScopedOverheadCollector overhead_collector(zeMemGetAllocProperties_id);
-    status = zeMemGetAllocProperties(ctx, ptr, &props, &device);
-  }
-
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_DEBUG("Failed to get memory properties for pointer: {} in context: {}, error: {:x}.",
-                 ptr, static_cast<const void*>(ctx), static_cast<uint32_t>(status));
-    return mem_info;
-  }
-  mem_info.device = device;
-
-  // Conversion from L0 -> PTI view memory types
-  switch (props.type) {
-    case ZE_MEMORY_TYPE_UNKNOWN:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY;
-      mem_info.is_p2p_capable = false;
-      break;
-    case ZE_MEMORY_TYPE_HOST:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST;
-      mem_info.is_p2p_capable = false;
-      break;
-    case ZE_MEMORY_TYPE_DEVICE:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE;
-      mem_info.is_p2p_capable = true;
-      break;
-    case ZE_MEMORY_TYPE_SHARED:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED;
-      mem_info.is_p2p_capable = true;
-      break;
-    case ZE_MEMORY_TYPE_HOST_IMPORTED:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST;
-      mem_info.is_p2p_capable = false;
-      break;
-    default:
-      mem_info.type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY;
-      mem_info.is_p2p_capable = false;
-      break;
-  }
-
-  return mem_info;
-}
-
-[[nodiscard]] inline ZeKernelCommandProps GetTransferProps(
-    std::string_view name, size_t bytes_transferred, ze_context_handle_t src_context,
-    const void* src, ze_context_handle_t dst_context, const void* dst, size_t pattern_size = 0) {
-  SPDLOG_TRACE("In {}", __FUNCTION__);
-  PTI_ASSERT(!name.empty());
-
-  ZeKernelCommandProps transfer_properties{};
-  transfer_properties.name = std::string(name);
-  transfer_properties.bytes_transferred = bytes_transferred;
-  transfer_properties.value_size = pattern_size;
-  transfer_properties.type = KernelCommandType::kMemory;
-
-  PtiMemoryCommandRoute memory_route{};
-
-  const auto src_info = GetMemoryInfo(src_context, src);
-  const auto dst_info = GetMemoryInfo(dst_context, dst);
-
-  memory_route.is_peer_2_peer = (src_info.is_p2p_capable && dst_info.is_p2p_capable) &&
-                                (src_info.device != nullptr) && (dst_info.device != nullptr) &&
-                                (src_info.device != dst_info.device);
-
-  memory_route.src_type = src_info.type;
-  memory_route.dst_type = dst_info.type;
-
-  transfer_properties.name += "(" + memory_route.GetCompactStringForTypes();
-
-  ze_bool_t can_access_peer = 0;
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  if (memory_route.is_peer_2_peer) {
-    overhead::ScopedOverheadCollector overhead_collector(zeDeviceCanAccessPeer_id);
-    status = zeDeviceCanAccessPeer(src_info.device, dst_info.device, &can_access_peer);
-  }
-
-  if (status == ZE_RESULT_SUCCESS && can_access_peer) {
-    transfer_properties.name += memory_route.GetCompactStringForP2P();
-  }
-
-  transfer_properties.name += ")";
-  SPDLOG_TRACE("\t\tIn {}, ops name: {}, p2p: {}", __FUNCTION__, transfer_properties.name,
-               can_access_peer ? "true" : "false");
-
-  transfer_properties.route = memory_route;
-  transfer_properties.src_device = src_info.device;
-  transfer_properties.dst_device = dst_info.device;
-  transfer_properties.dst = const_cast<void*>(dst);
-  transfer_properties.src = const_cast<void*>(src);
-  return transfer_properties;
-}
-
-template <typename T>
-constexpr bool IsInOrder(const T& command_list_info) {
-  return command_list_info.immediate
-             ? command_list_info.immediate_flags != ZE_COMMAND_QUEUE_FLAG_FORCE_UINT32 &&
-                   (command_list_info.immediate_flags & ZE_COMMAND_QUEUE_FLAG_IN_ORDER) != 0
-             : command_list_info.flags != ZE_COMMAND_LIST_FLAG_FORCE_UINT32 &&
-                   (command_list_info.flags & ZE_COMMAND_LIST_FLAG_IN_ORDER) != 0;
-}
-
-#endif  // PTI_LEVELZERO_ZE_GPU_COMMAND_H_
diff --git a/sdk/src/levelzero/ze_graph_storage.h b/sdk/src/levelzero/ze_graph_storage.h
deleted file mode 100644
index 0c3c7891..00000000
--- a/sdk/src/levelzero/ze_graph_storage.h
+++ /dev/null
@@ -1,137 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_LEVELZERO_ZE_GRAPH_STORAGE_H_
-#define PTI_LEVELZERO_ZE_GRAPH_STORAGE_H_
-
-#include <level_zero/ze_api.h>
-
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "overhead_kinds.h"
-#include "ze_gpu_command.h"
-#include "ze_wrappers.h"
-
-class ZeGraphStorage {
- public:
-  explicit ZeGraphStorage(Level0Wrapper* wrapper) : loader_(wrapper) {}
-
-  std::shared_ptr<ZeGraphInfo> GetInfo(ze_executable_graph_handle_t executable_graph_handle) {
-    {
-      std::shared_lock lock(mutex_);
-      auto graph_it = graph_info_map_.find(executable_graph_handle);
-      if (graph_it != graph_info_map_.end()) {
-        return graph_it->second;
-      }
-    }
-
-    auto graph_info = CreateGraphInfo(executable_graph_handle);
-    if (!graph_info) {
-      return nullptr;
-    }
-
-    std::unique_lock lock(mutex_);
-    return graph_info_map_.try_emplace(executable_graph_handle, std::move(graph_info))
-        .first->second;
-  }
-
-  [[nodiscard]] std::vector<std::shared_ptr<ZeGraphInfo>> RemoveContext(
-      ze_context_handle_t context_handle) {
-    std::vector<std::shared_ptr<ZeGraphInfo>> removed;
-    {
-      std::unique_lock lock(mutex_);
-      for (auto graph_info_it = graph_info_map_.begin(); graph_info_it != graph_info_map_.end();) {
-        if (graph_info_it->second->context == context_handle) {
-          removed.push_back(std::move(graph_info_it->second));
-          graph_info_it = graph_info_map_.erase(graph_info_it);
-        } else {
-          ++graph_info_it;
-        }
-      }
-    }
-    return removed;
-  }
-
-  [[nodiscard]] std::shared_ptr<ZeGraphInfo> Remove(
-      ze_executable_graph_handle_t executable_graph_handle) {
-    std::shared_ptr<ZeGraphInfo> removed;
-    {
-      std::unique_lock lock(mutex_);
-      auto graph_info_it = graph_info_map_.find(executable_graph_handle);
-      if (graph_info_it != graph_info_map_.end()) {
-        removed = std::move(graph_info_it->second);
-        graph_info_map_.erase(graph_info_it);
-      }
-    }
-    return removed;
-  }
-
-  [[nodiscard]] auto RemoveAll() {
-    std::unique_lock lock(mutex_);
-    return std::exchange(graph_info_map_, {});
-  }
-
- private:
-  std::shared_ptr<ZeGraphInfo> CreateGraphInfo(
-      ze_executable_graph_handle_t executable_graph_handle) {
-    auto result = ZE_RESULT_SUCCESS;
-    ze_graph_handle_t graph_handle = nullptr;
-    {
-      overhead::ScopedOverheadCollector scoped{zeExecutableGraphGetSourceGraphExt_id};
-      result =
-          loader_->w_zeExecutableGraphGetSourceGraphExt(executable_graph_handle, &graph_handle);
-      if (result != ZE_RESULT_SUCCESS) {
-        return nullptr;
-      }
-    }
-
-    ze_command_list_handle_t command_list_handle = nullptr;
-    {
-      overhead::ScopedOverheadCollector scoped{zeGraphGetPrimaryCommandListExt_id};
-      result = loader_->w_zeGraphGetPrimaryCommandListExt(graph_handle, &command_list_handle);
-      if (result != ZE_RESULT_SUCCESS) {
-        return nullptr;
-      }
-    }
-
-    ze_device_handle_t device_handle = nullptr;
-    {
-      overhead::ScopedOverheadCollector scoped{zeCommandListGetDeviceHandle_id};
-      result = loader_->w_zeCommandListGetDeviceHandle(command_list_handle, &device_handle);
-      if (result != ZE_RESULT_SUCCESS) {
-        return nullptr;
-      }
-    }
-
-    ze_context_handle_t context_handle = nullptr;
-    {
-      overhead::ScopedOverheadCollector scoped{zeCommandListGetContextHandle_id};
-      result = loader_->w_zeCommandListGetContextHandle(command_list_handle, &context_handle);
-      if (result != ZE_RESULT_SUCCESS) {
-        return nullptr;
-      }
-    }
-
-    auto graph_info = std::make_shared<ZeGraphInfo>();
-    graph_info->graph = graph_handle;
-    graph_info->executable_graph = executable_graph_handle;
-    graph_info->primary_command_list = command_list_handle;
-    graph_info->device = device_handle;
-    graph_info->context = context_handle;
-    return graph_info;
-  }
-
-  Level0Wrapper* loader_;
-  mutable std::shared_mutex mutex_;
-  std::unordered_map<ze_executable_graph_handle_t, std::shared_ptr<ZeGraphInfo>> graph_info_map_;
-};
-
-#endif  // PTI_LEVELZERO_ZE_GRAPH_STORAGE_H_
diff --git a/sdk/src/levelzero/ze_kernel_name_cache.h b/sdk/src/levelzero/ze_kernel_name_cache.h
deleted file mode 100644
index 05a5c81e..00000000
--- a/sdk/src/levelzero/ze_kernel_name_cache.h
+++ /dev/null
@@ -1,120 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef SRC_LEVELZERO_ZE_KERNEL_NAME_CACHE_H_
-#define SRC_LEVELZERO_ZE_KERNEL_NAME_CACHE_H_
-
-#include <level_zero/ze_api.h>
-
-#include <mutex>
-#include <optional>
-#include <shared_mutex>
-#include <string>
-#include <unordered_map>
-
-#include "utils/ze_utils.h"
-
-/**
- * @brief Thread-safe cache for kernel names (mangled and demangled)
- *
- * Avoids repeated zeKernelGetName calls and demangling by caching both versions
- * per kernel. Uses shared_mutex for concurrent reads, exclusive writes.
- *
- * @tparam FetchFn Kernel name fetch function (default: utils::ze::GetKernelName)
- */
-template <typename FetchFn = std::string (*)(ze_kernel_handle_t, bool)>
-class ZeKernelNameCache {
- public:
-  ZeKernelNameCache() : fetch_fn_(utils::ze::GetKernelName) {}
-  explicit ZeKernelNameCache(FetchFn fetch) : fetch_fn_(fetch) {}
-
-  ~ZeKernelNameCache() = default;
-
-  ZeKernelNameCache(const ZeKernelNameCache&) = delete;
-  ZeKernelNameCache& operator=(const ZeKernelNameCache&) = delete;
-  ZeKernelNameCache(ZeKernelNameCache&&) = delete;
-  ZeKernelNameCache& operator=(ZeKernelNameCache&&) = delete;
-
-  /**
-   * @brief Get kernel name from cache or fetch if not cached
-   * @param kernel Kernel handle
-   * @param demangle Return demangled name if true, mangled if false
-   * @return Kernel name
-   */
-  std::string GetKernelName(ze_kernel_handle_t kernel, bool demangle) {
-    // Fast path: shared lock for concurrent reads
-    {
-      std::shared_lock<std::shared_mutex> read_lock(mutex_);
-      auto it = cache_.find(kernel);
-      if (it != cache_.end()) {
-        const KernelNames& names = it->second;
-        if (demangle && names.demangled_name.has_value()) {
-          return names.demangled_name.value();
-        }
-        if (!demangle && names.mangled_name.has_value()) {
-          return names.mangled_name.value();
-        }
-      }
-    }
-
-    // Slow path: unique lock to fetch and cache
-    std::unique_lock<std::shared_mutex> write_lock(mutex_);
-
-    // Double-check pattern
-    auto it = cache_.find(kernel);
-    if (it != cache_.end()) {
-      KernelNames& names = it->second;
-      if (demangle && names.demangled_name.has_value()) {
-        return names.demangled_name.value();
-      }
-      if (!demangle && names.mangled_name.has_value()) {
-        return names.mangled_name.value();
-      }
-
-      std::string name = fetch_fn_(kernel, demangle);
-      if (demangle) {
-        names.demangled_name = name;
-      } else {
-        names.mangled_name = name;
-      }
-      return name;
-    }
-
-    // New kernel - fetch and create entry
-    std::string name = fetch_fn_(kernel, demangle);
-    KernelNames names;
-    if (demangle) {
-      names.demangled_name = name;
-    } else {
-      names.mangled_name = name;
-    }
-    cache_[kernel] = names;
-
-    return name;
-  }
-
-  void RemoveKernel(ze_kernel_handle_t kernel) {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
-    cache_.erase(kernel);
-  }
-
-  void Clear() {
-    std::unique_lock<std::shared_mutex> lock(mutex_);
-    cache_.clear();
-  }
-
- private:
-  struct KernelNames {
-    std::optional<std::string> mangled_name;
-    std::optional<std::string> demangled_name;
-  };
-
-  std::unordered_map<ze_kernel_handle_t, KernelNames> cache_;
-  mutable std::shared_mutex mutex_;
-  FetchFn fetch_fn_;
-};
-
-#endif  // SRC_LEVELZERO_ZE_KERNEL_NAME_CACHE_H_
diff --git a/sdk/src/levelzero/ze_local_collection_helpers.h b/sdk/src/levelzero/ze_local_collection_helpers.h
deleted file mode 100644
index ec92f406..00000000
--- a/sdk/src/levelzero/ze_local_collection_helpers.h
+++ /dev/null
@@ -1,80 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_ZE_LOCAL_COLLECTION_HELPERS_H_
-#define PTI_TOOLS_ZE_LOCAL_COLLECTION_HELPERS_H_
-
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include "overhead_kinds.h"
-#include "pti_assert.h"
-
-// Workaround for supporting counter-based L0 events.
-// https://github.com/intel/compute-runtime/blob/master/level_zero/doc/experimental_extensions/COUNTER_BASED_EVENTS.md
-// These are now the default on BMG and newer platforms in 2025.3.
-// preferred solution would be
-// pseudo code:
-//
-// ```
-//   if(zeCommandListInorder(command_list) || zeEventIsCounterEvent(signal_event))
-//     Inject(CounterEvent() || SignalEvent()).
-// ```
-//
-// However, these APIs do not exist yet.
-// This code only works for in_order command lists.
-inline bool A2AppendWaitAndSignalEvent(ze_command_list_handle_t command_list,
-                                       ze_event_handle_t signal_event,
-                                       ze_event_handle_t wait_event) {
-  SPDLOG_DEBUG(" --- In: {}, CmdList: {}, Signal event: {}, Wait event: {}", __FUNCTION__,
-               static_cast<const void*>(command_list), static_cast<const void*>(signal_event),
-               static_cast<const void*>(wait_event));
-  ze_result_t wait_res = ZE_RESULT_SUCCESS;
-  {
-    overhead::ScopedOverheadCollector overhead_collector{zeCommandListAppendWaitOnEvents_id};
-    wait_res = zeCommandListAppendWaitOnEvents(command_list, 1U, &wait_event);
-  }
-  if (wait_res != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("In {}, zeCommandListAppendWaitOnEvents failed: 0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(wait_res));
-    return false;
-  }
-
-  ze_result_t signal_res = ZE_RESULT_SUCCESS;
-  {
-    overhead::ScopedOverheadCollector overhead_collector{zeCommandListAppendSignalEvent_id};
-    signal_res = zeCommandListAppendSignalEvent(command_list, signal_event);
-  }
-  if (signal_res != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("In {}, zeCommandListAppendSignalEvent failed: 0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(signal_res));
-    return false;
-  }
-
-  return true;
-}
-
-inline bool A2AppendSignalEvent(ze_command_list_handle_t command_list,
-                                ze_event_handle_t signal_event) {
-  SPDLOG_DEBUG(" --- In: {}, CmdList: {}, Signal event: {}", __FUNCTION__,
-               static_cast<const void*>(command_list), static_cast<const void*>(signal_event));
-
-  ze_result_t signal_res = ZE_RESULT_SUCCESS;
-  {
-    overhead::ScopedOverheadCollector overhead_collector{zeCommandListAppendSignalEvent_id};
-    signal_res = zeCommandListAppendSignalEvent(command_list, signal_event);
-  }
-  if (signal_res != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("In {}, zeCommandListAppendSignalEvent failed: 0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(signal_res));
-    return false;
-  }
-
-  return true;
-}
-
-#endif  // PTI_TOOLS_ZE_LOCAL_COLLECTION_HELPERS_H_
diff --git a/sdk/src/levelzero/ze_timer_helper.h b/sdk/src/levelzero/ze_timer_helper.h
deleted file mode 100644
index 3428607e..00000000
--- a/sdk/src/levelzero/ze_timer_helper.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_ZE_TIMER_HELPER_H_
-#define PTI_TOOLS_ZE_TIMER_HELPER_H_
-
-#include <level_zero/ze_api.h>
-
-#include "pti_assert.h"
-
-struct CPUGPUTimeInterpolationHelper {
-  constexpr static uint64_t kSyncDeltaDefault = 300000;   // 300000 ns == 300 us == 0.3 ms
-  constexpr static uint64_t kThresholdForMissync = 1500;  // device ticks
-  ze_device_handle_t device_;
-
-  // It is not GPU core or any other clock frequency,
-  // this is the frequency of the GPU timer used for profiling needs,
-  // expected that it is several MHz, e.g 12.5 MHz on PVC.
-  // It is not expected to be higher than 500 MHz
-  uint32_t gpu_timer_freq_hz_;
-  uint64_t gpu_timer_mask_;
-  uint64_t cpu_timestamp_;
-  uint64_t gpu_timestamp_;
-  uint64_t delta_ = kSyncDeltaDefault;
-  uint64_t nsec_in_gpu_timer_tick_;
-  CPUGPUTimeInterpolationHelper(ze_device_handle_t device, uint32_t gpu_timer_freq_hz,
-                                uint64_t gpu_timer_mask, uint64_t sync_delta)
-      : device_(device),
-        gpu_timer_freq_hz_(gpu_timer_freq_hz),
-        gpu_timer_mask_(gpu_timer_mask),
-        cpu_timestamp_(0),
-        gpu_timestamp_(0) {
-    PTI_ASSERT(device_ != nullptr);
-    PTI_ASSERT(gpu_timer_freq_hz != 0ULL);
-    PTI_ASSERT(gpu_timer_mask != 0ULL);
-    if (sync_delta != 0ULL) {
-      delta_ = sync_delta;
-    }
-    nsec_in_gpu_timer_tick_ = 1'000'000'000 / gpu_timer_freq_hz_;
-  }
-  uint64_t GetNsecInGPUTimerTick() const { return nsec_in_gpu_timer_tick_; }
-};
-
-#endif  // PTI_TOOLS_ZE_TIMER_HELPER_H_
diff --git a/sdk/src/levelzero/ze_visitor_commands.inc b/sdk/src/levelzero/ze_visitor_commands.inc
deleted file mode 100644
index a5a2767c..00000000
--- a/sdk/src/levelzero/ze_visitor_commands.inc
+++ /dev/null
@@ -1,31 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// API(s) supported by the visitor extension. These are Append calls required
-// to generate records while rebuilding an instrumented version of the user's
-// command list. While they map closely to core API(s) and other lists in PTI,
-// they not exactly 1:1. E.g., EventReset is needed due to bug in some versions
-// of the driver, etc... The comments are the spec version where the API was
-// introduced.
-APPEND_COMMAND(LaunchKernel)                // L0 spec 1.0
-APPEND_COMMAND(LaunchKernelWithArguments)   // L0 spec 1.14
-APPEND_COMMAND(LaunchKernelWithParameters)  // L0 spec 1.14
-APPEND_COMMAND(LaunchCooperativeKernel)     // L0 spec 1.0
-APPEND_COMMAND(LaunchKernelIndirect)        // L0 spec 1.0
-APPEND_COMMAND(MemoryCopy)                  // L0 spec 1.0
-APPEND_COMMAND(MemoryFill)                  // L0 spec 1.0
-APPEND_COMMAND(MemoryCopyRegion)            // L0 spec 1.0
-APPEND_COMMAND(MemoryCopyFromContext)       // L0 spec 1.0
-APPEND_COMMAND(ImageCopy)                   // L0 spec 1.0
-APPEND_COMMAND(ImageCopyRegion)             // L0 spec 1.0
-APPEND_COMMAND(ImageCopyToMemory)           // L0 spec 1.0
-APPEND_COMMAND(ImageCopyFromMemory)         // L0 spec 1.0
-APPEND_COMMAND(ImageCopyToMemoryExt)        // L0 spec 1.3
-APPEND_COMMAND(ImageCopyFromMemoryExt)      // L0 spec 1.3
-APPEND_COMMAND(EventReset)                  // L0 spec 1.0
-APPEND_COMMAND(Barrier)                     // L0 spec 1.0
-APPEND_COMMAND(MemoryRangesBarrier)         // L0 spec 1.0
-
diff --git a/sdk/src/levelzero/ze_wrappers.h b/sdk/src/levelzero/ze_wrappers.h
deleted file mode 100644
index 3aa3d6ae..00000000
--- a/sdk/src/levelzero/ze_wrappers.h
+++ /dev/null
@@ -1,388 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-
-#ifndef ZE_WRAPPERS_H_
-#define ZE_WRAPPERS_H_
-
-#include "library_loader.h"
-#if defined(_WIN32)
-#else
-#include <dlfcn.h>
-#endif
-
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#if defined(_WIN32)
-inline static constexpr const char* const kLevelZeroLoaderName = "ze_loader.dll";
-#else
-inline static constexpr const char* const kLevelZeroLoaderName = "libze_loader.so.1";
-#endif
-
-/*
- * Wrappers for L0 Introspection APIs and for Loader Enable/Disable Tracing.
- * They enable graceful handling (starting from library loading)
- * when L0 on the system doesn't have
- * the Introspection API implementation or Dynamic Tracing Enable/Disable
- */
-
-#define LOADER_LOAD_AND_DEBUG_PRINT(name)                          \
-  do {                                                             \
-    fptr_##name##_ = l0_loader_.GetSymbol<decltype(&name)>(#name); \
-    SPDLOG_DEBUG("Found fptr_{}_", #name);                         \
-  } while (0)
-
-class Level0Wrapper {
- public:
-  Level0Wrapper() {
-    try {
-      l0_loader_ = LibraryLoader{kLevelZeroLoaderName};
-      LOADER_LOAD_AND_DEBUG_PRINT(zelEnableTracingLayer);
-      LOADER_LOAD_AND_DEBUG_PRINT(zelDisableTracingLayer);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeEventPoolGetFlags);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeEventGetEventPool);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeEventPoolGetContextHandle);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListGetDeviceHandle);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListGetContextHandle);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListGetOrdinal);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListGetFlags);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListImmediateGetIndex);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListImmediateGetFlags);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListIsImmediate);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandQueueGetIndex);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandQueueGetOrdinal);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphCreateExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphDestroyExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphInstantiateExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphIsEmptyExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphDumpContentsExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphSetDestructionCallbackExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListBeginGraphCaptureExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListBeginCaptureIntoGraphExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListEndGraphCaptureExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListIsGraphCaptureEnabledExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListAppendGraphExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeCommandListGetGraphExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeGraphGetPrimaryCommandListExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeExecutableGraphGetSourceGraphExt);
-      LOADER_LOAD_AND_DEBUG_PRINT(zeExecutableGraphDestroyExt);
-    } catch ([[maybe_unused]] const std::runtime_error& e) {
-      SPDLOG_ERROR("Error Loading Level Zero symbols: {}", e.what());
-    }
-  }
-
-  ze_result_t w_zeEventPoolGetFlags(ze_event_pool_handle_t hEventPool,
-                                    ze_event_pool_flags_t* pFlags) const {
-    if (nullptr != fptr_zeEventPoolGetFlags_) {
-      return fptr_zeEventPoolGetFlags_(hEventPool, pFlags);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeEventGetEventPool(ze_event_handle_t hEvent, ze_event_pool_handle_t* phEventPool) {
-    if (nullptr != fptr_zeEventGetEventPool_) {
-      return fptr_zeEventGetEventPool_(hEvent, phEventPool);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeEventPoolGetContextHandle(ze_event_pool_handle_t hEventPool,
-                                            ze_context_handle_t* phContext) {
-    if (nullptr != fptr_zeEventPoolGetContextHandle_) {
-      return fptr_zeEventPoolGetContextHandle_(hEventPool, phContext);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListGetDeviceHandle(ze_command_list_handle_t command_list,
-                                             ze_device_handle_t* device) const {
-    if (nullptr != fptr_zeCommandListGetDeviceHandle_) {
-      return fptr_zeCommandListGetDeviceHandle_(command_list, device);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListGetContextHandle(ze_command_list_handle_t command_list,
-                                              ze_context_handle_t* context) const {
-    if (nullptr != fptr_zeCommandListGetContextHandle_) {
-      return fptr_zeCommandListGetContextHandle_(command_list, context);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListIsImmediate(ze_command_list_handle_t command_list,
-                                         ze_bool_t* isImmediate) const {
-    if (nullptr != fptr_zeCommandListIsImmediate_) {
-      return fptr_zeCommandListIsImmediate_(command_list, isImmediate);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListGetFlags(ze_command_list_handle_t command_list,
-                                      ze_command_list_flags_t* flags) const {
-    if (nullptr != fptr_zeCommandListGetFlags_) {
-      return fptr_zeCommandListGetFlags_(command_list, flags);
-    }
-
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListImmediateGetIndex(ze_command_list_handle_t command_list,
-                                               uint32_t* index) const {
-    if (nullptr != fptr_zeCommandListImmediateGetIndex_) {
-      return fptr_zeCommandListImmediateGetIndex_(command_list, index);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListImmediateGetFlags(ze_command_list_handle_t command_list,
-                                               ze_command_queue_flags_t* flags) const {
-    if (nullptr != fptr_zeCommandListImmediateGetFlags_) {
-      return fptr_zeCommandListImmediateGetFlags_(command_list, flags);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListGetOrdinal(ze_command_list_handle_t command_list,
-                                        uint32_t* ordinal) const {
-    if (nullptr != fptr_zeCommandListGetOrdinal_) {
-      return fptr_zeCommandListGetOrdinal_(command_list, ordinal);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandQueueGetIndex(ze_command_queue_handle_t command_queue,
-                                       uint32_t* index) const {
-    if (nullptr != fptr_zeCommandQueueGetIndex_) {
-      return fptr_zeCommandQueueGetIndex_(command_queue, index);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandQueueGetOrdinal(ze_command_queue_handle_t command_queue,
-                                         uint32_t* ordinal) const {
-    if (nullptr != fptr_zeCommandQueueGetOrdinal_) {
-      return fptr_zeCommandQueueGetOrdinal_(command_queue, ordinal);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphCreateExt(ze_context_handle_t hContext, const void* pNext,
-                                 ze_graph_handle_t* phGraph) const {
-    if (nullptr != fptr_zeGraphCreateExt_) {
-      return fptr_zeGraphCreateExt_(hContext, pNext, phGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphDestroyExt(ze_graph_handle_t hGraph) const {
-    if (nullptr != fptr_zeGraphDestroyExt_) {
-      return fptr_zeGraphDestroyExt_(hGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphInstantiateExt(ze_graph_handle_t hGraph, const void* pNext,
-                                      ze_executable_graph_handle_t* phExecutableGraph) const {
-    if (nullptr != fptr_zeGraphInstantiateExt_) {
-      return fptr_zeGraphInstantiateExt_(hGraph, pNext, phExecutableGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphIsEmptyExt(ze_graph_handle_t hGraph) const {
-    if (nullptr != fptr_zeGraphIsEmptyExt_) {
-      return fptr_zeGraphIsEmptyExt_(hGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphDumpContentsExt(ze_graph_handle_t hGraph, const char* filePath,
-                                       const void* pNext) const {
-    if (nullptr != fptr_zeGraphDumpContentsExt_) {
-      return fptr_zeGraphDumpContentsExt_(hGraph, filePath, pNext);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphSetDestructionCallbackExt(ze_graph_handle_t hGraph,
-                                                 zex_mem_graph_free_callback_fn_t pfnCallback,
-                                                 void* pUserData, const void* pNext) const {
-    if (nullptr != fptr_zeGraphSetDestructionCallbackExt_) {
-      return fptr_zeGraphSetDestructionCallbackExt_(hGraph, pfnCallback, pUserData, pNext);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListBeginGraphCaptureExt(ze_command_list_handle_t hCommandList,
-                                                  const void* pNext) const {
-    if (nullptr != fptr_zeCommandListBeginGraphCaptureExt_) {
-      return fptr_zeCommandListBeginGraphCaptureExt_(hCommandList, pNext);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListBeginCaptureIntoGraphExt(ze_command_list_handle_t hCommandList,
-                                                      ze_graph_handle_t hGraph,
-                                                      const void* pNext) const {
-    if (nullptr != fptr_zeCommandListBeginCaptureIntoGraphExt_) {
-      return fptr_zeCommandListBeginCaptureIntoGraphExt_(hCommandList, hGraph, pNext);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListEndGraphCaptureExt(ze_command_list_handle_t hCommandList,
-                                                const void* pNext,
-                                                ze_graph_handle_t* phGraph) const {
-    if (nullptr != fptr_zeCommandListEndGraphCaptureExt_) {
-      return fptr_zeCommandListEndGraphCaptureExt_(hCommandList, pNext, phGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListIsGraphCaptureEnabledExt(ze_command_list_handle_t hCommandList) const {
-    if (nullptr != fptr_zeCommandListIsGraphCaptureEnabledExt_) {
-      return fptr_zeCommandListIsGraphCaptureEnabledExt_(hCommandList);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListAppendGraphExt(ze_command_list_handle_t hCommandList,
-                                            ze_executable_graph_handle_t hGraph, const void* pNext,
-                                            ze_event_handle_t hSignalEvent, uint32_t numWaitEvents,
-                                            ze_event_handle_t* phWaitEvents) const {
-    if (nullptr != fptr_zeCommandListAppendGraphExt_) {
-      return fptr_zeCommandListAppendGraphExt_(hCommandList, hGraph, pNext, hSignalEvent,
-                                               numWaitEvents, phWaitEvents);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeCommandListGetGraphExt(ze_command_list_handle_t hCommandList,
-                                         ze_graph_handle_t* phGraph) const {
-    if (nullptr != fptr_zeCommandListGetGraphExt_) {
-      return fptr_zeCommandListGetGraphExt_(hCommandList, phGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeGraphGetPrimaryCommandListExt(ze_graph_handle_t hGraph,
-                                                ze_command_list_handle_t* phCommandList) const {
-    if (nullptr != fptr_zeGraphGetPrimaryCommandListExt_) {
-      return fptr_zeGraphGetPrimaryCommandListExt_(hGraph, phCommandList);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeExecutableGraphGetSourceGraphExt(ze_executable_graph_handle_t hGraph,
-                                                   ze_graph_handle_t* phSourceGraph) const {
-    if (nullptr != fptr_zeExecutableGraphGetSourceGraphExt_) {
-      return fptr_zeExecutableGraphGetSourceGraphExt_(hGraph, phSourceGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zeExecutableGraphDestroyExt(ze_executable_graph_handle_t hGraph) const {
-    if (nullptr != fptr_zeExecutableGraphDestroyExt_) {
-      return fptr_zeExecutableGraphDestroyExt_(hGraph);
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zelEnableTracingLayer() const {
-    if (nullptr != fptr_zelEnableTracingLayer_) {
-      return fptr_zelEnableTracingLayer_();
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t w_zelDisableTracingLayer() const {
-    if (nullptr != fptr_zelDisableTracingLayer_) {
-      return fptr_zelDisableTracingLayer_();
-    }
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-  }
-
-  ze_result_t InitIntrospectionWrappers() const {
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-
-    if (nullptr == fptr_zeEventPoolGetFlags_ || nullptr == fptr_zeCommandListGetDeviceHandle_ ||
-        nullptr == fptr_zeEventGetEventPool_ || nullptr == fptr_zeEventPoolGetContextHandle_ ||
-        nullptr == fptr_zeCommandListGetContextHandle_ ||
-        nullptr == fptr_zeCommandListIsImmediate_ ||
-        nullptr == fptr_zeCommandListImmediateGetIndex_ ||
-        nullptr == fptr_zeCommandQueueGetIndex_ || nullptr == fptr_zeCommandQueueGetOrdinal_ ||
-        nullptr == fptr_zeCommandListGetOrdinal_) {
-      return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-    return ZE_RESULT_SUCCESS;
-  }
-
-  ze_result_t InitGraphWrappers() const {
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-
-    if (nullptr == fptr_zeGraphCreateExt_ || nullptr == fptr_zeGraphDestroyExt_ ||
-        nullptr == fptr_zeGraphInstantiateExt_ || nullptr == fptr_zeGraphIsEmptyExt_ ||
-        nullptr == fptr_zeGraphDumpContentsExt_ ||
-        nullptr == fptr_zeGraphSetDestructionCallbackExt_ ||
-        nullptr == fptr_zeCommandListBeginGraphCaptureExt_ ||
-        nullptr == fptr_zeCommandListBeginCaptureIntoGraphExt_ ||
-        nullptr == fptr_zeCommandListEndGraphCaptureExt_ ||
-        nullptr == fptr_zeCommandListIsGraphCaptureEnabledExt_ ||
-        nullptr == fptr_zeCommandListAppendGraphExt_ || nullptr == fptr_zeCommandListGetGraphExt_ ||
-        nullptr == fptr_zeGraphGetPrimaryCommandListExt_ ||
-        nullptr == fptr_zeExecutableGraphGetSourceGraphExt_ ||
-        nullptr == fptr_zeExecutableGraphDestroyExt_) {
-      return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-    return ZE_RESULT_SUCCESS;
-  }
-
-  ze_result_t InitDynamicTracingWrappers() const {
-    SPDLOG_DEBUG("In {}", __FUNCTION__);
-
-    if (nullptr == fptr_zelEnableTracingLayer_ || nullptr == fptr_zelDisableTracingLayer_) {
-      return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-    return ZE_RESULT_SUCCESS;
-  }
-
- private:
-  LibraryLoader l0_loader_;
-  decltype(&zeEventPoolGetFlags) fptr_zeEventPoolGetFlags_ = nullptr;
-  decltype(&zeEventGetEventPool) fptr_zeEventGetEventPool_ = nullptr;
-  decltype(&zeEventPoolGetContextHandle) fptr_zeEventPoolGetContextHandle_ = nullptr;
-  decltype(&zeCommandListGetDeviceHandle) fptr_zeCommandListGetDeviceHandle_ = nullptr;
-  decltype(&zeCommandListGetContextHandle) fptr_zeCommandListGetContextHandle_ = nullptr;
-  decltype(&zeCommandListGetFlags) fptr_zeCommandListGetFlags_ = nullptr;
-  decltype(&zeCommandListIsImmediate) fptr_zeCommandListIsImmediate_ = nullptr;
-  decltype(&zeCommandListImmediateGetIndex) fptr_zeCommandListImmediateGetIndex_ = nullptr;
-  decltype(&zeCommandListImmediateGetFlags) fptr_zeCommandListImmediateGetFlags_ = nullptr;
-  decltype(&zeCommandListGetOrdinal) fptr_zeCommandListGetOrdinal_ = nullptr;
-  decltype(&zeCommandQueueGetIndex) fptr_zeCommandQueueGetIndex_ = nullptr;
-  decltype(&zeCommandQueueGetOrdinal) fptr_zeCommandQueueGetOrdinal_ = nullptr;
-  decltype(&zelEnableTracingLayer) fptr_zelEnableTracingLayer_ = nullptr;
-  decltype(&zelDisableTracingLayer) fptr_zelDisableTracingLayer_ = nullptr;
-  decltype(&zeGraphCreateExt) fptr_zeGraphCreateExt_ = nullptr;
-  decltype(&zeGraphDestroyExt) fptr_zeGraphDestroyExt_ = nullptr;
-  decltype(&zeGraphInstantiateExt) fptr_zeGraphInstantiateExt_ = nullptr;
-  decltype(&zeGraphIsEmptyExt) fptr_zeGraphIsEmptyExt_ = nullptr;
-  decltype(&zeGraphDumpContentsExt) fptr_zeGraphDumpContentsExt_ = nullptr;
-  decltype(&zeGraphSetDestructionCallbackExt) fptr_zeGraphSetDestructionCallbackExt_ = nullptr;
-  decltype(&zeCommandListBeginGraphCaptureExt) fptr_zeCommandListBeginGraphCaptureExt_ = nullptr;
-  decltype(&zeCommandListBeginCaptureIntoGraphExt) fptr_zeCommandListBeginCaptureIntoGraphExt_ =
-      nullptr;
-  decltype(&zeCommandListEndGraphCaptureExt) fptr_zeCommandListEndGraphCaptureExt_ = nullptr;
-  decltype(&zeCommandListIsGraphCaptureEnabledExt) fptr_zeCommandListIsGraphCaptureEnabledExt_ =
-      nullptr;
-  decltype(&zeCommandListAppendGraphExt) fptr_zeCommandListAppendGraphExt_ = nullptr;
-  decltype(&zeCommandListGetGraphExt) fptr_zeCommandListGetGraphExt_ = nullptr;
-  decltype(&zeGraphGetPrimaryCommandListExt) fptr_zeGraphGetPrimaryCommandListExt_ = nullptr;
-  decltype(&zeExecutableGraphGetSourceGraphExt) fptr_zeExecutableGraphGetSourceGraphExt_ = nullptr;
-  decltype(&zeExecutableGraphDestroyExt) fptr_zeExecutableGraphDestroyExt_ = nullptr;
-};
-#undef LOADER_LOAD_AND_DEBUG_PRINT
-#endif
diff --git a/sdk/src/libpti.map b/sdk/src/libpti.map
deleted file mode 100644
index c2e13b49..00000000
--- a/sdk/src/libpti.map
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  global:
-    pti*;     /* Public API */
-    Pti*;     /* Private but exported symbols (used by pti_view) */
-    itt*;     /* Private but exported symbols (ITT collector, used by pti_view) */
-    Itt*;     /* Private but exported symbols (ITT collector, used by pti_view) */
-    xpti*;    /* Used by SYCL collector (XPTI tracing) */
-    extern "C++" {
-      SyclCollector::TpCallback*;  /* XPTI tracepoint callback */
-    };
-
-  local:
-    *;
-};
diff --git a/sdk/src/libpti_view.map b/sdk/src/libpti_view.map
deleted file mode 100644
index 0bc80591..00000000
--- a/sdk/src/libpti_view.map
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  global:
-    pti*;     /* Public API */
-    __itt*;   /* Used to collect data for Intel® ITT */
-    xpti*;    /* Used by SYCL collector (XPTI tracing) */
-
-  local:
-    *;
-};
diff --git a/sdk/src/lz_api_tracing_api_loader.h b/sdk/src/lz_api_tracing_api_loader.h
deleted file mode 100644
index d5eac198..00000000
--- a/sdk/src/lz_api_tracing_api_loader.h
+++ /dev/null
@@ -1,104 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef LZ_API_TRACING_API_LOADER_H_
-#define LZ_API_TRACING_API_LOADER_H_
-
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/layers/zel_tracing_register_cb.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <level_zero/zet_api.h>
-#include <spdlog/cfg/env.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-
-#include <memory>
-
-#include "utils/library_loader.h"
-#include "utils/utils.h"
-
-namespace pti {
-
-#if defined(_WIN32)
-inline static constexpr const char* const kLevelZeroLoaderName = "ze_loader.dll";
-#else
-inline static constexpr const char* const kLevelZeroLoaderName = "libze_loader.so.1";
-#endif
-
-class PtiLzTracerLoader {
- public:
-  static auto& Instance() {
-    static PtiLzTracerLoader instance{};
-    return instance;
-  }
-
-  void Unload() { api_dlsyms_lib_.reset(nullptr); }
-
-  bool Available() const { return api_dlsyms_lib_ != nullptr; }
-
-  decltype(&zeInitDrivers) zeInitDrivers_ = nullptr;                              // NOLINT
-  decltype(&zesDriverGetDeviceByUuidExp) zesDriverGetDeviceByUuidExp_ = nullptr;  // NOLINT
-  decltype(&zeKernelGetBinaryExp) zeKernelGetBinaryExp_ = nullptr;                // NOLINT
-  decltype(&zeExecutableGraphGetSourceGraphExt) zeExecutableGraphGetSourceGraphExt_ =
-      nullptr;                                                                            // NOLINT
-  decltype(&zeGraphGetPrimaryCommandListExt) zeGraphGetPrimaryCommandListExt_ = nullptr;  // NOLINT
-  decltype(&zeGraphCreateExt) zeGraphCreateExt_ = nullptr;                                // NOLINT
-  decltype(&zeCommandListBeginCaptureIntoGraphExt) zeCommandListBeginCaptureIntoGraphExt_ =
-      nullptr;                                                                            // NOLINT
-  decltype(&zeCommandListEndGraphCaptureExt) zeCommandListEndGraphCaptureExt_ = nullptr;  // NOLINT
-  decltype(&zeGraphInstantiateExt) zeGraphInstantiateExt_ = nullptr;                      // NOLINT
-  decltype(&zetDeviceEnableMetricsExp) zetDeviceEnableMetricsExp_ = nullptr;              // NOLINT
-  decltype(&zetDeviceDisableMetricsExp) zetDeviceDisableMetricsExp_ = nullptr;            // NOLINT
-  decltype(&zeCommandListIsImmediate) zeCommandListIsImmediate_ = nullptr;                // NOLINT
-  decltype(&zeCommandListGetFlags) zeCommandListGetFlags_ = nullptr;                      // NOLINT
-  decltype(&zeCommandListImmediateGetFlags) zeCommandListImmediateGetFlags_ = nullptr;    // NOLINT
-
-  // Forward to implementation in core library
-#include "tracing_api_dlsym_public.gen"  // Auto-generated callbacks
-
-#define APPEND_COMMAND(X) \
-  decltype(&zeCommandListAppend##X) zeCommandListAppend##X##_ = nullptr;  // NOLINT
-#include "levelzero/ze_visitor_commands.inc"
-#undef APPEND_COMMAND
-
- private:
-  PtiLzTracerLoader() {
-    try {
-      api_dlsyms_lib_ = std::make_unique<LibraryLoader>(kLevelZeroLoaderName);
-    } catch (const std::exception& e) {
-      SPDLOG_ERROR("Unable to load {} because {}", kLevelZeroLoaderName, e.what());
-      api_dlsyms_lib_ = nullptr;
-      return;
-    }
-#define LEVEL_ZERO_LOADER_GET_SYMBOL(X) \
-  X##_ = api_dlsyms_lib_->GetSymbol<decltype(&X)>(#X)  // NOLINT
-#include "tracing_api_dlsym_private.gen"               // Auto-generated callbacks
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeInitDrivers);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zesDriverGetDeviceByUuidExp);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeKernelGetBinaryExp);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeExecutableGraphGetSourceGraphExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeGraphGetPrimaryCommandListExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeGraphCreateExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeCommandListBeginCaptureIntoGraphExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeCommandListEndGraphCaptureExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeGraphInstantiateExt);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zetDeviceEnableMetricsExp);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zetDeviceDisableMetricsExp);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeCommandListIsImmediate);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeCommandListGetFlags);
-    LEVEL_ZERO_LOADER_GET_SYMBOL(zeCommandListImmediateGetFlags);
-#undef LEVEL_ZERO_LOADER_GET_SYMBOL
-#define APPEND_COMMAND(X)                                                                    \
-  zeCommandListAppend##X##_ = api_dlsyms_lib_->GetSymbol<decltype(&zeCommandListAppend##X)>( \
-      "zeCommandListAppend" #X);  // NOLINT
-#include "levelzero/ze_visitor_commands.inc"
-#undef APPEND_COMMAND
-  }
-  std::unique_ptr<LibraryLoader> api_dlsyms_lib_ = nullptr;
-};
-}  // namespace pti
-
-#endif  // LZ_API_TRACING_API_LOADER_H_
diff --git a/sdk/src/metrics/metric_state_manager.cc b/sdk/src/metrics/metric_state_manager.cc
deleted file mode 100644
index 9b19dfc1..00000000
--- a/sdk/src/metrics/metric_state_manager.cc
+++ /dev/null
@@ -1,210 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "metric_state_manager.h"
-
-#include <cstdlib>
-#include <mutex>
-#include <shared_mutex>
-#include <vector>
-
-#include "lz_api_tracing_api_loader.h"
-#include "pti/pti_metrics.h"
-#include "spdlog/spdlog.h"
-#include "utils/utils.h"
-#include "utils/ze_utils.h"
-#include "ze_driver_init.h"
-
-namespace pti {
-namespace metrics {
-
-namespace {
-ze_result_t DeviceEnableMetricsExp(ze_device_handle_t device) {
-  auto enable_metrics = PtiLzTracerLoader::Instance().zetDeviceEnableMetricsExp_;
-  if (enable_metrics) {
-    return enable_metrics(device);
-  }
-  return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ze_result_t DeviceDisableMetricsExp(ze_device_handle_t device) {
-  auto disable_metrics = PtiLzTracerLoader::Instance().zetDeviceDisableMetricsExp_;
-  if (disable_metrics) {
-    return disable_metrics(device);
-  }
-  return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-}  // namespace
-
-MetricStateManager& MetricStateManager::Instance() {
-  static MetricStateManager instance;
-  return instance;
-}
-
-pti_result MetricStateManager::EnableSingleDevice(ze_device_handle_t device) {
-  auto it = device_ref_counts_.find(device);
-  if (it != device_ref_counts_.end()) {
-    it->second++;
-    return PTI_SUCCESS;
-  }
-
-  const auto status = DeviceEnableMetricsExp(device);
-  if (status != ZE_RESULT_SUCCESS) {
-    if (status == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
-      SPDLOG_ERROR(
-          "zetDeviceEnableMetricsExp is not supported by the Level Zero driver. "
-          "WORKAROUND: Set the environment variable ZET_ENABLE_METRICS=1 before running your "
-          "application.");
-      return PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED;
-    }
-    SPDLOG_ERROR("zetDeviceEnableMetricsExp failed with status: 0x{:x}",
-                 static_cast<uint32_t>(status));
-    return PTI_ERROR_DRIVER;
-  }
-
-  device_ref_counts_[device] = 1;
-  return PTI_SUCCESS;
-}
-
-pti_result MetricStateManager::DisableSingleDevice(ze_device_handle_t device) {
-  auto it = device_ref_counts_.find(device);
-  if (it == device_ref_counts_.end()) {
-    // Device not in our map, nothing to disable
-    return PTI_SUCCESS;
-  }
-
-  if (it->second > 1) {
-    // Other users still need metrics enabled on this device, only drop this reference
-    it->second--;
-    return PTI_SUCCESS;
-  }
-
-  // This was the last reference, disable metrics on this device. The reference is kept on
-  // failure so that a later call can retry the disable.
-  const auto status = DeviceDisableMetricsExp(device);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_WARN("zetDeviceDisableMetricsExp failed with status: 0x{:x}",
-                static_cast<uint32_t>(status));
-    return PTI_ERROR_DRIVER;
-  }
-
-  device_ref_counts_.erase(it);
-  return PTI_SUCCESS;
-}
-
-pti_result MetricStateManager::EnableMetric(pti_device_handle_t device) {
-  bool metrics_enabled_env = (::utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-  if (metrics_enabled_env) {
-    // The driver already has metrics enabled on every device, so there is nothing to reference
-    // count here.
-    return PTI_SUCCESS;
-  }
-
-  // Driver initialization is done before taking state_mutex_: it calls into zeInit/zesInit and
-  // enumerates drivers and extensions, which is far too much work to hold a global lock across.
-  // ZeDriverInit is idempotent, so constructing it outside the lock is safe.
-  ZeDriverInit init_drivers{};
-  if (!init_drivers.Success()) {
-    SPDLOG_ERROR("Level Zero driver initialization failed");
-    return PTI_ERROR_DRIVER;
-  }
-
-  std::lock_guard<std::shared_mutex> lock(state_mutex_);
-
-  if (device == nullptr) {
-    // Enumerate through init_drivers.Drivers() rather than the argument-less overload.
-    // ZeDriverInit unions the drivers reported by zeDriverGet with those from zeInitDrivers, so
-    // the argument-less overload can miss devices that PtiMetricsCollectorHandler still discovers
-    // and validates against. Any such device would never be reference counted here, and the
-    // handler would then permanently report metrics as not enabled on all devices.
-    // The unique overload is required, not just preferred: one physical device may be reported by
-    // several driver handles, and a duplicate would take an extra reference that no matching
-    // ptiMetricsDisable call would ever release.
-    std::vector<ze_device_handle_t> devices_to_enable =
-        ::utils::ze::GetUniqueDeviceList(init_drivers.Drivers());
-    if (devices_to_enable.empty()) {
-      SPDLOG_ERROR("No devices found to enable metrics");
-      return PTI_ERROR_DRIVER;
-    }
-
-    // Track all successfully enabled devices for rollback on failure
-    std::vector<ze_device_handle_t> enabled_devs;
-    pti_result overall_status = PTI_SUCCESS;
-
-    for (auto dev : devices_to_enable) {
-      pti_result status = EnableSingleDevice(dev);
-      if (status != PTI_SUCCESS) {
-        overall_status = status;
-        // Rollback: release every reference this call acquired, including devices that were
-        // already enabled and only had their reference count incremented.
-        for (auto enabled_dev : enabled_devs) {
-          DisableSingleDevice(enabled_dev);
-        }
-        SPDLOG_ERROR("Failed to enable metrics on device {}: {}", static_cast<void*>(dev),
-                     ptiResultTypeToString(status));
-        return overall_status;
-      }
-      enabled_devs.push_back(dev);
-    }
-    return PTI_SUCCESS;
-  } else {
-    return EnableSingleDevice(reinterpret_cast<ze_device_handle_t>(device));
-  }
-}
-
-pti_result MetricStateManager::DisableMetric(pti_device_handle_t device) {
-  bool metrics_enabled_env = (::utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-  if (metrics_enabled_env) {
-    // EnableMetric() took no reference in this mode, so there is nothing to release. The driver
-    // keeps metrics enabled for the lifetime of the process.
-    return PTI_SUCCESS;
-  }
-
-  std::lock_guard<std::shared_mutex> lock(state_mutex_);
-
-  if (device == nullptr) {
-    // Make a copy of keys since we may modify the map during iteration
-    std::vector<ze_device_handle_t> devices_to_disable;
-    devices_to_disable.reserve(device_ref_counts_.size());
-    for (const auto& pair : device_ref_counts_) {
-      devices_to_disable.push_back(pair.first);
-    }
-
-    pti_result overall_status = PTI_SUCCESS;
-    for (auto dev : devices_to_disable) {
-      pti_result status = DisableSingleDevice(dev);
-      if (status != PTI_SUCCESS) {
-        overall_status = status;
-        // Continue trying to disable remaining devices
-      }
-    }
-    return overall_status;
-  } else {
-    return DisableSingleDevice(reinterpret_cast<ze_device_handle_t>(device));
-  }
-}
-
-bool MetricStateManager::IsMetricEnabled(pti_device_handle_t device) {
-  bool metrics_enabled_env = (::utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-  if (metrics_enabled_env) {
-    return true;
-  }
-
-  // Shared lock: this path only reads device_ref_counts_ and is on the hot path of every
-  // metrics API call via MetricsUsable().
-  std::shared_lock<std::shared_mutex> lock(state_mutex_);
-
-  if (device == nullptr) {
-    return !device_ref_counts_.empty();
-  } else {
-    ze_device_handle_t ze_device = reinterpret_cast<ze_device_handle_t>(device);
-    auto it = device_ref_counts_.find(ze_device);
-    return (it != device_ref_counts_.end() && it->second > 0);
-  }
-}
-
-}  // namespace metrics
-}  // namespace pti
diff --git a/sdk/src/metrics/metric_state_manager.h b/sdk/src/metrics/metric_state_manager.h
deleted file mode 100644
index 9ce224fc..00000000
--- a/sdk/src/metrics/metric_state_manager.h
+++ /dev/null
@@ -1,58 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_METRICS_METRIC_STATE_MANAGER_H_
-#define PTI_METRICS_METRIC_STATE_MANAGER_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-
-#include <mutex>
-#include <shared_mutex>
-#include <unordered_map>
-
-#include "pti/pti_metrics.h"
-
-namespace pti {
-namespace metrics {
-
-// Global metric enable/disable state manager with per-device reference counting
-class MetricStateManager {
- public:
-  static MetricStateManager& Instance();
-
-  // If device is nullptr, enables/disables metrics for all devices
-  pti_result EnableMetric(pti_device_handle_t device);
-  pti_result DisableMetric(pti_device_handle_t device);
-
-  // Check if metrics are enabled for a device (or any device if nullptr)
-  // Returns true if metrics are enabled via environment variable OR
-  // if the device has a positive reference count
-  bool IsMetricEnabled(pti_device_handle_t device = nullptr);
-
- private:
-  MetricStateManager() = default;
-  ~MetricStateManager() = default;
-  MetricStateManager(const MetricStateManager&) = delete;
-  MetricStateManager& operator=(const MetricStateManager&) = delete;
-
-  pti_result EnableSingleDevice(ze_device_handle_t device);
-  pti_result DisableSingleDevice(ze_device_handle_t device);
-
-  std::unordered_map<ze_device_handle_t, int32_t> device_ref_counts_;
-
-  // Protects device_ref_counts_. A shared_mutex rather than a plain mutex because
-  // IsMetricEnabled() only reads the map and is reached from every metrics entry point via
-  // PtiMetricsCollectorHandler::MetricsUsable(); an exclusive lock there would serialize all of
-  // them against each other. EnableMetric()/DisableMetric() mutate the map and still take it
-  // exclusively.
-  std::shared_mutex state_mutex_;
-};
-
-}  // namespace metrics
-}  // namespace pti
-
-#endif  // PTI_METRICS_METRIC_STATE_MANAGER_H_
diff --git a/sdk/src/metrics/metrics_handler.h b/sdk/src/metrics/metrics_handler.h
deleted file mode 100644
index e8b00260..00000000
--- a/sdk/src/metrics/metrics_handler.h
+++ /dev/null
@@ -1,2549 +0,0 @@
-
-// ==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_API_METRICS_HANDLER_H_
-#define SRC_API_METRICS_HANDLER_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <spdlog/cfg/env.h>
-#include <spdlog/spdlog.h>
-#include <stdbool.h>
-
-#include <algorithm>
-#include <atomic>
-#include <iostream>
-#include <mutex>
-#include <shared_mutex>
-#include <string>
-#include <string_view>
-#include <thread>
-
-#include "metric_state_manager.h"
-#include "pti/pti_metrics.h"
-#include "utils/pti_filesystem.h"
-#include "utils/pti_string_pool.h"
-#include "utils/utils.h"
-#include "utils/ze_utils.h"
-#include "ze_driver_init.h"
-
-namespace {
-// Metrics collection constants
-constexpr uint32_t kMaxMetricCountPerGroup = 512;
-constexpr uint32_t kMetricPoolEventCount = 1000;
-
-// Platform-specific buffer sizes
-#ifndef _WIN32
-constexpr uint32_t kMaxMetricSamples = 2048;
-#else
-constexpr uint32_t kMaxMetricSamples = 32768;
-#endif
-
-// Buffer management constants
-constexpr uint8_t kMaxDataCaptureCount = 10;
-constexpr size_t kMaxBufferSizePadding = 512;
-constexpr uint32_t kTileCountPadding = 2;  // For systems with 2 tiles
-// Buffer size calculations
-constexpr size_t kMaxMetricBufferSize =
-    kMaxMetricSamples * kMaxMetricCountPerGroup * kTileCountPadding + kMaxBufferSizePadding;
-
-// Sampling and aggregation defaults
-constexpr uint32_t kDefaultSamplingIntervalNs = 1'000'000U;  // 1 millisecond
-
-// Important constants for metrics collection and handling
-constexpr uint64_t kMask64Bits = 0xFFFFFFFFFFFFFFFF;
-
-constexpr uint32_t kReportReasonContextSwitchBit = (1u << 3);  // Value of 8
-constexpr std::string_view kTimeStampMetric = "QueryBeginTime";
-constexpr std::string_view kReportReasonMetric = "ReportReason";
-
-}  // namespace
-
-enum class ptiMetricProfilerState {
-  PROFILER_DISABLED = 0,
-  PROFILER_ENABLED = 1,
-  PROFILER_PAUSED = 2,
-};
-
-struct pti_metrics_device_descriptor_t {
-  ze_device_handle_t device_ = nullptr;
-  ze_device_handle_t parent_device_ = nullptr;
-  uint64_t host_time_origin_ = 0;
-  uint64_t device_time_origin_ = 0;
-  uint64_t device_timer_frequency_ = 0;
-  uint64_t device_timer_mask_ = 0;
-  uint64_t metric_time_origin_ = 0;
-  uint64_t metric_timer_frequency_ = 0;
-  uint64_t metric_timer_mask_ = 0;
-  ze_driver_handle_t driver_ = nullptr;
-  ze_context_handle_t context_ = nullptr;
-  ze_event_pool_handle_t event_pool_ = nullptr;
-  ze_event_handle_t event_ = nullptr;
-  int32_t num_sub_devices_ = 0;
-  zet_metric_group_handle_t metrics_group_ = nullptr;
-  ze_pci_ext_properties_t pci_properties_;
-  std::unique_ptr<std::thread> profiling_thread_ = nullptr;
-
-  std::string metric_file_name_ = "";
-  std::ofstream metric_file_stream_;
-  bool stall_sampling_ = false;
-
-  // Per-device data
-  std::vector<uint8_t> metric_data_ = {};
-  uint8_t capture_count_ = 0;
-
-  mutable std::mutex file_access_mutex_;  // Protects file operations during GetCalculatedData
-
-  // Atomic state - no mutex needed
-  std::atomic<ptiMetricProfilerState> profiling_state_ = ptiMetricProfilerState::PROFILER_DISABLED;
-
-  // Per-device thread start synchronization (not shared across devices!)
-  std::mutex profiling_thread_start_mutex_;
-  std::condition_variable profiling_thread_start_cv_;
-  bool profiling_thread_initialized_ = false;  // Protected by profiling_thread_start_mutex_
-
-  // Query-specific fields. Capacity grows by adding a chunk rather than
-  // resizing, so slots already handed out keep their handles.
-  std::vector<zet_metric_query_pool_handle_t> query_pool_chunks_;
-  std::vector<ze_event_pool_handle_t> event_pool_chunks_;
-
-  // A query paired 1:1 with the event that signals its data is ready.
-  using MetricQuerySlot = std::pair<zet_metric_query_handle_t, ze_event_handle_t>;
-
-  // all_slots_ owns every slot taken from the pools, for teardown; free_slots_
-  // holds the ones available for reuse.
-  std::vector<MetricQuerySlot> all_slots_;
-  std::vector<MetricQuerySlot> free_slots_;
-};
-
-class PtiMetricsProfiler {
- protected:
-  // per driver metric contexts
-  std::vector<ze_context_handle_t> metric_contexts_;
-
-  // descriptors where device and sub device profiling information is saved
-  std::unordered_map<ze_device_handle_t, std::shared_ptr<pti_metrics_device_descriptor_t>>
-      device_descriptors_;
-  mutable std::once_flag device_descriptors_initialized_;
-
-  // temporary directory name where raw data is saved to disc
-  std::string data_dir_name_;
-  // spdlogger for user specific log file
-  std::shared_ptr<spdlog::logger> user_logger_;
-  // condition variable for the profiling thread to wait for the profiling state to change
-  std::condition_variable cv_pause_;
-
-  // max number of samples used for allocating local buffer and setting hw full notification
-  inline static std::atomic<uint32_t> max_metric_samples_ = kMaxMetricSamples;
-
-  // maximum number of hw buffer reads before local buffer is written to disc
-  inline static uint8_t max_data_capture_count_ = kMaxDataCaptureCount;
-
- public:
-  PtiMetricsProfiler() = delete;
-  PtiMetricsProfiler(const PtiMetricsProfiler &) = delete;
-  PtiMetricsProfiler &operator=(const PtiMetricsProfiler &) = delete;
-  PtiMetricsProfiler(PtiMetricsProfiler &&) = delete;
-  PtiMetricsProfiler &operator=(PtiMetricsProfiler &&) = delete;
-
-  PtiMetricsProfiler(pti_device_handle_t device_handle,
-                     pti_metrics_group_handle_t metrics_group_handle) {
-    auto data_dir = utils::CreateTempDirectory();
-
-    PTI_ASSERT(pti::utils::filesystem::exists(data_dir));
-    SPDLOG_DEBUG("Temp dir {}", data_dir.string());
-
-    data_dir_name_ = data_dir.generic_string();
-
-    bool enable_logging = (utils::GetEnv("PTI_LogToFile") == "1");
-    std::string log_filename = enable_logging ? utils::GetEnv("PTI_LogFileName") : "";
-    SPDLOG_INFO("Metrics profiler logging is {}. Log file name: {}",
-                enable_logging ? "enabled" : "disabled",
-                log_filename.empty() ? "N/A" : log_filename);
-    user_logger_ = utils::GetLogStream(enable_logging, std::move(log_filename));
-
-    // Ensure thread-safe one-time initialization
-    std::call_once(device_descriptors_initialized_, [this, device_handle, metrics_group_handle]() {
-      EnumerateDevices(device_handle, metrics_group_handle);
-    });
-    SPDLOG_DEBUG("Found {} devices for metrics profiling", device_descriptors_.size());
-  }
-
-  static uint64_t GetMaxMetricBufferSize() {
-    // kTileCountPadding is for systems with multiple tiles
-    // kMaxBufferSizePadding is for extra padding
-    // TODO: may need to be adjusted per specific target
-    return static_cast<uint64_t>(max_metric_samples_) * kMaxMetricCountPerGroup *
-               kTileCountPadding +
-           kMaxBufferSizePadding;
-  }
-
-  virtual ~PtiMetricsProfiler() {
-    metric_contexts_.clear();
-
-    // Stopping runaway collections in case stop was not called
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      // close the data file
-      it->second->metric_file_stream_.close();
-
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      if (it->second->profiling_state_ != ptiMetricProfilerState::PROFILER_DISABLED) {
-        SPDLOG_DEBUG("Stopping runaway metrics collection");
-        it->second->profiling_state_.store(ptiMetricProfilerState::PROFILER_DISABLED,
-                                           std::memory_order_release);
-
-        cv_pause_.notify_one();
-        it->second->profiling_thread_->join();
-        it->second->profiling_thread_.reset();
-        it->second->metric_file_stream_.close();
-      }
-    }
-    device_descriptors_.clear();
-    user_logger_.reset();
-    try {
-      pti::utils::filesystem::remove_all(data_dir_name_);
-    } catch (...) {
-      SPDLOG_DEBUG("Failed to delete temporary data directory: {:s} ", data_dir_name_);
-    }
-  }
-
- protected:
-  // Helper: Wait for a profiling thread to complete initialization
-  // Returns PTI_SUCCESS if thread initialized successfully, PTI_ERROR_DRIVER on failure
-  pti_result WaitForProfilingThreadInitialization(
-      std::shared_ptr<pti_metrics_device_descriptor_t> desc) {
-    {
-      // Wait with predicate to avoid lost wakeup
-      std::unique_lock<std::mutex> thread_start_lock(desc->profiling_thread_start_mutex_);
-      desc->profiling_thread_start_cv_.wait(
-          thread_start_lock, [&desc]() { return desc->profiling_thread_initialized_; });
-    }
-
-    // Check if the profiling thread successfully initialized
-    ptiMetricProfilerState final_state = desc->profiling_state_.load(std::memory_order_acquire);
-
-    if (final_state == ptiMetricProfilerState::PROFILER_DISABLED) {
-      // Thread failed to initialize
-      SPDLOG_DEBUG("Profiling thread failed to initialize");
-      if (desc->profiling_thread_ && desc->profiling_thread_->joinable()) {
-        desc->profiling_thread_->join();
-        desc->profiling_thread_.reset();
-      }
-      return PTI_ERROR_DRIVER;
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  // Helper: Signal that profiling thread has completed initialization (success or failure)
-  // Should be called by profiling thread after initialization attempt
-  static void SignalThreadInitialized(std::shared_ptr<pti_metrics_device_descriptor_t> desc,
-                                      ptiMetricProfilerState state) {
-    // Set state first
-    desc->profiling_state_.store(state, std::memory_order_release);
-
-    // Then set flag and notify under lock
-    {
-      std::lock_guard<std::mutex> lock(desc->profiling_thread_start_mutex_);
-      desc->profiling_thread_initialized_ = true;
-      desc->profiling_thread_start_cv_.notify_one();
-    }
-  }
-
- public:
-  virtual pti_result StartProfiling(bool start_paused) = 0;
-
-  virtual pti_result PauseProfiling() {
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_ENABLED) {
-        SPDLOG_DEBUG("Pausing profiling");
-        it->second->profiling_state_.store(ptiMetricProfilerState::PROFILER_PAUSED,
-                                           std::memory_order_release);
-      } else {
-        if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_DISABLED) {
-          SPDLOG_DEBUG("Attempted to pause a disabled metrics profiling session");
-          return PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED;
-        } else if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_PAUSED) {
-          SPDLOG_DEBUG("Attempted to pause an already pause metrics profiling session");
-          return PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED;
-        }
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
-  virtual pti_result ResumeProfiling() {
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_PAUSED) {
-        SPDLOG_DEBUG("Resume profiling");
-        it->second->profiling_state_.store(ptiMetricProfilerState::PROFILER_ENABLED,
-                                           std::memory_order_release);
-        cv_pause_.notify_one();
-      } else {
-        if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_DISABLED) {
-          SPDLOG_DEBUG("Attempted to resume a disabled metrics profiling session");
-          return PTI_ERROR_METRICS_COLLECTION_NOT_PAUSED;
-        } else if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_ENABLED) {
-          SPDLOG_DEBUG("Attempted to resume an already running metrics profiling session");
-          return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-        }
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
-  virtual pti_result StopProfiling() {
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      // Collection should be running or paused before stop is called
-      if (it->second->profiling_thread_ == nullptr ||
-          it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_DISABLED) {
-        SPDLOG_DEBUG("Attempting to stop a metrics collection that hasn't been started");
-        return PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED;
-      }
-
-      it->second->profiling_state_.store(ptiMetricProfilerState::PROFILER_DISABLED,
-                                         std::memory_order_release);
-
-      // If profiling state is in paused mode when stop is called, unblock the profiling thread by
-      // notifying that the state has changed
-      cv_pause_.notify_one();
-      it->second->profiling_thread_->join();
-      SPDLOG_DEBUG("Stopping profiling for device: {}", static_cast<const void *>(it->first));
-      it->second->profiling_thread_.reset();
-      it->second->metric_file_stream_.close();
-    }
-    return PTI_SUCCESS;
-  }
-
-  // Default implementation. Inheriting class should invoke parent implementation as well as
-  // implement class specific handling of the data.
-  virtual pti_result GetCalculatedData(
-      [[maybe_unused]] pti_metrics_group_handle_t metrics_group_handle,
-      [[maybe_unused]] pti_value_t *metrics_values_buffer,
-      [[maybe_unused]] uint32_t *metrics_values_count) {
-    pti_result result = PTI_SUCCESS;
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      // Collection should be stopped before dump is called
-      if (it->second->profiling_state_ != ptiMetricProfilerState::PROFILER_DISABLED) {
-        SPDLOG_DEBUG(
-            "Attempting to calculate data from a metrics collection that hasn't been stopped");
-        result = PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED;
-      }
-    }
-
-    // Stopping runaway collection if stop is not called before dump is called
-    if (result != PTI_SUCCESS) {
-      // Don't capture result from Stop and return previous error
-      SPDLOG_DEBUG("Stopping runaway collection");
-      StopProfiling();
-    }
-    return result;
-  }
-
- private:
-  void EnumerateDevices(pti_device_handle_t device_handle,
-                        pti_metrics_group_handle_t metrics_group_handle) {
-    bool stall_sampling = false;
-    ze_device_handle_t device = static_cast<ze_device_handle_t>(device_handle);
-    PTI_ASSERT(device != nullptr);
-    zet_metric_group_handle_t group = static_cast<zet_metric_group_handle_t>(metrics_group_handle);
-    PTI_ASSERT(group != nullptr);
-
-    // get group name for metric group
-    zet_metric_group_properties_t group_props;
-    std::memset(&group_props, 0, sizeof(group_props));
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    ze_result_t status = zetMetricGroupGetProperties(
-        static_cast<zet_metric_group_handle_t>(metrics_group_handle), &group_props);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    std::string group_name = group_props.name;
-    if (group_name == "EuStallSampling") {
-      stall_sampling = true;
-    }
-
-    static std::mutex driver_mutex;
-    uint32_t num_drivers = 0;
-    {
-      std::lock_guard<std::mutex> lock(driver_mutex);
-      status = zeDriverGet(&num_drivers, nullptr);
-    }
-
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    if (num_drivers > 0) {
-      //      int32_t did = 0;
-      std::vector<ze_driver_handle_t> drivers(num_drivers);
-      status = zeDriverGet(&num_drivers, drivers.data());
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      for (auto driver : drivers) {
-        ze_context_handle_t context = nullptr;
-        ze_context_desc_t cdesc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-        status = zeContextCreate(driver, &cdesc, &context);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-        metric_contexts_.push_back(context);
-
-        uint32_t num_sub_devices = 0;
-        status = zeDeviceGetSubDevices(device, &num_sub_devices, nullptr);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        std::shared_ptr<pti_metrics_device_descriptor_t> desc =
-            std::make_shared<pti_metrics_device_descriptor_t>();
-
-        desc->stall_sampling_ = stall_sampling;
-
-        desc->device_ = device;
-        desc->parent_device_ = nullptr;
-        desc->num_sub_devices_ = num_sub_devices;
-
-        desc->device_timer_frequency_ = utils::ze::GetDeviceTimerFrequency(device);
-        desc->device_timer_mask_ = utils::ze::GetDeviceTimestampMask(device);
-        desc->metric_timer_frequency_ = utils::ze::GetDeviceTimerFrequency(device);
-        desc->metric_timer_mask_ = utils::ze::GetMetricTimestampMask(device);
-
-        ze_pci_ext_properties_t pci_device_properties;
-        std::memset(&pci_device_properties, 0, sizeof(pci_device_properties));
-        ze_result_t status = zeDevicePciGetPropertiesExt(device, &pci_device_properties);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc->pci_properties_ = pci_device_properties;
-
-        desc->driver_ = driver;
-        desc->context_ = context;
-        desc->metrics_group_ = group;
-
-        uint64_t host_time = 0;
-        uint64_t ticks = 0;
-        uint64_t device_time = 0;
-        uint64_t metric_time = 0;
-
-        status = zeDeviceGetGlobalTimestamps(device, &host_time, &ticks);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        device_time = ticks & desc->device_timer_mask_;
-        device_time = device_time * NSEC_IN_SEC / desc->device_timer_frequency_;
-
-        metric_time = ticks & desc->metric_timer_mask_;
-        metric_time = metric_time * NSEC_IN_SEC / desc->metric_timer_frequency_;
-
-        desc->host_time_origin_ = host_time;
-        desc->device_time_origin_ = device_time;
-        desc->metric_time_origin_ = metric_time;
-
-        desc->profiling_thread_.reset();
-        desc->profiling_state_.store(ptiMetricProfilerState::PROFILER_DISABLED,
-                                     std::memory_order_release);
-
-        desc->metric_file_name_ =
-            data_dir_name_ + "/." + group_name + "." + std::to_string(utils::GetPid()) + ".t";
-
-        desc->metric_file_stream_ = std::ofstream(
-            desc->metric_file_name_, std::ios::out | std::ios::trunc | std::ios::binary);
-
-        device_descriptors_[device] = std::move(desc);
-
-        if (num_sub_devices > 0) {
-          std::vector<ze_device_handle_t> sub_devices(num_sub_devices);
-
-          status = zeDeviceGetSubDevices(device, &num_sub_devices, sub_devices.data());
-          PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-          for (uint32_t j = 0; j < num_sub_devices; j++) {
-            std::shared_ptr<pti_metrics_device_descriptor_t> sub_desc =
-                std::make_shared<pti_metrics_device_descriptor_t>();
-
-            sub_desc->stall_sampling_ = stall_sampling;
-
-            sub_desc->device_ = sub_devices[j];
-            sub_desc->parent_device_ = device;
-            sub_desc->num_sub_devices_ = 0;
-
-            sub_desc->driver_ = driver;
-            sub_desc->context_ = context;
-            sub_desc->metrics_group_ = group;
-
-            sub_desc->device_timer_frequency_ = utils::ze::GetDeviceTimerFrequency(sub_devices[j]);
-            sub_desc->device_timer_mask_ = utils::ze::GetDeviceTimestampMask(sub_devices[j]);
-            sub_desc->metric_timer_frequency_ = utils::ze::GetDeviceTimerFrequency(sub_devices[j]);
-            sub_desc->metric_timer_mask_ = utils::ze::GetMetricTimestampMask(sub_devices[j]);
-
-            ze_pci_ext_properties_t pci_device_properties;
-            std::memset(&pci_device_properties, 0, sizeof(pci_device_properties));
-            ze_result_t status =
-                zeDevicePciGetPropertiesExt(sub_devices[j], &pci_device_properties);
-            PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-            sub_desc->pci_properties_ = pci_device_properties;
-
-            ticks = 0;
-            host_time = 0;
-            device_time = 0;
-            metric_time = 0;
-
-            status = zeDeviceGetGlobalTimestamps(sub_devices[j], &host_time, &ticks);
-            PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-            device_time = ticks & sub_desc->device_timer_mask_;
-            device_time = device_time * NSEC_IN_SEC / sub_desc->device_timer_frequency_;
-
-            metric_time = ticks & sub_desc->metric_timer_mask_;
-            metric_time = metric_time * NSEC_IN_SEC / sub_desc->metric_timer_frequency_;
-
-            sub_desc->host_time_origin_ = host_time;
-            sub_desc->device_time_origin_ = device_time;
-            sub_desc->metric_time_origin_ = metric_time;
-
-            sub_desc->driver_ = driver;
-            sub_desc->context_ = context;
-            sub_desc->metrics_group_ = group;
-
-            sub_desc->profiling_thread_.reset();
-            sub_desc->profiling_state_.store(ptiMetricProfilerState::PROFILER_DISABLED,
-                                             std::memory_order_release);
-
-            device_descriptors_[sub_devices[j]] = std::move(sub_desc);
-          }
-        }
-      }
-    }
-  }
-
- protected:
-  pti_result CollectionInitialize(std::shared_ptr<pti_metrics_device_descriptor_t> desc) {
-    PTI_ASSERT(desc != nullptr);
-
-    SPDLOG_DEBUG("Activating metric groups for context: {}, for device: {}",
-                 static_cast<const void *>(desc->context_),
-                 static_cast<const void *>(desc->device_));
-    // Access to zetContextActivateMetricGroups for different contexts and devices
-    // shouldn't be serialized
-    ze_result_t status =
-        zetContextActivateMetricGroups(desc->context_, desc->device_, 1, &(desc->metrics_group_));
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                            ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-    status = zeEventPoolCreate(desc->context_, &event_pool_desc, 1, &(desc->device_),
-                               &(desc->event_pool_));
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0,
-                                  ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-    status = zeEventCreate(desc->event_pool_, &event_desc, &(desc->event_));
-    if (status != ZE_RESULT_SUCCESS) {
-      status = zeEventPoolDestroy(desc->event_pool_);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_DEBUG("Failed to destroy event pool after event creation failure");
-      }
-      return PTI_ERROR_DRIVER;
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  pti_result CollectionFinalize(std::shared_ptr<pti_metrics_device_descriptor_t> desc) {
-    PTI_ASSERT(desc != nullptr);
-
-    ze_result_t status = zeEventDestroy(desc->event_);
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-    status = zeEventPoolDestroy(desc->event_pool_);
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    // Access to zetContextActivateMetricGroups for different contexts and devices
-    // shouldn't be serialized
-    // Disactivate the metric groups
-    status =
-        zetContextActivateMetricGroups(desc->context_, desc->device_, 0, &(desc->metrics_group_));
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  void SaveRawData(std::shared_ptr<pti_metrics_device_descriptor_t> desc, uint8_t *storage,
-                   size_t data_size, bool immediate_save_to_disc) {
-    if (data_size != 0) {
-      // Save the data to memory buffer
-      desc->metric_data_.insert(desc->metric_data_.end(), storage, storage + data_size);
-      desc->capture_count_++;  // per-device
-    }
-
-    // Save memory buffer to cache file if there is something to write and
-    // either we need an immediate save to disc or
-    // the local buffer is getting too big after a few captures or
-    // no data was captured from the hw buffer
-    if (!desc->metric_data_.empty() &&
-        (immediate_save_to_disc || desc->capture_count_ > kMaxDataCaptureCount || data_size == 0)) {
-      if (desc->metric_file_stream_.is_open()) {
-        desc->metric_file_stream_.write(reinterpret_cast<char *>(desc->metric_data_.data()),
-                                        desc->metric_data_.size());
-        if (immediate_save_to_disc) {
-          desc->metric_file_stream_
-              .flush();  // Explicit flush only when immediate save is requested
-        }
-      }
-      desc->metric_data_.clear();
-      desc->capture_count_ = 0;
-    }
-  }
-};
-
-// TODO: experiment with the max capture count to find the optimal number of hw buffer
-// to local buffer reads before writing to disc while minimizing collection overhead
-// and preventing data loss by not reading the hw buffer fast enough when data is ready
-// uint8_t PtiMetricsProfiler::max_data_capture_count_ = 10;
-
-class PtiStreamMetricsProfiler : public PtiMetricsProfiler {
- private:
-  uint32_t sampling_interval_;
-
- public:
-  PtiStreamMetricsProfiler() = delete;
-  PtiStreamMetricsProfiler(const PtiStreamMetricsProfiler &) = delete;
-  PtiStreamMetricsProfiler &operator=(const PtiStreamMetricsProfiler &) = delete;
-  PtiStreamMetricsProfiler(PtiStreamMetricsProfiler &&) = delete;
-  PtiStreamMetricsProfiler &operator=(PtiStreamMetricsProfiler &&) = delete;
-
-  PtiStreamMetricsProfiler(pti_device_handle_t device_handle,
-                           pti_metrics_group_handle_t metrics_group_handle,
-                           uint32_t sampling_interval)
-      : PtiMetricsProfiler(device_handle, metrics_group_handle) {
-    sampling_interval_ = sampling_interval;
-  }
-
-  ~PtiStreamMetricsProfiler() {}
-
-  pti_result StartProfiling(bool start_paused) {
-    PTI_ASSERT(device_descriptors_.size() == 1);
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      if (it->second->stall_sampling_) {
-        SPDLOG_TRACE("EU stall sampling is not supported");
-        continue;
-      }
-
-      // Collection should be stopped before start is called
-      if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_ENABLED) {
-        SPDLOG_DEBUG("Attempting to start a metrics collection that isn't stopped");
-        return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-      }
-
-      if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_PAUSED) {
-        SPDLOG_DEBUG("Attempting to start instead of resume a metrics collection that is paused");
-        return PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED;
-      }
-
-      // Reset initialization flag before launching thread
-      {
-        std::lock_guard<std::mutex> lock(it->second->profiling_thread_start_mutex_);
-        it->second->profiling_thread_initialized_ = false;
-      }
-      it->second->profiling_thread_ = std::make_unique<std::thread>(
-          &PtiStreamMetricsProfiler::PerDeviceStreamMetricsProfilingThread, this, it->second,
-          sampling_interval_, start_paused);
-
-      // Wait for thread initialization and check result
-      pti_result result = WaitForProfilingThreadInitialization(it->second);
-      if (result != PTI_SUCCESS) {
-        return result;
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
-  // PauseProfiling(), ResumeProfiling and StopProfiling() are same for all profiler types and are
-  // implemented in the parent class PtiMetricsProfiler
-
-  pti_result GetCalculatedData(pti_metrics_group_handle_t metrics_group_handle,
-                               pti_value_t *metrics_values_buffer, uint32_t *metrics_values_count) {
-    pti_result result = PtiMetricsProfiler::GetCalculatedData(
-        metrics_group_handle, metrics_values_buffer, metrics_values_count);
-    if (result != PTI_SUCCESS) {
-      return result;
-    }
-    ComputeMetrics(metrics_group_handle, metrics_values_buffer, metrics_values_count);
-    return PTI_SUCCESS;
-  }
-
- private:
-  bool ShouldSkipSample(bool report_reason_exist, uint32_t report_reason, uint64_t prev_timestamp,
-                        uint64_t current_timestamp) const {
-    return report_reason_exist && ((report_reason & kReportReasonContextSwitchBit) != 0) &&
-           (prev_timestamp != 0 && current_timestamp == prev_timestamp);
-  }
-
-  uint64_t ProcessTimestampOverflow(uint64_t current_timestamp, uint64_t prev_timestamp,
-                                    uint64_t time_span_between_wraparound) const {
-    if (current_timestamp <= prev_timestamp && time_span_between_wraparound != 0) {
-      auto new_timestamp = current_timestamp;
-      while (new_timestamp <= prev_timestamp) {
-        new_timestamp += time_span_between_wraparound;
-      }
-      return new_timestamp;
-    }
-    return current_timestamp;
-  }
-
-  void ComputeMetrics(pti_metrics_group_handle_t metrics_group_handle,
-                      pti_value_t *metrics_values_buffer, uint32_t *metrics_values_count) {
-    PTI_ASSERT(metrics_values_count != nullptr);
-    // Option 1: user wants metrics values count
-    if (metrics_values_buffer == nullptr) {
-      // Search for the top/parent device; it doesn't have a parent
-      auto it = device_descriptors_.begin();
-      while (it != device_descriptors_.end() && it->second->parent_device_ != nullptr) {
-        it++;
-      }
-
-      if (it == device_descriptors_.end() || it->second->metrics_group_ != metrics_group_handle) {
-        SPDLOG_TRACE("Could not find device and metric group");
-        SPDLOG_TRACE("Unable to calculate required data buffer size");
-        return;
-      }
-
-      // Synchronize access to the per-device metric file stream to prevent races
-      // when GetCalculatedData is invoked concurrently from multiple threads that
-      // read metrics for the same device.
-      std::lock_guard<std::mutex> file_lock(it->second->file_access_mutex_);
-
-      std::ifstream inf =
-          std::ifstream(it->second->metric_file_name_, std::ios::in | std::ios::binary);
-      PTI_ASSERT(inf.is_open());
-      inf.seekg(0, inf.end);
-      std::streamsize stream_file_size = inf.tellg();
-      PTI_ASSERT(stream_file_size >= 0);
-      size_t file_size = static_cast<size_t>(stream_file_size);
-
-      inf.seekg(0, inf.beg);  // rewind
-      std::vector<uint8_t> raw_metrics(file_size);
-
-      inf.read(reinterpret_cast<char *>(raw_metrics.data()), file_size);
-      auto raw_size = static_cast<size_t>(inf.gcount());
-      if (raw_size > 0) {
-        uint32_t num_reports = 0;
-        uint32_t total_values_count = 0;
-        ze_result_t status = zetMetricGroupCalculateMultipleMetricValuesExp(
-            it->second->metrics_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, raw_size,
-            raw_metrics.data(), &num_reports, &total_values_count, nullptr, nullptr);
-
-        if ((status != ZE_RESULT_SUCCESS) && (status != ZE_RESULT_WARNING_DROPPED_DATA)) {
-          SPDLOG_DEBUG("Unable to calculate required data buffer size");
-        }
-
-        *metrics_values_count = total_values_count;
-      }
-      inf.close();
-      return;
-    }
-
-    // Option 2: user wants the buffer filled.
-
-    *metrics_values_count = 0;
-    bool timestamp_metric_found = false;
-    bool report_reason_metric_found = false;
-
-    // Search for the top/parent device; it doesn't have a parent
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-
-      if (it->second->metrics_group_ != metrics_group_handle) {
-        SPDLOG_DEBUG("Could not find device and metric group");
-        SPDLOG_DEBUG("Unable to calculate process collected data");
-        return;
-      }
-
-      // Note: EU Stall sampling data is not logged in json format
-      if (it->second->stall_sampling_) {
-        SPDLOG_TRACE("EU stall sampling is not supported");
-        continue;
-      } else {  // not stall sampling
-
-        // Get metric list for metric group collected
-        auto metric_list = utils::ze::GetMetricList(it->second->metrics_group_);
-        PTI_ASSERT(!metric_list.empty());
-
-        // get group name for metric group
-        zet_metric_group_properties_t group_props;
-        std::memset(&group_props, 0, sizeof(group_props));
-        group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-        ze_result_t status = zetMetricGroupGetProperties(it->second->metrics_group_, &group_props);
-        PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-        std::string group_name = group_props.name;
-
-        // Get the index of the start timestamp from the metric list
-        auto ts_idx = utils::ze::GetMetricId(metric_list, kTimeStampMetric);
-        timestamp_metric_found = (ts_idx < metric_list.size());
-        if (!timestamp_metric_found) {
-          // no QueryBeginTime metric, this is not expected for stream metrics groups
-          // but we can still process the metrics values without timestamps
-          SPDLOG_DEBUG(
-              "QueryBeginTime metric is not found in the metric list,"
-              " unable to capture timestamps for the metrics values");
-        }
-        // Get the index of ReportReason metric from the metric list
-        auto report_reason_idx = utils::ze::GetMetricId(metric_list, kReportReasonMetric);
-        report_reason_metric_found = (report_reason_idx < metric_list.size());
-        if (!report_reason_metric_found) {
-          // no ReportReason metric, this is not expected for stream metrics
-          // groups, but we can still process the metrics values without it
-          SPDLOG_DEBUG(
-              "ReportReason metric is not found in the metric list,"
-              " metrics will be processed without report reason information");
-        }
-
-        // TODO: handle subdevices in case of implicit scaling
-        uint64_t time_span_between_clock_resets =
-            (it->second->metric_timer_mask_ == kMask64Bits)
-                ? 0
-                : (uint64_t)(((double)(it->second->metric_timer_mask_ + 1ull) *
-                              (double)static_cast<uint64_t>(NSEC_IN_SEC)) /
-                             (double)it->second->metric_timer_frequency_);
-
-        std::lock_guard<std::mutex> file_lock(it->second->file_access_mutex_);
-
-        // open input file stream where metrics data is saved
-        std::ifstream inf =
-            std::ifstream(it->second->metric_file_name_, std::ios::in | std::ios::binary);
-        PTI_ASSERT(inf.is_open());
-        inf.seekg(0, inf.end);
-        std::streamsize stream_file_size = inf.tellg();
-        PTI_ASSERT(stream_file_size >= 0);
-        size_t file_size = static_cast<size_t>(stream_file_size);
-
-        inf.seekg(0, inf.beg);  // rewind
-        std::vector<uint8_t> raw_metrics(file_size);
-
-        user_logger_->info("{\n\t\"displayTimeUnit\": \"us\",\n\t\"traceEvents\": [");
-
-        uint64_t cur_sampling_ts = 0;
-
-        uint32_t buffer_idx = 0;
-        // Read and process input file stream where metrics data is saved
-        while (!inf.eof()) {
-          inf.read(reinterpret_cast<char *>(raw_metrics.data()), file_size);
-
-          auto raw_size = static_cast<size_t>(inf.gcount());
-          if (raw_size > 0) {
-            // first call to Calculate metrics to capture the size of reports and values
-            // buffers
-            uint32_t num_reports = 0;
-            uint32_t total_values_count = 0;
-            ze_result_t status = zetMetricGroupCalculateMultipleMetricValuesExp(
-                it->second->metrics_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-                raw_size, raw_metrics.data(), &num_reports, &total_values_count, nullptr, nullptr);
-            if ((status != ZE_RESULT_SUCCESS) || (num_reports == 0) || (total_values_count == 0)) {
-              SPDLOG_DEBUG("Unable to calculate metrics");
-              continue;
-            }
-
-            // allocate buffers for reports and values with required sizes
-            std::vector<uint32_t> reports(num_reports);
-            std::vector<zet_typed_value_t> values(total_values_count);
-
-            // Second call to Calculate metrics to do the metrics calculations
-            status = zetMetricGroupCalculateMultipleMetricValuesExp(
-                it->second->metrics_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-                raw_size, raw_metrics.data(), &num_reports, &total_values_count, reports.data(),
-                values.data());
-            if ((status != ZE_RESULT_SUCCESS) && (status != ZE_RESULT_WARNING_DROPPED_DATA)) {
-              SPDLOG_DEBUG("Unable to calculate metrics");
-              continue;
-            }
-            // Note: There is a bug in L0 where the total value count returned from the second call
-            // to zetMetricGroupCalculateMultipleMetricValuesExp is less than the value obtained
-            // from the first call and used to allocate the buffer
-            *metrics_values_count += total_values_count;
-
-            // Process values
-            const zet_typed_value_t *value = values.data();
-            for (uint32_t i = 0; i < num_reports; ++i) {
-              uint32_t per_report_values_count = reports[i];
-              auto num_samples = per_report_values_count / metric_list.size();
-
-              for (size_t j = 0; j < num_samples; ++j) {
-                // v is array of metric_count values
-                const zet_typed_value_t *v = value + j * metric_list.size();
-
-                // Capture the timestamp using the timestamp index
-                uint64_t ts = timestamp_metric_found ? v[ts_idx].value.ui64 : 0;
-
-                // Looking into ReportReason metric to check
-                // if the sample is triggered by a context switch and
-                // if the sample timestamp needs to be adjusted to adjust on clock overflow
-                // (which is not expected on the system with 64bit timestamp width (mask))
-                if (cur_sampling_ts != 0) {
-                  PTI_ASSERT(timestamp_metric_found);
-
-                  if (ts <= cur_sampling_ts) {
-                    if (ShouldSkipSample(
-                            report_reason_metric_found,
-                            report_reason_metric_found ? v[report_reason_idx].value.ui32 : 0,
-                            cur_sampling_ts, ts)) {
-                      SPDLOG_DEBUG(
-                          "Skipping sample with context switch report reason "
-                          "and current timestamp: {}, previous timestamp: {}",
-                          ts, cur_sampling_ts);
-                      continue;
-                    }
-
-                    auto new_ts = ProcessTimestampOverflow(ts, cur_sampling_ts,
-                                                           time_span_between_clock_resets);
-                    // Checking if the adjustment happened
-                    // it will not in case of 64bit timestamp width
-                    if (new_ts == ts && time_span_between_clock_resets == 0) {
-                      SPDLOG_DEBUG(
-                          "Timestamps are not expected to be adjusted for clock overflow when "
-                          "time_span_between_clock_resets is 0, current timestamp: {}, "
-                          "previous timestamp: {}",
-                          ts, cur_sampling_ts);
-                    } else {
-                      PTI_ASSERT(new_ts > cur_sampling_ts && new_ts > ts);
-                      ts = new_ts;
-                    }
-                  }
-                }
-                cur_sampling_ts = ts;
-
-                std::string str = "";
-                if (j != 0) str += ",";
-                str += " {\n\t\t\"args\": {\n";
-
-                // Walk through the metric list and add metric values to output buffer
-                for (size_t k = 0; k < metric_list.size(); k++) {
-                  if (timestamp_metric_found && k == ts_idx) {
-                    metrics_values_buffer[buffer_idx++].ui64 = ts;
-                  } else {
-                    metrics_values_buffer[buffer_idx++].ui64 = v[k].value.ui64;
-                  }
-                }
-                // Walk through the metric list and log the metric parameters and values
-                for (size_t k = 0; k < metric_list.size(); k++) {
-                  // Skip the timestamp, it is logged separately
-                  if (k == ts_idx) {
-                    continue;
-                  }
-
-                  if (k != 0) str += ",\n";
-                  str +=
-                      "\t\t\t\"" + metric_list[k] + "\": " + utils::ze::GetMetricTypedValue(v[k]);
-                }
-                str += "\n\t\t\t},\n";
-                str += "\t\t\t\"cat\": \"" + group_name + "\",\n";
-                str += "\t\t\t\"name\": \"" + group_name + "\",\n";
-                str += "\t\t\t\"ph\": \"C\",\n";
-                str += "\t\t\t\"pid\": 0,\n";
-                str += "\t\t\t\"tid\": 0,\n";
-                str += "\t\t\t\"ts\": " + std::to_string(ts / NSEC_IN_USEC) + "\n";
-                str += "\t\t}";
-
-                user_logger_->info(str);
-              }
-              value += reports[i];
-            }
-          }
-        }
-        inf.close();
-        user_logger_->info("\n\t]\n}\n");
-        user_logger_->flush();
-        // break;  // TODO: only one device for now
-      }
-    }
-  }
-
-  void CaptureRawMetrics(zet_metric_streamer_handle_t streamer, uint8_t *storage, size_t ssize,
-                         std::shared_ptr<pti_metrics_device_descriptor_t> desc,
-                         bool immediate_save_to_disc = false) {
-    PTI_ASSERT(desc != nullptr);
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    size_t data_size = ssize;
-    status = zetMetricStreamerReadData(streamer, UINT32_MAX, &data_size, storage);
-    if (status == ZE_RESULT_WARNING_DROPPED_DATA) {
-      SPDLOG_WARN("Metric samples dropped.");
-    } else if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_WARN(
-          "zetMetricStreamerReadData failed with error code {:x}, ssize:{}, data_size: {}, dev "
-          "handler {}",
-          static_cast<std::size_t>(status), ssize, data_size,
-          static_cast<const void *>(device_descriptors_.begin()->first));
-    }
-    SPDLOG_DEBUG("Read {} bytes of raw metric data from the metric streamer for device: {}",
-                 data_size, static_cast<const void *>(desc->device_));
-
-    SaveRawData(std::move(desc), storage, data_size, immediate_save_to_disc);
-  }
-
-  void EventBasedCaptureRawMetrics(zet_metric_streamer_handle_t streamer, uint8_t *storage,
-                                   size_t ssize,
-                                   std::shared_ptr<pti_metrics_device_descriptor_t> desc) {
-    PTI_ASSERT(desc != nullptr);
-
-    ze_result_t status = zeEventQueryStatus(desc->event_);
-    if (!(status == ZE_RESULT_SUCCESS || status == ZE_RESULT_NOT_READY)) {
-      SPDLOG_WARN("zeEventQueryStatus failed with error code: 0x{:x}",
-                  static_cast<std::size_t>(status));
-    }
-
-    if (status == ZE_RESULT_SUCCESS) {
-      status = zeEventHostReset(desc->event_);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_WARN("zeEventHostReset failed with error code {:x}",
-                    static_cast<std::size_t>(status));
-      }
-      SPDLOG_DEBUG("New data is ready to read from the metric streamer for device: {}",
-                   static_cast<const void *>(desc->device_));
-    } else { /* ZE_RESULT_NOT_READY */
-      SPDLOG_DEBUG("No new data to read from the metric streamer for device: {}",
-                   static_cast<const void *>(desc->device_));
-      return;
-    }
-    bool immediate_save_to_disc = false;
-    CaptureRawMetrics(streamer, storage, ssize, std::move(desc), immediate_save_to_disc);
-  }
-
-  void PerDeviceStreamMetricsProfilingThread(std::shared_ptr<pti_metrics_device_descriptor_t> desc,
-                                             uint32_t sampling_interval, bool start_paused) {
-    PTI_ASSERT(desc != nullptr);
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    pti_result result = CollectionInitialize(desc);
-    PTI_ASSERT(result == PTI_SUCCESS);
-
-    uint32_t interval = (sampling_interval == 0) ? kDefaultSamplingIntervalNs : sampling_interval;
-    // TODO: Should there be a min and/or max?
-
-    zet_metric_streamer_desc_t streamer_desc = {ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC, nullptr,
-                                                max_metric_samples_, interval};
-
-    if (streamer_desc.notifyEveryNReports > max_metric_samples_) {
-      max_metric_samples_ = streamer_desc.notifyEveryNReports;
-    }
-
-    auto metrics_list = utils::ze::GetMetricList(desc->metrics_group_);
-    PTI_ASSERT(!metrics_list.empty());
-
-    std::vector<uint8_t> raw_metrics(PtiMetricsProfiler::GetMaxMetricBufferSize());
-
-    zet_metric_streamer_handle_t streamer = nullptr;
-    bool streamer_open = false;
-    ptiMetricProfilerState profiling_state = start_paused
-                                                 ? ptiMetricProfilerState::PROFILER_PAUSED
-                                                 : ptiMetricProfilerState::PROFILER_ENABLED;
-
-    // Try to open the streamer before notifying the main thread
-    // Only notify after we know if the streamer opened successfully
-    if (!start_paused) {
-      SPDLOG_DEBUG("Opening metric streamer for device: {}",
-                   static_cast<const void *>(desc->device_));
-      status = zetMetricStreamerOpen(desc->context_, desc->device_, desc->metrics_group_,
-                                     &streamer_desc, desc->event_, &streamer);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_DEBUG(
-            "Failed to open metric streamer during initialization. The sampling interval might be "
-            "too small. UMD driver returned {:x}",
-            static_cast<std::size_t>(status));
-#ifndef _WIN32
-        SPDLOG_DEBUG(
-            "Set the paranoid to 0, depending on Intel GPU kernel mode driver(s): i915 or Xe\n"
-            "/proc/sys/dev/i915/perf_stream_paranoid\n"
-            "/proc/sys/dev/xe/observation_paranoid\n"
-            "(Set whichever applicable to the system)");
-#endif /* _WIN32 */
-        // Signal failure to main thread by keeping state as DISABLED
-        SignalThreadInitialized(desc, ptiMetricProfilerState::PROFILER_DISABLED);
-        result = CollectionFinalize(std::move(desc));
-        return;
-      }
-      streamer_open = true;
-    }
-
-    // Signal successful initialization to main thread
-    SignalThreadInitialized(desc, profiling_state);
-
-    bool immediate_save_to_disc = true;
-    while (desc->profiling_state_.load(std::memory_order_acquire) !=
-           ptiMetricProfilerState::PROFILER_DISABLED) {
-      if (desc->profiling_state_.load(std::memory_order_acquire) ==
-          ptiMetricProfilerState::PROFILER_PAUSED) {
-        // close the streamer when profiler is paused
-        if (streamer_open == true) {
-          // Capture hw buffered raw data and immediately write it to disc before closing the
-          // streamer
-          CaptureRawMetrics(streamer, raw_metrics.data(),
-                            PtiMetricsProfiler::GetMaxMetricBufferSize(), desc,
-                            immediate_save_to_disc);
-
-          status = zetMetricStreamerClose(streamer);
-          PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-          streamer_open = false;
-        }
-
-        // Wait for the profiling state to change
-        std::mutex pause_mutex;
-        std::unique_lock pause_lock(pause_mutex);
-        while (desc->profiling_state_.load(std::memory_order_acquire) ==
-               ptiMetricProfilerState::PROFILER_PAUSED) {
-          cv_pause_.wait(pause_lock);
-        }
-      } else {  // PROFILER_ENABLED
-        // open the streamer when profiler is enabled
-        if (streamer_open == false) {
-          SPDLOG_DEBUG("Opening metric streamer for device: {}",
-                       static_cast<const void *>(desc->device_));
-          status = zetMetricStreamerOpen(desc->context_, desc->device_, desc->metrics_group_,
-                                         &streamer_desc, desc->event_, &streamer);
-          if (status != ZE_RESULT_SUCCESS) {
-            SPDLOG_DEBUG(
-                "Failed to open metric streamer. The sampling interval might be too small."
-                " UMD driver returned {:x}",
-                static_cast<std::size_t>(status));
-#ifndef _WIN32
-            SPDLOG_DEBUG(
-                "Set the paranoid to 0, depending on Intel GPU kernel mode driver(s): i915 or Xe\n"
-                "/proc/sys/dev/i915/perf_stream_paranoid\n"
-                "/proc/sys/dev/xe/observation_paranoid\n"
-                "(Set whichever applicable to the system)");
-#endif /* _WIN32 */
-            break;
-          }
-          streamer_open = true;
-        }
-        // Capture hw buffered raw data to local memory. Local memory is not written to disc
-        // immediately, It is written to disc after a few hw buffer reads or if local buffer is not
-        // empty but no data is captured from the hw buffer in this iteration
-        EventBasedCaptureRawMetrics(streamer, raw_metrics.data(),
-                                    PtiMetricsProfiler::GetMaxMetricBufferSize(), desc);
-      }
-    }
-
-    if (streamer_open) {
-      // Capture hw buffered raw data and immediately write it to disc before closing the streamer
-      CaptureRawMetrics(streamer, raw_metrics.data(), PtiMetricsProfiler::GetMaxMetricBufferSize(),
-                        desc, immediate_save_to_disc);
-
-      SPDLOG_DEBUG("Closing metric streamer for device: {}",
-                   static_cast<const void *>(desc->device_));
-      status = zetMetricStreamerClose(streamer);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-
-    result = CollectionFinalize(std::move(desc));
-    PTI_ASSERT(result == PTI_SUCCESS);
-  }
-};
-
-class PtiQueryMetricsProfiler : public PtiMetricsProfiler {
- private:
-  using MetricQuerySlot = pti_metrics_device_descriptor_t::MetricQuerySlot;
-
-  // Slot held by each kernel between its query-begin and its data collection.
-  std::unordered_map<uint64_t, MetricQuerySlot> kernel_to_slot_map_;
-  std::mutex query_injection_mutex_;
-  std::atomic<bool> exhaustion_reported_ = false;
-  // Raw query data size, constant for the metric group; filled on first read.
-  size_t cached_raw_data_size_ = 0;
-
- public:
-  PtiQueryMetricsProfiler() = delete;
-  PtiQueryMetricsProfiler(const PtiQueryMetricsProfiler &) = delete;
-  PtiQueryMetricsProfiler &operator=(const PtiQueryMetricsProfiler &) = delete;
-  PtiQueryMetricsProfiler(PtiQueryMetricsProfiler &&) = delete;
-  PtiQueryMetricsProfiler &operator=(PtiQueryMetricsProfiler &&) = delete;
-
-  PtiQueryMetricsProfiler(pti_device_handle_t device_handle,
-                          pti_metrics_group_handle_t metrics_group_handle)
-      : PtiMetricsProfiler(device_handle, metrics_group_handle) {}
-
-  ~PtiQueryMetricsProfiler() {
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    {
-      std::lock_guard<std::mutex> lock(query_injection_mutex_);
-      kernel_to_slot_map_.clear();
-    }
-
-    for (auto &[device, desc] : device_descriptors_) {
-      if (desc->parent_device_ != nullptr) {
-        continue;
-      }
-
-      // Slots must go before their pools: the driver refuses to destroy a pool
-      // whose objects are still alive.
-      DestroyAllSlots(desc);
-
-      for (auto *pool : desc->event_pool_chunks_) {
-        status = zeEventPoolDestroy(pool);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG("~PtiQueryMetricsProfiler(): Failed to destroy event pool");
-        }
-      }
-      desc->event_pool_chunks_.clear();
-
-      for (auto *pool : desc->query_pool_chunks_) {
-        status = zetMetricQueryPoolDestroy(pool);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_DEBUG("~PtiQueryMetricsProfiler(): Failed to destroy query pool: ");
-        }
-      }
-      desc->query_pool_chunks_.clear();
-
-      // Deactivate metric groups
-      status = zetContextActivateMetricGroups(desc->context_, device, 0, nullptr);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_DEBUG("~PtiQueryMetricsProfiler(): Failed to deactivate metric groups:");
-      }
-    }
-  }
-
-  pti_result StartProfiling(bool start_paused) {
-    if (start_paused == true) return PTI_ERROR_INTERNAL;
-    return InitializeQueryResources();
-  }
-
-  virtual pti_result StopProfiling() {
-    for (auto it = device_descriptors_.begin(); it != device_descriptors_.end(); ++it) {
-      if (it->second->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      // Collection should be running or paused before stop is called
-      if (it->second->profiling_state_ == ptiMetricProfilerState::PROFILER_DISABLED) {
-        SPDLOG_DEBUG(
-            "StopProfiling(): Attempting to stop a metrics collection that hasn't been started");
-        return PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED;
-      }
-
-      it->second->profiling_state_.store(ptiMetricProfilerState::PROFILER_DISABLED,
-                                         std::memory_order_release);
-    }
-
-    // A slot still mapped never had its data collected. Retire it rather than
-    // recycle it: the device may still reference a query whose end never ran.
-    {
-      std::lock_guard<std::mutex> lock(query_injection_mutex_);
-      if (!kernel_to_slot_map_.empty()) {
-        SPDLOG_DEBUG("StopProfiling(): retiring {} uncollected query slots",
-                     kernel_to_slot_map_.size());
-        kernel_to_slot_map_.clear();
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
-  // Guarded by the caller's data_mutex_, same as the rest of the collection path.
-  size_t &MutableCachedRawDataSize() { return cached_raw_data_size_; }
-
-  MetricQuerySlot GetSlotForKernel(uint64_t kernel_id) {
-    std::lock_guard<std::mutex> lock(query_injection_mutex_);
-    auto it = kernel_to_slot_map_.find(kernel_id);
-    return (it != kernel_to_slot_map_.end()) ? it->second : MetricQuerySlot{nullptr, nullptr};
-  }
-
-  // Caller must have finished reading the query's data.
-  void RecycleKernelSlot(uint64_t kernel_id, ze_device_handle_t device) {
-    std::lock_guard<std::mutex> lock(query_injection_mutex_);
-    auto it = kernel_to_slot_map_.find(kernel_id);
-    if (it == kernel_to_slot_map_.end()) {
-      return;
-    }
-    const MetricQuerySlot slot = it->second;
-    kernel_to_slot_map_.erase(it);
-
-    auto desc_it = device_descriptors_.find(device);
-    if (desc_it == device_descriptors_.end() || !desc_it->second) {
-      SPDLOG_DEBUG("RecycleKernelSlot: no descriptor for device {}, slot leaked",
-                   static_cast<void *>(device));
-      return;
-    }
-    ReleaseSlot(desc_it->second, slot);
-  }
-
-  pti_result HandleKernelAppendEnter(ze_command_list_handle_t cmd_list, ze_device_handle_t device,
-                                     uint64_t operation_id) {
-    try {
-      PTI_ASSERT(device != nullptr);
-      PTI_ASSERT(cmd_list != nullptr);
-      return InjectQueryBegin(cmd_list, device, operation_id);
-    } catch (const std::exception &e) {
-      SPDLOG_DEBUG("Exception in HandleKernelAppendEnter: {}", e.what());
-      return PTI_ERROR_INTERNAL;
-    }
-  }
-
-  pti_result HandleKernelAppendExit(ze_command_list_handle_t cmd_list, ze_device_handle_t device,
-                                    uint64_t operation_id) {
-    try {
-      PTI_ASSERT(cmd_list != nullptr);
-      return InjectQueryEnd(cmd_list, device, operation_id);
-    } catch (const std::exception &e) {
-      SPDLOG_DEBUG("Exception in HandleKernelAppendExit: {}", e.what());
-      return PTI_ERROR_INTERNAL;
-    }
-  }
-
- private:
-  // Add one query pool and one event pool, each backing kMetricPoolEventCount
-  // slots. Caller holds query_injection_mutex_.
-  bool AddPoolChunk(ze_device_handle_t device,
-                    const std::shared_ptr<pti_metrics_device_descriptor_t> &desc) {
-    zet_metric_query_pool_desc_t query_pool_desc = {};
-    query_pool_desc.stype = ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC;
-    query_pool_desc.pNext = nullptr;
-    query_pool_desc.type = ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE;
-    query_pool_desc.count = kMetricPoolEventCount;
-
-    zet_metric_query_pool_handle_t query_pool = nullptr;
-    ze_result_t status = zetMetricQueryPoolCreate(desc->context_, device, desc->metrics_group_,
-                                                  &query_pool_desc, &query_pool);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("AddPoolChunk: zetMetricQueryPoolCreate failed: 0x{:x}",
-                   static_cast<unsigned int>(status));
-      return false;
-    }
-
-    const ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                                  ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                                                  kMetricPoolEventCount};
-    ze_event_pool_handle_t event_pool = nullptr;
-    status = zeEventPoolCreate(desc->context_, &event_pool_desc, 1, &device, &event_pool);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("AddPoolChunk: zeEventPoolCreate failed: 0x{:x}",
-                   static_cast<unsigned int>(status));
-      zetMetricQueryPoolDestroy(query_pool);
-      return false;
-    }
-
-    desc->query_pool_chunks_.push_back(query_pool);
-    desc->event_pool_chunks_.push_back(event_pool);
-    SPDLOG_DEBUG("AddPoolChunk: chunk {} of {} slots added for device {}",
-                 desc->query_pool_chunks_.size(), kMetricPoolEventCount,
-                 static_cast<void *>(device));
-    return true;
-  }
-
-  // Reuse a free slot, else take the next one from the pools, adding a pool when
-  // the existing ones are fully handed out.
-  // Caller holds query_injection_mutex_.
-  MetricQuerySlot AcquireSlot(ze_device_handle_t device,
-                              const std::shared_ptr<pti_metrics_device_descriptor_t> &desc) {
-    if (!desc->free_slots_.empty()) {
-      MetricQuerySlot slot = desc->free_slots_.back();
-      desc->free_slots_.pop_back();
-      return slot;
-    }
-
-    const size_t slot_index = desc->all_slots_.size();
-    const size_t capacity = desc->query_pool_chunks_.size() * kMetricPoolEventCount;
-    if (slot_index >= capacity && !AddPoolChunk(device, desc)) {
-      // Warn once per profiler: skipping silently is indistinguishable from a
-      // workload that ran no kernels.
-      if (!exhaustion_reported_.exchange(true)) {
-        SPDLOG_WARN(
-            "Metrics scope: {} query slots on device {} are in flight and no further pool could "
-            "be added; metrics are skipped for further concurrent scopes",
-            slot_index, static_cast<void *>(device));
-      }
-      return MetricQuerySlot{nullptr, nullptr};
-    }
-
-    const size_t chunk = slot_index / kMetricPoolEventCount;
-    const uint32_t index_in_chunk = static_cast<uint32_t>(slot_index % kMetricPoolEventCount);
-
-    zet_metric_query_handle_t query = nullptr;
-    ze_result_t status =
-        zetMetricQueryCreate(desc->query_pool_chunks_[chunk], index_in_chunk, &query);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("AcquireSlot: zetMetricQueryCreate failed at chunk {} index {}: 0x{:x}", chunk,
-                   index_in_chunk, static_cast<unsigned int>(status));
-      return MetricQuerySlot{nullptr, nullptr};
-    }
-
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, index_in_chunk,
-                                  ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-    ze_event_handle_t event = nullptr;
-    status = zeEventCreate(desc->event_pool_chunks_[chunk], &event_desc, &event);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("AcquireSlot: zeEventCreate failed at chunk {} index {}: 0x{:x}", chunk,
-                   index_in_chunk, static_cast<unsigned int>(status));
-      zetMetricQueryDestroy(query);
-      return MetricQuerySlot{nullptr, nullptr};
-    }
-
-    const MetricQuerySlot slot{query, event};
-    desc->all_slots_.push_back(slot);
-    return slot;
-  }
-
-  // Caller holds query_injection_mutex_.
-  void ReleaseSlot(const std::shared_ptr<pti_metrics_device_descriptor_t> &desc,
-                   const MetricQuerySlot &slot) {
-    ze_result_t status = zetMetricQueryReset(slot.first);
-    if (status != ZE_RESULT_SUCCESS) {
-      // A slot that cannot be reset would hand stale data to the next kernel,
-      // so retire it instead of recycling it.
-      SPDLOG_DEBUG("ReleaseSlot: zetMetricQueryReset failed (0x{:x}); retiring slot",
-                   static_cast<unsigned int>(status));
-      return;
-    }
-    status = zeEventHostReset(slot.second);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("ReleaseSlot: zeEventHostReset failed (0x{:x}); retiring slot",
-                   static_cast<unsigned int>(status));
-      return;
-    }
-    desc->free_slots_.push_back(slot);
-  }
-
-  static void DestroyAllSlots(const std::shared_ptr<pti_metrics_device_descriptor_t> &desc) {
-    for (const auto &slot : desc->all_slots_) {
-      if (slot.second != nullptr) {
-        zeEventDestroy(slot.second);
-      }
-      if (slot.first != nullptr) {
-        zetMetricQueryDestroy(slot.first);
-      }
-    }
-    desc->all_slots_.clear();
-    desc->free_slots_.clear();
-  }
-
-  pti_result InitializeQueryResources() {
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    for (auto &[device, desc] : device_descriptors_) {
-      if (desc->parent_device_ != nullptr) {
-        // Skip sub-devices for now
-        continue;
-      }
-
-      // Collection should be stopped before start is called
-      if (desc->profiling_state_ == ptiMetricProfilerState::PROFILER_ENABLED) {
-        SPDLOG_DEBUG(
-            "InitializeQueryResources: Attempting to start a metrics collection that isn't "
-            "stopped");
-        return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-      }
-
-      if (desc->profiling_state_ == ptiMetricProfilerState::PROFILER_PAUSED) {
-        SPDLOG_DEBUG(
-            "InitializeQueryResources: Attempting to start instead of resume a metrics collection "
-            "that is paused");
-        return PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED;
-      }
-
-      pti_result result = CreateQueryEventPool(device, desc);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_DEBUG("InitializeQueryResources: Failed to create query pool for device");
-        return result;
-      }
-
-      // Activate metric groups for the device
-      status = zetContextActivateMetricGroups(desc->context_, device, 1, &desc->metrics_group_);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_DEBUG("InitializeQueryResources: Failed to activate metric groups:");
-        return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-      }
-
-      desc->profiling_state_.store(ptiMetricProfilerState::PROFILER_ENABLED,
-                                   std::memory_order_release);
-
-      SPDLOG_TRACE("InitializeQueryResources: Query resources initialized for device");
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  pti_result CreateQueryEventPool(ze_device_handle_t device,
-                                  std::shared_ptr<pti_metrics_device_descriptor_t> desc) {
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    // Add comprehensive logging
-    SPDLOG_TRACE("CreateQueryEventPool - Starting creation for device: {}",
-                 reinterpret_cast<void *>(device));
-
-    // Validate inputs before calling Level Zero
-    if (desc->context_ == nullptr) {
-      SPDLOG_DEBUG("CreateQueryEventPool - Context is null!");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (desc->metrics_group_ == nullptr) {
-      SPDLOG_DEBUG("CreateQueryEventPool - Metric group is null!");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (device == nullptr) {
-      SPDLOG_DEBUG("CreateQueryEventPool - Device is null!");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Check metric group properties
-    zet_metric_group_properties_t group_props = {};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    status = zetMetricGroupGetProperties(desc->metrics_group_, &group_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("CreateQueryEventPool - Failed to get metric group properties: {:#x}",
-                   static_cast<unsigned int>(status));
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    SPDLOG_TRACE("  Metric group name: {}", static_cast<const char *>(group_props.name));
-    SPDLOG_TRACE("  Metric group sampling type: 0x{:x}", group_props.samplingType);
-    SPDLOG_TRACE("  Metric count: {}", group_props.metricCount);
-
-    // Check if this is an event-based metric group
-    if (!(group_props.samplingType & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED)) {
-      SPDLOG_DEBUG("CreateQueryEventPool - Metric group is not event-based! Sampling type: 0x{:x}",
-                   group_props.samplingType);
-      SPDLOG_DEBUG("  Available types: TIME_BASED=0x2, EVENT_BASED=0x1");
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    std::lock_guard<std::mutex> lock(query_injection_mutex_);
-
-    // Pools and their recycled slots survive a stop/start cycle. Recreating them
-    // here would leak the old ones and desynchronize the slot indices.
-    if (!desc->query_pool_chunks_.empty()) {
-      return PTI_SUCCESS;
-    }
-
-    if (!AddPoolChunk(device, desc)) {
-      SPDLOG_DEBUG("CreateQueryEventPool: Failed to create the first pool chunk for device {}",
-                   static_cast<void *>(device));
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  pti_result InjectQueryBegin(ze_command_list_handle_t command_list, ze_device_handle_t device,
-                              uint64_t operation_id) {
-    SPDLOG_TRACE("In {}", __func__);
-    std::lock_guard<std::mutex> lock(query_injection_mutex_);
-
-    auto it = device_descriptors_.find(device);
-    if (it == device_descriptors_.end()) {
-      SPDLOG_DEBUG("InjectQueryBegin: Device not found in descriptors for query injection");
-      return PTI_ERROR_BAD_ARGUMENT;  // should not return an error, do nothing instead
-    }
-
-    auto &desc = it->second;
-
-    if (desc->query_pool_chunks_.empty()) {
-      SPDLOG_DEBUG("InjectQueryBegin: Query pool not initialized for device");
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    const MetricQuerySlot slot = AcquireSlot(device, desc);
-    if (slot.first == nullptr) {
-      // AcquireSlot already logged the reason.
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-    SPDLOG_TRACE(
-        "Injecting Query Begin for command list: {}, on device: {}, query handle: {},"
-        " event handle: {}",
-        static_cast<void *>(command_list), static_cast<void *>(device),
-        static_cast<void *>(slot.first), static_cast<void *>(slot.second));
-
-    // Inject query begin into command list
-    ze_result_t status = zetCommandListAppendMetricQueryBegin(command_list, slot.first);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("InjectQueryBegin: Failed to inject query begin: {}",
-                   static_cast<uint32_t>(status));
-      ReleaseSlot(desc, slot);
-      return PTI_ERROR_INTERNAL;
-    }
-
-    kernel_to_slot_map_[operation_id] = slot;
-
-    SPDLOG_TRACE("InjectQueryBegin: Successfully injected query begin for command list: {}",
-                 reinterpret_cast<void *>(command_list));
-    return PTI_SUCCESS;
-  }
-
-  pti_result InjectQueryEnd(ze_command_list_handle_t command_list, ze_device_handle_t device,
-                            uint64_t operation_id) {
-    std::lock_guard<std::mutex> lock(query_injection_mutex_);
-
-    auto slot_it = kernel_to_slot_map_.find(operation_id);
-    if (slot_it == kernel_to_slot_map_.end()) {
-      SPDLOG_DEBUG(
-          "InjectQueryEnd: No active query found for operation_id {} in query end injection",
-          operation_id);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    if (device_descriptors_.find(device) == device_descriptors_.end()) {
-      SPDLOG_DEBUG("InjectQueryEnd: Device not found in descriptors for query end injection");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // The event was paired with the query when the slot was acquired.
-    const MetricQuerySlot slot = slot_it->second;
-    SPDLOG_TRACE("Injecting Query End for command list: {}, query handle: {}, event handle: {}",
-                 static_cast<void *>(command_list), static_cast<void *>(slot.first),
-                 static_cast<void *>(slot.second));
-
-    ze_result_t status =
-        zetCommandListAppendMetricQueryEnd(command_list, slot.first, slot.second, 0, nullptr);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("InjectQueryEnd: Failed to inject query end: {}", static_cast<uint32_t>(status));
-      // The begin is already in the command list, so the device may still touch
-      // this query. Retire the slot rather than resetting it under the device.
-      kernel_to_slot_map_.erase(slot_it);
-      return PTI_ERROR_INTERNAL;
-    }
-
-    SPDLOG_TRACE("InjectQueryEnd: Successfully injected query end for command list: {}",
-                 reinterpret_cast<void *>(command_list));
-    return PTI_SUCCESS;
-  }
-};
-
-// Trace-based groups are not supported, so they are not reported to users
-inline bool IsTraceBasedGroup(zet_metric_group_handle_t group) {
-  zet_metric_group_properties_t group_props;
-  std::memset(&group_props, 0, sizeof(group_props));
-  group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-  if (zetMetricGroupGetProperties(group, &group_props) != ZE_RESULT_SUCCESS) {
-    return false;
-  }
-  return (group_props.samplingType & static_cast<uint32_t>(PTI_METRIC_GROUP_TYPE_TRACE_BASED)) != 0;
-}
-
-class PtiMetricsCollectorHandler {
- public:
-  PtiMetricsCollectorHandler(const PtiMetricsCollectorHandler &) = delete;
-  PtiMetricsCollectorHandler &operator=(const PtiMetricsCollectorHandler &) = delete;
-  PtiMetricsCollectorHandler(PtiMetricsCollectorHandler &&) = delete;
-  PtiMetricsCollectorHandler &operator=(PtiMetricsCollectorHandler &&) = delete;
-
-  PtiMetricsCollectorHandler() {
-    // initially set logging level to warn
-    // need to use warnings very carefully, only when absolutely necessary
-    // as on Windows encountered it is INFO (taken from compiler define) by default (?)
-    spdlog::set_level(spdlog::level::warn);
-    // Read Logging level required
-    // set environment variable PTILOG_LEVEL=<level>, where level=TRACE/DEBUG/INFO..
-    // Logs appear only when PTI_ENABLE_LOGGING=ON => SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE
-    std::string env_string = utils::GetEnv("PTILOG_LEVEL");
-    if (!env_string.empty()) {
-      spdlog::cfg::helpers::load_levels(env_string);
-    }
-    utils::SetGlobalSpdLogPattern();
-
-    // Initialize devices and check metric status. A failure here is not fatal: metrics may still be
-    // enabled later via ptiMetricsEnable(), which triggers RefreshMetricState(). The status is
-    // reported to the caller by the individual metrics APIs, which gate on metrics_enabled_.
-    static_cast<void>(InitializeDevicesWithMetrics());
-  }
-
-  ~PtiMetricsCollectorHandler() {
-    devices_.clear();
-    for (auto it : metric_groups_) {
-      it.second.clear();
-    }
-    metric_groups_.clear();
-    stream_metrics_profilers_.clear();
-    query_metrics_profilers_.clear();
-    device_collection_active_.clear();
-  }
-
-  inline bool IsDeviceHandleValid(ze_device_handle_t device_handle) const {
-    for (const auto *device : devices_) {
-      if (device_handle == device) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  // Non-refreshing form of MetricsUsable(): true only if the cached device/metric-group state is
-  // valid and metrics are still enabled in the driver. A cached flag alone cannot see a
-  // ptiMetricsDisable() that dropped the last reference, so MetricStateManager is consulted too.
-  inline bool MetricsCachedStateUsable() const {
-    if (!metrics_enabled_.load(std::memory_order_acquire)) {
-      return false;
-    }
-    if (!pti::metrics::MetricStateManager::Instance().IsMetricEnabled()) {
-      metrics_enabled_.store(false, std::memory_order_release);
-      SPDLOG_DEBUG(
-          "Metrics were disabled after initialization; metrics APIs are unavailable "
-          "until ptiMetricsEnable() is called again");
-      return false;
-    }
-    return true;
-  }
-
-  // Single gate for every metrics API. Rebuilds the cached state when metrics have been enabled
-  // since it was last built, so a disable -> enable sequence recovers from any entry point.
-  // Refreshing in only some APIs left the rest returning PTI_ERROR_DRIVER permanently unless the
-  // caller happened to re-enumerate devices first.
-  inline bool MetricsUsable() {
-    if (MetricsCachedStateUsable()) {
-      return true;
-    }
-    if (!pti::metrics::MetricStateManager::Instance().IsMetricEnabled()) {
-      return false;
-    }
-    return RefreshMetricState() == PTI_SUCCESS && metrics_enabled_.load(std::memory_order_acquire);
-  }
-
-  // Refresh metric state after ptiMetricsEnable() is called.
-  // This re-checks device metric status and updates metrics_enabled_ flag.
-  // Serialized on refresh_mutex_: unlike the constructor path, this can be reached
-  // concurrently from GetDeviceCount()/GetDevices() and mutates the shared device maps.
-  inline pti_result RefreshMetricState() {
-    std::lock_guard<std::mutex> refresh_lock(refresh_mutex_);
-
-    // Another thread may have completed the refresh while we waited for the lock.
-    if (metrics_enabled_.load(std::memory_order_acquire)) {
-      return PTI_SUCCESS;
-    }
-
-    auto status = InitializeDevicesWithMetrics();
-    if (status != PTI_SUCCESS) {
-      return status;
-    }
-    return PTI_SUCCESS;
-  }
-
-  inline pti_result GetDeviceCount(uint32_t *device_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    *device_count = static_cast<uint32_t>(devices_.size());
-
-    return PTI_SUCCESS;
-  }
-
-  inline pti_result GetDevices(pti_device_properties_t *pDevices, uint32_t *device_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (pDevices == nullptr || device_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    uint32_t num_devices = static_cast<uint32_t>(devices_.size());
-    if (num_devices < *device_count) {
-      SPDLOG_DEBUG("Device buffer size too small. Device count is {}", num_devices);
-      *device_count = num_devices;
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    for (size_t i = 0; i < num_devices; ++i) {
-      ze_device_properties_t device_properties;
-      std::memset(&device_properties, 0, sizeof(device_properties));
-      device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-
-      ze_result_t status = zeDeviceGetProperties(devices_[i], &device_properties);
-      if (status != ZE_RESULT_SUCCESS) {
-        return PTI_ERROR_DRIVER;
-      }
-
-      ze_pci_ext_properties_t pci_props;
-      std::memset(&pci_props, 0, sizeof(pci_props));
-      pci_props.stype = ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
-
-      status = zeDevicePciGetPropertiesExt(devices_[i], &pci_props);
-      if (status != ZE_RESULT_SUCCESS) {
-        return PTI_ERROR_DRIVER;
-      }
-
-      pDevices[i]._handle = static_cast<pti_device_handle_t>(devices_[i]);
-      pDevices[i]._address._domain = pci_props.address.domain;
-      pDevices[i]._address._bus = pci_props.address.bus;
-      pDevices[i]._address._device = pci_props.address.device;
-      pDevices[i]._address._function = pci_props.address.function;
-
-      pDevices[i]._model_name = string_pool_.Get(device_properties.name);
-
-      std::copy_n(device_properties.uuid.id, PTI_MAX_DEVICE_UUID_SIZE, pDevices[i]._uuid);
-    }
-    return PTI_SUCCESS;
-  }
-
-  // Check metric group handle in all available devices
-  inline bool IsMetricGroupHandleValid(zet_metric_group_handle_t metric_group_handle) const {
-    for (const auto &[device, groups] : metric_groups_) {
-      for (const auto *group : groups) {
-        if (metric_group_handle == group) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  // check metric group handle for specified device
-  inline bool IsMetricGroupHandleValid(pti_device_handle_t device_handle,
-                                       zet_metric_group_handle_t metric_group_handle) const {
-    // Fist make sure the device handle is valid
-    ze_device_handle_t device = static_cast<ze_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      return false;
-    }
-
-    auto it = metric_groups_.find(device);
-    if (it == metric_groups_.end()) {
-      return false;
-    }
-
-    for (const auto *group : it->second) {
-      if (metric_group_handle == group) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  // Not const: MetricsUsable() rebuilds the cached device/metric-group state when metrics have
-  // been enabled since it was last built.
-  inline pti_result GetMetricGroupCount(pti_device_handle_t device_handle,
-                                        uint32_t *metrics_group_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr || metrics_group_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    ze_device_handle_t device = static_cast<ze_device_handle_t>(device_handle);
-
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    auto it = metric_groups_.find(device);
-    *metrics_group_count =
-        (it != metric_groups_.end()) ? static_cast<uint32_t>(it->second.size()) : 0;
-
-    return PTI_SUCCESS;
-  }
-
-  // Not const: see GetMetricGroupCount().
-  inline pti_result GetMetricGroups(pti_device_handle_t device_handle,
-                                    pti_metrics_group_properties_t *metrics_groups,
-                                    uint32_t *metrics_group_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr || metrics_groups == nullptr || metrics_group_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    ze_device_handle_t device = static_cast<ze_device_handle_t>(device_handle);
-
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    auto it = metric_groups_.find(device);
-    if (it == metric_groups_.end()) {
-      *metrics_group_count = 0;
-      return PTI_SUCCESS;  // No groups for this device
-    }
-
-    const auto &device_metric_groups = it->second;
-    uint32_t group_count = static_cast<uint32_t>(device_metric_groups.size());
-
-    if (group_count < *metrics_group_count) {
-      SPDLOG_DEBUG("Metric Group buffer size too small. Group count is {}", group_count);
-      *metrics_group_count = group_count;
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Populate the supplied buffer with discovered metric group properties
-    for (size_t i = 0; i < group_count; ++i) {
-      zet_metric_group_properties_t group_props;
-      std::memset(&group_props, 0, sizeof(group_props));
-      group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-
-      ze_result_t status = zetMetricGroupGetProperties(device_metric_groups[i], &group_props);
-      if (status != ZE_RESULT_SUCCESS) {
-        return PTI_ERROR_DRIVER;
-      }
-
-      metrics_groups[i]._handle = device_metric_groups[i];
-      // PTI sampling types for performance metrics should match L0 sampling types
-      metrics_groups[i]._type = static_cast<pti_metrics_group_type>(group_props.samplingType);
-      metrics_groups[i]._domain = group_props.domain;
-      metrics_groups[i]._metric_count = group_props.metricCount;
-      // User must allocate metric properties buffer and get it populated as a separate step.
-      metrics_groups[i]._metric_properties = nullptr;
-      metrics_groups[i]._name = string_pool_.Get(group_props.name);
-      metrics_groups[i]._description = string_pool_.Get(group_props.description);
-    }
-
-    *metrics_group_count = group_count;
-    return PTI_SUCCESS;
-  }
-
-  // Not const: see GetMetricGroupCount().
-  inline pti_result GetMetrics(pti_metrics_group_handle_t metrics_group_handle,
-                               pti_metric_properties_t *metrics) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (metrics_group_handle == nullptr || metrics == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_metric_group_handle_t group = static_cast<zet_metric_group_handle_t>(metrics_group_handle);
-
-    if (IsMetricGroupHandleValid(group) != true) {
-      SPDLOG_DEBUG("Invalid metric group handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_metric_group_properties_t group_props;
-    std::memset(&group_props, 0, sizeof(group_props));
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    ze_result_t status = zetMetricGroupGetProperties(group, &group_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    std::vector<zet_metric_handle_t> metric_list(group_props.metricCount, nullptr);
-    status = zetMetricGet(group, &group_props.metricCount, metric_list.data());
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    for (uint32_t i = 0; i < group_props.metricCount; ++i) {
-      zet_metric_properties_t metric_props;
-      std::memset(&metric_props, 0, sizeof(metric_props));
-      metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-      status = zetMetricGetProperties(metric_list[i], &metric_props);
-      if (status != ZE_RESULT_SUCCESS) {
-        return PTI_ERROR_DRIVER;
-      }
-
-      metrics[i]._handle = static_cast<pti_metric_handle_t>(metric_list[i]);
-      metrics[i]._metric_type = static_cast<pti_metric_type>(metric_props.metricType);
-      metrics[i]._value_type = static_cast<pti_metric_value_type>(metric_props.resultType);
-      metrics[i]._name = string_pool_.Get(metric_props.name);
-      metrics[i]._description = string_pool_.Get(metric_props.description);
-      metrics[i]._units = string_pool_.Get(metric_props.resultUnits);
-    }
-    return PTI_SUCCESS;
-  }
-
-  // Note: ConfigureMetricGroups currently supports only one metric group
-  // TODO: Add support for multiple metric groups
-  inline pti_result ConfigureMetricGroups(
-      pti_device_handle_t device_handle,
-      pti_metrics_group_collection_params_t *metric_config_params, uint32_t metrics_group_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (metric_config_params == nullptr || device_handle == nullptr ||
-        metric_config_params->_group_handle == nullptr || metrics_group_count == 0) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      // Protect access to the device_mutexes_ map to avoid races during mutex initialization
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    // Check collection state under device lock
-    if (device_collection_active_[device_handle] == CollectionState::ENABLED) {
-      SPDLOG_DEBUG("Cannot configure while collection is active");
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-    }
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_metric_group_handle_t group =
-        static_cast<zet_metric_group_handle_t>(metric_config_params->_group_handle);
-
-    if (IsMetricGroupHandleValid(device, group) != true) {
-      SPDLOG_DEBUG("Invalid metric group handle configured");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // TODO: Add support for more than 1 metric group per device at the time
-    if (metrics_group_count > 1) {
-      SPDLOG_DEBUG("Multiple metric groups not yet supported");
-      return PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    // If Configure is called more than once on the same device, the new call would overwrite the
-    // previous configuration
-    // Clean up existing profilers with proper synchronization
-    {
-      std::lock_guard<std::shared_mutex> profiler_lock(profilers_mutex_);
-      if (stream_metrics_profilers_.find(device_handle) != stream_metrics_profilers_.end()) {
-        stream_metrics_profilers_[device_handle].reset();
-        stream_metrics_profilers_.erase(device_handle);
-      }
-      if (query_metrics_profilers_.find(device_handle) != query_metrics_profilers_.end()) {
-        query_metrics_profilers_[device_handle].reset();
-        query_metrics_profilers_.erase(device_handle);
-      }
-    }
-
-    zet_metric_group_properties_t group_props;
-    std::memset(&group_props, 0, sizeof(group_props));
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    ze_result_t status = zetMetricGroupGetProperties(group, &group_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    // Create new profiler with proper synchronization
-    {
-      std::lock_guard<std::shared_mutex> profiler_lock(profilers_mutex_);
-
-      switch (group_props.samplingType) {
-        case ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED: {
-          uint32_t sampling_interval = metric_config_params->_sampling_interval;
-          std::unique_ptr<PtiStreamMetricsProfiler> stream_metrics_profiler =
-              std::make_unique<PtiStreamMetricsProfiler>(device_handle, group, sampling_interval);
-          stream_metrics_profilers_[device_handle] = std::move(stream_metrics_profiler);
-          break;
-        }
-        case ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED: {
-          std::unique_ptr<PtiQueryMetricsProfiler> query_metrics_profiler =
-              std::make_unique<PtiQueryMetricsProfiler>(device_handle, group);
-          query_metrics_profilers_[device_handle] = std::move(query_metrics_profiler);
-          break;
-        }
-        default: {
-          return PTI_ERROR_NOT_IMPLEMENTED;
-        }
-      }
-    }
-
-    return PTI_SUCCESS;
-  }
-
-  pti_result StartCollection(pti_device_handle_t device_handle, bool start_paused = false) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      // Protect access to the device_mutexes_ map to avoid races during mutex initialization
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    // Check current state
-    auto current_state = device_collection_active_[device_handle];
-    if (current_state == CollectionState::ENABLED) {
-      SPDLOG_DEBUG("Collection already enabled for device");
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-    }
-
-    if (current_state == CollectionState::PAUSED) {
-      SPDLOG_DEBUG("Collection already paused for device");
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED;
-    }
-
-    pti_result result = PTI_SUCCESS;
-    pti_result status = PTI_SUCCESS;
-
-    // Check if any profiler is configured for this device
-    {
-      std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-      if (stream_metrics_profilers_.find(device_handle) == stream_metrics_profilers_.end() &&
-          query_metrics_profilers_.find(device_handle) == query_metrics_profilers_.end()) {
-        SPDLOG_DEBUG(
-            "Attempted to start a metrics collection on a device that has not been configured.");
-        return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-      }
-    }
-
-    // Start profilers with proper synchronization
-    {
-      std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-      auto stream_it = stream_metrics_profilers_.find(device_handle);
-      if (stream_it != stream_metrics_profilers_.end() && stream_it->second) {
-        status = stream_it->second->StartProfiling(start_paused);
-        if (status != PTI_SUCCESS) {
-          SPDLOG_DEBUG("Failed to start stream profiler");
-          result = status;
-        }
-      }
-
-      auto query_it = query_metrics_profilers_.find(device_handle);
-      if (query_it != query_metrics_profilers_.end() && query_it->second) {
-        status = query_it->second->StartProfiling(start_paused);
-        if (status != PTI_SUCCESS) {
-          SPDLOG_DEBUG("Failed to start query profiler");
-          result = status;
-        }
-      }
-    }
-
-    // Update state on success
-    if (result == PTI_SUCCESS) {
-      device_collection_active_[device_handle] =
-          start_paused ? CollectionState::PAUSED : CollectionState::ENABLED;
-      SPDLOG_TRACE("Collection started successfully for device");
-    }
-    return result;
-  }
-
-  pti_result StartCollectionPaused(pti_device_handle_t device_handle) {
-    bool start_paused = true;
-    return StartCollection(device_handle, start_paused);
-  }
-
-  pti_result PauseCollection(pti_device_handle_t device_handle) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    pti_result result = PTI_SUCCESS;
-    pti_result status = PTI_SUCCESS;
-    {
-      std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-
-      if (stream_metrics_profilers_.find(device_handle) == stream_metrics_profilers_.end() &&
-          query_metrics_profilers_.find(device_handle) == query_metrics_profilers_.end()) {
-        SPDLOG_DEBUG(
-            "Attempted to pause a metrics collection on a device that has not been "
-            "configured for metrics collection.");
-        return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-      }
-
-      auto stream_it = stream_metrics_profilers_.find(device_handle);
-      if (stream_it != stream_metrics_profilers_.end() && stream_it->second) {
-        status = stream_it->second->PauseProfiling();
-        if (status != PTI_SUCCESS) {
-          result = status;
-        }
-      }
-
-      auto query_it = query_metrics_profilers_.find(device_handle);
-      if (query_it != query_metrics_profilers_.end() && query_it->second) {
-        status = query_it->second->PauseProfiling();
-        if (status != PTI_SUCCESS) {
-          result = status;
-        }
-      }
-    }
-    if (result == PTI_SUCCESS) {
-      device_collection_active_[device_handle] = CollectionState::PAUSED;
-      SPDLOG_TRACE("Collection paused successfully for device");
-    }
-
-    return result;
-  }
-
-  pti_result ResumeCollection(pti_device_handle_t device_handle) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    pti_result result = PTI_SUCCESS;
-    pti_result status = PTI_SUCCESS;
-
-    {
-      std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-
-      if (stream_metrics_profilers_.find(device_handle) == stream_metrics_profilers_.end() &&
-          query_metrics_profilers_.find(device_handle) == query_metrics_profilers_.end()) {
-        SPDLOG_DEBUG(
-            "Attempted to resume a metrics collection on a device that has not been configured.");
-        return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-      }
-
-      auto stream_it = stream_metrics_profilers_.find(device_handle);
-      if (stream_it != stream_metrics_profilers_.end() && stream_it->second) {
-        status = stream_it->second->ResumeProfiling();
-        if (status != PTI_SUCCESS) {
-          result = status;
-        }
-      }
-
-      auto query_it = query_metrics_profilers_.find(device_handle);
-      if (query_it != query_metrics_profilers_.end() && query_it->second) {
-        status = query_it->second->ResumeProfiling();
-        if (status != PTI_SUCCESS) {
-          result = status;
-        }
-      }
-    }
-
-    if (result == PTI_SUCCESS) {
-      device_collection_active_[device_handle] = CollectionState::ENABLED;
-      SPDLOG_TRACE("Collection resumed successfully for device");
-    }
-
-    return result;
-  }
-
-  pti_result StopCollection(pti_device_handle_t device_handle) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      // Protect access to the device_mutexes_ map to avoid races during mutex initialization
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    if (device_collection_active_[device_handle] == CollectionState::DISABLED) {
-      return PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED;
-    }
-
-    pti_result result = PTI_SUCCESS;
-    pti_result status = PTI_SUCCESS;
-
-    {
-      std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-
-      if (stream_metrics_profilers_.find(device_handle) == stream_metrics_profilers_.end() &&
-          query_metrics_profilers_.find(device_handle) == query_metrics_profilers_.end()) {
-        SPDLOG_DEBUG(
-            "Attempted to stop a metrics collection on a device that has not been configured.");
-        return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-      }
-
-      auto stream_it = stream_metrics_profilers_.find(device_handle);
-      if (stream_it != stream_metrics_profilers_.end() && stream_it->second) {
-        status = stream_it->second->StopProfiling();
-        if (status != PTI_SUCCESS) {
-          SPDLOG_DEBUG("Failed to stop stream profiler");
-          result = status;
-        }
-      }
-
-      auto query_it = query_metrics_profilers_.find(device_handle);
-      if (query_it != query_metrics_profilers_.end() && query_it->second) {
-        status = query_it->second->StopProfiling();
-        if (status != PTI_SUCCESS) {
-          SPDLOG_DEBUG("Failed to stop query profiler");
-          result = status;
-        }
-      }
-    }
-    // Update state only after attempting to stop all profilers
-    device_collection_active_[device_handle] = CollectionState::DISABLED;
-    SPDLOG_TRACE("Collection stopped successfully for device");
-
-    return result;
-  }
-
-  pti_result GetCalculatedData(pti_device_handle_t device_handle,
-                               pti_metrics_group_handle_t metrics_group_handle,
-                               pti_value_t *metrics_values_buffer, uint32_t *metrics_values_count) {
-    if (!MetricsUsable()) {
-      return PTI_ERROR_DRIVER;
-    }
-
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::mutex *per_device_mutex = nullptr;
-    {
-      // Protect access to the device_mutexes_ map to avoid races during mutex initialization
-      std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-      per_device_mutex = &device_mutexes_[device_handle];
-    }
-    std::lock_guard<std::mutex> device_lock(*per_device_mutex);
-
-    zet_device_handle_t device = static_cast<zet_device_handle_t>(device_handle);
-    if (IsDeviceHandleValid(device) != true) {
-      SPDLOG_DEBUG("Invalid device handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    zet_metric_group_handle_t group = static_cast<zet_metric_group_handle_t>(metrics_group_handle);
-    if (IsMetricGroupHandleValid(device, group) != true) {
-      SPDLOG_DEBUG("Invalid metric group handle used");
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    // For reading profilers
-    std::shared_lock<std::shared_mutex> profiler_lock(profilers_mutex_);
-
-    if (stream_metrics_profilers_.find(device_handle) == stream_metrics_profilers_.end() &&
-        query_metrics_profilers_.find(device_handle) == query_metrics_profilers_.end()) {
-      SPDLOG_DEBUG("Attempted to calculate metrics on a device that has not been configured.");
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    pti_result result = PTI_SUCCESS;
-    pti_result status = PTI_SUCCESS;
-
-    auto stream_it = stream_metrics_profilers_.find(device_handle);
-    if (stream_it != stream_metrics_profilers_.end() && stream_it->second) {
-      status = stream_it->second->GetCalculatedData(metrics_group_handle, metrics_values_buffer,
-                                                    metrics_values_count);
-      if (status != PTI_SUCCESS) {
-        result = status;
-      }
-    }
-
-    auto query_it = query_metrics_profilers_.find(device_handle);
-    if (query_it != query_metrics_profilers_.end() && query_it->second) {
-      status = query_it->second->GetCalculatedData(metrics_group_handle, metrics_values_buffer,
-                                                   metrics_values_count);
-      if (status != PTI_SUCCESS) {
-        result = status;
-      }
-    }
-
-    return result;
-  }
-
- private:
-  mutable StringPool string_pool_;
-  std::vector<ze_device_handle_t> devices_;
-  std::map<ze_device_handle_t, std::vector<zet_metric_group_handle_t>> metric_groups_;
-
-  std::unordered_map<pti_device_handle_t, std::unique_ptr<PtiStreamMetricsProfiler>>
-      stream_metrics_profilers_;
-  std::unordered_map<pti_device_handle_t, std::unique_ptr<PtiQueryMetricsProfiler>>
-      query_metrics_profilers_;
-  mutable std::shared_mutex profilers_mutex_;  // Protects: all profiler maps
-
-  std::unordered_map<pti_device_handle_t, std::mutex> device_mutexes_;
-  mutable std::mutex device_mutexes_mutex_;  // Protects: device_mutexes_ map, and insertion into
-                                             // device_collection_active_ by the refresh path
-
-  // Collection state tracking
-  enum class CollectionState { DISABLED, ENABLED, PAUSED };
-  std::unordered_map<pti_device_handle_t, CollectionState> device_collection_active_;
-
-  // mutable so that the const MetricsCachedStateUsable() can clear it when it observes that
-  // metrics have been disabled since the state was cached.
-  mutable std::atomic<bool> metrics_enabled_{false};
-
-  // Serializes RefreshMetricState()/InitializeDevicesWithMetrics(), which mutate devices_,
-  // metric_groups_ and string_pool_. The constructor runs before the
-  // instance is reachable, so only the post-construction refresh path needs this.
-  std::mutex refresh_mutex_;
-
-  // Can be called from constructor or later when metrics are enabled via ptiMetricsEnable().
-  pti_result InitializeDevicesWithMetrics() {
-    const bool metrics_enabled_via_env = ::utils::GetEnv("ZET_ENABLE_METRICS") == "1";
-    size_t enabled_count = 0;
-
-    ZeDriverInit init_drivers{};
-    auto l0_initialized = init_drivers.Success();
-    if (l0_initialized) {
-      if (devices_.empty()) {
-        devices_ = utils::ze::GetUniqueDeviceList(init_drivers.Drivers());
-        SPDLOG_DEBUG("In {} found {} devices", __func__, devices_.size());
-      }
-
-      // Pre-populate device mutexes and metric groups for all devices
-      for (auto device : devices_) {
-        if (!metrics_enabled_via_env &&
-            !pti::metrics::MetricStateManager::Instance().IsMetricEnabled(device)) {
-          SPDLOG_WARN("Metrics are disabled for device: {}", static_cast<void *>(device));
-          continue;
-        }
-
-        pti_device_handle_t device_handle = static_cast<pti_device_handle_t>(device);
-        {
-          std::lock_guard<std::mutex> device_map_lock(device_mutexes_mutex_);
-          device_mutexes_[device_handle];  // Creates mutex
-          device_collection_active_[device_handle] = CollectionState::DISABLED;
-        }
-
-        ze_device_properties_t device_props;
-        std::memset(&device_props, 0, sizeof(device_props));
-        device_props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-        if (zeDeviceGetProperties(device, &device_props) == ZE_RESULT_SUCCESS) {
-          string_pool_.Get(device_props.name);
-        }
-
-        if (metric_groups_.find(device) == metric_groups_.end()) {
-          auto &groups = metric_groups_[device];
-          utils::ze::FindMetricGroups(device, groups);
-          groups.erase(std::remove_if(groups.begin(), groups.end(), IsTraceBasedGroup),
-                       groups.end());
-
-          for (auto group : groups) {
-            RegisterMetricGroupStrings(group);
-          }
-        }
-        ++enabled_count;
-      }
-    } else {
-      SPDLOG_ERROR("Level Zero driver initialization failed");
-    }
-
-    const bool enabled = (enabled_count == devices_.size()) && !devices_.empty();
-    metrics_enabled_.store(l0_initialized && enabled, std::memory_order_release);
-
-    if (!enabled) {
-#ifndef _WIN32
-      if (enabled_count == 0) {
-        SPDLOG_WARN(
-            "Please also make sure: "
-            "on PVC: /proc/sys/dev/i915/perf_stream_paranoid "
-            "OR on BMG (or later): /proc/sys/dev/xe/observation_paranoid "
-            "is set to 0.");
-      }
-#endif /* _WIN32 */
-
-      SPDLOG_WARN(
-          "Metrics collection is not enabled on all devices present in the system. "
-          "Please make sure environment variable ZET_ENABLE_METRICS is set to 1, "
-          "or call ptiMetricsEnable() before calling any metrics collection APIs.");
-
-      return PTI_ERROR_METRICS_ENABLE_FAILED;
-    }
-    return PTI_SUCCESS;
-  }
-
-  void RegisterMetricGroupStrings(zet_metric_group_handle_t group) {
-    zet_metric_group_properties_t group_props;
-    std::memset(&group_props, 0, sizeof(group_props));
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    if (zetMetricGroupGetProperties(group, &group_props) == ZE_RESULT_SUCCESS) {
-      string_pool_.Get(group_props.name);
-      string_pool_.Get(group_props.description);
-
-      RegisterMetricStrings(group, group_props.metricCount);
-    }
-  }
-
-  void RegisterMetricStrings(zet_metric_group_handle_t group, uint32_t metric_count) {
-    std::vector<zet_metric_handle_t> metrics(metric_count);
-    ze_result_t status = zetMetricGet(group, &metric_count, metrics.data());
-    if (status != ZE_RESULT_SUCCESS) {
-      return;
-    }
-
-    for (auto metric : metrics) {
-      zet_metric_properties_t metric_props;
-      std::memset(&metric_props, 0, sizeof(metric_props));
-      metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-      if (zetMetricGetProperties(metric, &metric_props) == ZE_RESULT_SUCCESS) {
-        string_pool_.Get(metric_props.name);
-        string_pool_.Get(metric_props.description);
-        string_pool_.Get(metric_props.resultUnits);
-      }
-    }
-  }
-};
-
-// Required to access from ze_collector callbacks
-inline static auto &MetricsCollectorInstance() {
-  static PtiMetricsCollectorHandler metrics_collector{};
-  return metrics_collector;
-}
-
-#endif  // SRC_API_METRICS_HANDLER_H_
diff --git a/sdk/src/metrics/pti_metrics.cc b/sdk/src/metrics/pti_metrics.cc
deleted file mode 100644
index 97b126a5..00000000
--- a/sdk/src/metrics/pti_metrics.cc
+++ /dev/null
@@ -1,424 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "pti/pti_metrics.h"
-
-#include "metric_state_manager.h"
-#include "metrics_handler.h"
-
-namespace {
-
-// TODO: maybe_unused because SPDLOG_ERROR not guaranteed to be there on release builds
-void LogException([[maybe_unused]] const std::exception& excep) {
-  SPDLOG_ERROR("Caught exception before return: {}", excep.what());
-}
-}  // namespace
-/**
- * @brief Get the properties of all devices on the system on which metric collection can be done
- * usage: 1- Call ptiMetricsGetDevices(nullptr, device_count) to discover the required buffer
- *           size; the required buffer size will be written to device_count.
- *        2- Allocate devices buffer of size sizeof(pti_device_properties_t) * device_count
- *        3- Call ptiMetricsGetDevices(devices, device_count) to get the properties of the
- *           discovered devices written to devices
- *        WARNING: It is expected that devices buffer is sufficiently large to hold the
- *        properties for all discovered devices. Passing in a buffer that
- *        is not sufficiently large with incorrect device_count parameter will result is a
- *        buffer overrun
- *
- * @param[in/out] devices               Pointer to the array of devices. If nullptr, the number
- *                                          of devices is returned in *device_count
- *                                          if not nullptr, it should point to the buffer of size:
- *                                          sizeof(pti_device_description_t) * (*device_count)
- * @param[in/out] device_count          Number of devices
- *                                          in - if devices is nullptr or if device_count is
- *                                          less than the required minimum buffer size,
- *                                          device_count will contain the required buffer size
- *                                          out - devices buffer size used
- *                                          Note: device_count cannot be nullptr
- *
- * @return pti_result
- */
-pti_result ptiMetricsGetDevices(pti_device_properties_t* devices, uint32_t* device_count) {
-  try {
-    // device_count cannot be null
-    if (device_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    uint32_t num_devices = 0;
-    pti_result result = PTI_SUCCESS;
-
-    /* Step 1: discover number of device */
-    if (devices == nullptr) {
-      result = MetricsCollectorInstance().GetDeviceCount(&num_devices);
-      if (result == PTI_SUCCESS) {
-        *device_count = num_devices;
-        if (num_devices == 0) {
-          SPDLOG_WARN("No supported devices found");
-        }
-      } else {
-        SPDLOG_WARN("Failed to discover device count");
-      }
-    } else {
-      /* Step 2: populate devices buffer */
-      num_devices = *device_count;
-      result = MetricsCollectorInstance().GetDevices(devices, &num_devices);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_WARN("Failed to discover devices");
-      }
-    }
-    return result;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get the properties of the metric groups supported by the device
- * Usage: 1- Call ptiMetricsGetMetricGroups(device_handle, null, metrics_group_count) to discover
- * the required buffer size; the required buffer size will be written to metrics_group_count. 2-
- * Allocate metrics_groups buffer of size sizeof(pti_metrics_group_properties_t) *
- * metrics_group_count 3- Call ptiMetricsGetMetricGroups(device_handle, metrics_groups,
- * metrics_group_count) again to get the properties of the discovered metric groups written to
- * the supplied buffer WARNING: It is expected that metrics_groups is sufficiently large to hold
- * properties for all discovered metric groups. Passing in a buffer that is not sufficiently large
- * will result in a buffer overrun
- *
- * @param[in] device_handle                      Device handle
- * @param[in/out] metrics_groups              buffer where to save metric group properties for
- *                                               the metric groups that can be collected. Set to
- * null to discover the required buffer size
- * @param[in/out] metrics_group_count         if metrics_groups is set to null or
- *                                               metrics_group_count is less than the required
- * minimum buffer size, metrics_group_count will contain the metric group count Otherwise,
- * metrics_group_count will contain actual metric group count. Note: metrics_group_count
- * cannot be null
- *
- * @return pti_result
- */
-pti_result ptiMetricsGetMetricGroups(pti_device_handle_t device_handle,
-                                     pti_metrics_group_properties_t* metrics_groups,
-                                     uint32_t* metrics_group_count) {
-  try {
-    if (device_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // metrics_group_count cannot be null
-    if (metrics_group_count == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    uint32_t group_count = 0;
-    pti_result result = PTI_SUCCESS;
-
-    /* step 1: Get number of metric groups */
-    if (metrics_groups == nullptr) {
-      result = MetricsCollectorInstance().GetMetricGroupCount(device_handle, &group_count);
-      if (result == PTI_SUCCESS) {
-        *metrics_group_count = group_count;
-        if (group_count == 0) {
-          SPDLOG_WARN("No metric group found for specified device");
-        }
-      } else {
-        SPDLOG_WARN("Failed to discover metric group count");
-      }
-    } else {
-      /* Step 2: populate metrics_groups buffer */
-      group_count = *metrics_group_count;
-      result =
-          MetricsCollectorInstance().GetMetricGroups(device_handle, metrics_groups, &group_count);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_WARN("Failed to discover metric groups for specified device");
-      }
-    }
-
-    return result;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get properties for all metrics in a metric group.
- * Usage: 1- Get available metric groups on a specified device using ptiMetricsGetMetricGroups
- *        2- In the metric group properties structure of the metric group of interest, allocate
- * buffer _metric_properties of size sizeof(pti_metric_properties_t) * _metric_count
- *        3- call ptiMetricsGetMetricsProperties(metrics_group_handle, _metric_properties) to get
- * the metric properties written to the supplied buffer WARNING: It is expected that
- * _metric_properties buffer is sufficiently large to hold properties for all metrics in the
- * specified metric group. Passing in a buffer that is not suffitiently large will result in a
- * buffer overrun
- *
- * @param[in] metrics_group_handle            Metric group handle
- * @param[in/out] metrics                Buffer where to save metric properties for the
- *                                           specified metric group
- *
- * @return pti_result
- */
-pti_result ptiMetricsGetMetricsProperties(pti_metrics_group_handle_t metrics_group_handle,
-                                          pti_metric_properties_t* metrics) {
-  try {
-    if (metrics_group_handle == nullptr || metrics == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    pti_result result = PTI_SUCCESS;
-
-    /* Populate metrics buffer */
-    result = MetricsCollectorInstance().GetMetrics(metrics_group_handle, metrics);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_WARN("Failed to discover metrics for specified metric group");
-    }
-
-    return result;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Configure metric groups of interest.
- * Note: only 1 metric group of type PTI_METRIC_GROUP_TYPE_TIME_BASED can be specified at this time.
- * TODO: add support for multiple metric groups and different types
- *
- * @param[in] device_handle                  Device handle
- * @param[in] metric_config_params       Buffer of input parameters structures. Note: only 1 is
- * supported at this time
- * @param[in] metrics_group_count     Number of configuration structures in the configuration
- * buffer
- *
- * @return pti_result
- */
-pti_result ptiMetricsConfigureCollection(
-    pti_device_handle_t device_handle, pti_metrics_group_collection_params_t* metric_config_params,
-    uint32_t metrics_group_count) {
-  try {
-    if (device_handle == nullptr || metric_config_params == nullptr ||
-        metric_config_params->_group_handle == nullptr || metrics_group_count == 0) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (metrics_group_count > 1) {
-      SPDLOG_ERROR(
-          "pti metric collector currently supports the collection of "
-          "only one metric group at a time");
-      return PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return MetricsCollectorInstance().ConfigureMetricGroups(device_handle, metric_config_params,
-                                                            metrics_group_count);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Start metrics collection on specified device
- * Note: ptiMetricsConfigureCollection must be called first to configure the metric group(s) of
- * interest
- *
- * @param[in] device_handle                        Device handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsStartCollection(pti_device_handle_t device_handle) {
-  try {
-    return MetricsCollectorInstance().StartCollection(device_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Start metrics collection on specified device in paused mode
- * Note: ptiMetricsConfigureCollection must be called first to configure the metric group(s) of
- * interest
- *
- * @param[in] device_handle                        Device handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsStartCollectionPaused(pti_device_handle_t device_handle) {
-  try {
-    return MetricsCollectorInstance().StartCollectionPaused(device_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Pause metrics collection on specified device
- * Note: Collection  must be started first
- *
- * @param[in] device_handle                        Device handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsPauseCollection(pti_device_handle_t device_handle) {
-  try {
-    return MetricsCollectorInstance().PauseCollection(device_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Resume metrics collection on specified device
- * Note: Collection must be started and paused
- *
- * @param[in] device_handle                        Device handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsResumeCollection(pti_device_handle_t device_handle) {
-  try {
-    return MetricsCollectorInstance().ResumeCollection(device_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Stop metrics collection on specified device
- * Note: ptiMetricsStartCollection must be called first to Start the collection
- * This function terminates the collection but does not process the data
- * @param[in] device_handle                        Device handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsStopCollection(pti_device_handle_t device_handle) {
-  try {
-    return MetricsCollectorInstance().StopCollection(device_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief process and dump collected data on specified device
- * Note: ptiMetricsStopCollection must be called first to process collected data
- * ptiMetricsGetCalculatedData can only be called once after the collection is stopped and cannot be
-called between pa use and resume
- *
- * usage: 1- Call ptiMetricsGetCalculatedData(device_handle, metrics_group_handle, NULL,
-metrics_values_count) to discover the required buffer size for
- *           data collected for the specified metric group on on the specified device ;
- *           the required buffer size will be written to metrics_values_count in multiples of
-pti_value_t.
- *        2- Allocate metrics_values_buffer for holding  metrics_values_count values
- *        3- Call ptiMetricsGetCalculatedData(device_handle, metrics_group_handle,
-metrics_values_buffer, metrics_values_count) to get the values written to buffer
- * A sample contains a 64bit value container for each metric in the metric group.
- * based on the metric's value type, the 64bit value container should be converted appropriately.
- *
- * @param[in] device_handle                 Device handle
- * @param[in] metrics_group_handle          Metric Group handle
- * @param[in/out] metrics_values_buffer     Buffer where to save collected samples
- *                                          Set to null to discover the required buffer size
- * @param[in/out] metrics_values_count      If metrics_values_buffer is set to null,
-metrics_values_count will contain the number of pti_value_t
- *                                          values the buffer needs to be able to hold
- * @return pti_result
- */
-pti_result ptiMetricsGetCalculatedData(pti_device_handle_t device_handle,
-                                       pti_metrics_group_handle_t metrics_group_handle,
-                                       pti_value_t* metrics_values_buffer,
-                                       uint32_t* metrics_values_count) {
-  try {
-    // metrics_values_count cannot be null
-    if (metrics_values_count == nullptr || device_handle == nullptr ||
-        metrics_group_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    uint32_t values_count = 0;
-    pti_result result = PTI_SUCCESS;
-
-    /* Step 1: discover the required buffer size */
-    if (metrics_values_buffer == nullptr) {
-      result = MetricsCollectorInstance().GetCalculatedData(device_handle, metrics_group_handle,
-                                                            nullptr, &values_count);
-      if (result == PTI_SUCCESS) {
-        *metrics_values_count = values_count;
-        if (values_count == 0) {
-          SPDLOG_WARN("No samples found");
-          result = PTI_ERROR_METRICS_NO_DATA_COLLECTED;
-        }
-      } else {
-        SPDLOG_WARN("Failed to determine required buffer size");
-      }
-    } else {
-      /* Step 2: populate buffer */
-      if (*metrics_values_count == 0) {
-        SPDLOG_ERROR("Invalid buffer size used for getting calculated data");
-        result = PTI_ERROR_BAD_ARGUMENT;
-      } else {
-        result = MetricsCollectorInstance().GetCalculatedData(
-            device_handle, metrics_group_handle, metrics_values_buffer, metrics_values_count);
-
-        if (result != PTI_SUCCESS) {
-          SPDLOG_WARN("Failed to save values in buffer");
-        }
-      }
-    }
-
-    return result;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsEnable(pti_device_handle_t device) {
-  try {
-    return pti::metrics::MetricStateManager::Instance().EnableMetric(device);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsDisable(pti_device_handle_t device) {
-  try {
-    return pti::metrics::MetricStateManager::Instance().DisableMetric(device);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
diff --git a/sdk/src/metrics/pti_metrics_scope.cc b/sdk/src/metrics/pti_metrics_scope.cc
deleted file mode 100644
index fb9b34a3..00000000
--- a/sdk/src/metrics/pti_metrics_scope.cc
+++ /dev/null
@@ -1,1094 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <pti/pti_metrics_scope.h>
-#include <spdlog/spdlog.h>
-
-#include <mutex>
-#include <shared_mutex>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "metrics_handler.h"
-#include "pti/pti_callback.h"
-#include "pti/pti_metrics.h"
-#include "pti_assert.h"
-#include "pti_metrics_scope_buffer.h"
-#include "pti_metrics_scope_buffer_handler.h"
-#include "pti_metrics_scope_helper.h"
-
-namespace {
-
-// Global map to manage scope collection handles
-std::unordered_map<pti_scope_collection_handle_t, std::unique_ptr<_pti_scope_collection_handle_t>>
-    g_scope_handles;
-
-// Mutex to protect the global map, adding/remoing objects from this
-// this map also serves to validate that handle passed by user is valid
-std::shared_mutex g_scope_handles_mutex;
-
-// For now - most of scope operations are serialized
-// TODO - do it by Scope to allow more parallelism
-std::mutex g_scope_ops_mutex;
-
-// TODO: maybe_unused because SPDLOG_ERROR not guaranteed to be there on release builds
-void LogException([[maybe_unused]] const std::exception& excep) {
-  SPDLOG_ERROR("Caught exception before return: {}", excep.what());
-}
-
-bool IsOurHandle(pti_scope_collection_handle_t handle) {
-  std::shared_lock<std::shared_mutex> lock(g_scope_handles_mutex);
-  return g_scope_handles.find(handle) != g_scope_handles.end();
-}
-
-/**
- * @brief Callback function for scope-based metrics collection
- * This function handles GPU operation events and injects metric queries automatically
- *
- * @param[in] domain                    Callback domain (GPU operation events)
- * @param[in] driver_group_id           Driver group identifier
- * @param[in] driver_api_id             Driver API identifier
- * @param[in] backend_context           Backend context handle
- * @param[in] cb_data                   Callback data containing operation details
- * @param[in] user_data                 User data (scope collection handle)
- * @param[in/out] instance_user_data    Instance-specific user data
- */
-void MetricsScopeCallback(pti_callback_domain domain,
-                          [[maybe_unused]] pti_api_group_id driver_group_id,
-                          [[maybe_unused]] uint32_t driver_api_id,
-                          pti_backend_ctx_t backend_context, void* cb_data, void* user_data,
-                          [[maybe_unused]] void** instance_user_data) {
-  SPDLOG_TRACE(
-      "========================= MetricsScopeCallback triggered =================================");
-  SPDLOG_TRACE("Domain: {}", ptiCallbackDomainTypeToString(domain));
-  SPDLOG_TRACE("Driver Group ID: {}", static_cast<uint64_t>(driver_group_id));
-  SPDLOG_TRACE("Driver API ID: {}", driver_api_id);
-  SPDLOG_TRACE("Instance user data: {}", static_cast<void*>(instance_user_data));
-
-  _pti_scope_collection_handle_t* scope_collection_handle =
-      static_cast<_pti_scope_collection_handle_t*>(user_data);
-
-  if (!scope_collection_handle || !scope_collection_handle->is_collection_active_) {
-    SPDLOG_TRACE("MetricsScopeCallback: Collection not active, returning");
-    return;
-  }
-  auto* callback_data = static_cast<pti_callback_gpu_op_data*>(cb_data);
-  if (callback_data == nullptr) {
-    SPDLOG_TRACE("MetricsScopeCallback: Callback data is null. Skipping ",
-                 ptiCallbackDomainTypeToString(domain));
-    return;
-  }
-
-  // Delegate to handle method for cleaner separation
-  HandleKernelEvent(scope_collection_handle, callback_data, backend_context, domain);
-}
-
-}  // namespace
-
-/**
- * @brief Collect query data for a completed kernel operation
- * This function retrieves raw metric data from the query associated with the kernel
- * and stores it in the collection buffer for later processing
- *
- * @param[in] scope_collection_handle    Scope collection handle
- * @param[in] kernel_id                  Unique identifier for the kernel
- * @param[in] kernel_name                Name of the kernel
- * @param[in] queue                      Level Zero command queue handle
- */
-void CollectQueryDataForKernel(pti_scope_collection_handle_t scope_collection_handle,
-                               uint64_t kernel_id, const char* kernel_name,
-                               ze_command_queue_handle_t queue, pti_device_handle_t device) {
-  SPDLOG_TRACE(
-      "CollectQueryDataForKernel: Collecting query data for kernel ID: {} "
-      "About to acquire data_mutex_",
-      kernel_id);
-  std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-  auto profiler_it = scope_collection_handle->query_profilers_.find(device);
-  if (profiler_it == scope_collection_handle->query_profilers_.end() || !profiler_it->second) {
-    SPDLOG_TRACE("CollectQueryDataForKernel: no profiler for device {}, skipping",
-                 static_cast<void*>(device));
-    return;
-  }
-
-  auto& profiler = profiler_it->second;
-
-  // Get query from profiler (single source of truth)
-  auto [query, completion_event] = profiler->GetSlotForKernel(kernel_id);
-
-  if (!ValidateQueryAndEvent(query, completion_event, kernel_id)) {
-    // Keep the slot: its data has not been read, so it must not be reused.
-    return;
-  }
-
-  // Get raw metric data
-  std::vector<uint8_t> raw_data;
-  if (!GetRawMetricData(query, raw_data, kernel_name, profiler->MutableCachedRawDataSize())) {
-    SPDLOG_DEBUG(
-        "CollectQueryDataForKernel: INTERNAL ERROR:"
-        " Failed to get raw metric data for kernel ID: {}",
-        kernel_id);
-    return;
-  }
-
-  // Create kernel data record
-  auto kernel_data =
-      CreateKernelMetricData(kernel_id, kernel_name, raw_data.data(), raw_data.size(), queue);
-
-  if (!kernel_data) {
-    SPDLOG_DEBUG(
-        "CollectQueryDataForKernel: INTERNAL ERROR:"
-        " Failed to create kernel metric data for kernel ID: {}",
-        kernel_id);
-    return;
-  }
-
-  // Store the data in buffer
-  bool success =
-      StoreKernelData(scope_collection_handle, device, std::move(kernel_data), raw_data.size());
-  if (success) {
-    SPDLOG_TRACE(
-        "CollectQueryDataForKernel: Successfully collected {} bytes of metric data for kernel: {}",
-        raw_data.size(), kernel_name);
-  } else {
-    SPDLOG_WARN(
-        "CollectQueryDataForKernel: Failed to store metric data for kernel ID {} on device {}; "
-        "record dropped",
-        kernel_id, static_cast<void*>(device));
-  }
-
-  // The data has been read, so the slot can serve another kernel.
-  profiler->RecycleKernelSlot(kernel_id, static_cast<ze_device_handle_t>(device));
-}
-
-/**
- * @brief Allocate and initialize the scope collection handle
- * Usage: Call this function first to create a scope collection handle before configuring metrics
- * collection
- *
- * @param[out] scope_collection_handle       Pointer to store the scope collection handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeEnable(pti_scope_collection_handle_t* scope_collection_handle) {
-  try {
-    if (scope_collection_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    pti_result status = ptiMetricsEnable(nullptr);
-    if (status != PTI_SUCCESS) {
-      SPDLOG_ERROR("{}: Failed to enable metrics: {}", __FUNCTION__, ptiResultTypeToString(status));
-      return status;
-    }
-    SPDLOG_INFO("ptiMetricsScopeEnable: Successfully enabled metrics for all devices");
-
-    auto handle = std::make_unique<_pti_scope_collection_handle_t>();
-
-    // Create the handle
-    pti_scope_collection_handle_t new_handle = handle.get();
-
-    // Protect global map access with mutex
-    {
-      std::lock_guard<std::shared_mutex> lock(g_scope_handles_mutex);
-      g_scope_handles[new_handle] = std::move(handle);
-    }
-
-    *scope_collection_handle = new_handle;
-
-    SPDLOG_TRACE("ptiMetricsScopeEnable: Scope metrics collection handle enabled");
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Configure MetricsScope collection
- *
- * @param[in] scope_collection_handle        Scope collection handle obtained from
- * ptiMetricsScopeEnable
- * @param[in] collection_mode                Collection mode;
- *                                           currently only PTI_METRICS_SCOPE_AUTO_KERNEL is
- * supported
- * @param[in] devices_to_profile             Array of device handles for target devices;
- *                                           currently only one device per MetricsScope is supported
- * @param[in] device_count                   Number of devices in the devices_to_profile array
- * @param[in] metric_names                   Array of metric names to collect
- * @param[in] metric_count                   Number of metric names in the metric_names array
- *
- * @return pti_result
- *
- */
-pti_result ptiMetricsScopeConfigure(pti_scope_collection_handle_t scope_collection_handle,
-                                    pti_metrics_scope_mode_t collection_mode,
-                                    pti_device_handle_t* devices_to_profile, uint32_t device_count,
-                                    const char** metric_names, size_t metric_count) {
-  try {
-    std::lock_guard<std::mutex> lock(g_scope_ops_mutex);
-
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Validate all input arguments
-    auto result = ValidateConfigurationArguments(devices_to_profile, device_count, metric_names,
-                                                 metric_count);
-    if (result != PTI_SUCCESS) {
-      return result;
-    }
-
-    if (scope_collection_handle->is_collection_active_) {
-      SPDLOG_DEBUG("ptiMetricsScopeConfigure: Cannot reconfigure while collection is active");
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-    }
-
-    std::lock_guard<std::mutex> data_lock(scope_collection_handle->data_mutex_);
-
-    std::vector<pti_device_properties_t> all_devices;
-    result = GetAllAvailableDevices(all_devices);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_DEBUG("ptiMetricsScopeConfigure: Failed to enumerate available devices");
-      return result;
-    }
-    std::unordered_set<pti_device_handle_t> available_device_handles;
-    available_device_handles.reserve(all_devices.size());
-    for (const auto& device : all_devices) {
-      available_device_handles.insert(device._handle);
-    }
-
-    // Set up the scope collection handle with all requested devices
-    scope_collection_handle->requested_devices_.clear();
-    scope_collection_handle->failed_devices_.clear();
-    scope_collection_handle->metrics_group_handles_.clear();
-
-    // Stop any profilers from a previous Configure before clearing them.
-    // The destructor would otherwise destroy L0 resources while the profiler
-    // is still in PROFILER_ENABLED state, causing a segfault.
-    if (scope_collection_handle->is_configured_) {
-      for (auto& [device, profiler] : scope_collection_handle->query_profilers_) {
-        if (profiler) {
-          profiler->StopProfiling();
-        }
-      }
-    }
-    scope_collection_handle->query_profilers_.clear();
-
-    scope_collection_handle->next_buffer_ids_.clear();
-    scope_collection_handle->collected_metrics_group_name_ = nullptr;
-    scope_collection_handle->requested_metric_indices_.clear();
-    scope_collection_handle->requested_metric_names_.clear();
-    scope_collection_handle->requested_metric_units_.clear();
-    scope_collection_handle->requested_value_types_.clear();
-    scope_collection_handle->is_configured_ = false;
-
-    scope_collection_handle->buffer_manager_ =
-        std::make_unique<PtiMetricsScopeBufferHandler<PtiMetricsScopeBuffer>>();
-
-    // Auto mode: lazy-create profilers on whichever devices the workload
-    // actually touches. requested_devices_ stays empty.
-    if (device_count == 0) {
-      scope_collection_handle->auto_detect_mode_ = true;
-    } else {  // Explicit mode: profile only on specified devices
-      scope_collection_handle->auto_detect_mode_ = false;
-      for (uint32_t i = 0; i < device_count; ++i) {
-        result = ValidateTargetDevice(devices_to_profile[i], available_device_handles);
-        if (result != PTI_SUCCESS) {
-          SPDLOG_DEBUG("ptiMetricsScopeConfigure: Device validation failed for device {}: {}",
-                       static_cast<void*>(devices_to_profile[i]), static_cast<int>(result));
-          return result;
-        }
-        scope_collection_handle->requested_devices_.insert(devices_to_profile[i]);
-      }
-    }
-
-    // Pick the device set for uniformity check + representative metadata
-    // resolution: explicit list in explicit mode, all enumerated devices in
-    // auto mode.
-    const std::unordered_set<pti_device_handle_t>& candidate_devices =
-        scope_collection_handle->auto_detect_mode_ ? available_device_handles
-                                                   : scope_collection_handle->requested_devices_;
-
-    if (candidate_devices.size() > 1) {
-      result = ValidateDevicesUniform(candidate_devices, all_devices);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_DEBUG("Device uniformity validation failed: {}", static_cast<int>(result));
-        return result;
-      }
-    }
-
-    // Set up requested metric properties (once for all devices)
-    result = SetupMetricProperties(scope_collection_handle, metric_names, metric_count);
-    if (result != PTI_SUCCESS) {
-      return result;
-    }
-
-    // Only support AUTO_KERNEL mode for now
-    if (collection_mode != PTI_METRICS_SCOPE_AUTO_KERNEL) {
-      SPDLOG_DEBUG("ptiMetricsScopeConfigure: Only AUTO_KERNEL mode supported");
-      return PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    // Resolve metric group on a representative device so metadata is
-    // queryable before the first kernel append. Pure enumeration, no L0
-    // claim; uniformity guarantees the resolution applies to all devices.
-    if (!candidate_devices.empty()) {
-      pti_device_handle_t representative = *candidate_devices.begin();
-      result = ResolveGroupFromMetricNames(scope_collection_handle, representative);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_DEBUG("ptiMetricsScopeConfigure: failed to resolve metric group for metadata: {}",
-                     static_cast<int>(result));
-        return result;
-      }
-    }
-
-    // Default buffer size when caller doesn't set one explicitly.
-    // ptiMetricsScopeSetCollectionBufferSize can override; calling it is optional.
-    if (scope_collection_handle->configured_buffer_size_ == 0) {
-      scope_collection_handle->configured_buffer_size_ = kMinCollectionBufferSize;
-    }
-
-    // Profilers/buffers are built lazily on first kernel append per device.
-    scope_collection_handle->is_configured_ = true;
-    return PTI_SUCCESS;
-
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Query the estimated collection buffer size required for collecting metrics for the
- * specified scope count
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] scopes_number                  Number of scopes to estimate collection buffer size
- * @param[out] estimated_buffer_size         Pointer to store the estimated collection buffer size
- * in bytes
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeQueryCollectionBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, size_t scopes_number,
-    size_t* estimated_buffer_size) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->is_configured_) {
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    // TODO: as soon as there is Level-Zero API that allows to Query metrcis recornd size
-    // - we should use it here
-    size_t estimated_per_scope = kEstimatedSizeOfRawRecord;
-
-    if (scopes_number > kMaxNumberOfRawRecordsPerCollectionBuffer) {
-      SPDLOG_WARN(
-          "ptiMetricsScopeQueryCollectionBufferSize: Requested scopes_number ({}) exceeds "
-          "maximum per buffer ({}). Capping to maximum.",
-          scopes_number, kMaxNumberOfRawRecordsPerCollectionBuffer);
-      scopes_number = kMaxNumberOfRawRecordsPerCollectionBuffer;
-      return PTI_WARN_METRICS_SCOPE_PARTIAL_BUFFER;
-    }
-
-    PTI_ASSERT(scopes_number <= kMaxNumberOfRawRecordsPerCollectionBuffer);
-    size_t buffer_size = scopes_number * estimated_per_scope;
-
-    *estimated_buffer_size =
-        (buffer_size > kMinCollectionBufferSize) ? buffer_size : kMinCollectionBufferSize;
-
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Set the collection buffer size to be used during collection
- * Note: As soon as the first such buffer is full, PTI will allocate a second one and so on.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] buffer_size                    Size of the collection buffer in bytes for later
- * allocation
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeSetCollectionBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, size_t buffer_size) {
-  try {
-    std::lock_guard<std::mutex> lock(g_scope_ops_mutex);
-
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{} could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->is_configured_) {
-      SPDLOG_DEBUG("{}: Scope collection handle not configured", __func__);
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    if (scope_collection_handle->is_collection_active_) {
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-    }
-
-    if (!scope_collection_handle->buffer_manager_) {
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    if (buffer_size < kMinCollectionBufferSize) {
-      SPDLOG_WARN(
-          "ptiMetricsScopeSetCollectionBufferSize: requested size {} below minimum {}, "
-          "clamping",
-          buffer_size, kMinCollectionBufferSize);
-      buffer_size = kMinCollectionBufferSize;
-    }
-
-    // Profilers and per-device buffers are created lazily on first kernel
-    // append, so there's nothing to pre-allocate here.
-    scope_collection_handle->configured_buffer_size_ = buffer_size;
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Begin the metrics collection
- *
- * @param[in] scope_collection_handle    Scope collection handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeStartCollection(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    std::lock_guard<std::mutex> lock(g_scope_ops_mutex);
-
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->is_configured_) {
-      SPDLOG_DEBUG("{}: Scope collection handle not configured", __func__);
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    PTI_ASSERT(scope_collection_handle->configured_buffer_size_ >= kMinCollectionBufferSize);
-
-    if (scope_collection_handle->is_collection_active_) {
-      SPDLOG_DEBUG("ptiMetricsScopeStartCollection: Collection already active");
-      return PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED;
-    }
-
-    // Register the callback for automatic query injection with the handle as user_data
-    pti_result result = ptiCallbackSubscribe(&scope_collection_handle->callback_subscriber_,
-                                             MetricsScopeCallback, scope_collection_handle);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_DEBUG("ptiMetricsScopeStartCollection: Failed to subscribe to callback: {}",
-                   static_cast<int>(result));
-      return result;
-    }
-
-    // Enable GPU operation completion domain
-    result = ptiCallbackEnableDomain(scope_collection_handle->callback_subscriber_,
-                                     PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_DEBUG(
-          "ptiMetricsScopeStartCollection: Failed to enable GPU_OPERATION_COMPLETED domain: {}",
-          static_cast<int>(result));
-      ptiCallbackUnsubscribe(scope_collection_handle->callback_subscriber_);
-      scope_collection_handle->callback_subscriber_ = 0;
-      return result;
-    }
-
-    // Enable driver GPU operation append for query injection
-    result = ptiCallbackEnableDomain(scope_collection_handle->callback_subscriber_,
-                                     PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_DEBUG(
-          "ptiMetricsScopeStartCollection: Failed to enable DRIVER_GPU_OPERATION_APPEND domain: {}",
-          static_cast<int>(result));
-      ptiCallbackUnsubscribe(scope_collection_handle->callback_subscriber_);
-      scope_collection_handle->callback_subscriber_ = 0;
-      return result;
-    }
-
-    scope_collection_handle->is_collection_active_ = true;
-
-    SPDLOG_TRACE(
-        "ptiMetricsScopeStartCollection: Scope metrics collection started with callback "
-        "registration");
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-static pti_result InternalMetricsScopeStopCollectionNoHandleCheck(
-    pti_scope_collection_handle_t scope_collection_handle) {
-  if (!scope_collection_handle->is_collection_active_) {
-    SPDLOG_DEBUG("{}: Collection not active", __func__);
-    return PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED;
-  }
-  // Disable callback domains first
-  if (scope_collection_handle->callback_subscriber_ != 0) {
-    pti_result result = ptiCallbackDisableDomain(scope_collection_handle->callback_subscriber_,
-                                                 PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_WARN("{}: Failed to disable GPU_OPERATION_COMPLETED domain: {}", __func__,
-                  static_cast<int>(result));
-    }
-    result = ptiCallbackDisableDomain(scope_collection_handle->callback_subscriber_,
-                                      PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_WARN("{}: Failed to disable DRIVER_GPU_OPERATION_APPEND domain: {}", __func__,
-                  static_cast<int>(result));
-    }
-
-    // Unregister the callback
-    result = ptiCallbackUnsubscribe(scope_collection_handle->callback_subscriber_);
-    if (result != PTI_SUCCESS) {
-      SPDLOG_WARN("ptiMetricsScopeStopCollection: Failed to unsubscribe callback: {}",
-                  static_cast<int>(result));
-    }
-    scope_collection_handle->callback_subscriber_ = 0;
-    // Finalize current buffer for all devices
-    if (scope_collection_handle->buffer_manager_) {
-      scope_collection_handle->buffer_manager_->FinalizeAllCurrentBuffers();
-    }
-
-    scope_collection_handle->is_collection_active_ = false;
-    SPDLOG_TRACE("{}: Scope metrics collection stopped and callback unregistered", __func__);
-
-    return PTI_SUCCESS;
-  }
-  return PTI_ERROR_INTERNAL;
-}
-
-/**
- * @brief Stop metrics scope collection
- *
- * @param[in] scope_collection_handle        Scope collection handle
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeStopCollection(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    std::lock_guard<std::mutex> lock(g_scope_ops_mutex);
-
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    return InternalMetricsScopeStopCollectionNoHandleCheck(scope_collection_handle);
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get metadata for user's metrics buffer in a scope collection
- * This function provides type and unit information for all requested metrics.
- * Call this function to get metadata per scope that applies to all records in all buffers.
- *
- * The metadata structure contains direct pointers to metric information stored within the
- * scope collection handle. These pointers remain valid until ptiMetricsScopeDisable is called.
- *
- * Usage:
- *  - User must set metadata->_struct_size = sizeof(pti_metrics_scope_record_metadata_t) before
- * calling
- *  - Function populates metadata->_metrics_count and the three array pointers
- *  - No memory allocation is performed by this function
- *  - Returned pointers reference internal scope collection data (no copying)
- *
- * @param[in] scope_collection_handle    Scope collection handle
- * @param[out] metadata                  Metadata structure to populate
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeGetMetricsMetadata(pti_scope_collection_handle_t scope_collection_handle,
-                                             pti_metrics_scope_record_metadata_t* metadata) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!metadata) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Validate that user set _struct_size
-    if (metadata->_struct_size == 0) {
-      SPDLOG_TRACE("{}: Metadata struct size is 0/not set", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->is_configured_) {
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    size_t metrics_count =
-        static_cast<size_t>(scope_collection_handle->requested_metric_properties_.size());
-
-    // Populate metadata struct fields with direct pointers
-    metadata->_metrics_count = metrics_count;
-
-    if (metrics_count > 0) {
-      metadata->_value_types = scope_collection_handle->requested_value_types_.data();
-      metadata->_metric_names = scope_collection_handle->requested_metric_names_.data();
-      metadata->_metric_units = scope_collection_handle->requested_metric_units_.data();
-    } else {
-      // No metrics case
-      metadata->_value_types = nullptr;
-      metadata->_metric_names = nullptr;
-      metadata->_metric_units = nullptr;
-    }
-
-    return PTI_SUCCESS;
-
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get the number of collection buffers available
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[out] buffer_count                  Pointer to store the number of available collection
- * buffers
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeGetCollectionBuffersCount(
-    pti_scope_collection_handle_t scope_collection_handle, size_t* buffer_count) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    if (!buffer_count) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (scope_collection_handle->is_collection_active_) {
-      return PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED;
-    }
-
-    if (!scope_collection_handle->buffer_manager_) {
-      *buffer_count = 0;
-      return PTI_SUCCESS;
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    *buffer_count = scope_collection_handle->buffer_manager_->GetBufferCount();
-
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get the collection buffer of the specified index and its size
- * Note: The size might be handy for future usage when such buffers might be stored by the user
- * for fully offline processing.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] buffer_index                   Index of the collection buffer to retrieve
- * @param[out] buffer                        Pointer to store the collection buffer address
- * @param[out] buffer_size                   Pointer to store the collection buffer size in bytes
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeGetCollectionBuffer(pti_scope_collection_handle_t scope_collection_handle,
-                                              size_t buffer_index, void** buffer,
-                                              size_t* buffer_size) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!buffer || !buffer_size) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->buffer_manager_) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    PtiMetricsScopeBuffer* target_buffer =
-        scope_collection_handle->buffer_manager_->GetBuffer(buffer_index);
-    if (!target_buffer) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    *buffer = target_buffer->GetRawBuffer();
-    *buffer_size = target_buffer->GetUsedSize();
-
-    return PTI_SUCCESS;
-
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Get information about the collection buffer
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] collection_buffer              Collection buffer to query properties for
- * @param[in/out] props                      Pointer to store the collection buffer properties;
- *                                           user must not forget to initialize props->_struct_size
- * prior to the call
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeGetCollectionBufferProperties(
-    pti_scope_collection_handle_t scope_collection_handle, void* collection_buffer,
-    pti_metrics_scope_collection_buffer_properties_t* props) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!collection_buffer || !props) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Validate structure size.
-    // To be used in further version to distinguish between versions of this structure
-    if (props->_struct_size < sizeof(pti_metrics_scope_collection_buffer_properties_t)) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->buffer_manager_) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    PtiMetricsScopeBuffer* found_buffer =
-        scope_collection_handle->buffer_manager_->FindBufferByRawPointer(collection_buffer);
-    if (!found_buffer) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Fill properties using Buffer methods
-    props->_device_handle = found_buffer->GetDeviceHandle();
-    props->_num_scopes = found_buffer->GetRecordCount();
-    props->_buffer_size = found_buffer->GetUsedSize();
-
-    // TODO: Add timing information if needed
-    props->_host_time_first_scope_append = 0;
-    props->_host_time_last_scope_append = 0;
-    props->_metric_group_name = scope_collection_handle->collected_metrics_group_name_;
-
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Query for the required metrics buffer size for storing calculated metrics records
- *
- * This function calculates the exact metrics buffer size needed to store all records
- * from a collection buffer, including space for strings and metric values.
- *
- * @param[in] scope_collection_handle           Scope collection handle
- * @param[in] collection_buffer                 Collection buffer to query
- * @param[out] required_metrics_buffer_size     Required metrics buffer size in bytes
- * @param[out] records_count                    Number of records that will be stored
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeQueryMetricsBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, void* collection_buffer,
-    size_t* required_metrics_buffer_size, size_t* records_count) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!collection_buffer || !required_metrics_buffer_size || !records_count) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    PtiMetricsScopeBuffer* found_buffer =
-        scope_collection_handle->buffer_manager_->FindBufferByRawPointer(collection_buffer);
-    if (!found_buffer) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    *records_count = found_buffer->GetRecordCount();
-    // this is indeed self-check.
-    PTI_ASSERT(*records_count <= kMaxNumberOfRawRecordsPerCollectionBuffer);
-    if (*records_count == 0) {
-      *required_metrics_buffer_size = 0;
-      return PTI_SUCCESS;
-    }
-
-    size_t total_size = 0;
-
-    // Space for record structs (aligned)
-    size_t records_array_size = *records_count * sizeof(pti_metrics_scope_record_t);
-    records_array_size = AlignUp(records_array_size, 8);
-    total_size += records_array_size;
-
-    // Calculate space needed for each record's data
-    // TODO: maybe can be optimized if the size of each record is the same
-    for (size_t i = 0; i < *records_count; ++i) {
-      const KernelMetricData* kernel_data = found_buffer->GetRecord(i);
-      if (!kernel_data) continue;
-
-      // Space for metric values array
-      auto num_metrics = scope_collection_handle->requested_metric_properties_.size();
-      if (num_metrics > 0) {
-        size_t values_size = num_metrics * sizeof(pti_value_t);
-        total_size += AlignUp(values_size, 8);
-      }
-    }
-
-    *required_metrics_buffer_size = total_size;
-    return PTI_SUCCESS;
-
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Calculate metrics from collection data and populate into user-provided metrics buffer
- * Usage:   The user must first call ptiMetricsScopeQueryMetricsBufferSize to determine
- *          the required metrics buffer size, then allocate the metrics buffer and call this
- * function.
- *
- * @param[in] scope_collection_handle        Scope collection handle
- * @param[in] collection_buffer              Collection buffer containing raw metrics data
- * @param[in] metrics_buffer                 User metrics buffer for storing records
- * @param[in] metrics_buffer_size            Size of metrics_buffer in bytes
- * @param[out] records_count                 Number of records that will be/were written to the
- * metrics buffer
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeCalculateMetrics(pti_scope_collection_handle_t scope_collection_handle,
-                                           void* collection_buffer, void* metrics_buffer,
-                                           size_t metrics_buffer_size, size_t* records_count) {
-  try {
-    if (!IsOurHandle(scope_collection_handle)) {
-      SPDLOG_DEBUG("{}: could not find a scope_collection_handle", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // TODO: Validate collection_buffer - that it is indeed our buffer
-    if (!collection_buffer || !metrics_buffer || !records_count) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (!scope_collection_handle->buffer_manager_) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Get the total size needed for all records
-    size_t total_size_needed = 0;
-    size_t total_records = 0;
-    pti_result size_result = ptiMetricsScopeQueryMetricsBufferSize(
-        scope_collection_handle, collection_buffer, &total_size_needed, &total_records);
-    if (size_result != PTI_SUCCESS) {
-      return size_result;
-    }
-
-    if (total_records == 0) {
-      *records_count = 0;
-      return PTI_ERROR_METRICS_SCOPE_INVALID_COLLECTION_BUFFER;
-    }
-
-    // Calculate size per record
-    size_t size_per_record = total_size_needed / total_records;
-
-    // Calculate how many records can fit
-    size_t records_that_fit = metrics_buffer_size / size_per_record;
-
-    // Make sure we don't exceed the available records
-    if (records_that_fit > total_records) {
-      records_that_fit = total_records;
-    }
-
-    if (records_that_fit == 0) {
-      *records_count = 0;
-      SPDLOG_DEBUG(
-          "ptiMetricsScopeCalculateMetrics: Buffer too small ({} bytes) for even one record "
-          "(need {} bytes). Minimum buffer size required: {} bytes",
-          metrics_buffer_size, size_per_record, size_per_record);
-      return PTI_ERROR_METRICS_SCOPE_COLLECTION_BUFFER_TOO_SMALL;
-    }
-
-    if (records_that_fit < total_records) {
-      SPDLOG_WARN(
-          "ptiMetricsScopeCalculateMetrics: Buffer can fit {} of {} records. "
-          "For complete data, allocate {} bytes (current: {} bytes)",
-          records_that_fit, total_records, total_size_needed, metrics_buffer_size);
-      // Continue processing what fits
-    }
-
-    std::lock_guard<std::mutex> lock(scope_collection_handle->data_mutex_);
-
-    // Find the buffer
-    PtiMetricsScopeBuffer* found_buffer =
-        scope_collection_handle->buffer_manager_->FindBufferByRawPointer(collection_buffer);
-    if (!found_buffer) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Layout the buffer
-    uint8_t* buffer_ptr = static_cast<uint8_t*>(metrics_buffer);
-    uint8_t* current_pos = buffer_ptr;
-
-    // Records array at the beginning (sized for records_that_fit)
-    size_t final_records_array_size =
-        AlignUp(records_that_fit * sizeof(pti_metrics_scope_record_t), 8);
-    pti_metrics_scope_record_t* records =
-        reinterpret_cast<pti_metrics_scope_record_t*>(current_pos);
-    current_pos += final_records_array_size;
-
-    pti_device_handle_t device = found_buffer->GetDeviceHandle();
-    auto it = scope_collection_handle->metrics_group_handles_.find(device);
-    if (it == scope_collection_handle->metrics_group_handles_.end()) {
-      SPDLOG_DEBUG("No metrics group handle found for device {}", static_cast<void*>(device));
-      return PTI_ERROR_INTERNAL;
-    }
-    zet_metric_group_handle_t metric_group = static_cast<zet_metric_group_handle_t>(it->second);
-
-    // Process each kernel record, ensuring we do not overflow the buffer
-    size_t records_written = 0;
-    for (size_t i = 0; i < total_records; ++i) {
-      uint8_t* next_pos = ProcessSingleRecord(scope_collection_handle, found_buffer, records,
-                                              metric_group, i, current_pos);
-      if ((next_pos - buffer_ptr) > static_cast<ptrdiff_t>(metrics_buffer_size)) {
-        // Not enough space for this record, stop writing
-        break;
-      }
-      current_pos = next_pos;
-      ++records_written;
-    }
-
-    *records_count = records_written;
-
-    // Return a warning if we couldn't fit all records
-    if (records_written < total_records) {
-      return PTI_WARN_METRICS_SCOPE_PARTIAL_BUFFER;
-    }
-
-    return PTI_SUCCESS;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  }
-}
-
-/**
- * @brief Disable MetricsScope and free all associated resources
- *
- * @param[in] scope_collection_handle        Scope collection handle to cleanup
- *
- * @return pti_result
- */
-pti_result ptiMetricsScopeDisable(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    std::lock_guard<std::mutex> lock(g_scope_ops_mutex);
-
-    pti_result stop_result = PTI_SUCCESS;
-
-    // Remove handle from global registry under exclusive lock
-    {
-      std::lock_guard<std::shared_mutex> lock(g_scope_handles_mutex);
-
-      // Validate handle exists in the registry
-      auto it = g_scope_handles.find(scope_collection_handle);
-      if (it == g_scope_handles.end()) {
-        return PTI_ERROR_BAD_ARGUMENT;
-      }
-      PTI_ASSERT(it != g_scope_handles.end());
-
-      // Stop collection if still active
-      if (scope_collection_handle->is_collection_active_) {
-        stop_result = InternalMetricsScopeStopCollectionNoHandleCheck(scope_collection_handle);
-        if (stop_result != PTI_SUCCESS) {
-          SPDLOG_WARN("Failed to stop collection during disable: {}",
-                      static_cast<int>(stop_result));
-        }
-      }
-      // Remove handle from registry
-      g_scope_handles.erase(it);
-    }
-
-    // Release this handle's metrics reference. The reference count in MetricStateManager
-    // decides whether the driver actually disables metrics. Done outside
-    // g_scope_handles_mutex to keep the driver call off a global registry lock.
-    pti_result disable_status = ptiMetricsDisable(nullptr);
-    if (disable_status != PTI_SUCCESS) {
-      SPDLOG_WARN("{}: Failed to disable metrics: {}", __FUNCTION__,
-                  ptiResultTypeToString(disable_status));
-    }
-
-    SPDLOG_TRACE("Scope metrics collection handle disabled");
-    return stop_result;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return PTI_ERROR_INTERNAL;
-  }
-}
diff --git a/sdk/src/metrics/pti_metrics_scope_buffer.h b/sdk/src/metrics/pti_metrics_scope_buffer.h
deleted file mode 100644
index 72d4605d..00000000
--- a/sdk/src/metrics/pti_metrics_scope_buffer.h
+++ /dev/null
@@ -1,134 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef SRC_API_PTI_METRICS_SCOPE_BUFFER_H_
-#define SRC_API_PTI_METRICS_SCOPE_BUFFER_H_
-
-#include <level_zero/ze_api.h>
-#include <spdlog/spdlog.h>
-
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "pti/pti.h"
-#include "pti/pti_callback.h"
-
-namespace {
-
-// Key constants limiting sizes of Metrics Scope buffers
-
-// this cap number of records per buffer is to avoid allocating too large buffers
-// that might lead to memory allocation failures.
-// this makes max buffer ~ 10 MB
-constexpr size_t kMaxNumberOfRawRecordsPerCollectionBuffer = 10000;
-
-// Estimate based on metric group properties
-// based on observation, the size of each collection is about 700-900 bytes,
-// depending on the hardware. Choosing 960 for now, as it is divisible by 64 (cacheline size)
-// TODO: ask Level-Zero for the API to query for it
-
-constexpr size_t kEstimatedSizeOfRawRecord = 960;
-
-// Minimum collection buffer size - bigger than estoimated one raw record size,
-// so that if it gets bigger - at least one record would fit there
-constexpr size_t kMinCollectionBufferSize = 2048;
-}  // namespace
-
-// Kernel metric data structure
-struct KernelMetricData {
-  uint64_t kernel_id = 0;
-  std::string kernel_name;
-  std::unique_ptr<uint8_t[]> raw_data;
-  size_t data_size = 0;
-  ze_command_queue_handle_t queue = nullptr;
-};
-
-/**
- * @brief PtiMetricsScopeBuffer class that contains actual collected data and manages buffer state
- * Tracks beginning position, current position, and can contain multiple scopes
- */
-class PtiMetricsScopeBuffer {
- public:
-  PtiMetricsScopeBuffer(size_t capacity, pti_device_handle_t device_handle, uint64_t buffer_id)
-      : used_size_(0),
-        capacity_(capacity),
-        device_handle_(device_handle),
-        buffer_id_(buffer_id),
-        is_finalized_(false) {
-    raw_buffer_ = std::make_unique<uint8_t[]>(capacity);
-    if (raw_buffer_) {
-      std::memset(raw_buffer_.get(), 0, capacity);
-    }
-
-    records_.reserve(64);
-  }
-
-  // PtiMetricsScopeBuffer state management
-  uint8_t* GetRawBuffer() const { return raw_buffer_.get(); }
-  size_t GetUsedSize() const { return used_size_; }
-
-  // PtiMetricsScopeBuffer metadata
-  pti_device_handle_t GetDeviceHandle() const { return device_handle_; }
-  uint64_t GetBufferId() const { return buffer_id_; }
-  size_t GetRecordCount() const { return records_.size(); }
-  bool IsFinalized() const { return is_finalized_; }
-
-  // Record management
-  bool AddKernelRecord(std::unique_ptr<KernelMetricData> kernel_data) {
-    if (!kernel_data) {
-      SPDLOG_DEBUG("AddKernelRecord: REJECT null kernel_data");
-      return false;
-    }
-    if (is_finalized_) {
-      SPDLOG_DEBUG(
-          "AddKernelRecord: REJECT buffer is_finalized, kernel_id={}, buffer_id={}, device={}",
-          kernel_data->kernel_id, buffer_id_, static_cast<void*>(device_handle_));
-      return false;
-    }
-
-    size_t required_space = kernel_data->data_size + sizeof(KernelMetricData);
-    if (!HasSpace(required_space)) {
-      SPDLOG_DEBUG(
-          "AddKernelRecord: REJECT no space (used={}, cap={}, required={}, data_size={}), "
-          "kernel_id={}, buffer_id={}",
-          used_size_, capacity_, required_space, kernel_data->data_size, kernel_data->kernel_id,
-          buffer_id_);
-      return false;
-    }
-
-    records_.push_back(std::move(kernel_data));
-    used_size_ += required_space;
-    return true;
-  }
-
-  const KernelMetricData* GetRecord(size_t index) const {
-    if (index >= records_.size()) {
-      return nullptr;
-    }
-    return records_[index].get();
-  }
-
-  // Buffer operations
-  bool HasSpace(size_t required_size) const { return (used_size_ + required_size) <= capacity_; }
-
-  void Finalize() { is_finalized_ = true; }
-
- private:
-  std::unique_ptr<uint8_t[]> raw_buffer_;
-  size_t used_size_;
-  size_t capacity_;
-  pti_device_handle_t device_handle_;
-  uint64_t buffer_id_;
-  bool is_finalized_;
-
-  // Records management
-  std::vector<std::unique_ptr<KernelMetricData>> records_;
-};
-
-#endif  // SRC_API_PTI_METRICS_SCOPE_BUFFER_H_
diff --git a/sdk/src/metrics/pti_metrics_scope_buffer_handler.h b/sdk/src/metrics/pti_metrics_scope_buffer_handler.h
deleted file mode 100644
index 16f3496a..00000000
--- a/sdk/src/metrics/pti_metrics_scope_buffer_handler.h
+++ /dev/null
@@ -1,255 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_API_PTI_METRICS_SCOPE_BUFFER_HANDLER_H_
-#define SRC_API_PTI_METRICS_SCOPE_BUFFER_HANDLER_H_
-
-#include <spdlog/spdlog.h>
-
-#include <functional>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
-#include "pti/pti.h"
-
-/**
- * @brief PtiMetricsScopeBufferHandler manages per-(device, thread) buffer history
- * for a scope collection handle. Each (device, thread) slot is an ordered vector
- * of buffers; the last element may be non-finalized ("current"), all earlier
- * elements are finalized.
- */
-template <typename BufferType>
-class PtiMetricsScopeBufferHandler {
- public:
-  PtiMetricsScopeBufferHandler() = default;
-
-  PtiMetricsScopeBufferHandler(const PtiMetricsScopeBufferHandler&) = delete;
-  PtiMetricsScopeBufferHandler& operator=(const PtiMetricsScopeBufferHandler&) = delete;
-  PtiMetricsScopeBufferHandler(PtiMetricsScopeBufferHandler&&) = delete;
-  PtiMetricsScopeBufferHandler& operator=(PtiMetricsScopeBufferHandler&&) = delete;
-
-  void RegisterDevice(pti_device_handle_t device) {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-
-    auto [it, inserted] = buffers_.try_emplace(device);
-    if (!inserted) {
-      SPDLOG_DEBUG("Device {} already registered, skipping", static_cast<void*>(device));
-      return;
-    }
-  }
-
-  // Create a buffer for a specific device on the calling thread.
-  // - If no current buffer exists for (device, this thread): allocate and push.
-  // - If current is empty (no records): discard it, allocate and push.
-  // - If current has records and is not finalized: return PTI_WARN_BUFFER_NOT_FINALIZED.
-  //   Caller must call FinalizeCurrentBuffer first to rotate.
-  pti_result CreateBuffer(size_t buffer_size, pti_device_handle_t device, uint64_t buffer_id) {
-    SPDLOG_DEBUG("CreateBuffer: Requesting buffer creation for device {}, thread {}, buffer_id {}",
-                 static_cast<void*>(device),
-                 std::hash<std::thread::id>{}(std::this_thread::get_id()), buffer_id);
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-
-    auto device_it = buffers_.find(device);
-    if (device_it == buffers_.end()) {
-      SPDLOG_DEBUG("CreateBuffer: Attempted to create buffer for unregistered device {}",
-                   static_cast<void*>(device));
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    auto thread_id = std::this_thread::get_id();
-    auto& vec = device_it->second[thread_id];
-
-    if (!vec.empty() && !vec.back()->IsFinalized()) {
-      if (vec.back()->GetRecordCount() == 0) {
-        SPDLOG_DEBUG("CreateBuffer: Replacing empty current buffer (device {}, thread {})",
-                     static_cast<void*>(device), std::hash<std::thread::id>{}(thread_id));
-        vec.pop_back();
-      } else {
-        SPDLOG_DEBUG("CreateBuffer: Current buffer not finalized (device {}, thread {})",
-                     static_cast<void*>(device), std::hash<std::thread::id>{}(thread_id));
-        return PTI_WARN_BUFFER_NOT_FINALIZED;
-      }
-    }
-
-    size_t actual_buffer_size = (buffer_size < kMaxBufferSize) ? buffer_size : kMaxBufferSize;
-    auto buffer = std::make_unique<BufferType>(actual_buffer_size, device, buffer_id);
-
-    if (!buffer->GetRawBuffer()) {
-      return PTI_ERROR_METRICS_SCOPE_OUT_OF_MEMORY;
-    }
-
-    vec.push_back(std::move(buffer));
-    return PTI_SUCCESS;
-  }
-
-  // Total number of buffers (any state) with at least one record.
-  size_t GetBufferCount() const {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    size_t total = 0;
-    for (const auto& [device, thread_map] : buffers_) {
-      for (const auto& [thread_id, vec] : thread_map) {
-        for (const auto& buf : vec) {
-          if (buf->GetRecordCount() > 0) {
-            total++;
-          }
-        }
-      }
-    }
-    return total;
-  }
-
-  // Iterate all buffers with data in deterministic device-handle order
-  // (within a device, thread-iteration order is unordered_map order).
-  BufferType* GetBuffer(size_t global_index) const {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    size_t current_index = 0;
-
-    for (const auto& [device, thread_map] : buffers_) {
-      for (const auto& [thread_id, vec] : thread_map) {
-        for (const auto& buf : vec) {
-          if (buf->GetRecordCount() == 0) {
-            continue;
-          }
-          if (current_index == global_index) {
-            return buf.get();
-          }
-          current_index++;
-        }
-      }
-    }
-    return nullptr;
-  }
-
-  // Returns the calling thread's current (non-finalized) buffer for the device,
-  // or nullptr if none.
-  BufferType* GetCurrentBuffer(pti_device_handle_t device) const {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    auto thread_id = std::this_thread::get_id();
-
-    auto device_it = buffers_.find(device);
-    if (device_it == buffers_.end()) {
-      return nullptr;
-    }
-
-    auto thread_it = device_it->second.find(thread_id);
-    if (thread_it == device_it->second.end() || thread_it->second.empty()) {
-      return nullptr;
-    }
-
-    auto& back = thread_it->second.back();
-
-    return back->IsFinalized() ? nullptr : back.get();
-  }
-
-  BufferType* FindBufferByRawPointer(void* raw_buffer) const {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    for (const auto& [device, thread_map] : buffers_) {
-      for (const auto& [thread_id, vec] : thread_map) {
-        for (const auto& buf : vec) {
-          if (buf->GetRawBuffer() == raw_buffer) {
-            return buf.get();
-          }
-        }
-      }
-    }
-    return nullptr;
-  }
-
-  // True if the calling thread has a non-finalized current buffer with at
-  // least one record for the given device.
-  bool HasCurrentBufferWithData(pti_device_handle_t device) const {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    auto thread_id = std::this_thread::get_id();
-    auto device_it = buffers_.find(device);
-    if (device_it == buffers_.end()) {
-      return false;
-    }
-    auto thread_it = device_it->second.find(thread_id);
-    if (thread_it == device_it->second.end() || thread_it->second.empty()) {
-      return false;
-    }
-    auto& back = thread_it->second.back();
-    return !back->IsFinalized() && back->GetRecordCount() > 0;
-  }
-
-  // Finalize the calling thread's current buffer for the device.
-  // - If empty (no records): pop it (silent discard).
-  // - If non-empty: flip its is_finalized flag in place.
-  // - If no current buffer: no-op.
-  pti_result FinalizeCurrentBuffer(pti_device_handle_t device) {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    auto thread_id = std::this_thread::get_id();
-    auto device_it = buffers_.find(device);
-    if (device_it == buffers_.end()) {
-      SPDLOG_DEBUG("FinalizeCurrentBuffer: Attempted to finalize buffer for unregistered device {}",
-                   static_cast<void*>(device));
-      return PTI_SUCCESS;
-    }
-    auto thread_it = device_it->second.find(thread_id);
-    if (thread_it == device_it->second.end() || thread_it->second.empty()) {
-      SPDLOG_DEBUG(
-          "FinalizeCurrentBuffer: Attempted to finalize buffer for non-existent thread {} on "
-          "device {}",
-          std::hash<std::thread::id>{}(thread_id), static_cast<void*>(device));
-      return PTI_SUCCESS;
-    }
-
-    auto& vec = thread_it->second;
-    if (!vec.back()->IsFinalized()) {
-      if (vec.back()->GetRecordCount() == 0) {
-        vec.pop_back();
-        SPDLOG_DEBUG(
-            "FinalizeCurrentBuffer: Discarded empty current buffer for thread {} on device {}",
-            std::hash<std::thread::id>{}(thread_id), static_cast<void*>(device));
-      } else {
-        vec.back()->Finalize();
-        SPDLOG_DEBUG(
-            "FinalizeCurrentBuffer: Finalized current buffer for thread {} on device {}, "
-            "record count: {}",
-            std::hash<std::thread::id>{}(thread_id), static_cast<void*>(device),
-            vec.back()->GetRecordCount());
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
-  // Finalize current buffers for all devices and all threads (cross-thread sweep).
-  // Used at end-of-collection from the API thread.
-  pti_result FinalizeAllCurrentBuffers() {
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-    for (auto& [device, thread_map] : buffers_) {
-      for (auto& [thread_id, vec] : thread_map) {
-        if (vec.empty() || vec.back()->IsFinalized()) {
-          continue;
-        }
-        if (vec.back()->GetRecordCount() == 0) {
-          vec.pop_back();
-        } else {
-          vec.back()->Finalize();
-        }
-      }
-    }
-    return PTI_SUCCESS;
-  }
-
- private:
-  // Per-(device, thread) buffer history. Outer container is std::map for
-  // deterministic iteration order (sorted by device handle), which GetBuffer()
-  // relies on for stable global indexing.
-  // Note: only the last element of each vector may have IsFinalized() == false
-  // (the "current" buffer).
-  std::map<pti_device_handle_t,
-           std::unordered_map<std::thread::id, std::vector<std::unique_ptr<BufferType>>>>
-      buffers_;
-
-  mutable std::mutex buffer_mutex_;
-  static constexpr size_t kMaxBufferSize = 1024 * 1024 * 1024;  // 1GB
-};
-
-#endif  // SRC_API_PTI_METRICS_SCOPE_BUFFER_HANDLER_H_
diff --git a/sdk/src/metrics/pti_metrics_scope_helper.h b/sdk/src/metrics/pti_metrics_scope_helper.h
deleted file mode 100644
index d7cf1f17..00000000
--- a/sdk/src/metrics/pti_metrics_scope_helper.h
+++ /dev/null
@@ -1,1068 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef SRC_API_PTI_METRICS_SCOPE_HELPER_H_
-#define SRC_API_PTI_METRICS_SCOPE_HELPER_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <pti/pti_metrics_scope.h>
-#include <spdlog/spdlog.h>
-
-#include <atomic>
-#include <cstring>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "metrics_handler.h"
-#include "pti/pti_callback.h"
-#include "pti_assert.h"
-#include "pti_metrics_scope_buffer.h"
-#include "pti_metrics_scope_buffer_handler.h"
-
-// Forward declarations
-struct _pti_scope_collection_handle_t;
-struct KernelMetricData;
-
-namespace {
-// Global mutex to serialize Level Zero API calls
-std::mutex g_level_zero_api_mutex;
-}  // namespace
-
-// Complete handle type
-struct _pti_scope_collection_handle_t {
-  _pti_scope_collection_handle_t() = default;
-  _pti_scope_collection_handle_t(const _pti_scope_collection_handle_t&) = delete;
-  _pti_scope_collection_handle_t& operator=(const _pti_scope_collection_handle_t&) = delete;
-  _pti_scope_collection_handle_t(_pti_scope_collection_handle_t&&) = delete;
-  _pti_scope_collection_handle_t& operator=(_pti_scope_collection_handle_t&&) = delete;
-
-  // Multi-device support
-  std::unordered_set<pti_device_handle_t>
-      requested_devices_;  // Devices user requested to profile, empty in auto-detect mode
-  std::unordered_set<pti_device_handle_t>
-      failed_devices_;  // Devices that failed configuration or activation
-  bool auto_detect_mode_ =
-      false;  // True when using auto-detect mode (devices=nullptr, device_count=0)
-
-  // Per-device resources
-  std::unordered_map<pti_device_handle_t, pti_metrics_group_handle_t> metrics_group_handles_;
-  std::unordered_map<pti_device_handle_t, std::unique_ptr<PtiQueryMetricsProfiler>>
-      query_profilers_;
-  std::unordered_map<pti_device_handle_t, uint64_t> next_buffer_ids_;
-
-  // Shared across all devices
-  const char* collected_metrics_group_name_ = nullptr;  // Single group name for all devices
-  std::vector<int32_t> requested_metric_indices_;       // Single set of indices for all devices
-  std::vector<pti_metric_properties_t> requested_metric_properties_;
-  std::vector<pti_metric_value_type> requested_value_types_;
-  std::vector<const char*> requested_metric_names_;
-  std::vector<const char*> requested_metric_units_;
-
-  std::atomic<bool> is_configured_ = false;
-  std::atomic<bool> is_collection_active_ = false;
-
-  pti_callback_subscriber_handle callback_subscriber_ = 0;
-  std::mutex data_mutex_;       // Thread safety for callback access
-  std::mutex buffer_id_mutex_;  // Guards next_buffer_ids_ only
-
-  std::unique_ptr<PtiMetricsScopeBufferHandler<PtiMetricsScopeBuffer>> buffer_manager_;
-  size_t configured_buffer_size_ = 0;
-
-  // Destructor to handle cleanup
-  ~_pti_scope_collection_handle_t() {
-    try {
-      // Finalize all device buffers
-      if (buffer_manager_) {
-        buffer_manager_->FinalizeAllCurrentBuffers();
-      }
-
-      // Stop all device profilers
-      if (is_configured_) {
-        for (auto& [device, profiler] : query_profilers_) {
-          if (profiler) {
-            pti_result stop_result = profiler->StopProfiling();
-            if (stop_result != PTI_SUCCESS) {
-              SPDLOG_WARN("Failed to stop profiler for device {}: {}", static_cast<void*>(device),
-                          static_cast<int>(stop_result));
-            }
-          }
-        }
-      }
-
-      // Log cleanup info
-      if (buffer_manager_) {
-        [[maybe_unused]] size_t buffer_count = buffer_manager_->GetBufferCount();
-        SPDLOG_TRACE("Cleaning up scope handle with {} collection buffers", buffer_count);
-      }
-
-      // Clean up collected data
-      requested_metric_properties_.clear();
-      query_profilers_.clear();
-
-      SPDLOG_TRACE("Scope metrics collection handle destroyed");
-    } catch (const std::exception& e) {
-      SPDLOG_DEBUG("Exception during scope handle destruction: {}", e.what());
-    } catch (...) {
-      SPDLOG_DEBUG("Unknown exception during scope handle destruction");
-    }
-  }
-};
-
-/**
- * @brief Helper to get all system devices
- * This function retrieves all devices available on the machine.
- * @param[out] devices Vector to store device properties
- * @return PTI_SUCCESS if devices retrieved, error code otherwise
- */
-inline pti_result GetAllAvailableDevices(std::vector<pti_device_properties_t>& devices) {
-  uint32_t device_count = 0;
-  pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-  if (result != PTI_SUCCESS) {
-    SPDLOG_DEBUG(
-        "GetAllAvailableDevices: Failed to enumerate devices (error: {}). "
-        "Ensure Level Zero drivers are properly installed",
-        static_cast<int>(result));
-    return result;
-  }
-
-  if (device_count == 0) {
-    SPDLOG_DEBUG(
-        "GetAllAvailableDevices: No devices available for metrics collection. "
-        "Ensure ZET_ENABLE_METRICS=1 and compatible GPU hardware is present");
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  devices.resize(device_count);
-  result = ptiMetricsGetDevices(devices.data(), &device_count);
-  if (result != PTI_SUCCESS) {
-    SPDLOG_DEBUG("GetAllAvailableDevices: Failed to get device properties (error: {})",
-                 static_cast<int>(result));
-    return result;
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Validate configuration arguments for metrics scope setup
- * This function validates all input arguments for the metrics scope configuration
- * including device count, metric names array, and scope collection handle
- *
- * @param[in] devices_to_profile         Array of device handles
- * @param[in] device_count               Number of devices in the array
- * @param[in] metric_names               Array of metric names
- *
- * @return PTI_SUCCESS if all arguments are valid, error code otherwise
- */
-inline pti_result ValidateConfigurationArguments(pti_device_handle_t* devices_to_profile,
-                                                 uint32_t device_count, const char** metric_names,
-                                                 size_t metrics_count) {
-  if (metric_names == nullptr) {
-    SPDLOG_DEBUG("{}: Metric names array is null", __func__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (metrics_count == 0) {
-    SPDLOG_DEBUG("{}: No metrics provided for configuration", __func__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  // Auto detect mode
-  if (device_count == 0) {
-    if (devices_to_profile != nullptr) {
-      SPDLOG_DEBUG("{}: Auto-detect mode requires devices_to_profile == nullptr", __func__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    // Valid auto mode
-    return PTI_SUCCESS;
-  }
-
-  // Explicit mode validation
-  if (devices_to_profile == nullptr) {
-    SPDLOG_DEBUG("{}: devices_to_profile cannot be nullptr with explicit device_count", __func__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Validate that a target device supports metrics collection
- * This function checks if the specified device handle is valid and supports
- * metrics collection by verifying it exists in the available devices list
- * and has metric groups available
- *
- * @param[in] target_device    Device handle to validate
- *
- * @return PTI_SUCCESS if device is valid and supports metrics, error code otherwise
- */
-inline pti_result ValidateTargetDevice(
-    pti_device_handle_t target_device,
-    const std::unordered_set<pti_device_handle_t>& available_device_handles) {
-  if (available_device_handles.find(target_device) == available_device_handles.end()) {
-    SPDLOG_DEBUG(
-        "ValidateTargetDevice: Specified device handle is not valid or not available for metrics "
-        "collection");
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  {
-    std::lock_guard<std::mutex> lock(g_level_zero_api_mutex);
-
-    // Additional validation: check if device supports metrics
-    ze_device_handle_t ze_device = static_cast<ze_device_handle_t>(target_device);
-    uint32_t metric_group_count = 0;
-    ze_result_t status = zetMetricGroupGet(ze_device, &metric_group_count, nullptr);
-    if (status != ZE_RESULT_SUCCESS || metric_group_count == 0) {
-      SPDLOG_DEBUG(
-          "ValidateTargetDevice: Device does not support metrics collection or no metric groups "
-          "available");
-      return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-    }
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Set up metric properties in the scope collection handle
- * This function initializes the requested_metric_properties vector with
- * the provided metric names, preparing them for group resolution
- *
- * @param[in] scope_collection_handle    Scope collection handle to configure
- * @param[in] metric_names               Array of metric names to set up
- * @param[in] metric_count               Number of metric names in the array
- *
- * @return PTI_SUCCESS if setup successful, error code otherwise
- */
-inline pti_result SetupMetricProperties(pti_scope_collection_handle_t scope_collection_handle,
-                                        const char** metric_names, size_t metric_count) {
-  if (metric_count == 0) {
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  scope_collection_handle->requested_metric_properties_.clear();
-  scope_collection_handle->requested_metric_properties_.reserve(metric_count);
-
-  for (size_t i = 0; i < metric_count; ++i) {
-    const char* name = metric_names[i];
-    if (name == nullptr || name[0] == '\0') {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    // Create basic property structure - will be filled in ResolveGroupFromMetricNames
-    pti_metric_properties_t prop = {};
-    prop._name = name;  // Store the name for now
-    scope_collection_handle->requested_metric_properties_.push_back(prop);
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Validate that all devices are the same type
- * This ensures all devices have the same model name, which means they share
- * identical metric groups and indices.
- *
- * @param devices_to_validate Set of device handles to validate for uniformity
- * @return PTI_SUCCESS if all devices are uniform,
- *         PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM if mixed types
- */
-inline pti_result ValidateDevicesUniform(
-    const std::unordered_set<pti_device_handle_t>& devices_to_validate,
-    const std::vector<pti_device_properties_t>& all_devices) {
-  if (devices_to_validate.empty()) return PTI_ERROR_BAD_ARGUMENT;
-  if (devices_to_validate.size() == 1) return PTI_SUCCESS;  // Single device always uniform
-
-  // Create lookup map for requested devices
-  std::unordered_map<pti_device_handle_t, const char*> device_models;
-  for (const auto& device : all_devices) {
-    if (devices_to_validate.find(device._handle) != devices_to_validate.end()) {
-      device_models[device._handle] = device._model_name;
-    }
-  }
-
-  // Get reference model from first device
-  auto reference_device = *devices_to_validate.begin();
-  auto it = device_models.find(reference_device);
-  if (it == device_models.end()) {
-    SPDLOG_DEBUG("Reference device handle {} not found in available devices",
-                 static_cast<void*>(reference_device));
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-  const char* reference_model = it->second;
-
-  // Compare all other devices
-  for (auto device : devices_to_validate) {
-    if (device == reference_device) continue;
-
-    auto it = device_models.find(device);
-    if (it == device_models.end()) {
-      SPDLOG_DEBUG("Device handle {} not found in available devices", static_cast<void*>(device));
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (std::strcmp(it->second, reference_model) != 0) {
-      SPDLOG_DEBUG("Device type mismatch: reference='{}', device='{}'", reference_model,
-                   it->second);
-      return PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM;
-    }
-  }
-
-  SPDLOG_DEBUG("All {} devices are uniform (model: {})", devices_to_validate.size(),
-               reference_model);
-  return PTI_SUCCESS;
-}
-
-inline pti_result GetMetricGroups(pti_device_handle_t device_handle,
-                                  std::vector<pti_metrics_group_properties_t>& groups) {
-  uint32_t group_count = 0;
-  {
-    std::lock_guard<std::mutex> lock(g_level_zero_api_mutex);
-    pti_result result = ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count);
-    if (result != PTI_SUCCESS || group_count == 0) {
-      return (result == PTI_SUCCESS) ? PTI_ERROR_BAD_ARGUMENT : result;
-    }
-  }
-  SPDLOG_TRACE("GetMetricGroups: group count: {}", group_count);
-
-  groups.resize(group_count);
-  for (auto& g : groups) {
-    g._metric_properties = nullptr;
-  }
-
-  {
-    std::lock_guard<std::mutex> lock(g_level_zero_api_mutex);
-    return ptiMetricsGetMetricGroups(device_handle, groups.data(), &group_count);
-  }
-}
-
-inline bool CheckMetricsInGroup(pti_scope_collection_handle_t scope_collection_handle,
-                                pti_metrics_group_properties_t& group_props,
-                                uint32_t metric_count) {
-  // Skip empty or non-event-based groups
-  if (group_props._metric_count == 0 || group_props._type != PTI_METRIC_GROUP_TYPE_EVENT_BASED) {
-    return false;
-  }
-
-  std::vector<pti_metric_properties_t> metrics(group_props._metric_count);
-  group_props._metric_properties = metrics.data();
-
-  pti_result result;
-  {
-    std::lock_guard<std::mutex> lock(g_level_zero_api_mutex);
-    result = ptiMetricsGetMetricsProperties(group_props._handle, group_props._metric_properties);
-  }
-  if (result != PTI_SUCCESS) {
-    return false;  // Skip groups we can't introspect
-  }
-
-  bool all_in_one_group = true;
-  for (uint32_t mi = 0; mi < metric_count; ++mi) {
-    const char* name = scope_collection_handle->requested_metric_properties_[mi]._name;
-    if (name == nullptr || name[0] == '\0') {
-      return false;
-    }
-
-    bool found_in_current_group = false;
-    for (uint32_t k = 0; k < group_props._metric_count; ++k) {
-      const char* n = group_props._metric_properties[k]._name;
-      if (n != nullptr && std::strcmp(n, name) == 0) {
-        found_in_current_group = true;
-
-        scope_collection_handle->requested_metric_indices_[mi] = k;
-        scope_collection_handle->requested_metric_properties_[mi] =
-            group_props._metric_properties[k];
-        break;
-      }
-    }
-
-    if (!found_in_current_group) {
-      all_in_one_group = false;
-    }
-  }
-
-  return all_in_one_group;
-}
-
-inline pti_result ValidateMetricAvailability(pti_scope_collection_handle_t scope_collection_handle,
-                                             uint32_t metric_count) {
-  for (uint32_t mi = 0; mi < metric_count; ++mi) {
-    if (scope_collection_handle->requested_metric_indices_[mi] == -1) {
-      return PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND;
-    }
-  }
-  return PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP;
-}
-
-/**
- * @brief Helper function to resolve a metric group that contains all provided metric names on the
- * given device Returns PTI_SUCCESS and sets metrics_group_handle_ if a single group contains all
- * names. Returns PTI_ERROR_BAD_ARGUMENT if any name is null/empty or no matching metric is found.
- * Returns PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION if names span multiple groups
- *
- * @param[in] scope_collection_handle    Scope collection handle containing device and metric names
- * @return pti_result
- */
-inline pti_result ResolveGroupFromMetricNames(pti_scope_collection_handle_t scope_collection_handle,
-                                              pti_device_handle_t device) {
-  if (scope_collection_handle == nullptr) {
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (!scope_collection_handle->auto_detect_mode_ &&
-      scope_collection_handle->requested_devices_.find(device) ==
-          scope_collection_handle->requested_devices_.end()) {
-    SPDLOG_DEBUG("ResolveGroupFromMetricNames: Device {} not in requested_devices_",
-                 static_cast<void*>(device));
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  pti_metrics_group_handle_t found_group = nullptr;
-
-  // Get all metric groups for the device
-  std::vector<pti_metrics_group_properties_t> groups;
-  pti_result result = GetMetricGroups(device, groups);
-  if (result != PTI_SUCCESS) return result;
-
-  uint32_t metric_count =
-      static_cast<uint32_t>(scope_collection_handle->requested_metric_properties_.size());
-  scope_collection_handle->requested_metric_indices_.resize(metric_count, -1);
-  scope_collection_handle->requested_value_types_.resize(metric_count);
-  scope_collection_handle->requested_metric_names_.resize(metric_count);
-  scope_collection_handle->requested_metric_units_.resize(metric_count);
-
-  // Find a group that contains all requested metrics
-  for (auto& group_props : groups) {
-    if (CheckMetricsInGroup(scope_collection_handle, group_props, metric_count)) {
-      found_group = group_props._handle;
-      if (scope_collection_handle->collected_metrics_group_name_ == nullptr) {
-        scope_collection_handle->collected_metrics_group_name_ = group_props._name;
-      }
-      break;  // Choose the first matched group
-    }
-  }
-
-  if (found_group == nullptr) {
-    SPDLOG_TRACE(
-        "ResolveGroupFromMetricNames: No single metric group contains all {} requested metrics",
-        metric_count);
-    return ValidateMetricAvailability(scope_collection_handle, metric_count);
-  }
-
-  scope_collection_handle->metrics_group_handles_[device] = found_group;
-
-  // Fill other requested properties
-  if (scope_collection_handle->requested_metric_names_[0] == nullptr) {
-    for (size_t i = 0; i < metric_count; ++i) {
-      scope_collection_handle->requested_metric_names_[i] =
-          scope_collection_handle->requested_metric_properties_[i]._name;
-      scope_collection_handle->requested_value_types_[i] =
-          scope_collection_handle->requested_metric_properties_[i]._value_type;
-      scope_collection_handle->requested_metric_units_[i] =
-          scope_collection_handle->requested_metric_properties_[i]._units;
-    }
-  }
-
-  return PTI_SUCCESS;
-}
-
-// Look up the metric-group handle on `device` by the group name already
-// resolved at Configure.
-inline pti_result ResolveGroupHandleByName(pti_scope_collection_handle_t scope_collection_handle,
-                                           pti_device_handle_t device) {
-  PTI_ASSERT(scope_collection_handle != nullptr);
-  PTI_ASSERT(scope_collection_handle->is_configured_);
-  if (scope_collection_handle->collected_metrics_group_name_ == nullptr) {
-    return PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION;
-  }
-
-  std::vector<pti_metrics_group_properties_t> groups;
-  pti_result result = GetMetricGroups(device, groups);
-  if (result != PTI_SUCCESS) return result;
-
-  const char* target_name = scope_collection_handle->collected_metrics_group_name_;
-  for (auto& g : groups) {
-    if (g._type != PTI_METRIC_GROUP_TYPE_EVENT_BASED) {
-      continue;
-    }
-    if (g._name != nullptr && std::strcmp(g._name, target_name) == 0) {
-      scope_collection_handle->metrics_group_handles_[device] = g._handle;
-      return PTI_SUCCESS;
-    }
-  }
-
-  SPDLOG_DEBUG("ResolveGroupHandleByName: group '{}' not found on device {}", target_name,
-               static_cast<void*>(device));
-  return PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND;
-}
-
-/**
- * @brief Align a size value up to the specified alignment boundary
- * This utility function rounds up a size to the next multiple of the alignment value
- *
- * @param[in] size        Size value to align
- * @param[in] alignment   Alignment boundary (bytes)
- *
- * @return Aligned size value
- */
-inline size_t AlignUp(size_t size, size_t alignment) {
-  if (alignment == 0) return size;
-  return ((size + alignment - 1) / alignment) * alignment;
-}
-
-/**
- * @brief Convert Level Zero typed value to PTI value format
- * This function converts a zet_typed_value_t to a pti_value_t based on the source type
- *
- * @param[in] src     Source typed value from Level Zero
- * @param[out] dst    Destination PTI value structure
- */
-inline void ConvertTypedValueToPtiValue(const zet_typed_value_t& src, pti_value_t& dst) {
-  switch (src.type) {
-    case ZET_VALUE_TYPE_UINT32:
-      dst.ui32 = src.value.ui32;
-      break;
-    case ZET_VALUE_TYPE_UINT64:
-      dst.ui64 = src.value.ui64;
-      break;
-    case ZET_VALUE_TYPE_FLOAT32:
-      dst.fp32 = src.value.fp32;
-      break;
-    case ZET_VALUE_TYPE_FLOAT64:
-      dst.fp64 = src.value.fp64;
-      break;
-    case ZET_VALUE_TYPE_BOOL8:
-      dst.b8 = src.value.b8;
-      break;
-    default:
-      dst.ui64 = 0;
-      break;
-  }
-}
-
-inline uint8_t* ProcessMetricValues(pti_scope_collection_handle_t scope_collection_handle,
-                                    const KernelMetricData* kernel_data,
-                                    pti_metrics_scope_record_t* record,
-                                    zet_metric_group_handle_t metric_group, uint8_t* current_pos) {
-  if (!kernel_data->raw_data || kernel_data->data_size == 0) {
-    record->_metrics_values = nullptr;
-    return current_pos;
-  }
-
-  uint32_t total_metric_values = 0;
-  zet_metric_group_calculation_type_t calculation_type =
-      ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES;
-
-  ze_result_t status = zetMetricGroupCalculateMetricValues(
-      metric_group, calculation_type, kernel_data->data_size, kernel_data->raw_data.get(),
-      &total_metric_values, nullptr);
-
-  if (status != ZE_RESULT_SUCCESS || total_metric_values == 0) {
-    record->_metrics_values = nullptr;
-    return current_pos;
-  }
-
-  std::vector<zet_typed_value_t> all_metric_values(total_metric_values);
-  status = zetMetricGroupCalculateMetricValues(metric_group, calculation_type,
-                                               kernel_data->data_size, kernel_data->raw_data.get(),
-                                               &total_metric_values, all_metric_values.data());
-
-  if (status != ZE_RESULT_SUCCESS) {
-    record->_metrics_values = nullptr;
-    return current_pos;
-  }
-
-  // Store only requested metric values
-  uint32_t requested_count =
-      static_cast<uint32_t>(scope_collection_handle->requested_metric_properties_.size());
-  record->_metrics_values = reinterpret_cast<pti_value_t*>(current_pos);
-
-  for (uint32_t j = 0; j < requested_count; ++j) {
-    uint32_t index = scope_collection_handle->requested_metric_indices_[j];
-    if (index < total_metric_values) {
-      ConvertTypedValueToPtiValue(all_metric_values[index], record->_metrics_values[j]);
-    }
-  }
-  current_pos += AlignUp(requested_count * sizeof(pti_value_t), 8);
-
-  return current_pos;
-}
-
-inline uint8_t* ProcessSingleRecord(pti_scope_collection_handle_t scope_collection_handle,
-                                    PtiMetricsScopeBuffer* found_buffer,
-                                    pti_metrics_scope_record_t* records,
-                                    zet_metric_group_handle_t metric_group, size_t record_index,
-                                    uint8_t* current_pos) {
-  const KernelMetricData* kernel_data = found_buffer->GetRecord(record_index);
-  if (!kernel_data) return current_pos;
-
-  pti_metrics_scope_record_t* record = &records[record_index];
-
-  // Set basic record fields
-  record->_kernel_id = kernel_data->kernel_id;
-  record->_queue = kernel_data->queue;
-
-  // Point directly to kernel_data's kernel_name
-  record->_kernel_name =
-      kernel_data->kernel_name.empty() ? nullptr : kernel_data->kernel_name.c_str();
-
-  // Process metric values
-  current_pos =
-      ProcessMetricValues(scope_collection_handle, kernel_data, record, metric_group, current_pos);
-
-  return current_pos;
-}
-
-// Helper to create KernelMetricData
-inline std::unique_ptr<KernelMetricData> CreateKernelMetricData(uint64_t kernel_id,
-                                                                const char* kernel_name,
-                                                                const uint8_t* raw_data,
-                                                                size_t data_size,
-                                                                ze_command_queue_handle_t queue) {
-  auto data = std::make_unique<KernelMetricData>();
-  if (!data) {
-    SPDLOG_DEBUG("CreateKernelMetricData: Failed to allocate KernelMetricData structure");
-    return nullptr;
-  }
-
-  data->kernel_id = kernel_id;
-  data->data_size = data_size;
-  data->queue = queue;
-  if (kernel_name) {
-    data->kernel_name = kernel_name;
-  }
-
-  // Handle raw data
-  if (raw_data && data_size > 0) {
-    try {
-      data->raw_data = std::make_unique<uint8_t[]>(data_size);
-      std::memcpy(data->raw_data.get(), raw_data, data_size);
-    } catch (const std::bad_alloc&) {
-      SPDLOG_DEBUG("CreateKernelMetricData: Raw data allocation failed.");
-      return nullptr;
-    }
-  }
-
-  return data;
-}
-
-/**
- * @brief Create a new metrics collection buffer
- */
-inline pti_result CreateNewBuffer(pti_scope_collection_handle_t scope_collection_handle,
-                                  pti_device_handle_t device) {
-  SPDLOG_TRACE(
-      "CreateNewBuffer: Creating new buffer for device {} About to acquire buffer_id_mutex_",
-      static_cast<void*>(device));
-  uint64_t buffer_id;
-  {
-    std::lock_guard<std::mutex> lock(scope_collection_handle->buffer_id_mutex_);
-    buffer_id = scope_collection_handle->next_buffer_ids_[device]++;
-  }
-  return scope_collection_handle->buffer_manager_->CreateBuffer(
-      scope_collection_handle->configured_buffer_size_, device, buffer_id);
-}
-
-// Helper function to extract GPU operation context data
-struct GpuOperationContext {
-  ze_context_handle_t context;
-  ze_command_queue_handle_t queue;
-  ze_command_list_handle_t cmd_list;
-  pti_backend_command_list_type submit_type;
-  ze_device_handle_t device;
-};
-
-inline GpuOperationContext ExtractGpuOperationContext(pti_callback_gpu_op_data* callback_data,
-                                                      pti_backend_ctx_t backend_context) {
-  return GpuOperationContext{static_cast<ze_context_handle_t>(backend_context),
-                             static_cast<ze_command_queue_handle_t>(callback_data->_queue_handle),
-                             static_cast<ze_command_list_handle_t>(callback_data->_cmd_list_handle),
-                             callback_data->_cmd_list_properties,
-                             static_cast<ze_device_handle_t>(callback_data->_device_handle)};
-}
-
-/**
- * @brief Log GPU operation context information for debugging
- */
-inline void LogGpuOperationContext([[maybe_unused]] const GpuOperationContext& ctx) {
-  SPDLOG_DEBUG("\tContext:     {}", static_cast<void*>(ctx.context));
-  SPDLOG_DEBUG("\tDevice:      {}", static_cast<void*>(ctx.device));
-  SPDLOG_DEBUG("\tQueue:       {}", static_cast<void*>(ctx.queue));
-  SPDLOG_DEBUG("\tCommandList: {}", static_cast<void*>(ctx.cmd_list));
-}
-
-/**
- * @brief Validate metric query and completion event state
- * This function checks if a metric query and its associated completion event are valid
- * and ready for data collection
- *
- * @param[in] query               Metric query handle to validate
- * @param[in] completion_event    Completion event handle to check
- * @param[in] kernel_id          Kernel ID for logging purposes
- *
- * @return true if query and event are valid and ready, false otherwise
- */
-inline bool ValidateQueryAndEvent(zet_metric_query_handle_t query,
-                                  ze_event_handle_t completion_event, uint64_t kernel_id) {
-  if (!query) {
-    SPDLOG_DEBUG("ValidateQueryAndEvent: No query found for kernel ID: {}", kernel_id);
-    return false;
-  }
-
-  if (!completion_event) {
-    SPDLOG_WARN(
-        "ValidateQueryAndEvent: No completion event found for query associated with kernel ID: {}",
-        kernel_id);
-    return false;
-  }
-
-  ze_result_t event_status = zeEventQueryStatus(completion_event);
-  if (event_status != ZE_RESULT_SUCCESS) {
-    if (event_status == ZE_RESULT_NOT_READY) {
-      SPDLOG_TRACE(
-          "ValidateQueryAndEvent: Query for kernel ID {} is not yet completed, skipping data "
-          "collection",
-          kernel_id);
-    } else {
-      SPDLOG_TRACE("ValidateQueryAndEvent: Error checking event status for kernel ID {}: 0x{:x}",
-                   kernel_id, static_cast<uint32_t>(event_status));
-    }
-    return false;
-  }
-
-  SPDLOG_TRACE(
-      "ValidateQueryAndEvent: Query completion event is signaled, proceeding with data collection");
-  return true;
-}
-
-/**
- * @brief Retrieve raw metric data from a completed query
- * This function extracts the raw metric data from a Level Zero metric query
- * and stores it in the provided vector
- *
- * @param[in] query         Metric query handle to get data from
- * @param[out] raw_data     Vector to store the retrieved raw data
- * @param[in] kernel_name   Kernel name for logging purposes
- * @param[in,out] cached_data_size  Raw data size for the metric group; probed once when 0
- *
- * @return true if data was successfully retrieved, false otherwise
- */
-inline bool GetRawMetricData(zet_metric_query_handle_t query, std::vector<uint8_t>& raw_data,
-                             [[maybe_unused]] const char* kernel_name, size_t& cached_data_size) {
-  SPDLOG_TRACE("GetRawMetricData: Attempting to retrieve raw metric data for kernel: {}",
-               kernel_name);
-  // The raw size is a property of the metric group, identical for every query,
-  // so it is probed once per profiler and reused from then on.
-  if (cached_data_size == 0) {
-    size_t queried_size = 0;
-    ze_result_t size_status = zetMetricQueryGetData(query, &queried_size, nullptr);
-    if (size_status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("GetRawMetricData: Failed to get query data size: {}",
-                   static_cast<uint64_t>(size_status));
-      return false;
-    }
-    SPDLOG_TRACE("GetRawMetricData: Raw data size {} bytes", queried_size);
-    if (queried_size == 0) {
-      SPDLOG_TRACE("GetRawMetricData: No metric data available for kernel: {}", kernel_name);
-      return false;
-    }
-    cached_data_size = queried_size;
-  }
-
-  size_t raw_data_size = cached_data_size;
-  raw_data.resize(raw_data_size);
-  ze_result_t status = zetMetricQueryGetData(query, &raw_data_size, raw_data.data());
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_TRACE("GetRawMetricData: Failed to get query data: {}", static_cast<uint64_t>(status));
-    return false;
-  }
-  SPDLOG_TRACE("GetRawMetricData: Successfully retrieved Query raw data");
-
-  return true;
-}
-
-/**
- * @brief Store kernel metric data in the collection buffer
- * This function manages buffer allocation and stores the kernel metric data.
- * If the current buffer is full, it creates a new buffer automatically.
- *
- * @param[in] scope_collection_handle    Scope collection handle containing buffer manager
- * @param[in] kernel_data               Kernel metric data to store
- * @param[in] raw_data_size             Size of the raw metric data
- *
- * @return true if data was successfully stored, false otherwise
- */
-inline bool StoreKernelData(pti_scope_collection_handle_t scope_collection_handle,
-                            pti_device_handle_t device,
-                            std::unique_ptr<KernelMetricData> kernel_data, size_t raw_data_size) {
-  SPDLOG_DEBUG("StoreKernelData: Storing data for kernel ID: {}, raw data size: {} bytes",
-               kernel_data->kernel_id, raw_data_size);
-  PtiMetricsScopeBuffer* current_buffer =
-      scope_collection_handle->buffer_manager_->GetCurrentBuffer(device);
-
-  // Check if current buffer has space
-  size_t required_space = raw_data_size + sizeof(struct KernelMetricData);
-  if (!current_buffer || !current_buffer->HasSpace(required_space)) {
-    // Current buffer is full, finalize it and create new one
-    if (current_buffer) {
-      scope_collection_handle->buffer_manager_->FinalizeCurrentBuffer(device);
-    }
-
-    // Create new buffer
-    SPDLOG_DEBUG(
-        "StoreKernelData: Current buffer full or not found for device {}, creating new buffer",
-        static_cast<void*>(device));
-    pti_result result = CreateNewBuffer(scope_collection_handle, device);
-    if (result != PTI_SUCCESS) {
-      return false;
-    }
-
-    current_buffer = scope_collection_handle->buffer_manager_->GetCurrentBuffer(device);
-    SPDLOG_DEBUG("StoreKernelData: After CreateNewBuffer, GetCurrentBuffer -> {}",
-                 static_cast<void*>(current_buffer));
-  }
-
-  // Add data to current buffer
-  return current_buffer && current_buffer->AddKernelRecord(std::move(kernel_data));
-}
-
-inline bool ValidateAppendedOperation(pti_callback_gpu_op_data* callback_data,
-                                      pti_gpu_op_details* op_details) {
-  if (callback_data->_operation_count > 1) {
-    SPDLOG_WARN(
-        "ValidateAppendedOperation: Metrics Scope: Multiple operations appended in a single "
-        "append. "
-        "Can not process such cases.");
-    return false;
-  }
-
-  // Check operation type and handle appropriately
-  switch (op_details->_operation_kind) {
-    case PTI_GPU_OPERATION_KIND_KERNEL:
-      // Process kernel operations normally
-      return true;
-    case PTI_GPU_OPERATION_KIND_MEMORY:
-    default:
-      // For now, skip memory operations due to known issue with query submission
-      SPDLOG_TRACE(
-          "ValidateAppendedOperation: Skipping memory (known limitation) or other operation type: "
-          "{}",
-          static_cast<uint32_t>(op_details->_operation_kind));
-      return false;
-  }
-}
-
-// Forward declaration for the helper function
-void CollectQueryDataForKernel(pti_scope_collection_handle_t scope_collection_handle,
-                               uint64_t kernel_id, const char* kernel_name,
-                               ze_command_queue_handle_t queue, pti_device_handle_t device);
-
-inline void HandleGpuOperationCompleted(pti_scope_collection_handle_t scope_collection_handle,
-                                        pti_callback_gpu_op_data* callback_data,
-                                        const GpuOperationContext& ctx,
-                                        [[maybe_unused]] pti_device_handle_t device) {
-  SPDLOG_TRACE("GPU OP COMPLETED");
-  SPDLOG_TRACE("\tSubmit type: {}", static_cast<int>(ctx.submit_type));
-
-  // Process several GPU ops - they might come in a batch
-  if (callback_data->_operation_count > 0 && callback_data->_operation_details != nullptr) {
-    auto* op_details_array = static_cast<pti_gpu_op_details*>(callback_data->_operation_details);
-
-    for (uint32_t i = 0; i < callback_data->_operation_count; ++i) {
-      const pti_gpu_op_details* op_details = &op_details_array[i];
-
-      uint64_t kernel_id = op_details->_operation_id;
-      const char* kernel_name = op_details->_name;
-
-      SPDLOG_TRACE("\tKernel ID: {}, Name: {}", kernel_id, kernel_name);
-
-      // Collect query data for this completed kernel
-      CollectQueryDataForKernel(scope_collection_handle, kernel_id, kernel_name, ctx.queue,
-                                static_cast<pti_device_handle_t>(ctx.device));
-    }
-  }
-}
-
-inline PtiQueryMetricsProfiler* FindProfiler(pti_scope_collection_handle_t scope,
-                                             pti_device_handle_t device) {
-  auto it = scope->query_profilers_.find(device);
-  if (it == scope->query_profilers_.end() || !it->second) {
-    return nullptr;
-  }
-  return it->second.get();
-}
-
-inline bool ShouldLazyCreateProfiler(pti_scope_collection_handle_t scope,
-                                     pti_device_handle_t device) {
-  if (scope->failed_devices_.count(device)) {
-    return false;
-  }
-  if (scope->auto_detect_mode_) {
-    return true;
-  }
-  return scope->requested_devices_.count(device) != 0;
-}
-
-inline PtiQueryMetricsProfiler* CreateProfilerForDevice(pti_scope_collection_handle_t scope,
-                                                        pti_device_handle_t device) {
-  PTI_ASSERT(scope != nullptr);
-  PTI_ASSERT(scope->is_configured_);
-  PTI_ASSERT(scope->buffer_manager_ != nullptr);
-
-  pti_result res = ResolveGroupHandleByName(scope, device);
-  if (res != PTI_SUCCESS) {
-    SPDLOG_WARN("CreateProfilerForDevice: ResolveGroupHandleByName failed for device {}: {}",
-                static_cast<void*>(device), static_cast<int>(res));
-    scope->failed_devices_.insert(device);
-    return nullptr;
-  }
-
-  PTI_ASSERT(scope->metrics_group_handles_[device] != nullptr);
-  auto new_profiler =
-      std::make_unique<PtiQueryMetricsProfiler>(device, scope->metrics_group_handles_[device]);
-  pti_result start_res = new_profiler->StartProfiling(false);
-  if (start_res != PTI_SUCCESS) {
-    SPDLOG_WARN(
-        "CreateProfilerForDevice: StartProfiling failed for device {} ({}); "
-        "skipping metrics for this device (likely held by another process)",
-        static_cast<void*>(device), static_cast<int>(start_res));
-    scope->failed_devices_.insert(device);
-    return nullptr;
-  }
-
-  PTI_ASSERT(scope->configured_buffer_size_ >= kMinCollectionBufferSize);
-
-  scope->buffer_manager_->RegisterDevice(device);
-
-  uint64_t buffer_id = 0;
-  {
-    std::lock_guard<std::mutex> id_lock(scope->buffer_id_mutex_);
-    scope->next_buffer_ids_[device] = 0;
-    buffer_id = scope->next_buffer_ids_[device]++;
-  }
-  pti_result buf_res =
-      scope->buffer_manager_->CreateBuffer(scope->configured_buffer_size_, device, buffer_id);
-  if (buf_res != PTI_SUCCESS && buf_res != PTI_WARN_BUFFER_NOT_FINALIZED) {
-    SPDLOG_WARN("CreateProfilerForDevice: failed to pre-allocate buffer for device {}: {}",
-                static_cast<void*>(device), static_cast<int>(buf_res));
-    scope->failed_devices_.insert(device);
-    return nullptr;
-  }
-
-  PtiQueryMetricsProfiler* raw = new_profiler.get();
-  scope->query_profilers_[device] = std::move(new_profiler);
-  SPDLOG_DEBUG("CreateProfilerForDevice: lazily created profiler for device {}",
-               static_cast<void*>(device));
-  return raw;
-}
-
-inline void HandleAppendEnter(pti_scope_collection_handle_t scope,
-                              pti_callback_gpu_op_data* callback_data,
-                              pti_gpu_op_details* op_details, const GpuOperationContext& ctx,
-                              pti_device_handle_t device) {
-  PTI_ASSERT(scope != nullptr);
-  PTI_ASSERT(callback_data != nullptr);
-  PTI_ASSERT(callback_data->_phase == PTI_CB_PHASE_API_ENTER);
-  std::lock_guard<std::mutex> lock(scope->data_mutex_);
-
-  uint64_t kernel_id = 0;
-  if (callback_data->_operation_count > 0 && callback_data->_operation_details != nullptr) {
-    if (!ValidateAppendedOperation(callback_data, op_details)) {
-      return;
-    }
-    kernel_id = op_details->_operation_id;
-  }
-
-  PtiQueryMetricsProfiler* profiler = FindProfiler(scope, device);
-  if (profiler == nullptr) {
-    if (!ShouldLazyCreateProfiler(scope, device)) {
-      SPDLOG_DEBUG("HandleAppendEnter: skipping device {} (not requested or previously failed)",
-                   static_cast<void*>(device));
-      return;
-    }
-    profiler = CreateProfilerForDevice(scope, device);
-    if (profiler == nullptr) {
-      return;
-    }
-  }
-
-  SPDLOG_TRACE("API Enter phase - injecting query begin (kernel ID: {})", kernel_id);
-  profiler->HandleKernelAppendEnter(ctx.cmd_list, ctx.device, kernel_id);
-}
-
-// TODO(JIRA): EXIT only reads query_profilers_; could use a per-device
-// read/shared lock instead of data_mutex_.
-inline void HandleAppendExit(pti_scope_collection_handle_t scope,
-                             pti_callback_gpu_op_data* callback_data,
-                             pti_gpu_op_details* op_details, const GpuOperationContext& ctx,
-                             pti_device_handle_t device) {
-  PTI_ASSERT(scope != nullptr);
-  PTI_ASSERT(callback_data != nullptr);
-  PTI_ASSERT(callback_data->_phase == PTI_CB_PHASE_API_EXIT);
-  std::lock_guard<std::mutex> lock(scope->data_mutex_);
-
-  PtiQueryMetricsProfiler* profiler = FindProfiler(scope, device);
-  if (profiler == nullptr) {
-    SPDLOG_DEBUG("HandleAppendExit: no profiler for device {} (not requested or skipped)",
-                 static_cast<void*>(device));
-    return;
-  }
-
-  uint64_t kernel_id = 0;
-  if (callback_data->_operation_count > 0 && callback_data->_operation_details != nullptr) {
-    if (!ValidateAppendedOperation(callback_data, op_details)) {
-      return;
-    }
-    kernel_id = op_details->_operation_id;
-  }
-
-  SPDLOG_TRACE("API Exit phase - injecting query end (kernel ID: {})", kernel_id);
-  profiler->HandleKernelAppendExit(ctx.cmd_list, ctx.device, kernel_id);
-}
-
-inline void HandleGpuOperationAppended(pti_scope_collection_handle_t scope_collection_handle,
-                                       pti_callback_gpu_op_data* callback_data,
-                                       pti_gpu_op_details* op_details,
-                                       const GpuOperationContext& ctx, pti_device_handle_t device) {
-  SPDLOG_TRACE("GPU OP APPENDED");
-  if (callback_data->_phase == PTI_CB_PHASE_API_ENTER) {
-    HandleAppendEnter(scope_collection_handle, callback_data, op_details, ctx, device);
-    return;
-  }
-  if (callback_data->_phase == PTI_CB_PHASE_API_EXIT) {
-    HandleAppendExit(scope_collection_handle, callback_data, op_details, ctx, device);
-  }
-}
-
-inline void HandleKernelEvent(pti_scope_collection_handle_t scope_collection_handle,
-                              pti_callback_gpu_op_data* callback_data,
-                              pti_backend_ctx_t backend_context, pti_callback_domain domain) {
-  SPDLOG_TRACE("In {}: {}", __func__, "Processing GPU operation appending or completion");
-
-  auto* op_details = static_cast<pti_gpu_op_details*>(callback_data->_operation_details);
-  if (op_details == nullptr) {
-    SPDLOG_DEBUG("MetricsScope: Operation details are null. Skipping domain {}",
-                 ptiCallbackDomainTypeToString(domain));
-    return;
-  }
-
-  GpuOperationContext ctx = ExtractGpuOperationContext(callback_data, backend_context);
-  LogGpuOperationContext(ctx);
-
-  pti_device_handle_t callback_device = static_cast<pti_device_handle_t>(ctx.device);
-  if (domain == PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED) {
-    HandleGpuOperationCompleted(scope_collection_handle, callback_data, ctx, callback_device);
-  } else if (domain == PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED) {
-    HandleGpuOperationAppended(scope_collection_handle, callback_data, op_details, ctx,
-                               static_cast<pti_device_handle_t>(ctx.device));
-  }
-}
-
-#endif  // SRC_API_PTI_METRICS_SCOPE_HELPER_H_
diff --git a/sdk/src/overhead_kinds.cc b/sdk/src/overhead_kinds.cc
deleted file mode 100644
index 70f69935..00000000
--- a/sdk/src/overhead_kinds.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "overhead_kinds.h"
-
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-
-namespace overhead {
-
-// Single definition of overhead_collection_enabled - all compilation units share this one instance
-std::atomic<bool> overhead_collection_enabled{false};
-
-// Single definition of overhead callback
-OnZeOverheadFinishCallback ocallback_{nullptr};
-
-}  // namespace overhead
-
-#endif  // PTI_OVERHEAD_TRACKING_ENABLED
diff --git a/sdk/src/overhead_kinds.h b/sdk/src/overhead_kinds.h
deleted file mode 100644
index 682d407a..00000000
--- a/sdk/src/overhead_kinds.h
+++ /dev/null
@@ -1,238 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_OVERHEAD_H_
-#define PTI_TOOLS_OVERHEAD_H_
-
-/*
- * Overhead collection methods:  These are called from collectors when they make
- * runtime api calls in order to estimate cost of making the api calls.   The
- * overhead captured is trickled into the buffer stream via buffer callback -
- * ocallback.
- */
-#include <atomic>
-#include <type_traits>
-
-#include "pti/pti_driver_levelzero_api_ids.h"
-#include "unikernel.h"
-#include "utils.h"
-
-namespace overhead {
-
-enum class OverheadRuntimeType {
-  kSycl = 0,
-  kL0,
-};
-
-typedef void (*OnZeOverheadFinishCallback)(void* data, ZeKernelCommandExecutionRecord& kcexec);
-
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-extern std::atomic<bool> overhead_collection_enabled;
-extern OnZeOverheadFinishCallback
-    ocallback_;  // Overhead callback registered for any overhead records that need
-                 // to be captured and sent to buffer.
-
-#else
-inline std::atomic<bool> overhead_collection_enabled{false};
-inline OnZeOverheadFinishCallback ocallback_{nullptr};
-#endif
-
-inline thread_local uint64_t init_ref_count = 0;
-
-inline static void SetOverheadCallback(OnZeOverheadFinishCallback callback) {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  ocallback_ = callback;
-#else
-  (void)callback;
-#endif
-}
-
-//
-// TODO -- change the init to take in a param of type ovehead_kind and use that
-// -- instead of assuming KIND_TIME only.
-//
-// Mark or up ref count for this function to include in overhead time
-//   Overhead is captured for any runtime calls made that have a chance to
-//   affect device times.
-//
-
-inline void Init() {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  if (!overhead_collection_enabled) {
-    return;
-  }
-  if (map_overhead_per_kind.empty()) {
-    pti_view_record_overhead overhead_rec = pti_view_record_overhead();
-    overhead_rec._overhead_kind = pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME;
-    overhead_rec._view_kind._view_kind = pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD;
-    overhead_rec._overhead_start_timestamp_ns = 0;
-    overhead_rec._overhead_end_timestamp_ns = 0;
-    overhead_rec._overhead_count = 0;
-    map_overhead_per_kind[{pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME}] = overhead_rec;
-  }
-
-  auto tid = PidTidInfo::Get().tid;
-  auto start_time_ns = utils::GetTime();
-  auto overhead_it =
-      map_overhead_per_kind.find({pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME});
-  init_ref_count++;
-  if (overhead_it != map_overhead_per_kind.cend()) {
-    if (overhead_it->second._overhead_start_timestamp_ns != 0) {
-      return;
-    }
-    overhead_it->second._overhead_start_timestamp_ns = start_time_ns;
-  } else {
-    pti_view_record_overhead overhead_rec = pti_view_record_overhead();
-    overhead_rec._view_kind._view_kind = pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD;
-    overhead_rec._overhead_kind = pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME;
-    overhead_rec._overhead_start_timestamp_ns = start_time_ns;
-    overhead_rec._overhead_thread_id = tid;
-    map_overhead_per_kind[{pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME}] = overhead_rec;
-  }
-#endif
-}
-
-inline void ResetRecord() {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  auto overhead_it =
-      map_overhead_per_kind.find({pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME});
-  if (overhead_it != map_overhead_per_kind.cend()) {
-    overhead_it->second._overhead_duration_ns = 0;
-    overhead_it->second._overhead_start_timestamp_ns = 0;
-    overhead_it->second._overhead_end_timestamp_ns = 0;
-    overhead_it->second._overhead_count = 0;
-    PTI_ASSERT(init_ref_count == 0);
-  }
-#endif
-}
-
-inline void FiniLevel0(OverheadRuntimeType runtime_type,
-                       [[maybe_unused]] pti_api_id_driver_levelzero api_id) {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  if (!overhead_collection_enabled) {
-    return;
-  }
-
-  // Init not called, nothing to do.
-  if (init_ref_count == 0) {
-    return;
-  }
-
-  if (init_ref_count > 1) {  // we are not done if there is more than 1 ref
-    init_ref_count--;        // count for this object per thread basis.
-    return;
-  }
-
-  init_ref_count--;
-
-  uint64_t end_time_ns = utils::GetTime();
-  auto overhead_it =
-      map_overhead_per_kind.find({pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME});
-
-  if (overhead_it != map_overhead_per_kind.cend()) {
-    // Note: it could be surprising that duration is zero - but this can happen,
-    // especially on Windows where PTI at the moment uses QueryPerformanceCounter
-    // which has a coarse granularity of ~ 100ns.
-    uint64_t duration = end_time_ns - overhead_it->second._overhead_start_timestamp_ns;
-    overhead_it->second._overhead_duration_ns += duration;
-    if (runtime_type == OverheadRuntimeType::kSycl) {
-      overhead_it->second._overhead_count += 1;
-    }
-    if (runtime_type == OverheadRuntimeType::kL0) {
-      overhead_it->second._overhead_count += 1;
-    }
-    overhead_it->second._overhead_end_timestamp_ns = end_time_ns;
-    overhead_it->second._overhead_thread_id = PidTidInfo::Get().tid;
-    overhead_it->second._api_id = api_id;  // Turn this
-    // back on if we need to propagate api_name to user.
-    if ((runtime_type == OverheadRuntimeType::kL0) && (ocallback_ != nullptr)) {
-      ocallback_(&overhead_it->second, overhead_data);
-    }
-    ResetRecord();
-  }
-#else
-  (void)runtime_type;
-  (void)api_id;
-#endif
-}
-
-inline void FiniSycl(OverheadRuntimeType runtime_type) {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  // Init not called, nothing to do.
-  if (init_ref_count == 0) {
-    return;
-  }
-
-  if (init_ref_count > 1) {
-    init_ref_count--;
-    return;
-  }
-  init_ref_count--;
-
-  uint64_t end_time_ns = utils::GetTime();
-  auto overhead_it =
-      map_overhead_per_kind.find({pti_view_overhead_kind::PTI_VIEW_OVERHEAD_KIND_TIME});
-  if (overhead_it != map_overhead_per_kind.cend()) {
-    uint64_t duration = end_time_ns - overhead_it->second._overhead_start_timestamp_ns;
-    overhead_it->second._overhead_duration_ns += duration;
-    if (runtime_type == OverheadRuntimeType::kSycl) {
-      overhead_it->second._overhead_count += 1;
-    }
-    if (runtime_type == OverheadRuntimeType::kL0) {
-      overhead_it->second._overhead_count += 1;
-    }
-    overhead_it->second._overhead_end_timestamp_ns = end_time_ns;
-    overhead_it->second._overhead_thread_id = utils::GetTid();
-    if ((runtime_type == OverheadRuntimeType::kSycl) && (ocallback_ != nullptr)) {
-      ocallback_(&overhead_it->second, overhead_data);
-    }
-    ResetRecord();
-  }
-#else
-  (void)runtime_type;
-#endif
-}
-
-template <typename E>
-class ScopedOverheadCollector {
- public:
-  constexpr explicit ScopedOverheadCollector(E api_id) : identifier_(api_id) {
-    static_assert(std::is_enum_v<E>, "Must be overhead enum type");
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-    Init();
-#endif
-  }
-
-  ScopedOverheadCollector(const ScopedOverheadCollector&) = delete;
-  ScopedOverheadCollector& operator=(const ScopedOverheadCollector&) = delete;
-  ScopedOverheadCollector(ScopedOverheadCollector&&) = delete;
-  ScopedOverheadCollector& operator=(ScopedOverheadCollector&&) = delete;
-
-  ~ScopedOverheadCollector() noexcept {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-    if constexpr (std::is_same_v<E, pti_api_id_driver_levelzero>) {
-      FiniLevel0(OverheadRuntimeType::kL0, identifier_);
-    }
-    // Remove and add SYCL/other runtimes here as needed.
-    static_assert(std::is_same_v<E, pti_api_id_driver_levelzero>, "Unsupported overhead enum type");
-#endif
-  }
-
- private:
-  E identifier_;
-};
-
-}  // namespace overhead
-
-static inline void overhead_fini(pti_api_id_driver_levelzero api_id) {
-#ifdef PTI_OVERHEAD_TRACKING_ENABLED
-  overhead::FiniLevel0(overhead::OverheadRuntimeType::kL0, api_id);
-#else
-  (void)api_id;
-#endif
-}
-
-#endif  // PTI_TOOLS_OVERHEAD_H_
diff --git a/sdk/src/pc_sampling/pti_pc_sampling.cc b/sdk/src/pc_sampling/pti_pc_sampling.cc
deleted file mode 100644
index 41ce291a..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling.cc
+++ /dev/null
@@ -1,409 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pti/pti_pc_sampling.h"
-
-#include "pc_sampling/pti_pc_sampling_collector.h"
-#include "pc_sampling/pti_pc_sampling_internal.h"
-#include "pti/pti_metrics.h"
-
-pti_result ptiPcSamplingEnable(pti_pc_sampling_handle_t* handle) {
-  return pti::pc_sampling::PtiPcSamplingHandleStorage::Instance().Create(handle);
-}
-
-pti_result ptiPcSamplingConfigure(pti_pc_sampling_handle_t handle,
-                                  const pti_device_handle_t* devices, size_t device_count,
-                                  uint32_t sampling_period_ns) {
-  const pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (handle->state_ != pti::pc_sampling::PcSamplingState::kEnabled) {
-    SPDLOG_ERROR(
-        "{}: cannot configure PC sampling because handle is not in the initial state for "
-        "configuration, "
-        "current state is {}",
-        __FUNCTION__, pti::pc_sampling::PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED;
-  }
-
-  return pti::pc_sampling::ApplyConfiguration(handle, devices, device_count, sampling_period_ns);
-}
-
-pti_result ptiPcSamplingQueryCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                                  size_t* buffer_size) {
-  const pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (buffer_size == nullptr) {
-    SPDLOG_ERROR("{}: buffer_size output pointer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  *buffer_size = pti::pc_sampling::GetCollectionBufferSize(handle);
-  return PTI_SUCCESS;
-}
-
-pti_result ptiPcSamplingSetCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                                size_t buffer_size) {
-  const pti_result startable_status = pti::pc_sampling::ValidateStartableHandle(handle);
-  if (startable_status != PTI_SUCCESS) {
-    return startable_status;
-  }
-
-  if (!pti::pc_sampling::IsValidCollectionBufferSize(buffer_size)) {
-    SPDLOG_ERROR("{}: invalid buffer size {}; expected a multiple of {} bytes in [{}, {}]",
-                 __FUNCTION__, buffer_size, pti::pc_sampling::kEuStallSamplingRawReportSize,
-                 pti::pc_sampling::kMinCollectionBufferSize,
-                 pti::pc_sampling::kMaxCollectionBufferSize);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const std::optional<size_t> environment_size =
-      pti::pc_sampling::GetEnvironmentCollectionBufferSize();
-  if (environment_size.has_value()) {
-    SPDLOG_WARN("{}: ignoring requested buffer size {}; {} overrides it with {}", __FUNCTION__,
-                buffer_size, pti::pc_sampling::kCollectionBufferSizeEnv, *environment_size);
-    return PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV;
-  }
-
-  handle->collection_buffer_size_ = buffer_size;
-  return PTI_SUCCESS;
-}
-
-namespace {
-
-// Starts collection on a handle that already carries a resolved configuration.
-pti_result StartConfiguredCollection(pti_pc_sampling_handle_t handle) {
-  pti::pc_sampling::ClearProfiledDeviceData(handle);
-
-  pti_device_handle_t profiling_device = nullptr;
-  const pti_result configured_device_status =
-      pti::pc_sampling::GetConfiguredDevice(handle, &profiling_device);
-  if (configured_device_status != PTI_SUCCESS) {
-    return configured_device_status;
-  }
-
-  ze_driver_handle_t driver =
-      pti::pc_sampling::PtiPcSamplingHandleStorage::Instance().GetDriver(profiling_device);
-  zet_metric_group_handle_t metric_group =
-      pti::pc_sampling::PtiPcSamplingHandleStorage::Instance().GetMetricGroup(profiling_device);
-  if (driver == nullptr || metric_group == nullptr) {
-    SPDLOG_ERROR("{}: configured device {} is missing PC sampling configuration", __FUNCTION__,
-                 static_cast<const void*>(profiling_device));
-    return PTI_ERROR_INTERNAL;
-  }
-
-  const size_t collection_buffer_size = pti::pc_sampling::GetCollectionBufferSize(handle);
-  handle->collector.reset(new (std::nothrow) pti::pc_sampling::PtiPcSamplingDataCollector(
-      profiling_device, driver, metric_group, handle->collected_raw_data_, handle->samples_dropped_,
-      collection_buffer_size));
-  if (handle->collector == nullptr) {
-    SPDLOG_ERROR("{}: collector creation returned null", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  handle->collected_metric_group_ = metric_group;
-
-  const pti_result start_status = handle->collector->Start(handle->sampling_period_ns_);
-  if (start_status != PTI_SUCCESS) {
-    pti::pc_sampling::ClearProfiledDeviceData(handle);
-    return start_status;
-  }
-
-  handle->started_collection_buffer_size_ = collection_buffer_size;
-  handle->state_ = pti::pc_sampling::PcSamplingState::kStarted;
-  return PTI_SUCCESS;
-}
-
-}  // namespace
-
-pti_result ptiPcSamplingStartCollection(pti_pc_sampling_handle_t handle) {
-  const pti_result startable_status = pti::pc_sampling::ValidateStartableHandle(handle);
-  if (startable_status != PTI_SUCCESS) {
-    return startable_status;
-  }
-
-  // Configuration is optional: apply the default one when the caller skipped
-  // ptiPcSamplingConfigure.
-  const bool applied_default_configuration =
-      handle->state_ == pti::pc_sampling::PcSamplingState::kEnabled;
-  if (applied_default_configuration) {
-    SPDLOG_INFO(
-        "{}: PC sampling was not configured explicitly, applying the default configuration "
-        "(PTI selected device, sampling period {} ns)",
-        __FUNCTION__, pti::pc_sampling::kDefaultSamplingPeriodNs);
-    const pti_result default_configure_status = pti::pc_sampling::ApplyConfiguration(
-        handle, /*devices=*/nullptr, /*device_count=*/0, /*sampling_period_ns=*/0);
-    if (default_configure_status != PTI_SUCCESS) {
-      return default_configure_status;
-    }
-  }
-
-  const pti_result start_status = StartConfiguredCollection(handle);
-  if (start_status != PTI_SUCCESS && applied_default_configuration) {
-    // Leave the handle as the caller found it, so an explicit ptiPcSamplingConfigure
-    // is still accepted after a failed implicitly configured start.
-    SPDLOG_WARN(
-        "{}: failed to start collection on the default configuration, reverting handle to "
-        "unconfigured state. Check suitable default configuration for the device.",
-        __FUNCTION__);
-    handle->configured_devices_.clear();
-    handle->sampling_period_ns_ = pti::pc_sampling::kDefaultSamplingPeriodNs;
-    handle->state_ = pti::pc_sampling::PcSamplingState::kEnabled;
-  }
-
-  return start_status;
-}
-
-pti_result ptiPcSamplingStopCollection(pti_pc_sampling_handle_t handle) {
-  const pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (handle->state_ == pti::pc_sampling::PcSamplingState::kStopped) {
-    SPDLOG_ERROR("{}: PC sampling is already stopped", __FUNCTION__);
-    return PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED;
-  }
-
-  if (handle->state_ != pti::pc_sampling::PcSamplingState::kStarted) {
-    SPDLOG_ERROR("{}: cannot stop PC sampling on not running collection, current state is {}",
-                 __FUNCTION__, pti::pc_sampling::PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_NOT_STARTED;
-  }
-
-  if (handle->collector == nullptr) {
-    SPDLOG_ERROR("{}: collector is missing while collection is running", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  const pti_result stop_status = handle->collector->Stop();
-  if (handle->collector->IsStopped()) {
-    handle->collector.reset();
-    handle->state_ = pti::pc_sampling::PcSamplingState::kStopped;
-  }
-
-  return stop_status;
-}
-
-pti_result ptiPcSamplingGetStallReasons(pti_pc_sampling_handle_t handle,
-                                        pti_pc_sampling_stall_reason_info_t* reasons,
-                                        size_t* reason_count) {
-  const pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (reason_count == nullptr) {
-    SPDLOG_ERROR("{}: reason_count output pointer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result stall_reasons_status = pti::pc_sampling::EnsureStallReasons(handle);
-  if (stall_reasons_status != PTI_SUCCESS) {
-    return stall_reasons_status;
-  }
-
-  const size_t total_reasons = handle->stall_reasons_.size();
-
-  if (reasons == nullptr) {
-    *reason_count = total_reasons;
-    return PTI_SUCCESS;
-  }
-
-  if (*reason_count > total_reasons) {
-    SPDLOG_WARN(
-        "{}: provided reasons buffer holds {} entries but only {} stall reasons exist; "
-        "the required count will be returned without populating the output buffer",
-        __FUNCTION__, *reason_count, total_reasons);
-    *reason_count = total_reasons;
-    return PTI_SUCCESS;
-  }
-
-  const size_t entries_to_copy = (std::min)(*reason_count, total_reasons);
-  *reason_count = entries_to_copy;
-  for (size_t i = 0; i < entries_to_copy; ++i) {
-    reasons[i]._name = handle->stall_reasons_[i].first;
-    reasons[i]._description = handle->stall_reasons_[i].second;
-  }
-
-  return PTI_SUCCESS;
-}
-
-pti_result ptiPcSamplingGetProfiledDevices(pti_pc_sampling_handle_t handle,
-                                           pti_device_handle_t* devices, size_t* device_count) {
-  const pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (device_count == nullptr) {
-    SPDLOG_ERROR("{}: device_count output pointer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (handle->state_ != pti::pc_sampling::PcSamplingState::kStopped) {
-    SPDLOG_ERROR("{}: profiled devices can be queried only after collection is stopped",
-                 __FUNCTION__);
-    return PTI_ERROR_PC_SAMPLING_NOT_STOPPED;
-  }
-
-  return pti::pc_sampling::FillProfiledDevices(handle, devices, device_count);
-}
-
-pti_result ptiPcSamplingGetObservedKernelHandles(pti_pc_sampling_handle_t handle,
-                                                 pti_device_handle_t device,
-                                                 uint64_t* kernel_handles, size_t* kernel_count) {
-  const pti_result handle_status = pti::pc_sampling::ValidateStoppedCollectionHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (kernel_count == nullptr) {
-    SPDLOG_ERROR("{}: kernel_count output pointer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result device_status =
-      pti::pc_sampling::ValidateConfiguredProfiledDevice(handle, device);
-  if (device_status != PTI_SUCCESS) {
-    return device_status;
-  }
-
-  const pti_result aggregate_status = pti::pc_sampling::EnsureAggregatedResults(handle);
-  if (aggregate_status != PTI_SUCCESS) {
-    return aggregate_status;
-  }
-
-  return pti::pc_sampling::FillObservedKernelHandles(handle, kernel_handles, kernel_count);
-}
-
-pti_result ptiPcSamplingGetObservedKernelInfo(pti_pc_sampling_handle_t handle,
-                                              pti_device_handle_t device, uint64_t kernel_handle,
-                                              pti_pc_sampling_kernel_info_t* kernel_info) {
-  const pti_result handle_status = pti::pc_sampling::ValidateStoppedCollectionHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (kernel_info == nullptr || kernel_info->_struct_size < sizeof(pti_pc_sampling_kernel_info_t)) {
-    SPDLOG_ERROR("{}: kernel_info output is invalid", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result device_status =
-      pti::pc_sampling::ValidateConfiguredProfiledDevice(handle, device);
-  if (device_status != PTI_SUCCESS) {
-    return device_status;
-  }
-
-  const pti_result aggregate_status = pti::pc_sampling::EnsureAggregatedResults(handle);
-  if (aggregate_status != PTI_SUCCESS) {
-    return aggregate_status;
-  }
-
-  return pti::pc_sampling::FillObservedKernelInfo(device, handle, kernel_handle, kernel_info);
-}
-
-pti_result ptiPcSamplingGetSamplesPerInstruction(pti_pc_sampling_handle_t handle,
-                                                 pti_device_handle_t device, uint64_t kernel_handle,
-                                                 pti_pc_sampling_instruction_t* instruction_buffer,
-                                                 size_t instruction_buffer_count,
-                                                 uint64_t* samples_buffer,
-                                                 size_t samples_buffer_count) {
-  const pti_result handle_status = pti::pc_sampling::ValidateStoppedCollectionHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (instruction_buffer == nullptr || samples_buffer == nullptr) {
-    SPDLOG_ERROR("{}: instruction_buffer or samples_buffer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result device_status =
-      pti::pc_sampling::ValidateConfiguredProfiledDevice(handle, device);
-  if (device_status != PTI_SUCCESS) {
-    return device_status;
-  }
-
-  const pti_result aggregate_status = pti::pc_sampling::EnsureAggregatedResults(handle);
-  if (aggregate_status != PTI_SUCCESS) {
-    return aggregate_status;
-  }
-
-  return pti::pc_sampling::FillSamplesPerInstruction(handle, kernel_handle, instruction_buffer,
-                                                     instruction_buffer_count, samples_buffer,
-                                                     samples_buffer_count);
-}
-
-pti_result ptiPcSamplingGetDeviceStatus(pti_pc_sampling_handle_t handle, pti_device_handle_t device,
-                                        pti_pc_sampling_device_status_t* device_status) {
-  const pti_result handle_status = pti::pc_sampling::ValidateStoppedCollectionHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  const size_t expected_struct_size = sizeof(pti_pc_sampling_device_status_t);
-  if (device == nullptr || device_status == nullptr ||
-      device_status->_struct_size != expected_struct_size) {
-    SPDLOG_ERROR("{}: device status output is invalid", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  const pti_result aggregate_status = pti::pc_sampling::EnsureAggregatedResults(handle);
-  if (aggregate_status != PTI_SUCCESS) {
-    return aggregate_status;
-  }
-
-  const pti_pc_sampling_device_status_t& device_data = handle->device_aggregate_.status;
-  if (device_data._device != device) {
-    SPDLOG_ERROR("{}: device does not match the profiled PC sampling device", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  *device_status = device_data;
-  return PTI_SUCCESS;
-}
-
-pti_result ptiPcSamplingDisable(pti_pc_sampling_handle_t handle) {
-  pti_result handle_status = pti::pc_sampling::ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (handle->state_ != pti::pc_sampling::PcSamplingState::kStopped) {
-    SPDLOG_WARN("{}: destroying PC sampling handle while collection state is {}", __FUNCTION__,
-                pti::pc_sampling::PcSamplingStateToString(handle->state_));
-    // Attempt to stop collection if it's still running before destroying handle
-    if (handle->state_ == pti::pc_sampling::PcSamplingState::kStarted) {
-      handle_status = ptiPcSamplingStopCollection(handle);
-      if (handle_status != PTI_SUCCESS && handle_status != PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED) {
-        SPDLOG_WARN("{}: failed to stop collection before destroying handle, status: {:#x}",
-                    __FUNCTION__, static_cast<uint32_t>(handle_status));
-      }
-    }
-  }
-
-  pti::pc_sampling::ClearProfiledDeviceData(handle);
-
-  pti_result destroy_result =
-      pti::pc_sampling::PtiPcSamplingHandleStorage::Instance().Destroy(handle);
-
-  // Release this handle's metrics reference. The reference count in MetricStateManager
-  // decides whether the driver actually disables metrics.
-  pti_result disable_status = ptiMetricsDisable(nullptr);
-  if (disable_status != PTI_SUCCESS) {
-    SPDLOG_WARN("{}: Failed to disable metrics: {}", __FUNCTION__,
-                ptiResultTypeToString(disable_status));
-  }
-
-  return destroy_result;
-}
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_aggregator.cc b/sdk/src/pc_sampling/pti_pc_sampling_aggregator.cc
deleted file mode 100644
index e3924da1..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_aggregator.cc
+++ /dev/null
@@ -1,346 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pc_sampling/pti_pc_sampling_aggregator.h"
-
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "pc_sampling/pti_pc_sampling_internal.h"
-#include "pc_sampling/pti_pc_sampling_l0.h"
-
-namespace {
-
-using namespace pti::pc_sampling;
-
-uint64_t GetMetricValueAsUint64(const zet_typed_value_t& typed_value) {
-  switch (typed_value.type) {
-    case ZET_VALUE_TYPE_UINT32:
-      return typed_value.value.ui32;
-    case ZET_VALUE_TYPE_UINT64:
-      return typed_value.value.ui64;
-    case ZET_VALUE_TYPE_BOOL8:
-      return typed_value.value.b8;
-    default:
-      SPDLOG_ERROR("{}: unsupported metric value type {}", __FUNCTION__,
-                   static_cast<int64_t>(typed_value.type));
-      return 0;
-  }
-}
-
-// Map a metric index to its stall-reason index. Reasons are all metrics except
-// the IP metric, preserving metric-group order.
-inline size_t ReasonIndexForMetric(size_t metric_index, size_t ip_metric_index) {
-  return (metric_index < ip_metric_index) ? metric_index : metric_index - 1;
-}
-
-struct AggregationScratch {
-  std::unordered_set<uint64_t> unique_pcs;
-  uint64_t dropped_sample_count = 0;
-  std::unordered_set<uint64_t> dropped_pcs;
-  std::vector<uint32_t> reports;
-  std::vector<zet_typed_value_t> values;
-};
-
-struct PendingKernelAggregate {
-  uint64_t kernel_handle = 0;
-  const char* kernel_name = nullptr;
-  std::vector<uint64_t> aggregated_samples;
-  std::vector<uint64_t> instruction_offsets;
-  std::vector<uint64_t> flattened_samples;
-  std::unordered_map<uint64_t, size_t> instruction_rows;
-};
-
-using PendingKernelMap = std::unordered_map<uint64_t, PendingKernelAggregate>;
-
-PendingKernelAggregate& GetOrCreateKernelAggregate(const KernelBinaryInfo& kernel_info,
-                                                   size_t reason_count,
-                                                   PendingKernelMap* pending_kernels) {
-  const uint64_t kernel_handle = kernel_info.kernel_base_address_;
-  auto kernel_it = pending_kernels->find(kernel_handle);
-  if (kernel_it == pending_kernels->end()) {
-    PendingKernelAggregate kernel_aggregate;
-    kernel_aggregate.kernel_handle = kernel_handle;
-    kernel_aggregate.kernel_name = kernel_info.kernel_name_;
-    kernel_aggregate.aggregated_samples.assign(reason_count, 0);
-    kernel_aggregate.flattened_samples.reserve(reason_count);
-    kernel_it = pending_kernels->emplace(kernel_handle, std::move(kernel_aggregate)).first;
-  }
-
-  return kernel_it->second;
-}
-
-size_t GetOrCreateInstructionRow(uint64_t ip, size_t reason_count,
-                                 PendingKernelAggregate* kernel_aggregate) {
-  const uint64_t offset = ip - kernel_aggregate->kernel_handle;
-  auto row_it = kernel_aggregate->instruction_rows.find(offset);
-  if (row_it != kernel_aggregate->instruction_rows.end()) {
-    return row_it->second;
-  }
-
-  const size_t row_index = kernel_aggregate->instruction_offsets.size();
-  kernel_aggregate->instruction_offsets.push_back(offset);
-  kernel_aggregate->instruction_rows.emplace(offset, row_index);
-  kernel_aggregate->flattened_samples.insert(kernel_aggregate->flattened_samples.end(),
-                                             reason_count, 0);
-
-  return row_index;
-}
-
-uint64_t AccumulateUnmappedSampleCount(const zet_typed_value_t* sample_values, size_t metric_count,
-                                       size_t ip_metric_index) {
-  uint64_t sample_sum = 0;
-  for (size_t metric_index = 0; metric_index < metric_count; ++metric_index) {
-    if (metric_index == ip_metric_index) {
-      continue;
-    }
-    sample_sum += GetMetricValueAsUint64(sample_values[metric_index]);
-  }
-
-  return sample_sum;
-}
-
-void AccumulateMappedSample(const zet_typed_value_t* sample_values, size_t metric_count,
-                            size_t ip_metric_index, size_t instruction_row,
-                            PendingKernelAggregate* kernel_aggregate,
-                            pti_pc_sampling_device_status_t* device_status) {
-  for (size_t metric_index = 0; metric_index < metric_count; ++metric_index) {
-    if (metric_index == ip_metric_index) {
-      continue;
-    }
-
-    const uint64_t metric_value = GetMetricValueAsUint64(sample_values[metric_index]);
-    const size_t reason_index = ReasonIndexForMetric(metric_index, ip_metric_index);
-    const size_t flat_index =
-        instruction_row * kernel_aggregate->aggregated_samples.size() + reason_index;
-    kernel_aggregate->flattened_samples[flat_index] += metric_value;
-    kernel_aggregate->aggregated_samples[reason_index] += metric_value;
-    device_status->_total_sample_count += metric_value;
-  }
-}
-
-void AggregateSample(uint64_t ip, const zet_typed_value_t* sample_values, size_t metric_count,
-                     size_t ip_metric_index, size_t reason_count,
-                     pti_pc_sampling_device_status_t* device_status,
-                     PendingKernelMap* pending_kernels, AggregationScratch* scratch) {
-  const KernelBinaryInfo* kernel_info = KernelInfoStorage::Instance().FindByIpAddress(ip);
-  if (kernel_info == nullptr) {
-    // Drop PCs that do not map to a tracked kernel.
-    scratch->dropped_sample_count +=
-        AccumulateUnmappedSampleCount(sample_values, metric_count, ip_metric_index);
-    scratch->dropped_pcs.insert(ip);
-    return;
-  }
-
-  PendingKernelAggregate& kernel_aggregate =
-      GetOrCreateKernelAggregate(*kernel_info, reason_count, pending_kernels);
-  const size_t instruction_row = GetOrCreateInstructionRow(ip, reason_count, &kernel_aggregate);
-
-  scratch->unique_pcs.insert(ip);
-  AccumulateMappedSample(sample_values, metric_count, ip_metric_index, instruction_row,
-                         &kernel_aggregate, device_status);
-}
-
-bool DecodeMetricBlock(zet_metric_group_handle_t metric_group, const std::vector<uint8_t>& chunk,
-                       pti_pc_sampling_device_status_t* device_status,
-                       AggregationScratch* scratch) {
-  bool chunk_dropped = false;
-  if (!CalculateMetricValues(metric_group, chunk, &scratch->reports, &scratch->values,
-                             &chunk_dropped)) {
-    return false;
-  }
-  if (chunk_dropped) {
-    device_status->_samples_dropped = 1;
-  }
-
-  return true;
-}
-
-void AggregateDecodedReports(size_t ip_metric_index, size_t reason_count,
-                             pti_pc_sampling_device_status_t* device_status,
-                             PendingKernelMap* pending_kernels, AggregationScratch* scratch) {
-  if (scratch->reports.empty() || scratch->values.empty()) {
-    return;
-  }
-
-  // Assumes the decoded report stride is reason_count + 1: every metric in the
-  // group is an EVENT stall reason except the single IP metric.
-  const size_t metric_count = reason_count + 1;
-  const zet_typed_value_t* value = scratch->values.data();
-  for (size_t report_index = 0; report_index < scratch->reports.size(); ++report_index) {
-    const size_t per_report_value_count = static_cast<size_t>(scratch->reports[report_index]);
-    const size_t sample_count = metric_count == 0 ? 0 : per_report_value_count / metric_count;
-    if (metric_count != 0 && per_report_value_count % metric_count != 0) {
-      SPDLOG_WARN(
-          "{}: report index {} has {} values which is not a multiple of the metric count {}",
-          __FUNCTION__, report_index, per_report_value_count, metric_count);
-    }
-
-    for (size_t sample_index = 0; sample_index < sample_count; ++sample_index) {
-      const zet_typed_value_t* sample_values = value + sample_index * metric_count;
-      const uint64_t ip =
-          NormalizeInstructionPointer(GetMetricValueAsUint64(sample_values[ip_metric_index]));
-      if (ip == 0) {
-        continue;
-      }
-
-      AggregateSample(ip, sample_values, metric_count, ip_metric_index, reason_count, device_status,
-                      pending_kernels, scratch);
-    }
-    value += per_report_value_count;
-  }
-}
-
-bool PersistKernelSamplesFile(const PendingKernelAggregate& pending_kernel, size_t reason_count,
-                              KernelAggregate* kernel_aggregate) {
-  if (kernel_aggregate == nullptr || !kernel_aggregate->samples_file.OpenTemp()) {
-    return false;
-  }
-
-  if (reason_count != 0 && pending_kernel.instruction_offsets.size() >
-                               ((std::numeric_limits<size_t>::max)() / reason_count)) {
-    kernel_aggregate->samples_file.Reset();
-    return false;
-  }
-
-  const size_t offsets_bytes = pending_kernel.instruction_offsets.size() * sizeof(uint64_t);
-  if (offsets_bytes != 0 &&
-      !kernel_aggregate->samples_file.Append(
-          reinterpret_cast<const uint8_t*>(pending_kernel.instruction_offsets.data()),
-          offsets_bytes)) {
-    kernel_aggregate->samples_file.Reset();
-    return false;
-  }
-
-  const size_t samples_bytes = pending_kernel.flattened_samples.size() * sizeof(uint64_t);
-  if (samples_bytes != 0 &&
-      !kernel_aggregate->samples_file.Append(
-          reinterpret_cast<const uint8_t*>(pending_kernel.flattened_samples.data()),
-          samples_bytes)) {
-    kernel_aggregate->samples_file.Reset();
-    return false;
-  }
-
-  if (!kernel_aggregate->samples_file.Finalize()) {
-    kernel_aggregate->samples_file.Reset();
-    return false;
-  }
-
-  return true;
-}
-
-pti_result PersistAggregates(const PendingKernelMap& pending_kernels, size_t reason_count,
-                             DeviceAggregate* device_aggregate) {
-  for (const auto& [kernel_handle, pending_kernel] : pending_kernels) {
-    KernelAggregate kernel_aggregate;
-    kernel_aggregate.kernel_handle = pending_kernel.kernel_handle;
-    kernel_aggregate.kernel_name_ = pending_kernel.kernel_name;
-    kernel_aggregate.reason_count = reason_count;
-    kernel_aggregate.instruction_count = pending_kernel.instruction_offsets.size();
-    kernel_aggregate.aggregated_samples = pending_kernel.aggregated_samples;
-
-    if (!PersistKernelSamplesFile(pending_kernel, reason_count, &kernel_aggregate)) {
-      SPDLOG_ERROR("{}: failed to persist aggregate for kernel handle {:#x}", __FUNCTION__,
-                   kernel_handle);
-      return PTI_ERROR_INTERNAL;
-    }
-
-    device_aggregate->kernels.emplace(kernel_handle, std::move(kernel_aggregate));
-  }
-
-  return PTI_SUCCESS;
-}
-
-}  // namespace
-
-namespace pti::pc_sampling {
-
-pti_result AggregateCollectedData(pti_device_handle_t device,
-                                  zet_metric_group_handle_t metric_group, bool samples_dropped,
-                                  const TempRawDataFile& raw_data_file, size_t ip_metric_index,
-                                  size_t reason_count, DeviceAggregate* device_aggregate) {
-  if (device_aggregate == nullptr) {
-    SPDLOG_ERROR("{}: device_aggregate is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  device_aggregate->Clear();
-  if (device == nullptr) {
-    SPDLOG_ERROR("{}: device is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  pti_pc_sampling_device_status_t& device_status = device_aggregate->status;
-  device_status._struct_size = sizeof(pti_pc_sampling_device_status_t);
-  device_status._device = device;
-  device_status._samples_dropped = static_cast<uint32_t>(samples_dropped);
-
-  const size_t raw_data_size = raw_data_file.size();
-  SPDLOG_DEBUG("{}: device={}, raw_data_size={}, metric_group={}, metric_count={}, reason_count={}",
-               __FUNCTION__, static_cast<const void*>(device), raw_data_size,
-               static_cast<const void*>(metric_group), reason_count + 1, reason_count);
-
-  if (metric_group == nullptr || raw_data_size == 0) {
-    return PTI_SUCCESS;
-  }
-
-  if (ip_metric_index > reason_count) {
-    SPDLOG_ERROR("{}: invalid IP metric index {}", __FUNCTION__, ip_metric_index);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  AggregationScratch scratch;
-  PendingKernelMap pending_kernels;
-  std::vector<uint8_t> raw_data;
-  if (!raw_data_file.ReadAll(&raw_data)) {
-    SPDLOG_ERROR("{}: failed to read raw data", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  if (!raw_data.empty()) {
-    if (!DecodeMetricBlock(metric_group, raw_data, &device_status, &scratch)) {
-      return PTI_ERROR_INTERNAL;
-    }
-    AggregateDecodedReports(ip_metric_index, reason_count, &device_status, &pending_kernels,
-                            &scratch);
-  }
-
-  device_status._total_pc_count = scratch.unique_pcs.size();
-
-  const pti_result persist_status =
-      PersistAggregates(pending_kernels, reason_count, device_aggregate);
-  if (persist_status != PTI_SUCCESS) {
-    return persist_status;
-  }
-
-  if (!scratch.dropped_pcs.empty()) {
-    if (scratch.unique_pcs.empty() && KernelInfoStorage::Instance().Size() != 0) {
-      SPDLOG_WARN(
-          "{}: device={} has {} unmapped stall samples across {} PCs; none matched a "
-          "tracked kernel binary, so kernel sampling data cannot be attributed",
-          __FUNCTION__, static_cast<const void*>(device), scratch.dropped_sample_count,
-          scratch.dropped_pcs.size());
-    } else {
-      SPDLOG_INFO("{}: device={} dropped {} unmapped stall samples across {} PCs", __FUNCTION__,
-                  static_cast<const void*>(device), scratch.dropped_sample_count,
-                  scratch.dropped_pcs.size());
-    }
-  }
-
-  SPDLOG_DEBUG("{}: device={}, kernels={}, mapped_sample_count={}, mapped_pc_count={}",
-               __FUNCTION__, static_cast<const void*>(device), device_aggregate->kernels.size(),
-               device_status._total_sample_count, device_status._total_pc_count);
-  return PTI_SUCCESS;
-}
-
-}  // namespace pti::pc_sampling
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_aggregator.h b/sdk/src/pc_sampling/pti_pc_sampling_aggregator.h
deleted file mode 100644
index 87e51851..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_aggregator.h
+++ /dev/null
@@ -1,63 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_AGGREGATE_API_H_
-#define PTI_PC_SAMPLING_AGGREGATE_API_H_
-
-#include <level_zero/zet_api.h>
-
-#include <cstdint>
-#include <unordered_map>
-#include <vector>
-
-#include "pti/pti_pc_sampling.h"
-#include "pti_pc_sampling_raw_data_file.h"
-
-namespace pti::pc_sampling {
-
-/**
- * @brief File-backed aggregate for a single observed kernel.
- */
-struct KernelAggregate {
-  uint64_t kernel_handle = 0;               /**< Unique kernel identifier (== base_address) */
-  const char* kernel_name_ = nullptr;       /**< PTI-owned kernel name valid until teardown */
-  size_t reason_count = 0;                  /**< Number of persisted stall reasons */
-  size_t instruction_count = 0;             /**< Number of persisted instructions */
-  std::vector<uint64_t> aggregated_samples; /**< In-memory aggregated samples per stall reason */
-  TempRawDataFile samples_file;             /**< Instruction offsets + flattened sample rows */
-};
-
-/**
- * @brief Aggregated results for the single profiled device.
- */
-struct DeviceAggregate {
-  pti_pc_sampling_device_status_t status{};              /**< Device-level totals */
-  std::unordered_map<uint64_t, KernelAggregate> kernels; /**< kernel_handle -> aggregate */
-
-  void Clear() {
-    status = pti_pc_sampling_device_status_t{};
-    kernels.clear();
-  }
-};
-
-/**
- * @brief Reads the spilled raw data and folds it into a compact
- * per-kernel/per-instruction aggregate for the single profiled device.
- *
- * - ip_metric_index: index of the "IP" metric within the metric report.
- * - reason_count: number of stall reasons. Total metric count is reason_count + 1.
- *
- * PCs that do not map to a tracked kernel are dropped (not stored); the dropped
- * sample/PC counts are logged. Device totals reflect mapped samples only.
- */
-pti_result AggregateCollectedData(pti_device_handle_t device,
-                                  zet_metric_group_handle_t metric_group, bool samples_dropped,
-                                  const TempRawDataFile& raw_data, size_t ip_metric_index,
-                                  size_t reason_count, DeviceAggregate* device_aggregate);
-
-}  // namespace pti::pc_sampling
-
-#endif  // PTI_PC_SAMPLING_AGGREGATE_API_H_
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_collector.cc b/sdk/src/pc_sampling/pti_pc_sampling_collector.cc
deleted file mode 100644
index 8dfe427f..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_collector.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pc_sampling/pti_pc_sampling_collector.h"
-
-#include <spdlog/spdlog.h>
-
-#include <chrono>
-#include <exception>
-#include <mutex>
-#include <thread>
-#include <vector>
-
-#include "pc_sampling/pti_pc_sampling_internal.h"
-
-namespace pti::pc_sampling {
-
-PtiPcSamplingDataCollector::PtiPcSamplingDataCollector(
-    pti_device_handle_t device, ze_driver_handle_t driver, zet_metric_group_handle_t metric_group,
-    TempRawDataFile& raw_data, bool& samples_dropped, size_t collection_buffer_size)
-    : device_(device),
-      driver_(driver),
-      metric_group_(metric_group),
-      raw_data_(raw_data),
-      samples_dropped_(samples_dropped),
-      collection_buffer_size_(collection_buffer_size) {}
-
-pti_result PtiPcSamplingDataCollector::Start(uint32_t sampling_period_ns) {
-  constexpr auto kStartTimeout = std::chrono::seconds(5);
-
-  const auto cleanup_start_failure = [this] {
-    raw_data_.Reset();
-    handles_.Reset();
-    state_.store(State::kIdle, std::memory_order_release);
-  };
-
-  State expected_state = State::kIdle;
-  if (!state_.compare_exchange_strong(expected_state, State::kStarting, std::memory_order_acq_rel,
-                                      std::memory_order_acquire)) {
-    SPDLOG_ERROR("{}: collector is not idle", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  samples_dropped_ = false;
-  handles_.Reset();
-  SPDLOG_INFO("{}: starting metric streamer with collection buffer size {} bytes", __FUNCTION__,
-              collection_buffer_size_);
-  try {
-    read_buffer_.resize(collection_buffer_size_);
-  } catch (const std::exception& e) {
-    SPDLOG_ERROR("{}: failed to allocate {} byte collection buffer: {}", __FUNCTION__,
-                 collection_buffer_size_, e.what());
-    cleanup_start_failure();
-    return PTI_ERROR_INTERNAL;
-  }
-  if (!CreateMetricStreamerContext(driver_, &handles_.context)) {
-    cleanup_start_failure();
-    return PTI_ERROR_INTERNAL;
-  }
-  if (!raw_data_.OpenTemp()) {
-    cleanup_start_failure();
-    return PTI_ERROR_INTERNAL;
-  }
-
-  thread_ = std::thread(&PtiPcSamplingDataCollector::StreamerThread, this, sampling_period_ns);
-
-  {
-    std::unique_lock<std::mutex> cv_lock(start_cv_mutex_);
-    const bool signaled = start_cv_.wait_for(cv_lock, kStartTimeout, [this] {
-      return state_.load(std::memory_order_acquire) != State::kStarting;
-    });
-
-    if (!signaled) {
-      state_.store(State::kStopRequested, std::memory_order_release);
-      thread_.join();
-      cleanup_start_failure();
-      return PTI_ERROR_INTERNAL;
-    }
-  }
-
-  if (state_.load(std::memory_order_acquire) == State::kError) {
-    thread_.join();
-    cleanup_start_failure();
-    return PTI_ERROR_INTERNAL;
-  }
-
-  return PTI_SUCCESS;
-}
-
-pti_result PtiPcSamplingDataCollector::Stop() {
-  if (!thread_.joinable()) {
-    return PTI_ERROR_INTERNAL;
-  }
-
-  state_.store(State::kStopRequested, std::memory_order_release);
-  // Joining the worker is the synchronization point before the control thread
-  // finalizes the handle-owned deferred raw-data spill file.
-  thread_.join();
-
-  const bool drain_succeeded =
-      handles_.streamer == nullptr || !raw_data_.IsOpen() ||
-      ReadMetricStreamerData(handles_.streamer, read_buffer_.data(), read_buffer_.size(),
-                             &raw_data_, &samples_dropped_, true);
-
-  const bool finalize_succeeded = raw_data_.Finalize();
-  if (!finalize_succeeded) {
-    SPDLOG_WARN("{}: failed to flush deferred raw data file", __FUNCTION__);
-  }
-
-  SPDLOG_DEBUG("{}: device={}, metric_group={}, raw_data_size={}, samples_dropped={}", __FUNCTION__,
-               static_cast<const void*>(device_), static_cast<const void*>(metric_group_),
-               raw_data_.size(), samples_dropped_);
-
-  handles_.Reset();
-  state_.store(State::kStopped, std::memory_order_release);
-
-  if (!drain_succeeded || !finalize_succeeded) {
-    return PTI_ERROR_INTERNAL;
-  }
-
-  if (raw_data_.size() == 0) {
-    SPDLOG_WARN(
-        "{}: no EU stall data received from device {}; likely the profiling window was too short. "
-        "Please try profiling longer or decrease the sampling period.",
-        __FUNCTION__, static_cast<const void*>(device_));
-    return PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED;
-  }
-  return PTI_SUCCESS;
-}
-
-bool PtiPcSamplingDataCollector::IsStopped() const {
-  return state_.load(std::memory_order_acquire) == State::kStopped;
-}
-
-void PtiPcSamplingDataCollector::StreamerThread(uint32_t sampling_period_ns) {
-  constexpr uint64_t kEventWaitTimeoutNs = 50'000'000;
-
-  if (state_.load(std::memory_order_acquire) != State::kStarting || handles_.context == nullptr) {
-    state_.store(State::kError, std::memory_order_release);
-    start_cv_.notify_one();
-    return;
-  }
-
-  if (!OpenMetricStreamer(
-          handles_.context, reinterpret_cast<ze_device_handle_t>(device_), metric_group_,
-          sampling_period_ns == 0 ? kDefaultSamplingPeriodNs : sampling_period_ns, &handles_)) {
-    state_.store(State::kError, std::memory_order_release);
-    start_cv_.notify_one();
-    return;
-  }
-
-  state_.store(State::kRunning, std::memory_order_release);
-  start_cv_.notify_one();
-
-  while (state_.load(std::memory_order_acquire) != State::kStopRequested) {
-    WaitForMetricStreamerReport(handles_.event, kEventWaitTimeoutNs);
-    ReadMetricStreamerData(handles_.streamer, read_buffer_.data(), read_buffer_.size(), &raw_data_,
-                           &samples_dropped_, false);
-  }
-}
-
-}  // namespace pti::pc_sampling
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_collector.h b/sdk/src/pc_sampling/pti_pc_sampling_collector.h
deleted file mode 100644
index 370f5601..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_collector.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_COLLECTOR_H_
-#define PTI_PC_SAMPLING_COLLECTOR_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-
-#include <atomic>
-#include <condition_variable>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "pc_sampling/pti_pc_sampling_l0.h"
-#include "pc_sampling/pti_pc_sampling_raw_data_file.h"
-#include "pti/pti_pc_sampling.h"
-
-namespace pti::pc_sampling {
-
-class PtiPcSamplingDataCollector {
- public:
-  PtiPcSamplingDataCollector(pti_device_handle_t device, ze_driver_handle_t driver,
-                             zet_metric_group_handle_t metric_group, TempRawDataFile& raw_data,
-                             bool& samples_dropped, size_t collection_buffer_size);
-  ~PtiPcSamplingDataCollector() {
-    if (thread_.joinable()) {
-      state_.store(State::kStopRequested, std::memory_order_release);
-      thread_.join();
-    }
-
-    handles_.Reset();
-    state_.store(State::kIdle, std::memory_order_release);
-  }
-
-  PtiPcSamplingDataCollector(const PtiPcSamplingDataCollector&) = delete;
-  PtiPcSamplingDataCollector& operator=(const PtiPcSamplingDataCollector&) = delete;
-  PtiPcSamplingDataCollector(PtiPcSamplingDataCollector&&) = delete;
-  PtiPcSamplingDataCollector& operator=(PtiPcSamplingDataCollector&&) = delete;
-
-  pti_result Start(uint32_t sampling_period_ns);
-  pti_result Stop();
-  bool IsStopped() const;
-
- private:
-  enum class State : uint32_t {
-    kIdle = 0,
-    kStarting = 1,
-    kRunning = 2,
-    kStopRequested = 3,
-    kStopped = 4,
-    kError = 5,
-    kForceUint32 = 0x7fffffff,
-  };
-
-  void StreamerThread(uint32_t sampling_period_ns);
-
-  std::mutex start_cv_mutex_;
-  std::condition_variable start_cv_;
-  std::atomic<State> state_{State::kIdle};
-  std::thread thread_;
-
-  pti_device_handle_t device_ = nullptr;
-  ze_driver_handle_t driver_ = nullptr;
-  zet_metric_group_handle_t metric_group_ = nullptr;
-
-  MetricStreamerHandles handles_;
-  TempRawDataFile& raw_data_;
-  bool& samples_dropped_;
-  size_t collection_buffer_size_;
-  // Allocated in Start() so allocation failures are reported before the worker starts.
-  std::vector<uint8_t> read_buffer_;
-};
-
-}  // namespace pti::pc_sampling
-
-#endif  // PTI_PC_SAMPLING_COLLECTOR_H_
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_internal.h b/sdk/src/pc_sampling/pti_pc_sampling_internal.h
deleted file mode 100644
index 32050f8b..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_internal.h
+++ /dev/null
@@ -1,1147 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Internal implementation details for PC Sampling feature.
-// This header provides:
-//   - State machine for PC sampling collection lifecycle
-//   - Handle storage and validation utilities
-//   - Kernel callback infrastructure to track kernel binary info
-//
-// Note: This is an internal header and should not be included by users.
-//
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_INTERNAL_H_
-#define PTI_PC_SAMPLING_INTERNAL_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <charconv>
-#include <cstring>
-#include <iterator>
-#include <limits>
-#include <memory>
-#include <new>
-#include <optional>
-#include <shared_mutex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "lz_api_tracing_api_loader.h"
-#include "pti/pti_callback.h"
-#include "pti/pti_metrics.h"
-#include "pti/pti_pc_sampling.h"
-#include "pti_pc_sampling_aggregator.h"
-#include "pti_pc_sampling_collector.h"
-#include "pti_pc_sampling_l0.h"
-#include "pti_pc_sampling_raw_data_file.h"
-#include "utils/pti_string_pool.h"
-#include "utils/utils.h"
-
-namespace pti::pc_sampling {
-
-//-----------------------------------------------------------------------------
-// Constants
-//-----------------------------------------------------------------------------
-
-constexpr uint32_t kDefaultSamplingPeriodNs = 100'000;
-constexpr char kCollectionBufferSizeEnv[] = "PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE";
-// Level Zero raw reports are 64 bytes, so buffers must contain whole reports.
-constexpr size_t kEuStallSamplingRawReportSize = 64;
-constexpr size_t kDefaultCollectionBufferSize = 4 * 1024;
-constexpr size_t kMinCollectionBufferSize = kEuStallSamplingRawReportSize;
-constexpr size_t kMaxCollectionBufferSize = 64 * 1024 * 1024;
-
-//-----------------------------------------------------------------------------
-// Enumerations
-//-----------------------------------------------------------------------------
-
-/**
- * @brief State machine for PC sampling collection lifecycle.
- *
- * Valid transitions:
- *   ENABLED     -> CONFIGURED (via Configure; optional)
- *   ENABLED     -> CONFIGURED (via StartCollection, which applies the default configuration
- *                              when Configure was not called)
- *   CONFIGURED  -> STARTED    (via StartCollection)
- *   STARTED     -> STOPPED    (via StopCollection)
- */
-enum class PcSamplingState : uint32_t {
-  kEnabled = 0,    /**< Handle created but not configured yet */
-  kConfigured = 1, /**< Configuration accepted; collection not started */
-  kStarted = 2,    /**< Collection is currently running */
-  kStopped = 3,    /**< Collection stopped; query APIs now valid */
-  kForceUint32 = 0x7fffffff,
-};
-
-//-----------------------------------------------------------------------------
-// Data Structures
-//-----------------------------------------------------------------------------
-
-class PtiPcSamplingDataCollector;
-
-/**
- * @brief Information about a kernel binary collected during kernel creation callback.
- *
- * Used to correlate PC samples with kernel source code.
- */
-struct KernelBinaryInfo {
-  uint64_t kernel_base_address_ = 0;             /**< Base address of kernel in device memory */
-  size_t kernel_binary_size_ = 0;                /**< Size of the kernel binary in bytes */
-  const char* kernel_name_ = nullptr;            /**< PTI-owned name valid until teardown */
-  pti_backend_kernel_t kernel_handle_ = nullptr; /**< Device kernel handle */
-  pti_backend_module_t module_handle_ = nullptr; /**< Module handle containing this kernel */
-  pti_device_handle_t device_handle_ = nullptr; /**< Device handle this kernel is associated with */
-};
-
-//-----------------------------------------------------------------------------
-// Utility Functions
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Convert PC sampling state to human-readable string.
- *
- * @param[in] state   The state to convert
- *
- * @return String representation of the state
- */
-inline const char* PcSamplingStateToString(PcSamplingState state) {
-  switch (state) {
-    case PcSamplingState::kEnabled:
-      return "ENABLED";
-    case PcSamplingState::kConfigured:
-      return "CONFIGURED";
-    case PcSamplingState::kStarted:
-      return "STARTED";
-    case PcSamplingState::kStopped:
-      return "STOPPED";
-    case PcSamplingState::kForceUint32:
-      return "FORCE_UINT32";
-  }
-  return "UNKNOWN";
-}
-
-/**
- * @brief Convert an EuStallSampling IP value into a byte address.
- *
- * EuStallSampling reports instruction pointers as 29 or 61 bit values.
- * They need to be shifted by 3 to align with kernel base address.
- * See e.g.:
- * https://github.com/intel/compute-runtime/blob/master/level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_xe2_hpg_xe3.inl
- */
-inline uint64_t NormalizeInstructionPointer(uint64_t instruction_pointer) {
-  constexpr uint32_t kEuStallSamplingIpShift = 3;
-  return (instruction_pointer << kEuStallSamplingIpShift);
-}
-
-/**
- * @brief Normalize a kernel base address into the EuStallSampling address domain.
- *
- * Kernel addresses returned by zexKernelGetBaseAddress may be 64-bit, while EuStallSampling reports
- * IPs in 29 or 61 bits. This function uses the device IP version to determine whether to truncate
- * the kernel base address to 32 bits for comparison with sampled IPs. See e.g.:
- * https://github.com/intel/compute-runtime/blob/master/shared/source/xe2_hpg_core/hw_info_bmg.cpp
- *
- * TODO: Make a proper check for the device IP version to determine if truncation is needed. For
- * now, we assume that if the device IP version is less than 7.0, we truncate to 32 bits.
- */
-inline uint64_t NormalizeKernelAddress(uint64_t kernel_address) {
-  constexpr uint64_t kInstructionPointerAddressMask = 0xFFFFFFFFull;
-  return kernel_address & kInstructionPointerAddressMask;
-}
-
-}  // namespace pti::pc_sampling
-
-//-----------------------------------------------------------------------------
-// External Handle Structure (C API compatibility)
-//-----------------------------------------------------------------------------
-
-/**
- * @brief PC sampling handle structure exposed through the C API.
- *
- * Contains the state machine and configuration for a sampling session.
- */
-struct _pti_pc_sampling_handle_t {
-  pti::pc_sampling::PcSamplingState state_ = pti::pc_sampling::PcSamplingState::kEnabled;
-  uint32_t sampling_period_ns_ = pti::pc_sampling::kDefaultSamplingPeriodNs;
-  // Set through ptiPcSamplingSetCollectionBufferSize; a valid
-  // PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE environment value takes precedence.
-  size_t collection_buffer_size_ = pti::pc_sampling::kDefaultCollectionBufferSize;
-  // Snapshot of the effective size used by the successfully started collection.
-  std::optional<size_t> started_collection_buffer_size_;
-  std::unordered_map<pti_device_handle_t, zet_metric_group_handle_t>
-      supported_device_metric_group_map_;
-  // Supported devices in Level Zero discovery order (zeDriverGet/zeDeviceGet).
-  // Used to pick a deterministic profiling device that matches the one the
-  // runtime (e.g. SYCL gpu_selector) executes kernels on.
-  std::vector<pti_device_handle_t> supported_devices_;
-  std::vector<pti_device_handle_t> configured_devices_;
-  zet_metric_group_handle_t collected_metric_group_ = nullptr;
-  pti::pc_sampling::TempRawDataFile collected_raw_data_;
-  bool samples_dropped_ = false;
-  std::unique_ptr<pti::pc_sampling::PtiPcSamplingDataCollector> collector;
-
-  // Lazily-computed, cached results. Built once on the first results query that
-  // needs them and reused for all subsequent queries (no recalculation).
-  bool aggregated_ = false;
-  pti::pc_sampling::DeviceAggregate device_aggregate_;
-  // Stall reasons in metric-group order, pooled so the pointers stay alive for
-  // the API caller. Size is the stall-reason count (IP metric excluded).
-  std::vector<std::pair<const char*, const char*>> stall_reasons_;
-  std::optional<size_t> ip_metric_index_;
-};
-
-namespace pti::pc_sampling {
-
-inline bool IsValidCollectionBufferSize(size_t buffer_size) {
-  return buffer_size >= kMinCollectionBufferSize && buffer_size <= kMaxCollectionBufferSize &&
-         buffer_size % kEuStallSamplingRawReportSize == 0;
-}
-
-inline std::optional<size_t> GetEnvironmentCollectionBufferSize() {
-  const std::string env_value = ::utils::GetEnv(kCollectionBufferSizeEnv);
-  if (env_value.empty()) {
-    return std::nullopt;
-  }
-
-  size_t buffer_size = 0;
-  const char* const end = env_value.data() + env_value.size();
-  const auto [parsed_end, error] = std::from_chars(env_value.data(), end, buffer_size);
-  if (error != std::errc{} || parsed_end != end || !IsValidCollectionBufferSize(buffer_size)) {
-    SPDLOG_WARN("{}: ignoring invalid {} value '{}'; expected a multiple of {} bytes in [{}, {}]",
-                __FUNCTION__, kCollectionBufferSizeEnv, env_value, kEuStallSamplingRawReportSize,
-                kMinCollectionBufferSize, kMaxCollectionBufferSize);
-    return std::nullopt;
-  }
-
-  return buffer_size;
-}
-
-inline size_t GetCollectionBufferSize(const pti_pc_sampling_handle_t handle) {
-  if (handle->started_collection_buffer_size_.has_value()) {
-    return *handle->started_collection_buffer_size_;
-  }
-
-  const std::optional<size_t> environment_size = GetEnvironmentCollectionBufferSize();
-  if (environment_size.has_value()) {
-    SPDLOG_INFO("{}: using environment collection buffer size {}", __FUNCTION__, *environment_size);
-    return *environment_size;
-  }
-  return handle->collection_buffer_size_;
-}
-
-inline void ClearProfiledDeviceData(pti_pc_sampling_handle_t handle) {
-  if (handle == nullptr) {
-    return;
-  }
-
-  handle->collected_metric_group_ = nullptr;
-  handle->collected_raw_data_.Reset();
-  handle->samples_dropped_ = false;
-  handle->collector.reset();
-  handle->aggregated_ = false;
-  handle->device_aggregate_.Clear();
-  handle->stall_reasons_.clear();
-  handle->ip_metric_index_.reset();
-}
-
-inline pti_result GetConfiguredDevice(const pti_pc_sampling_handle_t handle,
-                                      pti_device_handle_t* device) {
-  if (handle == nullptr || device == nullptr) {
-    SPDLOG_ERROR("{}: handle or output device pointer is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (handle->configured_devices_.empty()) {
-    SPDLOG_WARN("{}: no configured device is available on the handle", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  *device = handle->configured_devices_.front();
-  return PTI_SUCCESS;
-}
-
-inline StringPool& GetPcSamplingStringPool() {
-  static StringPool string_pool;
-  return string_pool;
-}
-
-inline const char* ResolveKernelName(ze_kernel_handle_t kernel_handle) {
-  static constexpr char kUnknownKernelName[] = "<unknown>";
-
-  if (kernel_handle == nullptr) {
-    SPDLOG_ERROR("{}: kernel_handle is null, returning {}", __FUNCTION__, kUnknownKernelName);
-    return kUnknownKernelName;
-  }
-
-  std::string demangled_name = ::utils::ze::GetKernelName(kernel_handle, true);
-
-  if (demangled_name.empty()) {
-    SPDLOG_WARN("{}: failed to resolve kernel name, returning {}", __FUNCTION__,
-                kUnknownKernelName);
-    return kUnknownKernelName;
-  }
-
-  return GetPcSamplingStringPool().Get(demangled_name);
-}
-
-//-----------------------------------------------------------------------------
-// Kernel Info Storage (Thread-Safe)
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Thread-safe storage for kernel binary information.
- *
- * Collects kernel metadata during kernel creation callbacks.
- */
-class KernelInfoStorage {
- public:
-  /**
-   * @brief Get the singleton instance.
-   */
-  static KernelInfoStorage& Instance() {
-    static KernelInfoStorage instance;
-    return instance;
-  }
-
-  /**
-   * @brief Add kernel information to the storage.
-   *
-   * Thread-safe: uses write lock.
-   *
-   * @param[in] info   The kernel binary info to store
-   */
-  void Add(KernelBinaryInfo info) {
-    std::lock_guard<std::shared_mutex> lock(mutex_);
-    // Use kernel base address as key since it's guaranteed unique
-    auto key = static_cast<uintptr_t>(info.kernel_base_address_);
-    kernel_info_map_[key] = std::make_unique<KernelBinaryInfo>(std::move(info));
-  }
-
-  /**
-   * @brief Find kernel info by ip address.
-   *
-   * Thread-safe: uses read lock. The returned pointer remains valid until
-   * Clear() is called (typically at ptiPcSamplingDisable).
-   *
-   * @param[in] ip_address   The instruction pointer address to search for
-   *
-   * @return Pointer to info if found, nullptr otherwise
-   */
-  const KernelBinaryInfo* FindByIpAddress(uint64_t ip_address) const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
-    for (const auto& [key, info_ptr] : kernel_info_map_) {
-      if (info_ptr->kernel_base_address_ <= ip_address &&
-          ip_address < info_ptr->kernel_base_address_ + info_ptr->kernel_binary_size_) {
-        return info_ptr.get();
-      }
-    }
-    return nullptr;
-  }
-
-  /**
-   * @brief Get the number of stored kernel infos.
-   */
-  size_t Size() const {
-    std::shared_lock<std::shared_mutex> lock(mutex_);
-    return kernel_info_map_.size();
-  }
-
-  /**
-   * @brief Clear all stored kernel information.
-   */
-  void Clear() {
-    std::lock_guard<std::shared_mutex> lock(mutex_);
-    kernel_info_map_.clear();
-  }
-
- private:
-  KernelInfoStorage() = default;
-  ~KernelInfoStorage() = default;
-  KernelInfoStorage(const KernelInfoStorage&) = delete;
-  KernelInfoStorage& operator=(const KernelInfoStorage&) = delete;
-
-  mutable std::shared_mutex mutex_;
-  std::unordered_map<uintptr_t, std::unique_ptr<KernelBinaryInfo>> kernel_info_map_;
-};
-
-//-----------------------------------------------------------------------------
-// Kernel Callback Implementation
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Callback function invoked when a kernel is created.
- *
- * Extracts kernel binary information (base address, module size, name)
- * and stores it for later correlation with PC samples.
- *
- * @param[in] domain              Callback domain (must be PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED)
- * @param[in] api_group           API group identifier (unused)
- * @param[in] api_id              API identifier (unused)
- * @param[in] ctx                 Backend context (unused)
- * @param[in] cb_data             Callback data, must be cast to pti_callback_kernel_data*
- * @param[in] user_data           User data passed during subscription (unused)
- * @param[in] instance_user_data  Per-instance user data (unused)
- */
-inline void KernelCreatedCallback(pti_callback_domain domain, pti_api_group_id /*api_group*/,
-                                  uint32_t /*api_id*/, pti_backend_ctx_t /*ctx*/, void* cb_data,
-                                  void* /*user_data*/, void** /*instance_user_data*/) {
-  // Filter for kernel created domain only
-  if (domain != PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED) {
-    return;
-  }
-
-  auto* data = static_cast<pti_callback_kernel_data*>(cb_data);
-  if (data == nullptr) {
-    SPDLOG_ERROR("{}: callback data is null", __FUNCTION__);
-    return;
-  }
-
-  // Only process EXIT phase where the kernel handle is valid and call succeeded
-  if (data->_phase != PTI_CB_PHASE_API_EXIT || data->_return_code != ZE_RESULT_SUCCESS) {
-    return;
-  }
-
-  // Initialize kernel info with data from callback
-  KernelBinaryInfo kernel_info;
-  kernel_info.kernel_handle_ = data->_device_kernel_handle;
-  kernel_info.module_handle_ = data->_module_handle;
-  kernel_info.device_handle_ = data->_device_handle;
-  const auto kernel_handle = reinterpret_cast<ze_kernel_handle_t>(data->_device_kernel_handle);
-  kernel_info.kernel_name_ = ResolveKernelName(kernel_handle);
-
-  SPDLOG_DEBUG("{}: kernel created - handle: {}, name: {}, module: {}, device: {}", __FUNCTION__,
-               static_cast<void*>(data->_device_kernel_handle), kernel_info.kernel_name_,
-               static_cast<void*>(data->_module_handle), static_cast<void*>(data->_device_handle));
-
-  // Query kernel base address using extension function
-  if (kernel_handle != nullptr) {
-    using ZexKernelGetBaseAddressFn = ze_result_t (*)(ze_kernel_handle_t, uint64_t*);
-
-    // Initialize extension function pointer only once (thread-safe in C++11+)
-    static ZexKernelGetBaseAddressFn get_base_addr = []() -> ZexKernelGetBaseAddressFn {
-      ze_driver_handle_t driver = nullptr;
-      uint32_t count = 1;
-      if (zeDriverGet(&count, &driver) != ZE_RESULT_SUCCESS || driver == nullptr) {
-        SPDLOG_WARN("KernelCreatedCallback: Failed to get driver handle");
-        return nullptr;
-      }
-
-      ZexKernelGetBaseAddressFn fn = nullptr;
-      ze_result_t status = zeDriverGetExtensionFunctionAddress(driver, "zexKernelGetBaseAddress",
-                                                               reinterpret_cast<void**>(&fn));
-
-      if (status != ZE_RESULT_SUCCESS || fn == nullptr) {
-        SPDLOG_WARN("KernelCreatedCallback: zexKernelGetBaseAddress extension not available");
-        return nullptr;
-      }
-      return fn;
-    }();
-
-    if (get_base_addr != nullptr) {
-      uint64_t base_address = 0;
-      ze_result_t status = get_base_addr(kernel_handle, &base_address);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_WARN("{}: zexKernelGetBaseAddress failed with status {:#x}", __FUNCTION__,
-                    static_cast<uint32_t>(status));
-      } else {
-        kernel_info.kernel_base_address_ = NormalizeKernelAddress(base_address);
-        SPDLOG_DEBUG("{}: kernel base address {:#x} for '{}'", __FUNCTION__, base_address,
-                     kernel_info.kernel_name_);
-      }
-    } else {
-      SPDLOG_WARN("{}: zexKernelGetBaseAddress extension not available, skipping kernel '{}'",
-                  __FUNCTION__, kernel_info.kernel_name_);
-    }
-
-    size_t kernel_size = 0;
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    auto* ze_kernel_get_binary_exp = pti::PtiLzTracerLoader::Instance().zeKernelGetBinaryExp_;
-    if (ze_kernel_get_binary_exp) {
-      status = ze_kernel_get_binary_exp(kernel_handle, &kernel_size, nullptr);
-    } else {
-      status = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_DEBUG("{}: zeKernelGetBinaryExp failed with status {:#x}", __FUNCTION__,
-                   static_cast<uint32_t>(status));
-    } else {
-      kernel_info.kernel_binary_size_ = kernel_size;
-    }
-  }
-
-  // Store the kernel info for later use
-  KernelInfoStorage::Instance().Add(std::move(kernel_info));
-}
-
-//-----------------------------------------------------------------------------
-// Handle Storage and Management
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Singleton storage for PC sampling handle.
- *
- * Ensures only one PC sampling session is active at a time.
- * Manages the lifecycle of the sampling handle and callback subscriptions.
- */
-class PtiPcSamplingHandleStorage {
- public:
-  /**
-   * @brief Get the singleton instance.
-   */
-  static PtiPcSamplingHandleStorage& Instance() {
-    static PtiPcSamplingHandleStorage storage;
-    return storage;
-  }
-
-  /**
-   * @brief Check if the given handle is the currently active handle.
-   *
-   * @param[in] handle   Handle to check
-   *
-   * @return true if handle matches the active handle
-   */
-  bool Contains(pti_pc_sampling_handle_t handle) const {
-    return handle_ != nullptr && handle_.get() == handle;
-  }
-
-  /**
-   * @brief Create a new PC sampling handle.
-   *
-   * Fails if a handle already exists or no compatible devices found.
-   *
-   * @param[out] handle   Pointer to receive the new handle
-   *
-   * @return PTI_SUCCESS or appropriate error code
-   */
-  pti_result Create(pti_pc_sampling_handle_t* handle) {
-    if (handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (handle_ != nullptr) {
-      SPDLOG_ERROR("{}: only one PC sampling handle can be enabled at a time", __FUNCTION__);
-      return PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED;
-    }
-
-    std::unordered_map<pti_device_handle_t, ze_driver_handle_t> supported_device_driver_map;
-    std::unordered_map<pti_device_handle_t, zet_metric_group_handle_t>
-        supported_device_metric_group_map;
-    std::vector<pti_device_handle_t> supported_devices_ordered;
-
-    // Initialize Level Zero (idempotent if already initialized) and enumerate
-    // drivers/devices through the shared utils so this stays in sync with the
-    // rest of the SDK. Driver enumeration uses zeDriverGet (via GetDriverList)
-    // to match the handles the SYCL runtime collects on.
-    ZeDriverInit init_drivers{};
-    if (!init_drivers.Success()) {
-      SPDLOG_ERROR("{}: failed to initialize Level Zero", __FUNCTION__);
-      return PTI_ERROR_PC_SAMPLING_UNSUPPORTED;
-    }
-
-    pti_result metric_status = ptiMetricsEnable(nullptr);
-    if (metric_status != PTI_SUCCESS) {
-      SPDLOG_ERROR("{}: Failed to enable metrics: {}", __FUNCTION__,
-                   ptiResultTypeToString(metric_status));
-      return metric_status;
-    }
-
-    for (ze_driver_handle_t driver : ::utils::ze::GetDriverList()) {
-      for (ze_device_handle_t device : ::utils::ze::GetDeviceList(driver)) {
-        ze_device_properties_t props{};
-        props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-
-        ze_result_t status = zeDeviceGetProperties(device, &props);
-        if (status != ZE_RESULT_SUCCESS) {
-          SPDLOG_ERROR("{}: zeDeviceGetProperties failed, status: {:#x}", __FUNCTION__,
-                       static_cast<uint32_t>(status));
-          continue;
-        }
-
-        if (props.type != ZE_DEVICE_TYPE_GPU) {
-          continue;
-        }
-
-        zet_metric_group_handle_t metric_group = FindEUStallMetricGroupHandle(device);
-        if (metric_group == nullptr) {
-          continue;
-        }
-
-        supported_device_driver_map.emplace(reinterpret_cast<pti_device_handle_t>(device), driver);
-        supported_device_metric_group_map.emplace(reinterpret_cast<pti_device_handle_t>(device),
-                                                  metric_group);
-        supported_devices_ordered.push_back(reinterpret_cast<pti_device_handle_t>(device));
-      }
-    }
-
-    if (supported_device_metric_group_map.empty()) {
-#ifndef _WIN32
-      SPDLOG_ERROR(
-          "{}: no devices supporting PC Sampling found.\n"
-          "Set the applicable Intel GPU driver paranoid mode to 0:\n"
-          "  i915: /proc/sys/dev/i915/perf_stream_paranoid\n"
-          "  xe:   /proc/sys/dev/xe/observation_paranoid\n"
-          "Also ensure that the installed Linux kernel and Intel GPU drivers support\n"
-          "EuStallSampling. The latest available driver versions are recommended.",
-          __FUNCTION__);
-#else
-      SPDLOG_ERROR(
-          "{}: no devices supporting PC Sampling found.\n"
-          "Ensure that the installed Intel GPU drivers support\n"
-          "EuStallSampling. The latest available driver versions are recommended.",
-          __FUNCTION__);
-#endif /* _WIN32 */
-      ptiMetricsDisable(nullptr);
-      return PTI_ERROR_PC_SAMPLING_UNSUPPORTED;
-    }
-
-    // Allocate the handle
-    auto collection_handle =
-        std::unique_ptr<_pti_pc_sampling_handle_t>(new (std::nothrow) _pti_pc_sampling_handle_t());
-    if (collection_handle == nullptr) {
-      ptiMetricsDisable(nullptr);
-      return PTI_ERROR_INTERNAL;
-    }
-
-    {
-      std::lock_guard lock(device_metric_group_map_mutex_);
-      device_driver_map_ = std::move(supported_device_driver_map);
-    }
-    collection_handle->supported_device_metric_group_map_ =
-        std::move(supported_device_metric_group_map);
-    collection_handle->supported_devices_ = std::move(supported_devices_ordered);
-
-    pti_pc_sampling_handle_t new_handle = collection_handle.get();
-    handle_ = std::move(collection_handle);
-
-    // Subscribe to kernel creation callbacks to track kernel binary info
-    pti_result callback_result =
-        ptiCallbackSubscribe(&callback_subscriber_, &KernelCreatedCallback, nullptr);
-    if (callback_result != PTI_SUCCESS) {
-      SPDLOG_ERROR("{}: ptiCallbackSubscribe failed with result {}", __FUNCTION__,
-                   static_cast<uint32_t>(callback_result));
-      handle_.reset();
-      ptiMetricsDisable(nullptr);
-      return callback_result;
-    }
-
-    // Enable the kernel created domain (EXIT phase only)
-    callback_result =
-        ptiCallbackEnableDomain(callback_subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED,
-                                0,   // api_enter = false
-                                1);  // api_exit = true
-    if (callback_result != PTI_SUCCESS) {
-      SPDLOG_ERROR("{}: ptiCallbackEnableDomain failed with result {}", __FUNCTION__,
-                   static_cast<uint32_t>(callback_result));
-      ptiCallbackUnsubscribe(callback_subscriber_);
-      callback_subscriber_ = nullptr;
-      handle_.reset();
-      ptiMetricsDisable(nullptr);
-      return callback_result;
-    }
-
-    *handle = new_handle;
-    return PTI_SUCCESS;
-  }
-
-  /**
-   * @brief Destroy the PC sampling handle and release all resources.
-   *
-   * @param[in] handle   Handle to destroy
-   *
-   * @return PTI_SUCCESS or appropriate error code
-   */
-  pti_result Destroy(pti_pc_sampling_handle_t handle) {
-    if (handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (handle_ == nullptr || handle_.get() != handle) {
-      SPDLOG_ERROR("{}: there is no active PC sampling handle", __FUNCTION__);
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    pti_result result = PTI_SUCCESS;
-    // Cleanup callback subscription
-    if (callback_subscriber_ != nullptr) {
-      result = ptiCallbackDisableDomain(callback_subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_ERROR("{}: ptiCallbackDisableDomain failed with result {}", __FUNCTION__,
-                     static_cast<uint32_t>(result));
-      }
-      result = ptiCallbackUnsubscribe(callback_subscriber_);
-      if (result != PTI_SUCCESS) {
-        SPDLOG_ERROR("{}: ptiCallbackUnsubscribe failed with result {}", __FUNCTION__,
-                     static_cast<uint32_t>(result));
-      }
-      callback_subscriber_ = nullptr;
-    }
-
-    // Clear kernel info storage
-    KernelInfoStorage::Instance().Clear();
-
-    {
-      std::lock_guard lock(device_metric_group_map_mutex_);
-      handle_->supported_device_metric_group_map_.clear();
-      device_driver_map_.clear();
-    }
-
-    handle_.reset();
-    return result;
-  }
-
-  ze_driver_handle_t GetDriver(pti_device_handle_t device) const {
-    std::shared_lock lock(device_metric_group_map_mutex_);
-    auto it = device_driver_map_.find(device);
-    return (it != device_driver_map_.end()) ? it->second : nullptr;
-  }
-
-  /**
-   * @brief Get the metric group handle for a device.
-   *
-   * @param[in] device   Device handle
-   *
-   * @return Metric group handle or nullptr if not found
-   */
-  zet_metric_group_handle_t GetMetricGroup(pti_device_handle_t device) const {
-    std::shared_lock lock(device_metric_group_map_mutex_);
-    if (handle_ == nullptr) {
-      return nullptr;
-    }
-
-    auto it = handle_->supported_device_metric_group_map_.find(device);
-    return (it != handle_->supported_device_metric_group_map_.end()) ? it->second : nullptr;
-  }
-
-  bool IsSupported(pti_device_handle_t device) const {
-    std::shared_lock lock(device_metric_group_map_mutex_);
-    return handle_ != nullptr && handle_->supported_device_metric_group_map_.find(device) !=
-                                     handle_->supported_device_metric_group_map_.end();
-  }
-
-  std::vector<pti_device_handle_t> GetSupportedDevices() const {
-    std::shared_lock lock(device_metric_group_map_mutex_);
-    if (handle_ == nullptr) {
-      return {};
-    }
-    return handle_->supported_devices_;
-  }
-
- private:
-  PtiPcSamplingHandleStorage() = default;
-  ~PtiPcSamplingHandleStorage() = default;
-  PtiPcSamplingHandleStorage(const PtiPcSamplingHandleStorage&) = delete;
-  PtiPcSamplingHandleStorage& operator=(const PtiPcSamplingHandleStorage&) = delete;
-
-  std::unique_ptr<_pti_pc_sampling_handle_t> handle_;
-  pti_callback_subscriber_handle callback_subscriber_ = nullptr;
-  mutable std::shared_mutex device_metric_group_map_mutex_;
-  std::unordered_map<pti_device_handle_t, ze_driver_handle_t> device_driver_map_;
-};
-
-inline zet_metric_group_handle_t ResolveCollectedMetricGroup(
-    const pti_pc_sampling_handle_t handle, pti_device_handle_t configured_device) {
-  if (handle->collected_metric_group_ != nullptr) {
-    return handle->collected_metric_group_;
-  }
-
-  return PtiPcSamplingHandleStorage::Instance().GetMetricGroup(configured_device);
-}
-
-//-----------------------------------------------------------------------------
-// Handle Validation Utilities
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Check if the handle belongs to this module.
- */
-inline bool IsOurHandle(pti_pc_sampling_handle_t handle) {
-  return PtiPcSamplingHandleStorage::Instance().Contains(handle);
-}
-
-inline bool IsPCSamplingSupportedDevice(pti_device_handle_t device) {
-  return PtiPcSamplingHandleStorage::Instance().IsSupported(device);
-}
-
-inline std::vector<pti_device_handle_t> GetAllSupportedDevices() {
-  return PtiPcSamplingHandleStorage::Instance().GetSupportedDevices();
-}
-
-/**
- * @brief Resolve the device filter and sampling period onto an enabled handle.
- *
- * Shared by the explicit ptiPcSamplingConfigure path and by the implicit default
- * configuration ptiPcSamplingStartCollection applies when Configure was skipped.
- * The caller is responsible for validating the handle and its state; on success
- * the handle moves to the CONFIGURED state.
- *
- * @param[in] handle               Enabled collection handle
- * @param[in] devices              Device filter; NULL selects the PTI-chosen device(s)
- * @param[in] device_count         Number of entries in devices; ignored when devices is NULL
- * @param[in] sampling_period_ns   Sampling period in nanoseconds; 0 selects the default period
- *
- * @return PTI_SUCCESS or appropriate error code
- */
-inline pti_result ApplyConfiguration(pti_pc_sampling_handle_t handle,
-                                     const pti_device_handle_t* devices, size_t device_count,
-                                     uint32_t sampling_period_ns) {
-  if (devices != nullptr && device_count == 0) {
-    SPDLOG_ERROR(
-        "{}: Invalid PC sampling configuration parameters passed, devices = {} device_count = {}",
-        __FUNCTION__, static_cast<const void*>(devices), device_count);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  constexpr size_t kMaxProfiledDevicesPerSession = 1;
-
-  // Find out list of supported devices
-  handle->configured_devices_.clear();
-
-  if (devices == nullptr) {
-    // all supported devices will be profiled if no device filter is provided
-    auto supported_devices = GetAllSupportedDevices();
-    if (supported_devices.empty()) {
-      SPDLOG_ERROR("{}: No supported devices found for PC sampling", __FUNCTION__);
-      return PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL;
-    }
-    const size_t devices_to_copy =
-        (std::min)(supported_devices.size(), kMaxProfiledDevicesPerSession);
-    handle->configured_devices_.reserve(devices_to_copy);
-    std::copy_n(supported_devices.begin(), devices_to_copy,
-                std::back_inserter(handle->configured_devices_));
-  } else {
-    for (size_t i = 0; i < device_count; ++i) {
-      if (IsPCSamplingSupportedDevice(devices[i])) {
-        handle->configured_devices_.push_back(devices[i]);
-        if (handle->configured_devices_.size() >= kMaxProfiledDevicesPerSession) {
-          break;
-        }
-      } else {
-        SPDLOG_WARN("{}: device {} does not support PC sampling and will be ignored", __FUNCTION__,
-                    static_cast<const void*>(devices[i]));
-      }
-    }
-  }
-
-  if (handle->configured_devices_.empty()) {
-    SPDLOG_ERROR("{}: None of the provided device(s) support PC sampling", __FUNCTION__);
-    return PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL;
-  }
-
-  handle->sampling_period_ns_ =
-      (sampling_period_ns == 0) ? kDefaultSamplingPeriodNs : sampling_period_ns;
-  handle->state_ = PcSamplingState::kConfigured;
-  return PTI_SUCCESS;
-}
-
-inline pti_result EnsureStallReasons(pti_pc_sampling_handle_t handle) {
-  if (handle == nullptr) {
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (handle->ip_metric_index_.has_value()) {
-    return PTI_SUCCESS;
-  }
-
-  pti_device_handle_t configured_device = nullptr;
-  if (GetConfiguredDevice(handle, &configured_device) != PTI_SUCCESS) {
-    configured_device =
-        handle->supported_devices_.empty() ? nullptr : handle->supported_devices_.front();
-  }
-  const zet_metric_group_handle_t metric_group =
-      ResolveCollectedMetricGroup(handle, configured_device);
-
-  if (metric_group == nullptr) {
-    // No collection happened; an empty reason table is valid.
-    handle->ip_metric_index_ = 0;
-    return PTI_SUCCESS;
-  }
-
-  auto [metric_names, ip_metric_index] = GetAllSupportedStallMetricNames(metric_group);
-  if (metric_names.empty()) {
-    handle->ip_metric_index_.reset();
-    handle->stall_reasons_.clear();
-    SPDLOG_ERROR("{}: failed to collect metric names", __FUNCTION__);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  std::vector<std::pair<const char*, const char*>> stall_reasons;
-  stall_reasons.reserve(metric_names.size());
-  for (const auto& [name, description] : metric_names) {
-    stall_reasons.emplace_back(GetPcSamplingStringPool().Get(name),
-                               GetPcSamplingStringPool().Get(description));
-  }
-
-  handle->stall_reasons_ = std::move(stall_reasons);
-  handle->ip_metric_index_ = ip_metric_index;
-
-  return PTI_SUCCESS;
-}
-
-inline pti_result EnsureAggregatedResults(pti_pc_sampling_handle_t handle) {
-  if (handle->aggregated_) {
-    return PTI_SUCCESS;
-  }
-
-  const pti_result reasons_status = EnsureStallReasons(handle);
-  if (reasons_status != PTI_SUCCESS) {
-    return reasons_status;
-  }
-
-  pti_device_handle_t configured_device = nullptr;
-  const pti_result configured_device_status = GetConfiguredDevice(handle, &configured_device);
-  if (configured_device_status != PTI_SUCCESS) {
-    return configured_device_status;
-  }
-
-  const zet_metric_group_handle_t metric_group =
-      ResolveCollectedMetricGroup(handle, configured_device);
-  const size_t reason_count = handle->stall_reasons_.size();
-  const pti_result aggregate_status = AggregateCollectedData(
-      configured_device, metric_group, handle->samples_dropped_, handle->collected_raw_data_,
-      *handle->ip_metric_index_, reason_count, &handle->device_aggregate_);
-  if (aggregate_status != PTI_SUCCESS) {
-    return aggregate_status;
-  }
-
-  handle->aggregated_ = true;
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Check if a device is configured for the given handle.
- */
-inline bool IsConfiguredDevice(const pti_pc_sampling_handle_t handle, pti_device_handle_t device) {
-  if (handle == nullptr || device == nullptr) {
-    return false;
-  }
-  return std::find(handle->configured_devices_.begin(), handle->configured_devices_.end(),
-                   device) != handle->configured_devices_.end();
-}
-
-/**
- * @brief Validate that the handle is valid and belongs to this module.
- */
-inline pti_result ValidateHandle(const pti_pc_sampling_handle_t handle) {
-  if (handle == nullptr) {
-    SPDLOG_ERROR("{}: handle is null", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  if (!PtiPcSamplingHandleStorage::Instance().Contains(handle)) {
-    SPDLOG_ERROR("{}: handle is invalid", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Validate handle is in a state from which collection can be started.
- *
- * Both ENABLED and CONFIGURED are startable: configuration is optional and the
- * default one is applied on start when it was skipped.
- */
-inline pti_result ValidateStartableHandle(const pti_pc_sampling_handle_t handle) {
-  const pti_result handle_status = ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (handle->state_ == PcSamplingState::kStarted) {
-    SPDLOG_ERROR("{}: collection is already running, current state is {}", __FUNCTION__,
-                 PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_ALREADY_STARTED;
-  }
-
-  if (handle->state_ == PcSamplingState::kStopped) {
-    SPDLOG_ERROR("{}: collection is already stopped, current state is {}", __FUNCTION__,
-                 PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED;
-  }
-
-  if (handle->state_ != PcSamplingState::kEnabled &&
-      handle->state_ != PcSamplingState::kConfigured) {
-    SPDLOG_ERROR("{}: collection cannot be started, current state is {}", __FUNCTION__,
-                 PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED;
-  }
-
-  return PTI_SUCCESS;
-}
-
-/**
- * @brief Validate handle is in stopped state for query operations.
- */
-inline pti_result ValidateStoppedCollectionHandle(const pti_pc_sampling_handle_t handle) {
-  const pti_result handle_status = ValidateHandle(handle);
-  if (handle_status != PTI_SUCCESS) {
-    return handle_status;
-  }
-
-  if (handle->state_ != PcSamplingState::kStopped) {
-    SPDLOG_ERROR("{}: collection must be stopped, current state is {}", __FUNCTION__,
-                 PcSamplingStateToString(handle->state_));
-    return PTI_ERROR_PC_SAMPLING_NOT_STOPPED;
-  }
-
-  return PTI_SUCCESS;
-}
-
-inline pti_result ValidateConfiguredProfiledDevice(const pti_pc_sampling_handle_t handle,
-                                                   pti_device_handle_t device) {
-  if (!IsConfiguredDevice(handle, device)) {
-    SPDLOG_ERROR("{}: device does not match the configured PC sampling device", __FUNCTION__);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  return PTI_SUCCESS;
-}
-
-inline pti_result FindKernelAggregate(const pti_pc_sampling_handle_t handle, uint64_t kernel_handle,
-                                      const KernelAggregate** kernel_aggregate) {
-  if (kernel_aggregate == nullptr) {
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  auto it = handle->device_aggregate_.kernels.find(kernel_handle);
-  if (it == handle->device_aggregate_.kernels.end()) {
-    SPDLOG_ERROR("{}: kernel handle {:#x} was not observed during collection", __FUNCTION__,
-                 kernel_handle);
-    return PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  *kernel_aggregate = &it->second;
-  return PTI_SUCCESS;
-}
-
-inline pti_result FillProfiledDevices(const pti_pc_sampling_handle_t handle,
-                                      pti_device_handle_t* devices, size_t* device_count) {
-  const size_t configured_device_count = handle->configured_devices_.size();
-  if (devices != nullptr && configured_device_count != 0 && *device_count != 0) {
-    const size_t copied_device_count = (std::min)(*device_count, configured_device_count);
-    std::copy_n(handle->configured_devices_.begin(), copied_device_count, devices);
-    *device_count = copied_device_count;
-  } else {
-    *device_count = configured_device_count;
-  }
-  return PTI_SUCCESS;
-}
-
-inline pti_result FillObservedKernelHandles(const pti_pc_sampling_handle_t handle,
-                                            uint64_t* kernel_handles, size_t* kernel_count) {
-  const auto& kernels = handle->device_aggregate_.kernels;
-  const size_t available_count = kernels.size();
-  if (kernel_handles == nullptr || *kernel_count == 0) {
-    *kernel_count = available_count;
-    return PTI_SUCCESS;
-  }
-
-  const size_t copy_count = (std::min)(*kernel_count, available_count);
-  size_t index = 0;
-  for (const auto& entry : kernels) {
-    if (index >= copy_count) {
-      break;
-    }
-    kernel_handles[index++] = entry.first;
-  }
-  *kernel_count = copy_count;
-  return PTI_SUCCESS;
-}
-
-inline pti_result FillObservedKernelInfo(pti_device_handle_t device,
-                                         const pti_pc_sampling_handle_t handle,
-                                         uint64_t kernel_handle,
-                                         pti_pc_sampling_kernel_info_t* kernel_info) {
-  const KernelAggregate* kernel_aggregate = nullptr;
-  const pti_result kernel_status = FindKernelAggregate(handle, kernel_handle, &kernel_aggregate);
-  if (kernel_status != PTI_SUCCESS) {
-    return kernel_status;
-  }
-
-  kernel_info->_device = device;
-  kernel_info->_kernel_handle = kernel_aggregate->kernel_handle;
-  kernel_info->_kernel_name = kernel_aggregate->kernel_name_;
-  kernel_info->_reason_count = kernel_aggregate->reason_count;
-  kernel_info->_instructions_with_samples_count = kernel_aggregate->instruction_count;
-
-  if (kernel_info->_aggregated_samples != nullptr) {
-    const size_t copy_count =
-        (std::min)(kernel_aggregate->reason_count, kernel_aggregate->aggregated_samples.size());
-    std::copy_n(kernel_aggregate->aggregated_samples.begin(), copy_count,
-                kernel_info->_aggregated_samples);
-  }
-
-  return PTI_SUCCESS;
-}
-
-inline pti_result FillSamplesPerInstruction(const pti_pc_sampling_handle_t handle,
-                                            uint64_t kernel_handle,
-                                            pti_pc_sampling_instruction_t* instruction_buffer,
-                                            size_t instruction_buffer_count,
-                                            uint64_t* samples_buffer, size_t samples_buffer_count) {
-  const KernelAggregate* kernel_aggregate = nullptr;
-  const pti_result kernel_status = FindKernelAggregate(handle, kernel_handle, &kernel_aggregate);
-  if (kernel_status != PTI_SUCCESS) {
-    return kernel_status;
-  }
-
-  const size_t persisted_instruction_count = kernel_aggregate->instruction_count;
-  const size_t reason_count = kernel_aggregate->reason_count;
-  const size_t offsets_bytes = persisted_instruction_count * sizeof(uint64_t);
-  if (reason_count != 0 &&
-      persisted_instruction_count > ((std::numeric_limits<size_t>::max)() / reason_count)) {
-    SPDLOG_ERROR("{}: sample matrix size overflows for kernel handle {:#x}", __FUNCTION__,
-                 kernel_aggregate->kernel_handle);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  const size_t sample_count = persisted_instruction_count * reason_count;
-  const size_t samples_bytes = sample_count * sizeof(uint64_t);
-  const size_t expected_size = offsets_bytes + samples_bytes;
-  if (expected_size != kernel_aggregate->samples_file.size()) {
-    SPDLOG_ERROR("{}: kernel samples file size is invalid for kernel handle {:#x}", __FUNCTION__,
-                 kernel_aggregate->kernel_handle);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  const size_t instruction_count =
-      (std::min)(instruction_buffer_count, persisted_instruction_count);
-  std::vector<uint64_t> instruction_offsets(instruction_count);
-  if (instruction_count != 0 &&
-      !kernel_aggregate->samples_file.ReadRange(0, instruction_count * sizeof(uint64_t),
-                                                instruction_offsets.data())) {
-    SPDLOG_ERROR("{}: failed to read instruction offsets for kernel handle {:#x}", __FUNCTION__,
-                 kernel_aggregate->kernel_handle);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  for (size_t i = 0; i < instruction_count; ++i) {
-    instruction_buffer[i]._instruction_offset = instruction_offsets[i];
-    instruction_buffer[i]._source_info = nullptr;
-  }
-
-  const size_t returned_sample_count = instruction_count * reason_count;
-  const size_t copied_sample_count = (std::min)(samples_buffer_count, returned_sample_count);
-  if (copied_sample_count != 0 &&
-      !kernel_aggregate->samples_file.ReadRange(
-          offsets_bytes, copied_sample_count * sizeof(*samples_buffer), samples_buffer)) {
-    SPDLOG_ERROR("{}: failed to read instruction samples for kernel handle {:#x}", __FUNCTION__,
-                 kernel_aggregate->kernel_handle);
-    return PTI_ERROR_INTERNAL;
-  }
-
-  return PTI_SUCCESS;
-}
-
-}  // namespace pti::pc_sampling
-
-#endif  // PTI_PC_SAMPLING_INTERNAL_H_
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_l0.h b/sdk/src/pc_sampling/pti_pc_sampling_l0.h
deleted file mode 100644
index 71acb343..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_l0.h
+++ /dev/null
@@ -1,470 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Helper functions for PC Sampling feature.
-// Provides utilities for:
-//   - Level Zero driver enumeration
-//   - Device discovery
-//   - EU Stall Sampling metric group lookup
-//
-// These helpers abstract the Level Zero API calls needed to
-// discover devices that support PC sampling via the EuStallSampling
-// metric group.
-//
-// =============================================================
-
-#ifndef SRC_PTI_PC_SAMPLING_HELPER_H_
-#define SRC_PTI_PC_SAMPLING_HELPER_H_
-
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/layers/zel_tracing_register_cb.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-#include "levelzero/ze_driver_init.h"
-#include "pc_sampling/pti_pc_sampling_raw_data_file.h"
-#include "utils/ze_utils.h"
-
-namespace pti::pc_sampling {
-
-inline void DestroyMetricStreamerContext(ze_context_handle_t* context);
-
-using StallMetricNameList = std::vector<std::pair<std::string, std::string>>;
-
-struct MetricStreamerHandles {
-  MetricStreamerHandles() = default;
-  MetricStreamerHandles(const MetricStreamerHandles&) = delete;
-  MetricStreamerHandles& operator=(const MetricStreamerHandles&) = delete;
-  MetricStreamerHandles(MetricStreamerHandles&& other) = delete;
-  MetricStreamerHandles& operator=(MetricStreamerHandles&& other) = delete;
-
-  ze_context_handle_t context = nullptr;
-  ze_device_handle_t device = nullptr;
-  ze_event_pool_handle_t event_pool = nullptr;
-  ze_event_handle_t event = nullptr;
-  zet_metric_streamer_handle_t streamer = nullptr;
-
-  void Reset() {
-    auto status = ZE_RESULT_SUCCESS;
-    if (streamer != nullptr) {
-      status = zetMetricStreamerClose(streamer);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_INFO("{}: zetMetricStreamerClose failed with status=0x{:x}", __FUNCTION__,
-                    static_cast<uint32_t>(status));
-      }
-      streamer = nullptr;
-    }
-    if (event != nullptr) {
-      status = zeEventDestroy(event);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_INFO("{}: zeEventDestroy failed with status=0x{:x}", __FUNCTION__,
-                    static_cast<uint32_t>(status));
-      }
-      event = nullptr;
-    }
-    if (event_pool != nullptr) {
-      status = zeEventPoolDestroy(event_pool);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_INFO("{}: zeEventPoolDestroy failed with status=0x{:x}", __FUNCTION__,
-                    static_cast<uint32_t>(status));
-      }
-      event_pool = nullptr;
-    }
-    if (context != nullptr && device != nullptr) {
-      status = zetContextActivateMetricGroups(context, device, 0, nullptr);
-      if (status != ZE_RESULT_SUCCESS) {
-        SPDLOG_WARN("{}: metric group deactivation failed with status=0x{:x}", __FUNCTION__,
-                    static_cast<uint32_t>(status));
-      }
-    }
-    DestroyMetricStreamerContext(&context);
-    device = nullptr;
-  }
-
-  ~MetricStreamerHandles() { Reset(); }
-};
-
-//-----------------------------------------------------------------------------
-// Metric Streamer Helpers
-//-----------------------------------------------------------------------------
-
-inline bool CreateNotificationEvent(ze_context_handle_t context, ze_event_pool_handle_t* event_pool,
-                                    ze_event_handle_t* event) {
-  if (event_pool == nullptr || event == nullptr) {
-    return false;
-  }
-
-  ze_event_pool_desc_t event_pool_desc{ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                       ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-  ze_result_t status = zeEventPoolCreate(context, &event_pool_desc, 0, nullptr, event_pool);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: zeEventPoolCreate failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  ze_event_desc_t event_desc{ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0, ZE_EVENT_SCOPE_FLAG_HOST,
-                             ZE_EVENT_SCOPE_FLAG_HOST};
-  status = zeEventCreate(*event_pool, &event_desc, event);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: zeEventCreate failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    zeEventPoolDestroy(*event_pool);
-    *event_pool = nullptr;
-    return false;
-  }
-
-  return true;
-}
-
-//-----------------------------------------------------------------------------
-// Metric Group Discovery
-//-----------------------------------------------------------------------------
-
-/**
- * @brief Find the EuStallSampling metric group for a device.
- *
- * This metric group is required for PC sampling functionality.
- *
- * @param[in] device   Device handle to search metric groups for
- *
- * @return Metric group handle if found, nullptr otherwise
- */
-inline zet_metric_group_handle_t FindEUStallMetricGroupHandle(ze_device_handle_t device) {
-  constexpr std::string_view kEuStallSamplingMetricGroupName = "EuStallSampling";
-
-  std::vector<zet_metric_group_handle_t> group_list;
-  ::utils::ze::FindMetricGroups(device, group_list);
-
-  if (group_list.empty()) {
-    SPDLOG_WARN("{}: No metric groups found for device, cannot support PC sampling", __FUNCTION__);
-    return nullptr;
-  }
-
-  // Search for the metric group with time-based sampling
-  for (zet_metric_group_handle_t group : group_list) {
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-
-    ze_result_t status = zetMetricGroupGetProperties(group, &group_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_ERROR("{}: zetMetricGroupGetProperties failed, status: {:#x}", __FUNCTION__,
-                   static_cast<uint32_t>(status));
-      return nullptr;
-    }
-
-    // Check for metric group with time-based sampling support
-    if (std::string_view(group_props.name) == kEuStallSamplingMetricGroupName &&
-        (group_props.samplingType & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED)) {
-      SPDLOG_INFO("{}: Found {} metric group for device: {}", __FUNCTION__,
-                  kEuStallSamplingMetricGroupName, static_cast<const void*>(device));
-      return group;
-    }
-  }
-
-  SPDLOG_WARN(
-      "{}: {} metric group not found for device, cannot support PC sampling for the device: {}",
-      __FUNCTION__, kEuStallSamplingMetricGroupName, static_cast<const void*>(device));
-
-  return nullptr;
-}
-
-inline bool CreateMetricStreamerContext(ze_driver_handle_t driver, ze_context_handle_t* context) {
-  if (context == nullptr) {
-    return false;
-  }
-
-  ze_context_desc_t contextDesc{ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-  ze_result_t status = zeContextCreate(driver, &contextDesc, context);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: zeContextCreate failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  return true;
-}
-
-inline void DestroyMetricStreamerContext(ze_context_handle_t* context) {
-  if (context == nullptr || *context == nullptr) {
-    return;
-  }
-
-  ze_result_t status = zeContextDestroy(*context);
-  *context = nullptr;
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_WARN("{}: zeContextDestroy failed with status=0x{:x}", __FUNCTION__,
-                static_cast<uint32_t>(status));
-  }
-}
-
-inline bool OpenMetricStreamer(ze_context_handle_t context, ze_device_handle_t device,
-                               zet_metric_group_handle_t metric_group, uint32_t sampling_period_ns,
-                               MetricStreamerHandles* handles) {
-  constexpr uint32_t kDefaultNotifyEveryNReports = 32'768;
-
-  if (handles == nullptr) {
-    return false;
-  }
-
-  ze_result_t status = zetContextActivateMetricGroups(context, device, 1, &metric_group);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: metric group activation failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  handles->context = context;
-  handles->device = device;
-  if (!CreateNotificationEvent(context, &handles->event_pool, &handles->event)) {
-    return false;
-  }
-
-  zet_metric_streamer_desc_t streamerDesc{ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC, nullptr,
-                                          kDefaultNotifyEveryNReports, sampling_period_ns};
-  status = zetMetricStreamerOpen(context, device, metric_group, &streamerDesc, handles->event,
-                                 &handles->streamer);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: zetMetricStreamerOpen failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  return true;
-}
-
-//-----------------------------------------------------------------------------
-// Metric Enumeration
-//-----------------------------------------------------------------------------
-
-inline bool CalculateMetricValues(zet_metric_group_handle_t metric_group,
-                                  const std::vector<uint8_t>& raw_data,
-                                  std::vector<uint32_t>* reports,
-                                  std::vector<zet_typed_value_t>* values, bool* samples_dropped) {
-  if (metric_group == nullptr || reports == nullptr || values == nullptr ||
-      samples_dropped == nullptr) {
-    return false;
-  }
-
-  reports->clear();
-  values->clear();
-
-  uint32_t report_count = 0;
-  uint32_t total_value_count = 0;
-  ze_result_t status = zetMetricGroupCalculateMultipleMetricValuesExp(
-      metric_group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, raw_data.size(),
-      raw_data.data(), &report_count, &total_value_count, nullptr, nullptr);
-  SPDLOG_DEBUG("{}: raw_data_size={}, report_count={}, total_value_count={}, status=0x{:x}",
-               __FUNCTION__, raw_data.size(), report_count, total_value_count,
-               static_cast<uint32_t>(status));
-  if (status == ZE_RESULT_WARNING_DROPPED_DATA) {
-    *samples_dropped = true;
-  } else if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: metric value count query failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  if (report_count == 0 || total_value_count == 0) {
-    return true;
-  }
-
-  reports->resize(report_count);
-  values->resize(total_value_count);
-  status = zetMetricGroupCalculateMultipleMetricValuesExp(
-      metric_group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES, raw_data.size(),
-      raw_data.data(), &report_count, &total_value_count, reports->data(), values->data());
-  SPDLOG_DEBUG("{}: decoded report_count={}, total_value_count={}, status=0x{:x}", __FUNCTION__,
-               report_count, total_value_count, static_cast<uint32_t>(status));
-  if (status == ZE_RESULT_WARNING_DROPPED_DATA) {
-    *samples_dropped = true;
-  } else if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: metric value decode failed with status=0x{:x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return false;
-  }
-
-  reports->resize(report_count);
-  values->resize(total_value_count);
-  return true;
-}
-
-inline void WaitForMetricStreamerReport(ze_event_handle_t event, uint64_t timeout_ns) {
-  if (event == nullptr) {
-    return;
-  }
-
-  ze_result_t status = zeEventHostSynchronize(event, timeout_ns);
-  if (status != ZE_RESULT_SUCCESS) {
-    if (status != ZE_RESULT_NOT_READY) {
-      SPDLOG_WARN("{}: zeEventHostSynchronize failed with status=0x{:x}", __FUNCTION__,
-                  static_cast<uint32_t>(status));
-    }
-    return;
-  }
-
-  status = zeEventHostReset(event);
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_WARN("{}: zeEventHostReset failed with status=0x{:x}", __FUNCTION__,
-                static_cast<uint32_t>(status));
-  }
-}
-
-constexpr size_t kMaxMetricStreamerReadsPerWorkerDrain = 64;
-
-inline bool ReadMetricStreamerData(zet_metric_streamer_handle_t streamer, uint8_t* buffer,
-                                   size_t buffer_size, TempRawDataFile* raw_data_file,
-                                   bool* samples_dropped, bool final_drain) {
-  if (streamer == nullptr || buffer == nullptr || buffer_size == 0 || raw_data_file == nullptr ||
-      samples_dropped == nullptr || !raw_data_file->IsOpen()) {
-    return false;
-  }
-
-  size_t read_count = 0;
-  while (read_count < kMaxMetricStreamerReadsPerWorkerDrain) {
-    size_t data_size = buffer_size;
-    ze_result_t status = zetMetricStreamerReadData(streamer, UINT32_MAX, &data_size, buffer);
-    ++read_count;
-    SPDLOG_DEBUG("{}: data read returned {} bytes with status=0x{:x}", __FUNCTION__, data_size,
-                 static_cast<uint32_t>(status));
-    if (status == ZE_RESULT_WARNING_DROPPED_DATA) {
-      *samples_dropped = true;
-    } else if (status != ZE_RESULT_SUCCESS) {
-      *samples_dropped = true;
-      SPDLOG_WARN("{}: data read failed with status=0x{:x}", __FUNCTION__,
-                  static_cast<uint32_t>(status));
-      return false;
-    }
-
-    if (data_size > buffer_size) {
-      *samples_dropped = true;
-      SPDLOG_ERROR("{}: metric streamer returned {} bytes for a {} byte buffer", __FUNCTION__,
-                   data_size, buffer_size);
-      return false;
-    }
-
-    if (data_size == 0) {
-      return true;
-    }
-
-    if (!raw_data_file->Append(buffer, data_size)) {
-      *samples_dropped = true;
-      SPDLOG_WARN("{}: failed to spill {} bytes of raw metric data", __FUNCTION__, data_size);
-      return false;
-    }
-
-    SPDLOG_DEBUG("{}: accumulated raw data size is {} bytes", __FUNCTION__, raw_data_file->size());
-
-    if (data_size < buffer_size) {
-      return true;
-    }
-  }
-
-  if (final_drain) {
-    *samples_dropped = true;
-    SPDLOG_WARN(
-        "{}: stopped final metric streamer drain after {} full reads; additional samples "
-        "may have been dropped",
-        __FUNCTION__, read_count);
-  }
-
-  return true;
-}
-
-/**
- * @brief Enumerate EU stall metric to collect stall names and IP metric index.
- *
- * @param[in] group Metric group handle to query.
- *
- * @return Returns the ordered `(metric_name, metric_description)`
- *         stall-metric list together with the metric-group index of the IP metric.
- *         Returns an empty pair if enumeration fails or the metric layout is invalid.
- */
-inline std::pair<StallMetricNameList, size_t> GetAllSupportedStallMetricNames(
-    zet_metric_group_handle_t group) {
-  size_t ip_metric_index = 0;
-  bool has_ip_metric = false;
-
-  uint32_t metric_count = 0;
-  ze_result_t status = zetMetricGet(group, &metric_count, nullptr);
-  if (status != ZE_RESULT_SUCCESS || metric_count == 0) {
-    SPDLOG_ERROR("{}: zetMetricGet failed to get metric count, status: {:#x}, metric_count: {}",
-                 __FUNCTION__, static_cast<uint32_t>(status), metric_count);
-    return {};
-  }
-
-  std::vector<zet_metric_handle_t> metric_list(metric_count, nullptr);
-  status = zetMetricGet(group, &metric_count, metric_list.data());
-  if (status != ZE_RESULT_SUCCESS) {
-    SPDLOG_ERROR("{}: zetMetricGet failed to get metrics, status: {:#x}", __FUNCTION__,
-                 static_cast<uint32_t>(status));
-    return {};
-  }
-
-  StallMetricNameList metric_names;
-  SPDLOG_DEBUG("{}: enumerating {} metrics from EuStallSampling group", __FUNCTION__, metric_count);
-  for (uint32_t metric_index = 0; metric_index < metric_count; ++metric_index) {
-    auto metric = metric_list[metric_index];
-    zet_metric_properties_t metric_props{};
-    metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-
-    status = zetMetricGetProperties(metric, &metric_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      SPDLOG_ERROR("{}: zetMetricGetProperties failed, status: {:#x}", __FUNCTION__,
-                   static_cast<uint32_t>(status));
-      return {};
-    }
-    SPDLOG_DEBUG("{}: metric name='{}', description='{}', units='{}', metric_type={}", __FUNCTION__,
-                 metric_props.name, metric_props.description, metric_props.resultUnits,
-                 static_cast<uint32_t>(metric_props.metricType));
-
-    if (metric_props.metricType == ZET_METRIC_TYPE_IP) {
-      if (has_ip_metric) {
-        SPDLOG_ERROR(
-            "{}: expected exactly one IP metric in EU stall sampling group, found another one "
-            "at index {} (previously found at index {})",
-            __FUNCTION__, metric_index, ip_metric_index);
-        return {};
-      }
-      ip_metric_index = metric_index;
-      has_ip_metric = true;
-      continue;
-    }
-
-    if (metric_props.metricType != ZET_METRIC_TYPE_EVENT) {
-      SPDLOG_ERROR(
-          "{}: metric '{}' has unsupported metric_type={} in EuStallSampling; expected one IP "
-          "metric and EVENT stall metrics only",
-          __FUNCTION__, metric_props.name, static_cast<uint32_t>(metric_props.metricType));
-      return {};
-    }
-
-    metric_names.emplace_back(metric_props.name, metric_props.description);
-  }
-
-  SPDLOG_DEBUG("{}: returning {} stall metrics after filtering", __FUNCTION__, metric_names.size());
-
-  if (!has_ip_metric) {
-    SPDLOG_ERROR("{}: failed to locate IP metric in EU stall sampling group", __FUNCTION__);
-    return {};
-  }
-
-  return {metric_names, ip_metric_index};
-}
-
-}  // namespace pti::pc_sampling
-
-#endif  // SRC_PTI_PC_SAMPLING_HELPER_H_
diff --git a/sdk/src/pc_sampling/pti_pc_sampling_raw_data_file.h b/sdk/src/pc_sampling/pti_pc_sampling_raw_data_file.h
deleted file mode 100644
index 8688fb3b..00000000
--- a/sdk/src/pc_sampling/pti_pc_sampling_raw_data_file.h
+++ /dev/null
@@ -1,225 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Temporary raw byte buffer for PC sampling payloads.
-// Stores exactly what callers append (no headers or record framing).
-// Any semantic layout is defined by higher-level PC sampling code.
-//
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_RAW_DATA_FILE_H_
-#define PTI_PC_SAMPLING_RAW_DATA_FILE_H_
-
-#include <spdlog/spdlog.h>
-
-#include <cstddef>
-#include <cstdint>
-#include <fstream>
-#include <functional>
-#include <random>
-#include <string>
-#include <system_error>
-#include <thread>
-#include <utility>
-#include <vector>
-
-#include "utils/pti_filesystem.h"
-#include "utils/utils.h"
-
-namespace pti::pc_sampling {
-
-class TempRawDataFile {
- public:
-  TempRawDataFile() = default;
-  ~TempRawDataFile() { Reset(); }
-
-  TempRawDataFile(const TempRawDataFile&) = delete;
-  TempRawDataFile& operator=(const TempRawDataFile&) = delete;
-
-  TempRawDataFile(TempRawDataFile&& other) noexcept
-      : stream_(std::move(other.stream_)), path_(std::move(other.path_)), size_(other.size_) {
-    other.path_.clear();
-    other.size_ = 0;
-  }
-
-  TempRawDataFile& operator=(TempRawDataFile&& other) = delete;
-
-  bool OpenTemp() {
-    Reset();
-    path_ = CreateRawDataPath();
-    if (path_.empty()) {
-      SPDLOG_ERROR("{}: failed to create a unique raw data file path", __FUNCTION__);
-      return false;
-    }
-
-    stream_.open(path_, std::ios::binary | std::ios::trunc);
-    if (!stream_.is_open()) {
-      SPDLOG_ERROR("{}: failed to open raw data file {}", __FUNCTION__, path_);
-      Reset();
-      return false;
-    }
-
-    SPDLOG_INFO("{}: created raw data file {}", __FUNCTION__, path_);
-
-    return true;
-  }
-
-  bool Append(const uint8_t* data, size_t data_size) {
-    if (!stream_.is_open() || (data == nullptr && data_size != 0)) {
-      return false;
-    }
-
-    if (data_size == 0) {
-      return true;
-    }
-
-    stream_.write(reinterpret_cast<const char*>(data), data_size);
-    if (!stream_) {
-      stream_.clear();
-      return false;
-    }
-
-    size_ += data_size;
-    return true;
-  }
-
-  bool Finalize() {
-    if (!stream_.is_open()) {
-      return path_.empty() || pti::utils::filesystem::exists(path_);
-    }
-
-    stream_.flush();
-    const bool flushed = static_cast<bool>(stream_);
-    if (!flushed) {
-      stream_.clear();
-    }
-    stream_.close();
-    return flushed;
-  }
-
-  bool ReadAll(std::vector<uint8_t>* raw_data) const {
-    if (raw_data == nullptr) {
-      return false;
-    }
-
-    raw_data->clear();
-    if (path_.empty() || size_ == 0) {
-      return true;
-    }
-
-    raw_data->resize(size_);
-    if (!ReadRange(0, size_, raw_data->data())) {
-      raw_data->clear();
-      return false;
-    }
-
-    return true;
-  }
-
-  bool ReadRange(size_t offset, size_t data_size, void* out) const {
-    if (out == nullptr && data_size != 0) {
-      return false;
-    }
-
-    if (data_size == 0) {
-      return offset <= size_;
-    }
-
-    if (path_.empty()) {
-      SPDLOG_ERROR("{}: raw data file path is empty", __FUNCTION__);
-      return false;
-    }
-
-    if (offset > size_ || data_size > size_ - offset) {
-      SPDLOG_ERROR("{}: requested range [{}:{}) exceeds file size {} for {}", __FUNCTION__, offset,
-                   offset + data_size, size_, path_);
-      return false;
-    }
-
-    std::ifstream input(path_, std::ios::binary);
-    if (!input.is_open()) {
-      SPDLOG_ERROR("{}: failed to open raw data file {}", __FUNCTION__, path_);
-      return false;
-    }
-
-    input.seekg(static_cast<std::streamoff>(offset), std::ios::beg);
-    if (!input) {
-      SPDLOG_ERROR("{}: failed to seek to offset {} in {}", __FUNCTION__, offset, path_);
-      return false;
-    }
-
-    input.read(reinterpret_cast<char*>(out), data_size);
-    if (!input || static_cast<size_t>(input.gcount()) != data_size) {
-      SPDLOG_ERROR("{}: failed to read {} bytes at offset {} from {}", __FUNCTION__, data_size,
-                   offset, path_);
-      return false;
-    }
-
-    return true;
-  }
-
-  void Reset() {
-    if (stream_.is_open()) {
-      stream_.close();
-    }
-
-    if (!path_.empty()) {
-      std::error_code error;
-      const std::string path = path_;
-      const bool removed = pti::utils::filesystem::remove(path_, error);
-      if (error) {
-        SPDLOG_WARN("{}: failed to delete raw data file {}: {}", __FUNCTION__, path,
-                    error.message());
-      } else if (removed) {
-        SPDLOG_INFO("{}: deleted raw data file {}", __FUNCTION__, path);
-      } else {
-        SPDLOG_DEBUG("{}: raw data file {} was already absent during reset", __FUNCTION__, path);
-      }
-      path_.clear();
-    }
-
-    size_ = 0;
-  }
-
-  bool IsOpen() const { return stream_.is_open(); }
-  bool HasPath() const { return !path_.empty(); }
-  const std::string& path() const { return path_; }
-  size_t size() const { return size_; }
-
- private:
-  static std::string CreateRawDataPath() {
-    std::random_device rand_dev;
-    std::mt19937_64 prng(rand_dev());
-    std::uniform_int_distribution<uint64_t> rand_num;
-    const auto temp_dir = pti::utils::filesystem::temp_directory_path();
-    const uint32_t pid = ::utils::GetPid();
-    const uint32_t tid = ::utils::GetTid();
-
-    for (size_t attempt = 0; attempt < 16; ++attempt) {
-      const auto candidate =
-          temp_dir / ("pti_pc_sampling_" + std::to_string(pid) + "_" + std::to_string(tid) + "_" +
-                      std::to_string(rand_num(prng)) + ".bin");
-      if (!pti::utils::filesystem::exists(candidate)) {
-        return candidate.string();
-      }
-
-      SPDLOG_WARN("{}: duplicate raw data filename candidate {}, retrying", __FUNCTION__,
-                  candidate.string());
-    }
-
-    SPDLOG_ERROR("{}: exhausted attempts while creating a raw data filename in {}", __FUNCTION__,
-                 temp_dir.string());
-    return {};
-  }
-
-  std::ofstream stream_;
-  std::string path_;
-  size_t size_ = 0;
-};
-
-}  // namespace pti::pc_sampling
-
-#endif  // PTI_PC_SAMPLING_RAW_DATA_FILE_H_
diff --git a/sdk/src/pti.cc b/sdk/src/pti.cc
deleted file mode 100644
index 1175ad82..00000000
--- a/sdk/src/pti.cc
+++ /dev/null
@@ -1,68 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pti/pti.h"
-
-#include "pti/pti_callback.h"
-
-#define PTI_CASE_ENUM_TO_STRING(e) \
-  case e:                          \
-    return #e;
-
-const char* ptiResultTypeToString(pti_result result_value) {
-  switch (result_value) {
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_BAD_API_ID)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_BAD_ARGUMENT)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_BAD_TIMESTAMP)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_DRIVER)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_EXTERNAL_ID_QUEUE_EMPTY)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_INTERNAL)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_COLLECTOR_UNAVAILABLE)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_ALREADY_STARTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_NOT_STARTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_NOT_STOPPED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_UNSUPPORTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL)
-    PTI_CASE_ENUM_TO_STRING(PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_ENABLE_FAILED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_COLLECTION_NOT_PAUSED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_NO_DATA_COLLECTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_OUT_OF_MEMORY)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_COLLECTION_BUFFER_TOO_SMALL)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_INSUFFICIENT_BUFFER)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_INVALID_COLLECTION_BUFFER)
-    PTI_CASE_ENUM_TO_STRING(PTI_WARN_METRICS_SCOPE_PARTIAL_BUFFER)
-    PTI_CASE_ENUM_TO_STRING(PTI_WARN_BUFFER_NOT_FINALIZED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_NO_CALLBACKS_SET)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_NO_GPU_VIEWS_ENABLED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_NOT_IMPLEMENTED)
-    PTI_CASE_ENUM_TO_STRING(PTI_ERROR_TRACING_NOT_INITIALIZED)
-    PTI_CASE_ENUM_TO_STRING(PTI_STATUS_END_OF_BUFFER)
-    PTI_CASE_ENUM_TO_STRING(PTI_SUCCESS)
-    case PTI_RESULT_FORCE_UINT32:
-    default:
-      break;
-  }
-
-  return "INVALID";
-}
-
-#undef PTI_CASE_ENUM_TO_STRING
diff --git a/sdk/src/pti_callbacks.cc b/sdk/src/pti_callbacks.cc
deleted file mode 100644
index 94143dc2..00000000
--- a/sdk/src/pti_callbacks.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "pti/pti_callback.h"
-
-#define PTI_CASE_ENUM_TO_STRING(e) \
-  case e:                          \
-    return #e;
-
-/**
- * The rest of Callback functions are in levelzero subdirectory files
- * because currently Callback API supports only Level-Zero.
- */
-
-const char* ptiCallbackDomainTypeToString(pti_callback_domain domain) {
-  switch (domain) {
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_API)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_CONTEXT_CREATED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_HOST_SYNCHRONIZATION)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_MODULE_LOADED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_DRIVER_MODULE_UNLOADED)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_INTERNAL_EVENT)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_INTERNAL_THREADS)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_INVALID)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_DOMAIN_MAX)
-  }
-
-  return "INVALID";
-}
-
-const char* ptiCallbackPhaseTypeToString(pti_callback_phase phase) {
-  switch (phase) {
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_API_ENTER)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_API_EXIT)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_INTERNAL_THREAD_START)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_INTERNAL_THREAD_END)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_INTERNAL_EVENT)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_INVALID)
-    PTI_CASE_ENUM_TO_STRING(PTI_CB_PHASE_MAX)
-  }
-
-  return "INVALID";
-}
diff --git a/sdk/src/pti_lib_handler.h b/sdk/src/pti_lib_handler.h
deleted file mode 100644
index e7cd8869..00000000
--- a/sdk/src/pti_lib_handler.h
+++ /dev/null
@@ -1,579 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_PTI_LIB_HANDLER_H_
-#define SRC_PTI_LIB_HANDLER_H_
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-
-#include <algorithm>
-#include <atomic>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <system_error>
-#include <unordered_set>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_metrics.h"
-#include "pti/pti_metrics_scope.h"
-#include "pti/pti_pc_sampling.h"
-#include "pti/pti_view.h"
-#include "utils/library_loader.h"
-#include "utils/platform_strings.h"
-#include "utils/utils.h"
-#include "xpti_adapter.h"
-
-#if defined(PTI_CCL_ITT_COMPILE)
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-
-#include <ittnotify.h>
-#include <ittnotify_config.h>
-
-#include "itt/itt_adapter.h"
-#include "itt/itt_lib_env.h"
-#include "itt/itt_metadata.h"
-
-#endif  // PTI_CCL_ITT_COMPILE
-
-namespace pti {
-
-inline std::string GetPathToPtiModule() {
-  auto pti_dir = ::utils::GetPathToSharedObject(GetPathToPtiModule);
-
-  pti_dir = ::utils::GetFilePath(pti_dir);
-  if (pti_dir.empty()) {
-    return pti_dir;
-  }
-
-  pti_dir += pti::strings::kModuleSubdir;
-  pti_dir += pti::strings::kOsPathSeparator;
-
-  return pti_dir;
-}
-
-#if defined(__linux__)
-
-// Upper bound on load attempts before giving up: a dependency chain costs one attempt
-// per library in it, plus one per retry of the library that depends on it.
-inline constexpr int kMaxDependencyLoadAttempts = 32;
-
-// Extracts the soname the dynamic loader could not find, e.g. out of
-// "libxptifw.so: cannot open shared object file: No such file or directory". Empty when
-// the failure is not a missing dependency (undefined symbol, wrong ELF class) or when
-// the loader names a path - neither leaves anything to pre-load.
-inline std::string MissingSonameFromLoaderError(std::string_view loader_error) {
-  constexpr std::string_view kNotFound = ": cannot open shared object file";
-
-  const auto pos = loader_error.find(kNotFound);
-  if (pos == std::string_view::npos) {
-    SPDLOG_TRACE("Loader error names no missing dependency: {}", loader_error);
-    return std::string{};
-  }
-
-  const auto soname = loader_error.substr(0, pos);
-  if (soname.empty() || soname.find_first_of("/\\") != std::string_view::npos) {
-    SPDLOG_TRACE("Loader error names a path rather than a soname, nothing to pre-load: {}",
-                 loader_error);
-    return std::string{};
-  }
-
-  SPDLOG_TRACE("Loader error names missing dependency {}", soname);
-  return std::string{soname};
-}
-
-// Fallback directories for a dependency the loader will not resolve by soname: the PTI
-// module directory, and its parent where the interface library and the runtime libraries
-// shipped next to it live.
-inline std::vector<utils::filesystem::path> DependencySearchDirs() {
-  const auto module_dir = utils::filesystem::path{GetPathToPtiModule()}.parent_path();
-  if (module_dir.empty()) {
-    SPDLOG_TRACE("PTI module directory is unknown: no fallback search directories");
-    return {};
-  }
-
-  SPDLOG_TRACE("Fallback dependency search directories: {} and {}", module_dir.string(),
-               module_dir.parent_path().string());
-  return {module_dir, module_dir.parent_path()};
-}
-
-// Pre-loads the given soname, so that a subsequent load can resolve it as a dependency.
-// By soname first, letting the loader search as it normally would: that picks the same
-// copy every other participant in the process would resolve. Then by full path from the
-// fallback directories, for deployments no RUNPATH covers.
-//
-// A candidate that fails because it needs something else first reports that soname in
-// next_missing, for the caller to satisfy before coming back to this one. Reported only
-// once every candidate has been tried: another copy of the same soname need not depend
-// on the same things.
-//
-// NOTE: a pre-load satisfies a NEEDED entry only if the file's SONAME equals the string
-// we were given - the loader matches an already loaded object by name, not by path. That
-// holds for the libraries this is used for, whose file names are their sonames; for a
-// conventionally versioned library the pre-load would succeed and satisfy nothing.
-// Harmless, as the caller stops retrying a soname it has pre-loaded.
-inline std::unique_ptr<LibraryLoader> PreloadDependency(const std::string& soname,
-                                                        std::string& next_missing) {
-  next_missing.clear();
-
-  SPDLOG_TRACE("Resolving dependency {}", soname);
-
-  std::vector<std::string> candidates{soname};
-  std::error_code error_code;
-  for (const auto& dir : DependencySearchDirs()) {
-    const auto candidate = dir / soname;
-    if (utils::filesystem::exists(candidate, error_code)) {
-      candidates.push_back(candidate.string());
-    } else {
-      SPDLOG_TRACE("No {} in {}", soname, dir.string());
-    }
-  }
-
-  // Held rather than returned right away, so every candidate still gets its turn.
-  std::string deeper_missing;
-
-  for (const auto& candidate : candidates) {
-    SPDLOG_TRACE("Trying {}", candidate);
-
-    std::string error;
-    auto library = LibraryLoader::Preload(candidate, error);
-    if (library != nullptr) {
-      if (candidate == soname) {
-        SPDLOG_DEBUG("Pre-loaded dependency {} through the loader's search path", soname);
-      } else {
-        // Bypassing the loader's search binds this copy to the soname process-wide,
-        // including for participants that would have resolved it somewhere else.
-        SPDLOG_WARN("Pre-loaded dependency {} by full path; it now satisfies {} process-wide",
-                    candidate, soname);
-      }
-      return library;
-    }
-    SPDLOG_DEBUG("Pre-load of {} failed: {}", candidate, error);
-
-    auto missing = MissingSonameFromLoaderError(error);
-    if (missing.empty() || missing == soname) {
-      // Either not a missing dependency at all, or the loader could not find what we
-      // asked for rather than something it needs first - reporting that would loop.
-      continue;
-    }
-
-    // Keep the first report: it comes from the copy the loader itself resolved, the one
-    // we would rather end up using.
-    SPDLOG_DEBUG("Pre-load of {} needs {} first", candidate, missing);
-    if (deeper_missing.empty()) {
-      deeper_missing = std::move(missing);
-    }
-  }
-
-  if (!deeper_missing.empty()) {
-    SPDLOG_DEBUG("No copy of {} loaded; the one the loader resolves needs {} first", soname,
-                 deeper_missing);
-    next_missing = std::move(deeper_missing);
-  } else {
-    SPDLOG_DEBUG(
-        "{} is reachable neither by soname nor from the PTI module directory or its parent",
-        soname);
-  }
-  return nullptr;
-}
-
-inline void ReleasePreloadedLibraries(
-    std::vector<std::unique_ptr<LibraryLoader>>& preloaded_libraries) {
-  for (auto it = preloaded_libraries.rbegin(); it != preloaded_libraries.rend(); ++it) {
-    it->reset();
-  }
-  preloaded_libraries.clear();
-}
-
-// Loads the PTI Core library, satisfying dependencies the dynamic loader cannot find by
-// itself. In a Python wheel the Core library's RPATH is $ORIGIN only, leaving it unable
-// to resolve dependencies that sit one directory up, next to the PTI interface library.
-// The loader raises those before any Core library code runs, so they cannot be handled
-// from there; they are pre-loaded from this side of the load instead.
-//
-// This has to stay on the interface library side of the load: dlopen searches with the
-// RUNPATH of the calling object, and only the interface library's $ORIGIN points at the
-// directory those libraries are deployed in.
-//
-// It also relies on pre-loading libxptifw.so not making XPTI dispatch to its
-// subscribers. XPTI loads them on the first functional call into the framework, not from
-// its library initializers. Were that to change, the pre-load would reach xptiTraceInit
-// while we are still inside the PtiLibHandler constructor this is called from, with its
-// forwarding pointers not yet resolved.
-inline std::unique_ptr<LibraryLoader> LoadCoreLibrary(const std::string& core_lib_path) {
-  std::string last_error;
-  std::vector<std::string> pending;                 // sonames left to satisfy, deepest last
-  std::unordered_set<std::string> preloaded_names;  // sonames already pre-loaded
-  std::vector<std::unique_ptr<LibraryLoader>> preloaded_libraries;
-
-  SPDLOG_TRACE("Loading PTI Core library {}", core_lib_path);
-
-  int attempt = 0;
-  for (; attempt < kMaxDependencyLoadAttempts; ++attempt) {
-    if (pending.empty()) {
-      try {
-        auto core_lib = std::make_unique<LibraryLoader>(core_lib_path);
-        [[maybe_unused]] const auto preloaded_count = preloaded_names.size();
-        // Core now owns references through its DT_NEEDED entries.
-        ReleasePreloadedLibraries(preloaded_libraries);
-        SPDLOG_TRACE("Loaded {} after pre-loading {} dependencies", core_lib_path, preloaded_count);
-        return core_lib;
-      } catch (const std::exception& e) {
-        last_error = e.what();
-      }
-      SPDLOG_TRACE("Load of {} failed: {}", core_lib_path, last_error);
-
-      auto missing = MissingSonameFromLoaderError(last_error);
-      if (missing.empty()) {
-        SPDLOG_TRACE("Not a missing dependency: pre-loading cannot help, giving up");
-        break;
-      }
-      if (preloaded_names.count(missing) != 0) {
-        SPDLOG_TRACE(
-            "{} is still reported missing after we pre-loaded it - its SONAME most likely differs "
-            "from the name depended on; giving up",
-            missing);
-        break;
-      }
-
-      SPDLOG_TRACE("Queueing {} to be pre-loaded", missing);
-      pending.push_back(std::move(missing));
-    }
-
-    std::string next_missing;
-    auto preloaded_library = PreloadDependency(pending.back(), next_missing);
-    if (preloaded_library != nullptr) {
-      SPDLOG_TRACE("{} satisfied, {} left to satisfy", pending.back(), pending.size() - 1);
-      preloaded_libraries.push_back(std::move(preloaded_library));
-      preloaded_names.insert(std::move(pending.back()));
-      pending.pop_back();
-      continue;
-    }
-
-    // What we just tried needs something else first: satisfy that and come back to this
-    // one - unless there is nothing to try, or it would send us in circles.
-    if (next_missing.empty()) {
-      SPDLOG_TRACE("Nothing further to try for {}: giving up", pending.back());
-      break;
-    }
-    if (preloaded_names.count(next_missing) != 0) {
-      SPDLOG_TRACE("{} wants {}, which we have already pre-loaded: giving up", pending.back(),
-                   next_missing);
-      break;
-    }
-    if (std::find(pending.begin(), pending.end(), next_missing) != pending.end()) {
-      SPDLOG_TRACE("{} wants {}, which is already waiting on it: dependency cycle, giving up",
-                   pending.back(), next_missing);
-      break;
-    }
-
-    SPDLOG_TRACE("Queueing {} ahead of {}", next_missing, pending.back());
-    pending.push_back(std::move(next_missing));
-  }
-
-  if (attempt == kMaxDependencyLoadAttempts) {
-    SPDLOG_TRACE(
-        "Stopped after {} attempts: the dependency chain is longer than we are willing "
-        "to follow",
-        attempt);
-  }
-  SPDLOG_TRACE("Giving up on {}, reporting: {}", core_lib_path, last_error);
-  ReleasePreloadedLibraries(preloaded_libraries);
-
-  throw std::runtime_error(last_error);
-}
-#else
-inline std::unique_ptr<LibraryLoader> LoadCoreLibrary(const std::string& core_lib_path) {
-  return std::make_unique<LibraryLoader>(core_lib_path);
-}
-#endif  // __linux__
-
-// API implemented in PTI Core library
-// to pass from PTI Interface library status of detected "foreign" XPTI subscribers,
-// if such were detected at the library load time
-void PtiSetXPTIEnvironmentDetails(bool is_foreign_subscriber, bool is_likely_unitrace_subscriber);
-class PtiLibHandler {
-#if defined(PTI_CCL_ITT_COMPILE)
-  using IttCollectorSetConfigurationFn = void(ITTAPI*)(itt_lib_env::IttCollectorConfig, const char*,
-                                                       const char*);
-  using IttCollectorSetCclGlobalAndDomainFn = void(ITTAPI*)(__itt_global*, const __itt_domain*);
-#endif  // PTI_CCL_ITT_COMPILE
-
- public:
-  static bool IsSuccessfullyInitialized() {
-    return successfully_initialized_instance_.load(std::memory_order_acquire) != nullptr;
-  }
-
-  static auto& Instance() {
-    static PtiLibHandler instance{};
-    return instance;
-  }
-
-  void Unload() { pti_view_lib_.reset(nullptr); }
-
-  bool ViewAvailable() const { return pti_view_lib_ != nullptr; }
-
-  // Forward to implementation in core library
-  decltype(&xptiTraceInit) xptiTraceInit_ = nullptr;  // NOLINT
-  // Forward to implementation in core library
-  decltype(&xptiTraceFinish) xptiTraceFinish_ = nullptr;                                  // NOLINT
-  decltype(&ptiViewEnable) ptiViewEnable_ = nullptr;                                      // NOLINT
-  decltype(&ptiViewDisable) ptiViewDisable_ = nullptr;                                    // NOLINT
-  decltype(&ptiViewGPULocalAvailable) ptiViewGPULocalAvailable_ = nullptr;                // NOLINT
-  decltype(&ptiViewOverheadKindToString) ptiViewOverheadKindToString_ = nullptr;          // NOLINT
-  decltype(&ptiViewMemoryTypeToString) ptiViewMemoryTypeToString_ = nullptr;              // NOLINT
-  decltype(&ptiViewMemcpyTypeToString) ptiViewMemcpyTypeToString_ = nullptr;              // NOLINT
-  decltype(&ptiViewSetCallbacks) ptiViewSetCallbacks_ = nullptr;                          // NOLINT
-  decltype(&ptiViewGetNextRecord) ptiViewGetNextRecord_ = nullptr;                        // NOLINT
-  decltype(&ptiFlushAllViews) ptiFlushAllViews_ = nullptr;                                // NOLINT
-  decltype(&ptiViewPushExternalCorrelationId) ptiViewPushExternalCorrelationId_ =         // NOLINT
-      nullptr;                                                                            // NOLINT
-  decltype(&ptiViewPopExternalCorrelationId) ptiViewPopExternalCorrelationId_ = nullptr;  // NOLINT
-  decltype(&ptiViewGetTimestamp) ptiViewGetTimestamp_ = nullptr;                          // NOLINT
-  decltype(&ptiViewSetTimestampCallback) ptiViewSetTimestampCallback_ = nullptr;          // NOLINT
-  decltype(&ptiViewGetApiIdName) ptiViewGetApiIdName_ = nullptr;                          // NOLINT
-  decltype(&ptiViewEnableDriverApi) ptiViewEnableDriverApi_ = nullptr;                    // NOLINT
-  decltype(&ptiViewEnableDriverApiClass) ptiViewEnableDriverApiClass_ = nullptr;          // NOLINT
-  decltype(&ptiViewEnableRuntimeApi) ptiViewEnableRuntimeApi_ = nullptr;                  // NOLINT
-  decltype(&ptiViewEnableRuntimeApiClass) ptiViewEnableRuntimeApiClass_ = nullptr;        // NOLINT
-
-  decltype(&ptiMetricsConfigureCollection) ptiMetricsConfigureCollection_ = nullptr;      // NOLINT
-  decltype(&ptiMetricsStopCollection) ptiMetricsStopCollection_ = nullptr;                // NOLINT
-  decltype(&ptiMetricsGetMetricGroups) ptiMetricsGetMetricGroups_ = nullptr;              // NOLINT
-  decltype(&ptiMetricsGetMetricsProperties) ptiMetricsGetMetricsProperties_ = nullptr;    // NOLINT
-  decltype(&ptiMetricsStartCollectionPaused) ptiMetricsStartCollectionPaused_ = nullptr;  // NOLINT
-  decltype(&ptiMetricsPauseCollection) ptiMetricsPauseCollection_ = nullptr;              // NOLINT
-  decltype(&ptiMetricsResumeCollection) ptiMetricsResumeCollection_ = nullptr;            // NOLINT
-  decltype(&ptiMetricsGetDevices) ptiMetricsGetDevices_ = nullptr;                        // NOLINT
-  decltype(&ptiMetricsStartCollection) ptiMetricsStartCollection_ = nullptr;              // NOLINT
-  decltype(&ptiMetricsGetCalculatedData) ptiMetricsGetCalculatedData_ = nullptr;          // NOLINT
-  decltype(&ptiMetricsEnable) ptiMetricsEnable_ = nullptr;                                // NOLINT
-  decltype(&ptiMetricsDisable) ptiMetricsDisable_ = nullptr;                              // NOLINT
-  decltype(&ptiCallbackSubscribe) ptiCallbackSubscribe_ = nullptr;                        // NOLINT
-  decltype(&ptiCallbackUnsubscribe) ptiCallbackUnsubscribe_ = nullptr;                    // NOLINT
-  decltype(&ptiCallbackEnableDomain) ptiCallbackEnableDomain_ = nullptr;                  // NOLINT
-  decltype(&ptiCallbackDisableDomain) ptiCallbackDisableDomain_ = nullptr;                // NOLINT
-  decltype(&ptiCallbackDisableAllDomains) ptiCallbackDisableAllDomains_ = nullptr;        // NOLINT
-  decltype(&ptiCallbackDomainTypeToString) ptiCallbackDomainTypeToString_ = nullptr;      // NOLINT
-  decltype(&ptiCallbackPhaseTypeToString) ptiCallbackPhaseTypeToString_ = nullptr;        // NOLINT
-  decltype(&PtiSetXPTIEnvironmentDetails) PtiSetXPTIEnvironmentDetails_ = nullptr;        // NOLINT
-
-  decltype(&ptiMetricsScopeEnable) ptiMetricsScopeEnable_ = nullptr;                    // NOLINT
-  decltype(&ptiMetricsScopeConfigure) ptiMetricsScopeConfigure_ = nullptr;              // NOLINT
-  decltype(&ptiMetricsScopeStartCollection) ptiMetricsScopeStartCollection_ = nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeStopCollection) ptiMetricsScopeStopCollection_ = nullptr;    // NOLINT
-  decltype(&ptiMetricsScopeDisable) ptiMetricsScopeDisable_ = nullptr;                  // NOLINT
-  decltype(&ptiMetricsScopeQueryCollectionBufferSize) ptiMetricsScopeQueryCollectionBufferSize_ =
-      nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeSetCollectionBufferSize) ptiMetricsScopeSetCollectionBufferSize_ =
-      nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeGetCollectionBuffersCount) ptiMetricsScopeGetCollectionBuffersCount_ =
-      nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeGetCollectionBuffer) ptiMetricsScopeGetCollectionBuffer_ =
-      nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeGetCollectionBufferProperties)
-      ptiMetricsScopeGetCollectionBufferProperties_ = nullptr;                            // NOLINT
-  decltype(&ptiMetricsScopeCalculateMetrics) ptiMetricsScopeCalculateMetrics_ = nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeQueryMetricsBufferSize) ptiMetricsScopeQueryMetricsBufferSize_ =
-      nullptr;  // NOLINT
-  decltype(&ptiMetricsScopeGetMetricsMetadata) ptiMetricsScopeGetMetricsMetadata_ =
-      nullptr;  // NOLINT
-
-  decltype(&ptiPcSamplingEnable) ptiPcSamplingEnable_ = nullptr;        // NOLINT
-  decltype(&ptiPcSamplingConfigure) ptiPcSamplingConfigure_ = nullptr;  // NOLINT
-  decltype(&ptiPcSamplingQueryCollectionBufferSize) ptiPcSamplingQueryCollectionBufferSize_ =
-      nullptr;  // NOLINT
-  decltype(&ptiPcSamplingSetCollectionBufferSize) ptiPcSamplingSetCollectionBufferSize_ =
-      nullptr;                                                                            // NOLINT
-  decltype(&ptiPcSamplingStartCollection) ptiPcSamplingStartCollection_ = nullptr;        // NOLINT
-  decltype(&ptiPcSamplingStopCollection) ptiPcSamplingStopCollection_ = nullptr;          // NOLINT
-  decltype(&ptiPcSamplingGetStallReasons) ptiPcSamplingGetStallReasons_ = nullptr;        // NOLINT
-  decltype(&ptiPcSamplingGetProfiledDevices) ptiPcSamplingGetProfiledDevices_ = nullptr;  // NOLINT
-  decltype(&ptiPcSamplingGetObservedKernelHandles) ptiPcSamplingGetObservedKernelHandles_ =
-      nullptr;  // NOLINT
-  decltype(&ptiPcSamplingGetObservedKernelInfo) ptiPcSamplingGetObservedKernelInfo_ =
-      nullptr;  // NOLINT
-  decltype(&ptiPcSamplingGetSamplesPerInstruction) ptiPcSamplingGetSamplesPerInstruction_ =
-      nullptr;                                                                      // NOLINT
-  decltype(&ptiPcSamplingGetDeviceStatus) ptiPcSamplingGetDeviceStatus_ = nullptr;  // NOLINT
-  decltype(&ptiPcSamplingDisable) ptiPcSamplingDisable_ = nullptr;                  // NOLINT
-
-#if defined(PTI_CCL_ITT_COMPILE)
-  IttCollectorSetConfigurationFn IttCollectorSetConfiguration_ = nullptr;            // NOLINT
-  IttCollectorSetCclGlobalAndDomainFn IttCollectorSetCclGlobalAndDomain_ = nullptr;  // NOLINT
-  decltype(&__itt_task_begin) itt_task_begin_ = nullptr;                             // NOLINT
-  decltype(&__itt_task_end) itt_task_end_ = nullptr;                                 // NOLINT
-  decltype(&__itt_metadata_add) itt_metadata_add_ = nullptr;                         // NOLINT
-#endif  // PTI_CCL_ITT_COMPILE
-
-  // Forward to implementation in core library
-  decltype(&xptiQuerySubscriberStreamDetailLevel) xptiQuerySubscriberStreamDetailLevel_ =  // NOLINT
-      nullptr;                                                                             // NOLINT
-
- private:
-  inline void CommunicateForeignXPTISubscriber() {
-    // Passing information about XPTI subscriber to PTI Core library right after it is loaded.
-    // This should be done before any other call to PTI Core, as it might create Sycl collector
-    // and it should not enable it, in case if some foreign subscriber already subscribed for XPTI
-    if (PtiSetXPTIEnvironmentDetails_) {
-      auto [is_foreign_subscriber, is_likely_unitrace_subscriber] = IsForeignXPTISubscriber();
-      PtiSetXPTIEnvironmentDetails_(is_foreign_subscriber, is_likely_unitrace_subscriber);
-    } else {
-      SPDLOG_DEBUG("PtiSetXPTIEnvironmentDetails_ is not available in the loaded library.");
-    }
-  }
-
-  PtiLibHandler() {
-    try {
-      spdlog::set_level(spdlog::level::off);
-
-      auto env_string = ::utils::GetEnv("PTILOG_LEVEL");
-      if (!env_string.empty()) {
-        spdlog::cfg::helpers::load_levels(env_string);
-      }
-      ::utils::SetGlobalSpdLogPattern();
-
-      auto pti_dir = GetPathToPtiModule();
-      pti_dir += strings::kPtiViewLib;
-      pti_view_lib_ = LoadCoreLibrary(pti_dir);
-    } catch (const std::exception& e) {
-      SPDLOG_ERROR("Unable to load {} because {}", strings::kPtiViewLib, e.what());
-      pti_view_lib_ = nullptr;
-      // Do NOT mark as successfully initialized on failure - ITT calls will safely no-op
-      return;
-    }
-#define PTI_VIEW_GET_SYMBOL(X) X##_ = pti_view_lib_->GetSymbol<decltype(&X)>(#X)  // NOLINT
-    PTI_VIEW_GET_SYMBOL(xptiTraceInit);
-    PTI_VIEW_GET_SYMBOL(xptiTraceFinish);
-    PTI_VIEW_GET_SYMBOL(xptiQuerySubscriberStreamDetailLevel);
-    PTI_VIEW_GET_SYMBOL(ptiViewEnable);
-    PTI_VIEW_GET_SYMBOL(ptiViewDisable);
-    PTI_VIEW_GET_SYMBOL(ptiViewGPULocalAvailable);
-    PTI_VIEW_GET_SYMBOL(ptiViewOverheadKindToString);
-    PTI_VIEW_GET_SYMBOL(ptiViewMemoryTypeToString);
-    PTI_VIEW_GET_SYMBOL(ptiViewMemcpyTypeToString);
-    PTI_VIEW_GET_SYMBOL(ptiViewSetCallbacks);
-    PTI_VIEW_GET_SYMBOL(ptiViewGetNextRecord);
-    PTI_VIEW_GET_SYMBOL(ptiFlushAllViews);
-    PTI_VIEW_GET_SYMBOL(ptiViewPushExternalCorrelationId);
-    PTI_VIEW_GET_SYMBOL(ptiViewPopExternalCorrelationId);
-    PTI_VIEW_GET_SYMBOL(ptiViewGetTimestamp);
-    PTI_VIEW_GET_SYMBOL(ptiViewSetTimestampCallback);
-    PTI_VIEW_GET_SYMBOL(ptiViewGetApiIdName);
-    PTI_VIEW_GET_SYMBOL(ptiViewEnableDriverApi);
-    PTI_VIEW_GET_SYMBOL(ptiViewEnableDriverApiClass);
-    PTI_VIEW_GET_SYMBOL(ptiViewEnableRuntimeApi);
-    PTI_VIEW_GET_SYMBOL(ptiViewEnableRuntimeApiClass);
-
-    PTI_VIEW_GET_SYMBOL(ptiMetricsConfigureCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsStopCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsGetMetricGroups);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsGetMetricsProperties);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsStartCollectionPaused);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsPauseCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsResumeCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsGetDevices);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsStartCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsGetCalculatedData);
-
-    PTI_VIEW_GET_SYMBOL(ptiMetricsEnable);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsDisable);
-
-    PTI_VIEW_GET_SYMBOL(ptiCallbackSubscribe);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackUnsubscribe);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackEnableDomain);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackDisableDomain);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackDisableAllDomains);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackDomainTypeToString);
-    PTI_VIEW_GET_SYMBOL(ptiCallbackPhaseTypeToString);
-
-    PTI_VIEW_GET_SYMBOL(PtiSetXPTIEnvironmentDetails);
-
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeEnable);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeConfigure);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeStartCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeStopCollection);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeDisable);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeQueryCollectionBufferSize);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeSetCollectionBufferSize);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeGetCollectionBuffersCount);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeGetCollectionBuffer);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeGetCollectionBufferProperties);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeCalculateMetrics);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeQueryMetricsBufferSize);
-    PTI_VIEW_GET_SYMBOL(ptiMetricsScopeGetMetricsMetadata);
-
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingEnable);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingConfigure);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingQueryCollectionBufferSize);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingSetCollectionBufferSize);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingStartCollection);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingStopCollection);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetStallReasons);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetProfiledDevices);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetObservedKernelHandles);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetObservedKernelInfo);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetSamplesPerInstruction);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingGetDeviceStatus);
-    PTI_VIEW_GET_SYMBOL(ptiPcSamplingDisable);
-
-#if defined(PTI_CCL_ITT_COMPILE)
-#define PTI_VIEW_GET_ITT_SYMBOL(X) \
-  X##_ = pti_view_lib_->GetSymbol<decltype(&__##X)>(#X "_collector")
-    PTI_VIEW_GET_ITT_SYMBOL(itt_task_begin);
-    PTI_VIEW_GET_ITT_SYMBOL(itt_task_end);
-    PTI_VIEW_GET_ITT_SYMBOL(itt_metadata_add);
-
-    IttCollectorSetConfiguration_ =
-        pti_view_lib_->GetSymbol<IttCollectorSetConfigurationFn>("IttCollectorSetConfiguration");
-    // Transfer the load-time decision even if ITT selected another collector
-    // and never called PTI's __itt_api_init.
-    if (IttCollectorSetConfiguration_ != nullptr) {
-      IttCollectorSetConfiguration_(itt_lib_env::GetIttCollectorConfig(),
-                                    itt_lib_env::GetSelectedIttCollectorPath().c_str(),
-                                    itt_lib_env::GetPtiIttCollectorPath().c_str());
-    } else {
-      SPDLOG_WARN("IttCollectorSetConfiguration is not available in the loaded library.");
-    }
-
-    IttCollectorSetCclGlobalAndDomain_ =
-        pti_view_lib_->GetSymbol<IttCollectorSetCclGlobalAndDomainFn>(
-            "IttCollectorSetCclGlobalAndDomain");
-
-    SPDLOG_DEBUG("{}() IttCollectorSetCclGlobalAndDomain_: {}", __FUNCTION__,
-                 IttCollectorSetCclGlobalAndDomain_ != nullptr ? "available" : "not available");
-    // Pass any oneCCL ITT global and domain already cached by the adapter.
-    // These pointers may be null if oneCCL has not initialized ITT yet.
-    // After this handler is initialized, __itt_api_init forwards any cached
-    // oneCCL pointers to the collector.
-    if (IttCollectorSetCclGlobalAndDomain_ != nullptr) {
-      auto* g = GetIttGlobalOfCclDomainAdapter();
-      auto* domain = GetIttCclDomainAdapter();
-      SPDLOG_DEBUG("{}() IttGlobalCollector: {}, CCL domain: {}", __FUNCTION__,
-                   static_cast<void*>(g), static_cast<const void*>(domain));
-      IttCollectorSetCclGlobalAndDomain_(g, domain);
-    }
-
-#undef PTI_VIEW_GET_ITT_SYMBOL
-#endif  // PTI_CCL_ITT_COMPILE
-
-#undef PTI_VIEW_GET_SYMBOL
-    CommunicateForeignXPTISubscriber();
-
-    // Mark as fully initialized at the very end
-    successfully_initialized_instance_.store(this, std::memory_order_release);
-  }
-
-  static inline std::atomic<PtiLibHandler*> successfully_initialized_instance_{nullptr};
-  std::unique_ptr<LibraryLoader> pti_view_lib_ = nullptr;
-};
-}  // namespace pti
-
-#endif  // SRC_PTI_LIB_HANDLER_H_
diff --git a/sdk/src/pti_memory_route.h b/sdk/src/pti_memory_route.h
deleted file mode 100644
index 5c6b7897..00000000
--- a/sdk/src/pti_memory_route.h
+++ /dev/null
@@ -1,90 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_MEMORY_ROUTE_
-#define PTI_MEMORY_ROUTE_
-
-#include <array>
-#include <cassert>
-#include <cstddef>
-#include <string>
-#include <string_view>
-
-#include "pti/pti_view.h"
-
-/**
- * \internal
- * @brief Representation of a memory copy route.
- */
-struct PtiMemoryCommandRoute {
-  pti_view_memory_type src_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY;
-  pti_view_memory_type dst_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY;
-  bool is_peer_2_peer = false;
-
-  // Intentional - compiler warns if developer adds a new memory type but forgets to update this
-  // function.
-  [[nodiscard]] static constexpr std::size_t GetIdx(pti_view_memory_type mem_type) {
-    static_assert(static_cast<std::size_t>(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY) == 0,
-                  "Expected MEMORY to be 0. Enum values must not change");
-    static_assert(static_cast<std::size_t>(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST) == 1,
-                  "Expected HOST to be 1. Enum values must not change");
-    static_assert(static_cast<std::size_t>(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE) == 2,
-                  "Expected DEVICE to be 2. Enum values must not change");
-    static_assert(static_cast<std::size_t>(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED) == 3,
-                  "Expected SHARED to be 3. Enum values must not change");
-    switch (mem_type) {
-      case pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY:
-      case pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST:
-      case pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE:
-      case pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED:
-        return static_cast<std::size_t>(mem_type);
-      case pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_FORCE_UINT32:
-        break;
-    }
-    return 0;
-  }
-
-  static char GetChar(pti_view_memory_type type) {
-    constexpr static std::array kCharTable = {'M', 'H', 'D', 'S'};
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
-    return kCharTable[GetIdx(type)];
-  }
-
-  std::string GetCompactStringForTypes() const {
-    return {GetChar(src_type), '2', GetChar(dst_type)};
-  }
-
-  std::string_view GetCompactStringForP2P() const { return is_peer_2_peer ? " - P2P" : ""; }
-
-  pti_view_memcpy_type GetMemcpyType() const {
-    using Mct = pti_view_memcpy_type;
-    // clang-format off
-    constexpr static std::array kMemcpyTypeTable = {
-        //                            M                                 H                                D                                 S
-        /* M */ std::array{Mct::PTI_VIEW_MEMCPY_TYPE_M2M, Mct::PTI_VIEW_MEMCPY_TYPE_M2H, Mct::PTI_VIEW_MEMCPY_TYPE_M2D, Mct::PTI_VIEW_MEMCPY_TYPE_M2S},
-        /* H */ std::array{Mct::PTI_VIEW_MEMCPY_TYPE_H2M, Mct::PTI_VIEW_MEMCPY_TYPE_H2H, Mct::PTI_VIEW_MEMCPY_TYPE_H2D, Mct::PTI_VIEW_MEMCPY_TYPE_H2S},
-        /* D */ std::array{Mct::PTI_VIEW_MEMCPY_TYPE_D2M, Mct::PTI_VIEW_MEMCPY_TYPE_D2H, Mct::PTI_VIEW_MEMCPY_TYPE_D2D, Mct::PTI_VIEW_MEMCPY_TYPE_D2S},
-        /* S */ std::array{Mct::PTI_VIEW_MEMCPY_TYPE_S2M, Mct::PTI_VIEW_MEMCPY_TYPE_S2H, Mct::PTI_VIEW_MEMCPY_TYPE_S2D, Mct::PTI_VIEW_MEMCPY_TYPE_S2S}};
-    // clang-format on
-
-    // PTI sets the enum, so no need for runtime check.
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
-    return kMemcpyTypeTable[GetIdx(src_type)][GetIdx(dst_type)];
-  }
-
-  /// @internal
-  /// @brief Returns true if the source memory should be considered the 'main' device
-  bool IsMainDeviceSrc() const {
-    if (src_type == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE &&
-        dst_type == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE) {
-      return false;
-    }
-    return src_type == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE ||
-           src_type == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED;
-  }
-};
-
-#endif  // PTI_MEMORY_ROUTE_
diff --git a/sdk/src/pti_version.cc b/sdk/src/pti_version.cc
deleted file mode 100644
index 7fadc69a..00000000
--- a/sdk/src/pti_version.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include "pti/pti_version.h"
-
-#include "platform_config.h"
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#pragma comment(linker, "/include:kPtiIdentifierString")
-#endif
-
-extern "C" {
-PTI_USED extern const char kPtiIdentifierString[] =  // NOLINT
-    "Intel(R) Profiling Tools Interfaces (PTI) Version " PTI_VERSION_STRING
-    " (" PTI_COMMIT_HASH_STRING ")";
-}  // extern "C"
-
-namespace {
-constexpr auto kPtiVersion = pti_version{PTI_VERSION_MAJOR, PTI_VERSION_MINOR, PTI_VERSION_PATCH};
-
-constexpr const char* const kPtiVersionString = PTI_VERSION_STRING;
-}  // namespace
-
-const char* ptiVersionString() { return kPtiVersionString; }
-
-pti_version ptiVersion() { return kPtiVersion; }
diff --git a/sdk/src/pti_view.cc b/sdk/src/pti_view.cc
deleted file mode 100644
index ee85ca40..00000000
--- a/sdk/src/pti_view.cc
+++ /dev/null
@@ -1,577 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pti/pti_view.h"
-
-#include <spdlog/spdlog.h>
-
-#include <array>
-#include <unordered_map>
-
-#include "internal_helper.h"
-#include "pti/pti_callback.h"
-#include "tracing_cb_api.gen"
-#include "view_handler.h"
-
-namespace {
-// TODO(PTI): maybe_unused because SPDLOG_ERROR not guaranteed to be there on release builds
-void LogException([[maybe_unused]] const std::exception& excep) {
-  SPDLOG_ERROR("Caught exception before return: {}", excep.what());
-}
-}  // namespace
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewEnable(pti_view_kind view_kind) {
-  SPDLOG_DEBUG("In {}, view_kind: {}", __FUNCTION__, static_cast<uint32_t>(view_kind));
-  try {
-    pti_result pti_state = Instance().GetState();
-    if (Instance().GetState() != pti_result::PTI_SUCCESS) {
-      return pti_state;
-    }
-    if (!(IsPtiViewKindEnum(view_kind))) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-    return Instance().Enable(view_kind);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewDisable(pti_view_kind view_kind) {
-  SPDLOG_DEBUG("In {}, view_kind: {}", __FUNCTION__, static_cast<uint32_t>(view_kind));
-  try {
-    pti_result pti_state = Instance().GetState();
-    if (Instance().GetState() != pti_result::PTI_SUCCESS) {
-      return pti_state;
-    }
-    if (!(IsPtiViewKindEnum(view_kind))) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-    return Instance().Disable(view_kind);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewGPULocalAvailable() {
-  try {
-    return Instance().GPULocalAvailable();
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewSetCallbacks(pti_fptr_buffer_requested fptr_bufferRequested,
-                               pti_fptr_buffer_completed fptr_bufferCompleted) {
-  try {
-    return Instance().RegisterBufferCallbacks(fptr_bufferRequested, fptr_bufferCompleted);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewGetNextRecord(uint8_t* buffer, size_t valid_bytes,
-                                pti_view_record_base** record) {
-  try {
-    return GetNextRecord(buffer, valid_bytes, record);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiFlushAllViews() {
-  try {
-    return Instance().FlushBuffers();
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewPushExternalCorrelationId(pti_view_external_kind external_kind,
-                                            uint64_t external_id) {
-  try {
-    return Instance().PushExternalKindId(external_kind, external_id);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-//
-// TODO(PTI): parse different exception types, analyse caught exception and return
-// different error code.
-//
-pti_result ptiViewPopExternalCorrelationId(pti_view_external_kind external_kind,
-                                           uint64_t* p_external_id) {
-  try {
-    return Instance().PopExternalKindId(external_kind, p_external_id);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-// Capture all overhead_kind types and associate strings to static storage
-//
-inline constexpr static std::array<const char* const, 6> kOverheadKindType = {
-    "INVALID", "UNKNOWN", "RESOURCE", "BUFFER_FLUSH", "BUFFER_DRIVER", "Instrumentation"};
-
-// Returns the stringified version of overhead kind type back.
-const char* ptiViewOverheadKindToString(pti_view_overhead_kind type) {
-  switch (type) {
-    case PTI_VIEW_OVERHEAD_KIND_INVALID:
-      return kOverheadKindType[0];
-    case PTI_VIEW_OVERHEAD_KIND_UNKNOWN:
-      return kOverheadKindType[1];
-    case PTI_VIEW_OVERHEAD_KIND_RESOURCE:
-      return kOverheadKindType[2];
-    case PTI_VIEW_OVERHEAD_KIND_BUFFER_FLUSH:
-      return kOverheadKindType[3];
-    case PTI_VIEW_OVERHEAD_KIND_DRIVER:
-      return kOverheadKindType[4];
-    case PTI_VIEW_OVERHEAD_KIND_TIME:
-      return kOverheadKindType[5];
-    case PTI_VIEW_OVERHEAD_KIND_FORCE_UINT32:
-      break;
-  }
-  return kOverheadKindType[0];
-}
-
-// Keep INVALID uppercase to match other types (for now).
-// Returns the stringified version of memory type back.
-const char* ptiViewMemoryTypeToString(pti_view_memory_type type) {
-  switch (type) {
-    case PTI_VIEW_MEMORY_TYPE_MEMORY:
-      return "Host (User Allocated)";
-    case PTI_VIEW_MEMORY_TYPE_HOST:
-      return "Host (Driver Allocated)";
-    case PTI_VIEW_MEMORY_TYPE_DEVICE:
-      return "Device";
-    case PTI_VIEW_MEMORY_TYPE_SHARED:
-      return "Shared";
-    case PTI_VIEW_MEMORY_TYPE_FORCE_UINT32:
-      break;
-  }
-  return "INVALID";
-}
-
-// Capture all memcpy types and associate strings to static storage
-//
-inline constexpr static std::array<const char* const, 17> kMemcpyType = {
-    "INVALID", "M2M", "M2H", "M2D", "M2S", "H2M", "H2H", "H2D", "H2S",
-    "D2M",     "D2H", "D2D", "D2S", "S2M", "S2H", "S2D", "S2S"};
-
-// Returns the stringified version of memcpy type back.
-const char* ptiViewMemcpyTypeToString(pti_view_memcpy_type type) {
-  switch (type) {
-    case PTI_VIEW_MEMCPY_TYPE_M2M:
-      return kMemcpyType[1];
-    case PTI_VIEW_MEMCPY_TYPE_M2H:
-      return kMemcpyType[2];
-    case PTI_VIEW_MEMCPY_TYPE_M2D:
-      return kMemcpyType[3];
-    case PTI_VIEW_MEMCPY_TYPE_M2S:
-      return kMemcpyType[4];
-    case PTI_VIEW_MEMCPY_TYPE_H2M:
-      return kMemcpyType[5];
-    case PTI_VIEW_MEMCPY_TYPE_H2H:
-      return kMemcpyType[6];
-    case PTI_VIEW_MEMCPY_TYPE_H2D:
-      return kMemcpyType[7];
-    case PTI_VIEW_MEMCPY_TYPE_H2S:
-      return kMemcpyType[8];
-    case PTI_VIEW_MEMCPY_TYPE_D2M:
-      return kMemcpyType[9];
-    case PTI_VIEW_MEMCPY_TYPE_D2H:
-      return kMemcpyType[10];
-    case PTI_VIEW_MEMCPY_TYPE_D2D:
-      return kMemcpyType[11];
-    case PTI_VIEW_MEMCPY_TYPE_D2S:
-      return kMemcpyType[12];
-    case PTI_VIEW_MEMCPY_TYPE_S2M:
-      return kMemcpyType[13];
-    case PTI_VIEW_MEMCPY_TYPE_S2H:
-      return kMemcpyType[14];
-    case PTI_VIEW_MEMCPY_TYPE_S2D:
-      return kMemcpyType[15];
-    case PTI_VIEW_MEMCPY_TYPE_S2S:
-      return kMemcpyType[16];
-    case PTI_VIEW_MEMCPY_TYPE_FORCE_UINT32:
-      break;
-  }
-  return kMemcpyType[0];
-}
-
-// Capture monotonic_raw which is not subject to jumps and adjustments; convert to real time and
-// return.
-uint64_t ptiViewGetTimestamp() {
-  return Instance().GetUserTimestamp();  // user timestamp func ptr is real time by default.
-}
-
-// Set callback function to get host timestamps from user.
-pti_result ptiViewSetTimestampCallback(pti_fptr_get_timestamp fptr_timestampRequested) {
-  try {
-    return Instance().RegisterTimestampCallback(fptr_timestampRequested);
-  } catch (const std::overflow_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-// Get api function name by api kind (LEVEL_ZERO_CALLS(default), OPENCL_CALLS, etc).
-pti_result ptiViewGetApiIdName(pti_api_group_id type, uint32_t unique_id, const char** name) {
-  pti_result result = pti_result::PTI_SUCCESS;
-  if (name != nullptr) {
-    try {
-      switch (type) {
-        case pti_api_group_id::PTI_API_GROUP_SYCL:
-          *name = pti_api_id_runtime_sycl_func_name.at(unique_id);
-          break;
-        case pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_LEVELZERO:
-        case pti_api_group_id::PTI_API_GROUP_LEVELZERO:
-          *name = pti_api_id_driver_levelzero_func_name.at(unique_id);
-          break;
-        case pti_api_group_id::PTI_API_GROUP_OPENCL:
-          result = pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-          break;
-        case pti_api_group_id::PTI_API_GROUP_RESERVED:
-          result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-          break;
-        default:
-          result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-          break;
-      }
-    } catch (const std::out_of_range&) {
-      result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-  } else {
-    result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return result;
-}
-
-// Enable/Disable driver specific API specified by api_id within the api_group_id.
-// TODO(PTI) --when groups have more than 1 driver Apis (say OCL) update this to call Reset
-// appropriately
-pti_result ptiViewEnableDriverApi(uint32_t enable, pti_api_group_id api_group_id, uint32_t api_id) {
-  SPDLOG_DEBUG("In {}, api_group_id:  {}, api_id: {}, enable?: {}", __func__,
-               static_cast<uint32_t>(api_group_id), static_cast<uint32_t>(api_id), enable);
-  try {
-    // Only valid groups for driver class are all or levelzero for now.
-    if (api_group_id == pti_api_group_id::PTI_API_GROUP_OPENCL) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-    if ((api_group_id != pti_api_group_id::PTI_API_GROUP_LEVELZERO) &&
-        (api_group_id != pti_api_group_id::PTI_API_GROUP_ALL)) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Set the group to be specific here.  All calls require it.
-    pti_api_group_id pti_group = pti_api_group_id::PTI_API_GROUP_LEVELZERO;
-    return Instance().CheckGranularityAndSetState(pti_group, api_id, enable);
-  } catch (const std::out_of_range&) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return PTI_SUCCESS;
-}
-
-// Enable/Disable runtime specific API specified by api_id within the api_group_id.
-// TODO(PTI)--when groups have more than 1 runtime Apis (say OV) update this to call Reset
-// appropriately
-pti_result ptiViewEnableRuntimeApi(uint32_t enable, pti_api_group_id api_group_id,
-                                   uint32_t api_id) {
-  SPDLOG_DEBUG("In {}, api_group_id:  {}, api_id: {}, enable?: {}", __func__,
-               static_cast<uint32_t>(api_group_id), static_cast<uint32_t>(api_id), enable);
-  try {
-    // Only valid groups for runtime class are all or sycl for now.
-    if ((api_group_id != pti_api_group_id::PTI_API_GROUP_SYCL) &&
-        (api_group_id != pti_api_group_id::PTI_API_GROUP_ALL)) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    // Set the group to be specific here.  All calls require it.
-    // TODO(PTI)-- Relook at this when api_group_id can be a valid group other than SYCL.
-    pti_api_group_id pti_group = pti_api_group_id::PTI_API_GROUP_SYCL;
-    return Instance().CheckGranularityAndSetState(pti_group, api_id, enable);
-  } catch (const std::out_of_range&) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return PTI_SUCCESS;
-}
-
-// Enable/Disable runtime APIs tracing specified by pti_class across specified api group(s).
-pti_result ptiViewEnableRuntimeApiClass(uint32_t enable, pti_api_class pti_class,
-                                        pti_api_group_id pti_group) {
-  pti_result status = pti_result::PTI_SUCCESS;
-  SPDLOG_DEBUG("In {}, api_group_id:  {}, pti_class: {}, enable?: {}", __func__,
-               static_cast<uint32_t>(pti_group), static_cast<uint32_t>(pti_class), enable);
-  // Only valid groups for runtime class are all or sycl for now.
-  if ((pti_group != pti_api_group_id::PTI_API_GROUP_SYCL) &&
-      (pti_group != pti_api_group_id::PTI_API_GROUP_ALL)) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  uint32_t new_value = (enable ? 1 : 0);
-  try {
-    switch (pti_class) {
-      case pti_api_class::PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION:  // No runtime synch yet.
-      case pti_api_class::PTI_API_CLASS_RESERVED: {
-        status = pti_result::PTI_ERROR_BAD_ARGUMENT;
-        break;
-      }
-      //*
-      //* Note conditional break for cases is needed to cover CLASS_ALL cases - ensure they are
-      // added below:
-      //*
-      //* Additionally: the GROUP_ALL check -- is needed for all cases to capture the all category
-      // and set granularities appropriately.
-      //*
-      case pti_api_class::PTI_API_CLASS_ALL:
-      case pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE: {
-        if ((pti_group == pti_api_group_id::PTI_API_GROUP_ALL ||
-             pti_group == pti_api_group_id::PTI_API_GROUP_SYCL)) {
-          // Set the class and group to be specific here.  All calls require it.
-          pti_api_class api_pti_class = pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE;
-          pti_api_group_id api_group_id = pti_api_group_id::PTI_API_GROUP_SYCL;
-          status =
-              Instance().ProcessGroupForRuntimePerClass(api_group_id, new_value, api_pti_class);
-        }
-        if (pti_class != pti_api_class::PTI_API_CLASS_ALL) {
-          break;
-        }
-        [[fallthrough]];
-      }
-      default:
-        break;  // last valid case -- unconditional break;
-    }
-  } catch (const std::out_of_range&) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return status;
-}
-
-// Enable/Disable driver APIs tracing specified by pti_class across specified api group(s).
-pti_result ptiViewEnableDriverApiClass(uint32_t enable, pti_api_class pti_class,
-                                       pti_api_group_id pti_group) {
-  SPDLOG_DEBUG("In {}, api_group_id:  {}, pti_class: {}, enable?: {}", __func__,
-               static_cast<uint32_t>(pti_group), static_cast<uint32_t>(pti_class), enable);
-  pti_result status = pti_result::PTI_SUCCESS;
-  // Only valid groups for driver class are all or levelzero for now.
-  if ((pti_group != pti_api_group_id::PTI_API_GROUP_LEVELZERO) &&
-      (pti_group != pti_api_group_id::PTI_API_GROUP_ALL)) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  uint32_t new_value = (enable ? 1 : 0);
-  try {
-    switch (pti_class) {
-      case pti_api_class::PTI_API_CLASS_RESERVED: {
-        status = pti_result::PTI_ERROR_BAD_ARGUMENT;
-        break;
-      }
-      //*
-      //* Note conditional break for cases is needed to cover CLASS_ALL cases - ensure they are
-      // added below:
-      //*
-      //* Additionally: the GROUP_ALL check -- is needed for all cases to capture the all category
-      // and set granularities appropriately.
-      case pti_api_class::PTI_API_CLASS_ALL: {
-        Instance().EnableAllDriverApisWithoutGranularity();
-        break;
-      }
-      case pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE:
-      case pti_api_class::PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION: {
-        if ((pti_group == pti_api_group_id::PTI_API_GROUP_ALL ||
-             pti_group == pti_api_group_id::PTI_API_GROUP_LEVELZERO)) {
-          // Set the class and group to be specific here.  All calls require it.
-          pti_api_group_id api_group_id = pti_api_group_id::PTI_API_GROUP_LEVELZERO;
-          status = Instance().ProcessGroupForDriverPerClass(api_group_id, new_value, pti_class);
-        }
-        if (pti_class != pti_api_class::PTI_API_CLASS_ALL) {
-          break;
-        }
-        [[fallthrough]];
-      }
-      default:
-        break;  // last valid case -- unconditional break;
-    }
-  } catch (const std::out_of_range&) {
-    status = pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return status;
-}
-
-pti_result ptiCallbackSubscribe(pti_callback_subscriber_handle* subscriber,
-                                pti_callback_function callback, void* user_data) {
-  try {
-    return Instance().CallbackSubscribe(subscriber, callback, user_data);
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackUnsubscribe(pti_callback_subscriber_handle subscriber) {
-  try {
-    return Instance().CallbackUnsubscribe(subscriber);
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackEnableDomain(pti_callback_subscriber_handle subscriber,
-                                   pti_callback_domain domain, uint32_t enter_cb,
-                                   uint32_t exit_cb) {
-  try {
-    return Instance().CallbackEnableDomain(subscriber, domain, enter_cb, exit_cb);
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackDisableDomain(pti_callback_subscriber_handle subscriber,
-                                    pti_callback_domain domain) {
-  try {
-    return Instance().CallbackDisableDomain(subscriber, domain);
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackDisableAllDomains(pti_callback_subscriber_handle subscriber) {
-  try {
-    return Instance().CallbackDisableAllDomains(subscriber);
-  } catch (const std::runtime_error& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (const std::exception& e) {
-    LogException(e);
-    return pti_result::PTI_ERROR_INTERNAL;
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
diff --git a/sdk/src/pti_view_load.cc b/sdk/src/pti_view_load.cc
deleted file mode 100644
index 3ddd2fbc..00000000
--- a/sdk/src/pti_view_load.cc
+++ /dev/null
@@ -1,1098 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-
-#include "pti/pti.h"
-#include "pti/pti_metrics.h"
-#include "pti/pti_metrics_scope.h"
-#include "pti/pti_pc_sampling.h"
-#include "pti/pti_view.h"
-#include "pti_lib_handler.h"
-
-static constexpr const char* const kInvalidString = "INVALID";
-
-pti_result ptiViewEnable(pti_view_kind view_kind) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewEnable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewEnable_(view_kind);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewDisable(pti_view_kind view_kind) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewDisable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewDisable_(view_kind);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewGPULocalAvailable() {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewGPULocalAvailable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewGPULocalAvailable_();
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-const char* ptiViewOverheadKindToString(pti_view_overhead_kind type) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return kInvalidString;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewOverheadKindToString_) {
-      return kInvalidString;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewOverheadKindToString_(type);
-  } catch (...) {
-    return kInvalidString;
-  }
-}
-const char* ptiViewMemoryTypeToString(pti_view_memory_type type) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return kInvalidString;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewMemoryTypeToString_) {
-      return kInvalidString;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewMemoryTypeToString_(type);
-  } catch (...) {
-    return kInvalidString;
-  }
-}
-
-const char* ptiViewMemcpyTypeToString(pti_view_memcpy_type type) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return kInvalidString;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewMemcpyTypeToString_) {
-      return kInvalidString;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewMemcpyTypeToString_(type);
-  } catch (...) {
-    return kInvalidString;
-  }
-}
-
-pti_result ptiViewSetCallbacks(pti_fptr_buffer_requested fptr_bufferRequested,
-                               pti_fptr_buffer_completed fptr_bufferCompleted) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewSetCallbacks_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewSetCallbacks_(fptr_bufferRequested,
-                                                               fptr_bufferCompleted);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewGetNextRecord(uint8_t* buffer, size_t valid_bytes,
-                                pti_view_record_base** record) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewGetNextRecord_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewGetNextRecord_(buffer, valid_bytes, record);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiFlushAllViews() {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiFlushAllViews_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiFlushAllViews_();
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewPushExternalCorrelationId(pti_view_external_kind external_kind,
-                                            uint64_t external_id) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewPushExternalCorrelationId_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewPushExternalCorrelationId_(external_kind,
-                                                                            external_id);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewPopExternalCorrelationId(pti_view_external_kind external_kind,
-                                           uint64_t* p_external_id) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewPopExternalCorrelationId_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewPopExternalCorrelationId_(external_kind,
-                                                                           p_external_id);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-uint64_t ptiViewGetTimestamp() {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return 0;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewGetTimestamp_) {
-      return 0;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewGetTimestamp_();
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewSetTimestampCallback(pti_fptr_get_timestamp fptr_timestampRequested) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewSetTimestampCallback_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewSetTimestampCallback_(fptr_timestampRequested);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewGetApiIdName(pti_api_group_id type, uint32_t unique_id, const char** name) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewGetApiIdName_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewGetApiIdName_(type, unique_id, name);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewEnableDriverApi(uint32_t enable, pti_api_group_id type, uint32_t api_id) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewEnableDriverApi_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewEnableDriverApi_(enable, type, api_id);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewEnableRuntimeApi(uint32_t enable, pti_api_group_id type, uint32_t api_id) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewEnableRuntimeApi_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewEnableRuntimeApi_(enable, type, api_id);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiViewEnableDriverApiClass(uint32_t enable, pti_api_class api_class,
-                                       pti_api_group_id group) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewEnableDriverApiClass_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewEnableDriverApiClass_(enable, api_class, group);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-pti_result ptiViewEnableRuntimeApiClass(uint32_t enable, pti_api_class api_class,
-                                        pti_api_group_id group) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiViewEnableRuntimeApiClass_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiViewEnableRuntimeApiClass_(enable, api_class, group);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-// Metrics functions
-pti_result ptiMetricsGetDevices(pti_device_properties_t* devices, uint32_t* device_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsGetDevices_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsGetDevices_(devices, device_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsEnable(pti_device_handle_t device) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsEnable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsEnable_(device);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsDisable(pti_device_handle_t device) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsDisable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsDisable_(device);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsGetMetricGroups(pti_device_handle_t device_handle,
-                                     pti_metrics_group_properties_t* metrics_groups,
-                                     uint32_t* metrics_group_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsGetMetricGroups_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsGetMetricGroups_(device_handle, metrics_groups,
-                                                                     metrics_group_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsGetMetricsProperties(pti_metrics_group_handle_t metrics_group_handle,
-                                          pti_metric_properties_t* metrics) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsGetMetricsProperties_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsGetMetricsProperties_(metrics_group_handle,
-                                                                          metrics);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsConfigureCollection(
-    pti_device_handle_t device_handle, pti_metrics_group_collection_params_t* metric_config_params,
-    uint32_t metrics_group_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsConfigureCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsConfigureCollection_(
-        device_handle, metric_config_params, metrics_group_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsStartCollection(pti_device_handle_t device_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsStartCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsStartCollection_(device_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsStartCollectionPaused(pti_device_handle_t device_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsStartCollectionPaused_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsStartCollectionPaused_(device_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsPauseCollection(pti_device_handle_t device_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsPauseCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsPauseCollection_(device_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsResumeCollection(pti_device_handle_t device_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsResumeCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsResumeCollection_(device_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsStopCollection(pti_device_handle_t device_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsStopCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsStopCollection_(device_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsGetCalculatedData(pti_device_handle_t device_handle,
-                                       pti_metrics_group_handle_t metrics_group_handle,
-                                       pti_value_t* metrics_values_buffer,
-                                       uint32_t* metrics_values_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsGetCalculatedData_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsGetCalculatedData_(
-        device_handle, metrics_group_handle, metrics_values_buffer, metrics_values_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-// Metrics Scope functions
-pti_result ptiMetricsScopeEnable(pti_scope_collection_handle_t* scope_collection_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeEnable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeEnable_(scope_collection_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeConfigure(pti_scope_collection_handle_t scope_collection_handle,
-                                    pti_metrics_scope_mode_t collection_mode,
-                                    pti_device_handle_t* devices_to_profile, uint32_t device_count,
-                                    const char** metric_names, size_t metric_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeConfigure_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeConfigure_(
-        scope_collection_handle, collection_mode, devices_to_profile, device_count, metric_names,
-        metric_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeStartCollection(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeStartCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeStartCollection_(scope_collection_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeStopCollection(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeStopCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeStopCollection_(scope_collection_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeDisable(pti_scope_collection_handle_t scope_collection_handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeDisable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeDisable_(scope_collection_handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeQueryCollectionBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, size_t scopes_number,
-    size_t* estimated_buffer_size) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeQueryCollectionBufferSize_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeQueryCollectionBufferSize_(
-        scope_collection_handle, scopes_number, estimated_buffer_size);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeSetCollectionBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, size_t buffer_size) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeSetCollectionBufferSize_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeSetCollectionBufferSize_(
-        scope_collection_handle, buffer_size);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeGetCollectionBuffersCount(
-    pti_scope_collection_handle_t scope_collection_handle, size_t* buffer_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBuffersCount_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBuffersCount_(
-        scope_collection_handle, buffer_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeGetCollectionBuffer(pti_scope_collection_handle_t scope_collection_handle,
-                                              size_t buffer_index, void** buffer,
-                                              size_t* buffer_size) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBuffer_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBuffer_(
-        scope_collection_handle, buffer_index, buffer, buffer_size);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeGetCollectionBufferProperties(
-    pti_scope_collection_handle_t scope_collection_handle, void* collection_buffer,
-    pti_metrics_scope_collection_buffer_properties_t* props) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBufferProperties_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeGetCollectionBufferProperties_(
-        scope_collection_handle, collection_buffer, props);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeCalculateMetrics(pti_scope_collection_handle_t scope_collection_handle,
-                                           void* collection_buffer, void* metrics_buffer,
-                                           size_t metrics_buffer_size, size_t* records_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeCalculateMetrics_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeCalculateMetrics_(
-        scope_collection_handle, collection_buffer, metrics_buffer, metrics_buffer_size,
-        records_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeQueryMetricsBufferSize(
-    pti_scope_collection_handle_t scope_collection_handle, void* collection_buffer,
-    size_t* required_metrics_buffer_size, size_t* records_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeQueryMetricsBufferSize_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeQueryMetricsBufferSize_(
-        scope_collection_handle, collection_buffer, required_metrics_buffer_size, records_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingEnable(pti_pc_sampling_handle_t* handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingEnable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingEnable_(handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingConfigure(pti_pc_sampling_handle_t handle,
-                                  const pti_device_handle_t* devices, size_t device_count,
-                                  uint32_t sampling_period_ns) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingConfigure_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingConfigure_(handle, devices, device_count,
-                                                                  sampling_period_ns);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingQueryCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                                  size_t* buffer_size) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingQueryCollectionBufferSize_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingQueryCollectionBufferSize_(handle,
-                                                                                  buffer_size);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingSetCollectionBufferSize(pti_pc_sampling_handle_t handle,
-                                                size_t buffer_size) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingSetCollectionBufferSize_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingSetCollectionBufferSize_(handle,
-                                                                                buffer_size);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingStartCollection(pti_pc_sampling_handle_t handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingStartCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingStartCollection_(handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingStopCollection(pti_pc_sampling_handle_t handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingStopCollection_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingStopCollection_(handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetStallReasons(pti_pc_sampling_handle_t handle,
-                                        pti_pc_sampling_stall_reason_info_t* reasons,
-                                        size_t* reason_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetStallReasons_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetStallReasons_(handle, reasons,
-                                                                        reason_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetProfiledDevices(pti_pc_sampling_handle_t handle,
-                                           pti_device_handle_t* devices, size_t* device_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetProfiledDevices_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetProfiledDevices_(handle, devices,
-                                                                           device_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetObservedKernelHandles(pti_pc_sampling_handle_t handle,
-                                                 pti_device_handle_t device,
-                                                 uint64_t* kernel_handles, size_t* kernel_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetObservedKernelHandles_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetObservedKernelHandles_(
-        handle, device, kernel_handles, kernel_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetObservedKernelInfo(pti_pc_sampling_handle_t handle,
-                                              pti_device_handle_t device, uint64_t kernel_handle,
-                                              pti_pc_sampling_kernel_info_t* kernel_info) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetObservedKernelInfo_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetObservedKernelInfo_(
-        handle, device, kernel_handle, kernel_info);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetSamplesPerInstruction(pti_pc_sampling_handle_t handle,
-                                                 pti_device_handle_t device, uint64_t kernel_handle,
-                                                 pti_pc_sampling_instruction_t* instruction_buffer,
-                                                 size_t instruction_buffer_count,
-                                                 uint64_t* samples_buffer,
-                                                 size_t samples_buffer_count) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetSamplesPerInstruction_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetSamplesPerInstruction_(
-        handle, device, kernel_handle, instruction_buffer, instruction_buffer_count, samples_buffer,
-        samples_buffer_count);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingGetDeviceStatus(pti_pc_sampling_handle_t handle, pti_device_handle_t device,
-                                        pti_pc_sampling_device_status_t* device_status) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingGetDeviceStatus_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingGetDeviceStatus_(handle, device,
-                                                                        device_status);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiPcSamplingDisable(pti_pc_sampling_handle_t handle) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiPcSamplingDisable_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiPcSamplingDisable_(handle);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiMetricsScopeGetMetricsMetadata(pti_scope_collection_handle_t scope_collection_handle,
-                                             pti_metrics_scope_record_metadata_t* metadata) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiMetricsScopeGetMetricsMetadata_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiMetricsScopeGetMetricsMetadata_(
-        scope_collection_handle, metadata);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackSubscribe(pti_callback_subscriber_handle* subscriber,
-                                pti_callback_function callback, void* user_data) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiCallbackSubscribe_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackSubscribe_(subscriber, callback, user_data);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackUnsubscribe(pti_callback_subscriber_handle subscriber) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiCallbackUnsubscribe_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackUnsubscribe_(subscriber);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackEnableDomain(pti_callback_subscriber_handle subscriber,
-                                   pti_callback_domain domain, uint32_t enter_cb,
-                                   uint32_t exit_cb) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiCallbackEnableDomain_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackEnableDomain_(subscriber, domain, enter_cb,
-                                                                   exit_cb);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackDisableDomain(pti_callback_subscriber_handle subscriber,
-                                    pti_callback_domain domain) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiCallbackDisableDomain_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackDisableDomain_(subscriber, domain);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-pti_result ptiCallbackDisableAllDomains(pti_callback_subscriber_handle subscriber) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ViewAvailable()) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (!pti::PtiLibHandler::Instance().ptiCallbackDisableAllDomains_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackDisableAllDomains_(subscriber);
-  } catch (...) {
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-}
-
-const char* ptiCallbackDomainTypeToString(pti_callback_domain domain) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ptiCallbackDomainTypeToString_) {
-      return kInvalidString;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackDomainTypeToString_(domain);
-  } catch (...) {
-    return kInvalidString;
-  }
-}
-
-const char* ptiCallbackPhaseTypeToString(pti_callback_phase phase) {
-  try {
-    if (!pti::PtiLibHandler::Instance().ptiCallbackPhaseTypeToString_) {
-      return kInvalidString;
-    }
-
-    return pti::PtiLibHandler::Instance().ptiCallbackPhaseTypeToString_(phase);
-  } catch (...) {
-    return kInvalidString;
-  }
-}
diff --git a/sdk/src/sycl/sycl_collector.cc b/sdk/src/sycl/sycl_collector.cc
deleted file mode 100644
index 8aca4f53..00000000
--- a/sdk/src/sycl/sycl_collector.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "sycl_collector.h"
-
-#include <cstring>
-#include <xpti/xpti_trace_framework.hpp>
-
-// NOLINTNEXTLINE
-XPTI_CALLBACK_API void xptiTraceInit(unsigned int major_version, unsigned int minor_version,
-                                     const char* version_str, const char* stream_name) {
-  XptiStreamRegistrationHandler::Instance().InitializeStream(major_version, minor_version,
-                                                             version_str, stream_name);
-}
-
-// NOLINTNEXTLINE
-XPTI_CALLBACK_API void xptiTraceFinish(const char* /*stream_name*/) {}
-
-#ifdef XPTI_HAS_STREAM_DETAIL_LEVEL
-XPTI_CALLBACK_API bool xptiQuerySubscriberStreamDetailLevel(const char* stream_name,
-                                                            xpti::stream_detail_level_t* level) {
-  // The framework calls this to query our desired detail level
-  if (!level) return false;
-
-  if (stream_name && std::strcmp(stream_name, "sycl") == 0) {
-    // Request BASIC level for minimal overhead on the sycl stream
-    *level = xpti::stream_detail_level_t::XPTI_STREAM_DETAIL_LEVEL_BASIC;
-  } else {
-    // Use NORMAL (default) for other streams
-    *level = xpti::stream_detail_level_t::XPTI_STREAM_DETAIL_LEVEL_NORMAL;
-  }
-  return true;
-}
-#endif
-
-// clang-format off
-extern "C" {
-  void
-#if (defined(_WIN32) || defined(_WIN64))
-  __declspec(dllexport)
-#else
-  __attribute__((visibility("default")))
-#endif
-  PtiSetXPTIEnvironmentDetails(bool is_foreign_subscriber,
-                               bool is_likely_unitrace_subscriber) {
-    SyclCollector::foreign_subscriber_ = is_foreign_subscriber;
-    SyclCollector::likely_unitrace_subscriber_ = is_likely_unitrace_subscriber;
-  }
-}
-// clang-format on
-
-#if (defined(_WIN32) || defined(_WIN64))
-
-#include <windows.h>
-
-BOOL WINAPI DllMain(HINSTANCE /*hinstDLL*/, DWORD fwdReason, LPVOID /*lpvReserved*/) {
-  switch (fwdReason) {
-    case DLL_PROCESS_ATTACH: {
-      break;
-    }
-    case DLL_THREAD_ATTACH:
-      break;
-    case DLL_THREAD_DETACH:
-      framework_finalized = true;
-      break;
-    case DLL_PROCESS_DETACH:
-      break;
-  }
-
-  return TRUE;
-}
-
-#else  // Linux (possibly macOS?)
-
-// NOLINTNEXTLINE
-__attribute__((destructor)) static void framework_fini() { framework_finalized = true; }
-
-#endif
diff --git a/sdk/src/sycl/sycl_collector.h b/sdk/src/sycl/sycl_collector.h
deleted file mode 100644
index 9ea236f7..00000000
--- a/sdk/src/sycl/sycl_collector.h
+++ /dev/null
@@ -1,478 +0,0 @@
-//
-// TODO(juf): need to put our own license here
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//
-#ifndef PTI_TOOLS_SYCL_COLLECTOR_H_
-#define PTI_TOOLS_SYCL_COLLECTOR_H_
-#include <spdlog/spdlog.h>
-
-#include <array>
-#include <atomic>
-#include <cstdio>
-#include <cstring>
-#include <ctime>
-#include <map>
-#include <string>
-#include <string_view>
-#include <unordered_map>
-#include <xpti/xpti_trace_framework.hpp>
-
-#include "library_loader.h"
-#include "platform_strings.h"
-#include "pti/pti_runtime_sycl_api_ids.h"
-#include "pti_api_ids_state_maps.h"
-#include "sycl_core_apis.h"
-#include "unikernel.h"
-#include "utils.h"
-
-inline static constexpr std::string_view kStashedSymbolName = "xptiGetStashedTuple";
-inline static constexpr std::string_view kUnknownFunctionName = "<unknown>";
-
-using StashedFuncPtr = decltype(&xptiGetStashedTuple);
-
-inline constexpr auto kMaxFuncNameLen = static_cast<std::size_t>(2048);
-static_assert(
-    kUnknownFunctionName.size() < kMaxFuncNameLen,
-    "Placeholder function name size must be less than the size of the max function name length");
-inline constexpr uint64_t kDefaultQueueId = PTI_INVALID_QUEUE_ID;
-
-using OnSyclRuntimeViewCallback = void (*)(void* data, ZeKernelCommandExecutionRecord& kcexec);
-
-enum class SyclImpl { kPi, kUr };
-
-inline thread_local std::map<uint64_t, uint64_t> node_q_map = {};
-struct SyclUrFuncT {
-  std::array<char, kMaxFuncNameLen> func_name;
-  uint32_t func_pid;
-  uint32_t func_tid;
-};
-
-inline thread_local bool framework_finalized = false;
-
-inline constexpr static std::array<const char* const, 13> kSTraceType = {
-    "TaskBegin",           "TaskEnd",     "Signal",    "NodeCreate", "FunctionWithArgsBegin",
-    "FunctionWithArgsEnd", "Metadata",    "WaitBegin", "WaitEnd",    "FunctionBegin",
-    "FunctionEnd",         "QueueCreate", "Other"};
-
-inline const char* GetTracePointTypeString(xpti::trace_point_type_t trace_type) {
-  switch (trace_type) {
-    case xpti::trace_point_type_t::task_begin:
-      return kSTraceType[0];
-    case xpti::trace_point_type_t::task_end:
-      return kSTraceType[1];
-    case xpti::trace_point_type_t::signal:
-      return kSTraceType[2];
-    case xpti::trace_point_type_t::node_create:
-      return kSTraceType[3];
-    case xpti::trace_point_type_t::function_with_args_begin:
-      return kSTraceType[4];
-    case xpti::trace_point_type_t::function_with_args_end:
-      return kSTraceType[5];
-    case xpti::trace_point_type_t::metadata:
-      return kSTraceType[6];
-    case xpti::trace_point_type_t::wait_begin:
-      return kSTraceType[7];
-    case xpti::trace_point_type_t::wait_end:
-      return kSTraceType[8];
-    case xpti::trace_point_type_t::function_begin:
-      return kSTraceType[9];
-    case xpti::trace_point_type_t::function_end:
-      return kSTraceType[10];
-    case xpti::trace_point_type_t::queue_create:
-      return kSTraceType[11];
-    default:
-      return kSTraceType[12];
-  }
-}
-
-inline std::string Truncate(const std::string& name) {
-  size_t pos = name.find_last_of(":");
-  if (pos != std::string::npos) {
-    return name.substr(pos + 1);
-  }
-  return name;
-}
-
-// Metadata key classification enum and cache
-enum class MetadataKeyType : uint8_t { kUnknown = 0, kKernel = 1, kMemory = 2 };
-inline thread_local std::unordered_map<xpti::string_id_t, MetadataKeyType> metadata_key_type_cache;
-
-inline MetadataKeyType ClassifyMetadataKey(xpti::string_id_t xpti_metadata_key) {
-  auto it = metadata_key_type_cache.find(xpti_metadata_key);
-  if (it != metadata_key_type_cache.end()) {
-    return it->second;
-  }
-
-  const auto* const xpti_metadata_name = xptiLookupString(xpti_metadata_key);
-  MetadataKeyType type = MetadataKeyType::kUnknown;
-
-  if (std::strcmp(xpti_metadata_name, "kernel_name") == 0) {
-    type = MetadataKeyType::kKernel;
-  } else if (std::strstr(xpti_metadata_name, "memory") != nullptr) {
-    type = MetadataKeyType::kMemory;
-  }
-
-  metadata_key_type_cache[xpti_metadata_key] = type;
-  return type;
-}
-
-inline bool IsMemoryOperation(xpti::string_id_t xpti_metadata_key) {
-  return ClassifyMetadataKey(xpti_metadata_key) == MetadataKeyType::kMemory;
-}
-
-inline bool IsKernelOperation(xpti::string_id_t xpti_metadata_key) {
-  return ClassifyMetadataKey(xpti_metadata_key) == MetadataKeyType::kKernel;
-}
-
-class SyclCollector {
- public:
-  // Variables to indicate the presence of a foreign subscriber to XPTI.
-  // To be set via call to ptiSetXPTIEnvironmentDetails before SyclCollector created
-  static inline bool foreign_subscriber_ = false;
-  static inline bool likely_unitrace_subscriber_ = false;
-
-  static auto& Instance() {
-    static SyclCollector sycl_collector{nullptr};
-    return sycl_collector;
-  }
-
-  void EnableTracing() {
-    // Do not change the behaviour here depending on foreign_subscriber_!
-    // The current behavior ensures that in the absence of XPTI subscription (and Sycl records)
-    // PTI generates to-called Special Records
-    // About Special Records: see comments in unitrace.h
-    enabled_ = true;
-    xptiForceSetTraceEnabled(enabled_);
-  }
-
-  void DisableTracing() {
-    enabled_ = false;
-    if (streams_found_) {
-      // Don't allow the collector to be disabled unless all the xpti streams we require are found.
-      xptiForceSetTraceEnabled(enabled_);
-    }
-  }
-
-  bool Enabled() const { return enabled_; }
-
-  void StreamsInitialized() { streams_found_ = true; }
-
-  //  For compiler versions < 2024.1.1. Manually load xptiGetStashedTuple.
-  inline static StashedFuncPtr GetStashedFuncPtrFromSharedObject() {
-    StashedFuncPtr xptiGetStashedTuple = nullptr;  // NOLINT
-    try {
-      auto xpti_lib = LibraryLoader{pti::strings::kXptiLibName};
-      xptiGetStashedTuple = xpti_lib.GetSymbol<StashedFuncPtr>(kStashedSymbolName.data());
-    } catch ([[maybe_unused]] const std::runtime_error& e) {
-      xptiGetStashedTuple = nullptr;
-      SPDLOG_ERROR("exception caught while trying to get {}: {}", kStashedSymbolName, e.what());
-    } catch (...) {
-      xptiGetStashedTuple = nullptr;
-      SPDLOG_ERROR("unknown exception caught while trying to get {}", kStashedSymbolName);
-    }
-    return xptiGetStashedTuple;
-  }
-
-  void SetCallback(const OnSyclRuntimeViewCallback callback) { acallback_ = callback; }
-
-  static XPTI_CALLBACK_API void TpCallback(uint16_t TraceType, xpti::trace_event_data_t* /*Parent*/,
-                                           xpti::trace_event_data_t* Event, uint64_t /*instance*/,
-                                           const void* user_data) {
-    const auto trace_type = static_cast<xpti::trace_point_type_t>(TraceType);
-
-    switch (trace_type) {
-      case xpti::trace_point_type_t::function_with_args_begin:
-        HandleFunctionWithArgsBegin(user_data);
-        break;
-      case xpti::trace_point_type_t::function_with_args_end:
-        HandleFunctionWithArgsEnd(user_data);
-        break;
-      case xpti::trace_point_type_t::task_begin:
-        HandleTaskBegin(Event);
-        break;
-      case xpti::trace_point_type_t::node_create:
-        HandleNodeCreate(Event);
-        break;
-      case xpti::trace_point_type_t::task_end:
-      case xpti::trace_point_type_t::queue_create:
-      default:
-        break;
-    }
-  }
-
- private:
-  static void HandleFunctionWithArgsBegin(const void* user_data) {
-    sycl_data_kview.cid_ = UniCorrId::GetUniCorrId();
-    sycl_data_mview.cid_ = sycl_data_kview.cid_;
-    SyclCollector::Instance().sycl_runtime_rec_.cid_ = sycl_data_kview.cid_;
-
-    if (!user_data) {
-      return;
-    }
-
-    const auto* args = static_cast<const xpti::function_with_args_t*>(user_data);
-    const auto api_id = static_cast<pti_api_id_runtime_sycl>(args->function_id);
-
-    auto& runtime_rec = SyclCollector::Instance().sycl_runtime_rec_;
-    runtime_rec.pid_ = PidTidInfo::Get().pid;
-    runtime_rec.tid_ = PidTidInfo::Get().tid;
-    runtime_rec.callback_id_ = args->function_id;
-
-    const ApiType api_type = GetApiType(api_id);
-
-    runtime_rec.start_time_ = utils::GetTime();
-    if (api_type == ApiType::kKernel) {
-      sycl_data_kview.sycl_enqk_begin_time_ = runtime_rec.start_time_;
-    } else if (api_type == ApiType::kMemory) {
-      sycl_data_mview.sycl_task_begin_time_ = runtime_rec.start_time_;
-    } else if (api_type == ApiType::kGraph) {
-      sycl_data_kview.sycl_task_begin_time_ = runtime_rec.start_time_;
-      sycl_data_mview.sycl_task_begin_time_ = runtime_rec.start_time_;
-      sycl_data_kview.sycl_enqk_begin_time_ = runtime_rec.start_time_;
-      sycl_data_mview.sycl_enqk_begin_time_ = runtime_rec.start_time_;
-    }
-  }
-
-  static void HandleFunctionWithArgsEnd(const void* user_data) {
-    // TODO(PTI): we may want to split this into a separate callback for
-    // function start/end to avoid measuring callback overhead.
-    const auto time = utils::GetTime();
-
-    if (!user_data) {
-      return;
-    }
-
-    const auto* args = static_cast<const xpti::function_with_args_t*>(user_data);
-    const auto api_id = static_cast<pti_api_id_runtime_sycl>(args->function_id);
-
-    const ApiType api_type = GetApiType(api_id);
-    auto& runtime_rec = SyclCollector::Instance().sycl_runtime_rec_;
-
-    if (api_type == ApiType::kKernel) {
-      runtime_rec.kid_ = sycl_data_kview.kid_;
-    } else if (api_type == ApiType::kMemory) {
-      runtime_rec.kid_ = sycl_data_mview.kid_;
-      runtime_rec.tid_ = sycl_data_mview.tid_;
-    }
-    if (args->ret_data) {
-      runtime_rec.result_ = *static_cast<uint32_t*>(args->ret_data);
-    }
-    runtime_rec.end_time_ = time;
-
-    // Check callback and invoke if needed
-    auto& instance = SyclCollector::Instance();
-    if (instance.acallback_ != nullptr) {
-      const std::lock_guard<std::mutex> lock(sycl_set_granularity_map_mtx);
-      const uint32_t id_enabled = pti_api_id_runtime_sycl_state[args->function_id];
-      const int32_t trace_all = instance.trace_all_env_value_;
-
-      if ((trace_all > 0) || ((trace_all < 0) && id_enabled)) {
-        if (instance.enabled_ && !framework_finalized) {
-          (instance.acallback_.load())(nullptr, runtime_rec);
-        }
-      }
-
-      // Reset state
-      runtime_rec.kid_ = 0;
-      sycl_data_kview.kid_ = 0;
-      sycl_data_kview.tid_ = 0;
-      sycl_data_kview.cid_ = 0;
-      sycl_data_mview.kid_ = 0;
-      sycl_data_mview.tid_ = 0;
-      sycl_data_mview.cid_ = 0;
-    }
-  }
-
-  static void HandleTaskBegin(xpti::trace_event_data_t* Event) {
-    if (!Event) {
-      return;
-    }
-
-    const uint64_t ID = Event->unique_id;
-    const uint64_t Instance_ID = Event->instance_id;
-    const auto* metadata = xptiQueryMetadata(Event);
-    auto time = utils::GetTime();
-
-    for (const auto& item : *metadata) {
-      if (IsKernelOperation(item.first)) {
-        const auto* payload = xptiQueryPayload(Event);
-        if (payload) {
-          if (payload->source_file) {
-            sycl_data_kview.source_file_name_ = std::string{payload->source_file};
-          }
-          sycl_data_kview.source_line_number_ = payload->line_no;
-        }
-
-        sycl_data_kview.sycl_node_id_ = ID;
-        const auto queue_id_loc = node_q_map.find(ID);
-        sycl_data_kview.sycl_queue_id_ =
-            (queue_id_loc != std::end(node_q_map)) ? queue_id_loc->second : kDefaultQueueId;
-        sycl_data_kview.sycl_invocation_id_ = static_cast<uint32_t>(Instance_ID);
-        sycl_data_kview.sycl_task_begin_time_ = time;
-        return;
-      }
-
-      if (IsMemoryOperation(item.first)) {
-        const auto queue_id_loc = node_q_map.find(ID);
-        sycl_data_mview.sycl_queue_id_ =
-            (queue_id_loc != std::end(node_q_map)) ? queue_id_loc->second : kDefaultQueueId;
-        sycl_data_mview.sycl_task_begin_time_ = time;
-        return;
-      }
-    }
-  }
-
-  static void HandleNodeCreate(xpti::trace_event_data_t* Event) {
-    if (!Event) {
-      return;
-    }
-
-    const uint64_t ID = Event->unique_id;
-    char* stashed_key = nullptr;
-    uint64_t stashed_value = 0;
-
-    auto& instance = SyclCollector::Instance();
-    if (instance.xptiGetStashedKV_ && (instance.xptiGetStashedKV_(&stashed_key, stashed_value) ==
-                                       xpti::result_t::XPTI_RESULT_SUCCESS)) {
-      if (std::strcmp(stashed_key, "queue_id") == 0) {
-        node_q_map[ID] = stashed_value;
-      }
-    } else {
-      node_q_map[ID] = kDefaultQueueId;
-    }
-
-    const uint64_t queue_id = node_q_map[ID];
-    const auto* metadata = xptiQueryMetadata(Event);
-
-    for (const auto& item : *metadata) {
-      if (IsKernelOperation(item.first)) {
-        sycl_data_kview.sycl_queue_id_ = queue_id;
-        return;
-      }
-      if (IsMemoryOperation(item.first)) {
-        sycl_data_mview.sycl_queue_id_ = queue_id;
-        return;
-      }
-    }
-  }
-
- private:
-  static constexpr const char* const kWarnForeignSubscriber =
-      "Another subscriber already subscribed to Sycl runtime events, "
-      "so PTI will not subscribe to them. It will affect correctness of PTI profile: "
-      "e.g. report zero XPU time for CPU callers of GPU kernels.";
-
-  static constexpr const char* const kWarnLikelyUnitraceSubscriber =
-      " Likely the application running under Unitrace. "
-      "To get correct PTI profile - run without Unitrace.";
-
-  explicit SyclCollector(OnSyclRuntimeViewCallback buffer_callback)
-      : acallback_(buffer_callback), xptiGetStashedKV_(GetStashedFuncPtrFromSharedObject()) {
-    if (foreign_subscriber_) {
-      SPDLOG_WARN("{}{}", kWarnForeignSubscriber,
-                  likely_unitrace_subscriber_ ? kWarnLikelyUnitraceSubscriber : "");
-    }
-  }
-
-  int32_t trace_all_env_value_ = utils::IsSetEnv("PTI_VIEW_RUNTIME_API");
-  inline static thread_local ZeKernelCommandExecutionRecord sycl_runtime_rec_;
-  std::atomic<OnSyclRuntimeViewCallback> acallback_ = nullptr;
-  std::atomic<bool> enabled_ = false;
-  std::atomic<bool> streams_found_ = false;
-  StashedFuncPtr xptiGetStashedKV_ = nullptr;
-};
-
-class XptiStreamRegistrationHandler {
- public:
-  // We register two streams. One for "sycl" and another for the sycl implementation (e.g. plugin
-  // interface or unified runtime)
-  constexpr static size_t kNumberOfStreams = 2;
-
-  static auto& Instance() {
-    static XptiStreamRegistrationHandler handler{};
-    return handler;
-  }
-
-  bool RegistrationComplete() const { return stream_count_ >= kNumberOfStreams; }
-
-  void InitializeStream(unsigned int /*major_version*/, unsigned int /*minor_version*/,
-                        [[maybe_unused]] const char* version_str, const char* stream_name) {
-    SPDLOG_TRACE("XPTI Stream: Found --->: {} v{}", stream_name, version_str);
-    if (std::strcmp(stream_name, "sycl") == 0) {  // SYCL Stream
-      stream_id_ = xptiRegisterStream(stream_name);
-      RegisterSyclCallbacks(stream_id_);
-      SPDLOG_DEBUG("Registered callbacks for {}", stream_name);
-      ++stream_count_;
-    } else if (std::strcmp(stream_name, "ur.call") == 0 ||
-               std::strcmp(stream_name, "ur") == 0) {  // UNIFIED
-                                                       // RUNTIME
-      stream_id_ = xptiRegisterStream(stream_name);
-      RegisterImplCallbacks(stream_id_);
-      SPDLOG_DEBUG("Registering callbacks for {}", stream_name);
-      ++stream_count_;
-    } else {
-      SPDLOG_DEBUG("XPTI Stream: {} v{} no callbacks registered!", stream_name, version_str);
-    }
-    CheckAndDisableCollectorIfNotEnabled();
-  }
-
- private:
-  // Helper to register a single callback and check result
-  static void RegisterCallback(uint8_t stream_id, xpti::trace_point_type_t trace_point) {
-    const auto result = xptiRegisterCallback(stream_id, static_cast<uint16_t>(trace_point),
-                                             SyclCollector::TpCallback);
-    if (result != xpti::result_t::XPTI_RESULT_SUCCESS) {
-      SPDLOG_ERROR("For XPTI Stream ID: {} Callback Registration for trace point {} returned: {}",
-                   static_cast<int32_t>(stream_id), static_cast<int32_t>(trace_point),
-                   static_cast<int32_t>(result));
-    }
-  }
-
-  static void RegisterSyclCallbacks(uint8_t stream_id) {
-    // Register callback to predefined trace point types
-    constexpr std::array<xpti::trace_point_type_t, 3> trace_points = {
-        xpti::trace_point_type_t::node_create, xpti::trace_point_type_t::task_begin,
-        xpti::trace_point_type_t::task_end};
-
-    for (const auto trace_point : trace_points) {
-      RegisterCallback(stream_id, trace_point);
-    }
-  }
-
-  static void RegisterImplCallbacks(uint8_t stream_id) {
-    RegisterCallback(stream_id, xpti::trace_point_type_t::function_with_args_begin);
-    RegisterCallback(stream_id, xpti::trace_point_type_t::function_with_args_end);
-    RegisterCallback(stream_id, xpti::trace_point_type_t::metadata);
-  }
-
-  //  Until the user calls EnableTracing(), disable tracing when we are
-  //  able to capture the sycl runtime streams sycl and sycl.pi
-  //  Empirically, we found the sycl.pi stream gets emitted after the sycl
-  //  stream.
-  void CheckAndDisableCollectorIfNotEnabled() const {
-    if (RegistrationComplete()) {
-      SyclCollector::Instance().StreamsInitialized();
-      if (!SyclCollector::Instance().Enabled()) {
-        SyclCollector::Instance().DisableTracing();
-        // To remove effects of first callbacks that Sycl collector gets
-        // until all streams registered
-        // Zeroing cid_ -s is particularly important for correlation_id fields correctness
-        sycl_data_kview.kid_ = 0;
-        sycl_data_kview.tid_ = 0;
-        sycl_data_kview.cid_ = 0;
-        sycl_data_mview.kid_ = 0;
-        sycl_data_mview.tid_ = 0;
-        sycl_data_mview.cid_ = 0;
-      }
-    }
-  }
-
-  uint8_t stream_id_ = 0;
-  std::atomic<size_t> stream_count_ = 0;
-};
-
-#endif
diff --git a/sdk/src/sycl/sycl_core_apis.h b/sdk/src/sycl/sycl_core_apis.h
deleted file mode 100644
index 0bc625ad..00000000
--- a/sdk/src/sycl/sycl_core_apis.h
+++ /dev/null
@@ -1,68 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef PTI_SRC_SYCL_SYCL_CORE_APIS_H_
-#define PTI_SRC_SYCL_SYCL_CORE_APIS_H_
-
-#include <array>
-
-#include "pti/pti_runtime_sycl_api_ids.h"
-
-// Classification of UR API calls that correspond to GPU operations submitted via sycl::queue.
-// Single source of truth used by:
-//   - sycl_collector.h  — to route callbacks to kernel / memory / graph handling
-//   - view_handler.h    — to enable/disable these APIs as a granularity class
-enum class ApiType { kInvalid = 0, kKernel = 1, kMemory = 2, kGraph = 3 };
-
-struct SyclCoreApi {
-  pti_api_id_runtime_sycl id;
-  ApiType type;
-};
-
-inline constexpr std::array kSyclCoreApis = {
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueUSMFill_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueUSMFill2D_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueUSMMemcpy_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueUSMMemcpy2D_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id, ApiType::kKernel},
-    // two APIs below removed in 2025.3+ compiler runtime,
-    // but we keep them around for the case when someone runs with earlier runtime
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueKernelLaunchCustomExp_id, ApiType::kKernel},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueCooperativeKernelLaunchExp_id, ApiType::kKernel},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueKernelLaunchWithArgsExp_id, ApiType::kKernel},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueMemBufferFill_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueMemBufferRead_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueMemBufferWrite_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueMemBufferCopy_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urUSMHostAlloc_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urUSMSharedAlloc_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urUSMDeviceAlloc_id, ApiType::kMemory},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueCommandBufferExp_id, ApiType::kGraph},
-    SyclCoreApi{pti_api_id_runtime_sycl::urEnqueueGraphExp_id, ApiType::kGraph},
-};
-
-// kSyclCoreApis must stay within the compiler's full-unroll budget.
-// Benchmarking shows that icpx -O2 completely unrolls the linear scan up to
-// N=36; at N=37 it switches to a partial unroll and performance degrades ~5x.
-// If this array grows beyond 36 entries, switch GetApiType to a sparse array
-// indexed by (id - min_id) for O(1) lookup without hashing overhead.
-// See: https://github.com/jfedorov/snippets/tree/main/perf_array_vs_unordered_map
-static_assert(kSyclCoreApis.size() <= 36,
-              "kSyclCoreApis exceeds the compiler unroll threshold (36). "
-              "Switch GetApiType to a sparse array lookup for better performance. "
-              "See https://github.com/jfedorov/snippets/tree/main/perf_array_vs_unordered_map");
-
-// Returns ApiType for the given api_id, or ApiType::kInvalid if not a core API.
-// Linear scan is intentional: benchmarking shows that for N <= 36 a completely
-// unrolled scan over a contiguous constexpr array is faster than both
-// std::unordered_map and a sparse array lookup.
-inline constexpr ApiType GetApiType(pti_api_id_runtime_sycl api_id) noexcept {
-  for (const auto& entry : kSyclCoreApis) {
-    if (entry.id == api_id) return entry.type;
-  }
-  return ApiType::kInvalid;
-}
-
-#endif  // PTI_SRC_SYCL_SYCL_CORE_APIS_H_
diff --git a/sdk/src/unikernel.h b/sdk/src/unikernel.h
deleted file mode 100644
index d993dbac..00000000
--- a/sdk/src/unikernel.h
+++ /dev/null
@@ -1,164 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNIKERNEL_H
-#define PTI_TOOLS_UNITRACE_UNIKERNEL_H
-
-#include <level_zero/layers/zel_tracing_api.h>
-
-#include <atomic>
-#include <cstdint>
-#include <cstring>
-#include <map>
-#include <stack>
-#include <string>
-
-#include "pti/pti_view.h"
-#include "pti_memory_route.h"
-#include "utils.h"
-
-class UniCorrId {
- public:
-  static uint32_t GetUniCorrId(void) {
-    return unique_id_.fetch_add(1, std::memory_order::memory_order_relaxed);
-  }
-
- private:
-  inline static std::atomic<uint32_t> unique_id_ = 1;  // start with 1
-};
-
-class UniKernelId {
- public:
-  static uint64_t GetKernelId(void) {
-    return kernel_id_.fetch_add(1, std::memory_order::memory_order_relaxed);
-  }
-
- private:
-  inline static std::atomic<uint64_t> kernel_id_ = 1;  // start with 1
-};
-
-enum class KernelCommandType { kInvalid = 0, kKernel = 1, kMemory = 2, kCommand = 3 };
-
-struct ZeKernelCommandExecutionRecord {
-  uint64_t sycl_node_id_;
-  uint64_t sycl_queue_id_ = PTI_INVALID_QUEUE_ID;
-  uint32_t sycl_invocation_id_;
-  uint64_t sycl_task_begin_time_;
-  uint64_t sycl_enqk_begin_time_;
-  std::string source_file_name_;
-  const char* sycl_function_name_ = nullptr;
-  uint32_t source_line_number_;
-
-  KernelCommandType command_type_;
-  uint64_t kid_;  // kernel id
-  uint32_t cid_;  // correlation id
-  uint32_t tid_;
-  uint32_t pid_;
-  int32_t tile_;
-  uint64_t append_time_;
-  uint64_t submit_time_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-  ze_pci_ext_properties_t pci_prop_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-
-  ze_command_queue_handle_t queue_ = nullptr;
-  ze_device_handle_t device_ = nullptr;    // in case of memcpy -- represents source
-  ze_context_handle_t context_ = nullptr;  // in case of memcpy -- represents source
-  ze_event_handle_t event_ = nullptr;      // event used for host synchronization.
-
-  PtiMemoryCommandRoute memory_route_;
-  ze_device_handle_t dst_device_;  // in case of memcpy -- represents destination (nullptr else)
-  ze_pci_ext_properties_t dst_pci_prop_;  // in case of memcpy -- represents destination
-
-  uint8_t src_device_uuid[PTI_MAX_DEVICE_UUID_SIZE];
-  uint8_t dst_device_uuid[PTI_MAX_DEVICE_UUID_SIZE];
-
-  bool implicit_scaling_;
-  std::string name_;
-  const char* sycl_func_name_;
-  size_t bytes_xfered_;
-  size_t value_set_;
-
-  uint32_t callback_id_;
-  uint64_t api_start_time_;
-  uint64_t api_end_time_;
-  uint64_t num_wait_events_ = 0;  // tracks wait event count for synchronization activity commands
-  uint32_t result_ = 0;
-};
-
-struct CommunicationRecord {
-  pti_view_external_kind external_kind_;
-  uint32_t pid_;
-  uint32_t tid_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-  uint64_t send_size_;
-  uint64_t recv_size_;
-  uint64_t communicator_id_;
-  const char* name_;
-};
-
-// This structure enables collectors to avoid retrieving pid and tid multiple times.
-// Especially taking into account that getting tid is syscall and thus expensive.
-// Collectors use PidTidInfo::Get() to access thread-local cached pid and tid.
-struct PidTidInfo {
-  uint32_t pid;
-  uint32_t tid;
-
-  static const PidTidInfo& Get() {
-    thread_local const PidTidInfo pid_tid_info = {utils::GetPid(), utils::GetTid()};
-    return pid_tid_info;
-  }
-};
-
-//
-// TODO -- refactor 2nd level callbacks so that callbacks are not bound to
-// ZeKernelCommandExecutionRecord but flexible to handle various smaller structures -- for now
-// side-back smaller structures via void*data in the callbacks.
-//
-inline thread_local ZeKernelCommandExecutionRecord
-    overhead_data;  // Placeholder till we refactor the 2nd level callbacks.
-
-struct ExternalCorrIdKey {
-  pti_view_external_kind _external_kind;
-};
-
-struct ExternalKeyCompare {
-  bool operator()(const ExternalCorrIdKey& lhs, const ExternalCorrIdKey& rhs) const {
-    return lhs._external_kind < rhs._external_kind;
-  }
-};
-
-struct OverheadKindKey {
-  pti_view_overhead_kind _overhead_kind;
-};
-
-struct OverheadKeyCompare {
-  bool operator()(const OverheadKindKey& lhs, const OverheadKindKey& rhs) const {
-    return (std::memcmp((char*)(&lhs), (char*)(&rhs), sizeof(OverheadKindKey)) < 0);
-  }
-};
-
-inline thread_local ZeKernelCommandExecutionRecord sycl_data_mview;
-inline thread_local ZeKernelCommandExecutionRecord sycl_data_kview;
-
-typedef std::map<ExternalCorrIdKey, std::stack<pti_view_record_external_correlation>,
-                 ExternalKeyCompare>
-    ExternalCorrelationIdMapType;
-
-inline thread_local ExternalCorrelationIdMapType thread_local_map_ext_corrid_vectors;
-inline thread_local ExternalCorrelationIdMapType thread_local_map_ext_corrid_vectors_deferred_erase;
-
-inline thread_local bool thread_local_is_within_subscriber_callback = false;
-
-inline thread_local std::map<OverheadKindKey, pti_view_record_overhead, OverheadKeyCompare>
-    map_overhead_per_kind;
-
-// Tracks on a per thread basis if a L0 view_kind has been activated/enabled.
-inline thread_local std::map<pti_view_kind, bool> map_view_kind_enabled;
-#endif  // PTI_TOOLS_UNITRACE_UNIKERNEL_H
diff --git a/sdk/src/utils/demangle.h b/sdk/src/utils/demangle.h
deleted file mode 100644
index 6d562faa..00000000
--- a/sdk/src/utils/demangle.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-//-- copied here from root of this project -- <pti-gpu/utils> directory to facilitate independent
-// ptisdk build
-//
-#ifndef PTI_UTILS_DEMANGLE_H_
-#define PTI_UTILS_DEMANGLE_H_
-
-#if __has_include(<cxxabi.h>)
-#define HAVE_CXXABI 1
-#include <cxxabi.h>
-
-#include <cstring>
-#else
-#define HAVE_CXXABI 0
-#endif
-#include <string>
-
-#include "pti_assert.h"
-
-namespace utils {
-
-static inline std::string Demangle(const char* name) {
-  PTI_ASSERT(name != nullptr);
-
-#if HAVE_CXXABI
-  int status = 0;
-  char* demangled = abi::__cxa_demangle(name, nullptr, 0, &status);
-  if (status != 0) {
-    return name;
-  }
-
-  // TODO(PTI): string_view might be more appropriate here
-  constexpr const char* const kPrefixToSkip = "typeinfo name for ";
-  const size_t prefix_to_skip_len = strlen(kPrefixToSkip);
-  const size_t shift =
-      (std::strncmp(demangled, kPrefixToSkip, prefix_to_skip_len) == 0) ? prefix_to_skip_len : 0;
-
-  std::string result(demangled + shift);
-  free(demangled);
-  return result;
-#else
-  return name;
-#endif
-}
-
-}  // namespace utils
-
-#undef HAVE_CXXABI
-
-#endif  // PTI_UTILS_DEMANGLE_H_
diff --git a/sdk/src/utils/internal_helper.h b/sdk/src/utils/internal_helper.h
deleted file mode 100644
index 7fd1d9eb..00000000
--- a/sdk/src/utils/internal_helper.h
+++ /dev/null
@@ -1,44 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef INTERNAL_HELPER_H_
-#define INTERNAL_HELPER_H_
-#include <type_traits>
-
-#include "pti/pti_view.h"
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Helper functions to detect wrong value converted to specific enum
-/// type
-template <typename IntType, typename EnumType, typename EnumVal>
-bool IsValid(IntType val, EnumVal V) {
-  static_assert(std::is_enum<EnumVal>::value);
-  static_assert(std::is_same<EnumType, EnumVal>::value);
-  return static_cast<IntType>(V) == val;
-}
-
-template <typename IntType, typename EnumType, typename EnumVal, typename... Next>
-bool IsValid(IntType val, EnumVal V, Next... oth) {
-  static_assert(std::is_enum<EnumVal>::value);
-  static_assert(std::is_same<EnumType, EnumVal>::value);
-
-  return static_cast<IntType>(V) == val || IsValid<IntType, EnumType, Next...>(val, oth...);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Checks is the provided value v belongs to pti_view_kind enums
-bool IsPtiViewKindEnum(int v) {
-  return IsValid<int, pti_view_kind, pti_view_kind, pti_view_kind, pti_view_kind, pti_view_kind,
-                 pti_view_kind, pti_view_kind, pti_view_kind, pti_view_kind, pti_view_kind,
-                 pti_view_kind, pti_view_kind>(
-      v, pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL, pti_view_kind::PTI_VIEW_DEVICE_CPU_KERNEL,
-      pti_view_kind::PTI_VIEW_DRIVER_API, pti_view_kind::PTI_VIEW_RESERVED,
-      pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD, pti_view_kind::PTI_VIEW_RUNTIME_API,
-      pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION, pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY,
-      pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL, pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P,
-      pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION, pti_view_kind::PTI_VIEW_COMMUNICATION);
-}
-#endif  // INTERNAL_HELPER_H_
diff --git a/sdk/src/utils/library_loader.h b/sdk/src/utils/library_loader.h
deleted file mode 100644
index cb5ff6a7..00000000
--- a/sdk/src/utils/library_loader.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// ==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UTILS_LIBRARY_LOADER_H_
-#define UTILS_LIBRARY_LOADER_H_
-
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <system_error>
-#include <type_traits>
-#include <utility>
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-class LibraryLoader {
- public:
-  using SymHandle = void*;
-#if defined(_WIN32)
-  using Handle = HMODULE;
-#else
-  using Handle = void*;
-#endif
-  LibraryLoader() {}
-
-  explicit LibraryLoader(const std::string& lib_name) {
-#if defined(_WIN32)
-    if (!SetDllDirectoryA("")) {
-      throw std::system_error(GetLastError(), std::system_category());
-    }
-    handle_ = LoadLibraryExA(static_cast<LPCSTR>(lib_name.c_str()), nullptr,
-                             static_cast<DWORD>(0x000000000));
-#else
-    handle_ = dlopen(lib_name.c_str(), RTLD_NOW);
-#endif
-    if (!handle_) {
-#if defined(_WIN32)
-      throw std::system_error(GetLastError(), std::system_category());
-#else
-      throw std::runtime_error(dlerror());
-#endif
-    }
-  }
-
-#if defined(__linux__)
-  // The caller owns this handle and releases it when the recovery chain completes.
-  static std::unique_ptr<LibraryLoader> Preload(const std::string& lib_name, std::string& error) {
-    auto* const handle = dlopen(lib_name.c_str(), RTLD_NOW | RTLD_LOCAL);
-    if (handle == nullptr) {
-      const auto* const dl_error = dlerror();
-      error = dl_error != nullptr ? dl_error : "unknown dlopen failure";
-      return nullptr;
-    }
-    return std::unique_ptr<LibraryLoader>(new LibraryLoader(handle));
-  }
-
-  static std::unique_ptr<LibraryLoader> Probe(const std::string& lib_name) {
-    auto* const handle = dlopen(lib_name.c_str(), RTLD_LAZY | RTLD_NOLOAD);
-    if (!handle) {
-      return nullptr;
-    }
-    return std::unique_ptr<LibraryLoader>(new LibraryLoader(handle));
-  }
-#endif  // __linux__
-
-  LibraryLoader(const LibraryLoader&) = delete;
-  LibraryLoader(LibraryLoader&& other) noexcept { std::swap(other.handle_, handle_); }
-  LibraryLoader& operator=(const LibraryLoader&) = delete;
-  LibraryLoader& operator=(LibraryLoader&& other) noexcept {
-    if (this != &other) {
-      std::swap(other.handle_, handle_);
-    }
-    return *this;
-  }
-
-  template <typename T>
-  [[nodiscard]] T GetSymbol(const char* sym_name) {
-    static_assert(std::is_pointer<T>::value);
-#if defined(_WIN32)
-    auto sym_addr = GetProcAddress(handle_, sym_name);
-#else
-    auto sym_addr = dlsym(handle_, sym_name);
-#endif
-    return reinterpret_cast<T>(reinterpret_cast<SymHandle>(sym_addr));  // NOLINT
-  }
-
-  Handle LibraryHandle() const { return handle_; }
-
-  virtual ~LibraryLoader() {
-    if (handle_) {
-#if defined(_WIN32)
-      [[maybe_unused]] auto result = FreeLibrary(handle_);
-#else
-      [[maybe_unused]] auto result = dlclose(handle_);
-#endif
-    }
-  }
-
- private:
-#if defined(__linux__)
-  explicit LibraryLoader(Handle handle) : handle_(handle) {}
-#endif  // __linux__
-
-  Handle handle_ = nullptr;
-};
-
-#endif
diff --git a/sdk/src/utils/platform_config.h.in b/sdk/src/utils/platform_config.h.in
deleted file mode 100644
index 9f4a2a29..00000000
--- a/sdk/src/utils/platform_config.h.in
+++ /dev/null
@@ -1,28 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UTILS_PLATFORM_CONFIG_H_
-#define UTILS_PLATFORM_CONFIG_H_
-
-#if defined(__GNUC__) || defined(__clang__)
-#ifdef __has_attribute
-#if __has_attribute(__used__)
-#define PTI_USED __attribute__((__used__))
-#endif
-#else
-#define PTI_USED __attribute__((__used__))
-#endif
-#endif
-
-#ifndef PTI_USED
-#define PTI_USED
-#endif
-
-#cmakedefine PTI_EXPERIMENTAL_FILESYSTEM
-
-#define PTI_MODULE_SUBDIR "@PTI_MODULE_SUBDIR@"
-
-#endif  // UTILS_PLATFORM_CONFIG_H_
diff --git a/sdk/src/utils/platform_strings.h b/sdk/src/utils/platform_strings.h
deleted file mode 100644
index b5142450..00000000
--- a/sdk/src/utils/platform_strings.h
+++ /dev/null
@@ -1,54 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef UTILS_PLATFORM_STRINGS_H_
-#define UTILS_PLATFORM_STRINGS_H_
-
-#include <string_view>
-
-#include "platform_config.h"
-#include "utils.h"
-
-#if !defined(PTI_XPTI_FRAMEWORK_DISPATCHER_NAME)
-#if defined(_WIN32)
-#define PTI_XPTI_FRAMEWORK_DISPATCHER_NAME_STRING "xptifw.dll"
-#else
-#define PTI_XPTI_FRAMEWORK_DISPATCHER_NAME_STRING "libxptifw.so"
-#endif
-#else
-#define PTI_XPTI_FRAMEWORK_DISPATCHER_NAME_STRING TOSTRING(PTI_XPTI_FRAMEWORK_DISPATCHER_NAME)
-#endif
-
-#if !defined(PTI_VIEW_CORE_LIB_NAME)
-#if defined(_WIN32)
-#define PTI_VIEW_CORE_LIB_NAME_STRING "pti.dll"
-#else
-#define PTI_VIEW_CORE_LIB_NAME_STRING "libpti.so"
-#endif
-#else
-#define PTI_VIEW_CORE_LIB_NAME_STRING TOSTRING(PTI_VIEW_CORE_LIB_NAME)
-#endif
-
-#if !defined(PTI_PLATFORM_SEPARATOR)
-#if defined(_WIN32)
-#define PTI_PLATFORM_SEPARATOR "\\"
-#else
-#define PTI_PLATFORM_SEPARATOR "/"
-#endif
-#endif
-
-#if !defined(PTI_MODULE_SUBDIR)
-#define PTI_MODULE_SUBDIR "pti"
-#endif
-
-namespace pti {
-namespace strings {
-inline static constexpr const char* const kXptiLibName = PTI_XPTI_FRAMEWORK_DISPATCHER_NAME_STRING;
-inline static constexpr const char* const kPtiViewLib = PTI_VIEW_CORE_LIB_NAME_STRING;
-inline static constexpr std::string_view kOsPathSeparator = PTI_PLATFORM_SEPARATOR;
-inline static constexpr std::string_view kModuleSubdir = PTI_MODULE_SUBDIR;
-}  // namespace strings
-}  // namespace pti
-#endif  // UTILS_PLATFORM_STRINGS_H_
diff --git a/sdk/src/utils/pti_assert.h b/sdk/src/utils/pti_assert.h
deleted file mode 100644
index e65d9e6c..00000000
--- a/sdk/src/utils/pti_assert.h
+++ /dev/null
@@ -1,30 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_UTILS_PTI_ASSERT_H_
-#define PTI_UTILS_PTI_ASSERT_H_
-
-#include <cstdio>
-#include <cstdlib>
-
-#if defined(__gnu_linux__)
-#define PTI_FUNCTION_NAME __PRETTY_FUNCTION__
-#elif defined(_WIN32)
-#define PTI_FUNCTION_NAME __FUNCSIG__
-#else
-#define PTI_FUNCTION_NAME __FUNCTION__
-#endif
-
-#define PTI_ASSERT(X)                                                            \
-  do {                                                                           \
-    if (!(X)) {                                                                  \
-      std::fprintf(stderr, "Condition " #X " Failed on %s at " __FILE__ ":%d\n", \
-                   PTI_FUNCTION_NAME, __LINE__);                                 \
-      std::abort();                                                              \
-    }                                                                            \
-  } while (0)
-
-#endif  // PTI_UTILS_PTI_ASSERT_H_
diff --git a/sdk/src/utils/pti_filesystem.h b/sdk/src/utils/pti_filesystem.h
deleted file mode 100644
index a986c6a0..00000000
--- a/sdk/src/utils/pti_filesystem.h
+++ /dev/null
@@ -1,38 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UTILS_PTI_FILESYSTEM_H_
-#define UTILS_PTI_FILESYSTEM_H_
-
-#include <system_error>
-
-#include "platform_config.h"
-
-#if defined(PTI_EXPERIMENTAL_FILESYSTEM)
-#include <experimental/filesystem>
-#else
-#include <filesystem>
-#endif
-
-namespace pti {
-namespace utils {
-#if defined(PTI_EXPERIMENTAL_FILESYSTEM)
-namespace filesystem = std::experimental::filesystem;
-#else
-namespace filesystem = std::filesystem;
-#endif
-
-inline filesystem::path AbsolutePath(const filesystem::path& path, std::error_code& error) {
-#if defined(PTI_EXPERIMENTAL_FILESYSTEM)
-  return filesystem::system_complete(path, error);
-#else
-  return filesystem::absolute(path, error);
-#endif
-}
-}  // namespace utils
-}  // namespace pti
-
-#endif  // UTILS_PTI_FILESYSTEM_H_
diff --git a/sdk/src/utils/pti_string_pool.h b/sdk/src/utils/pti_string_pool.h
deleted file mode 100644
index dac6f6f7..00000000
--- a/sdk/src/utils/pti_string_pool.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// ==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_STRING_POOL_H_
-#define PTI_STRING_POOL_H_
-
-#include <mutex>
-#include <shared_mutex>
-#include <string>
-#include <unordered_set>
-
-/**
- * Thread-safe string pool for efficient string storage and deduplication.
- *
- * This class stores unique strings and provides stable pointers to them.
- * Multiple registrations of the same string return the same pointer.
- * All returned pointers remain valid for the lifetime of the StringPool.
- */
-class StringPool {
- public:
-  StringPool() = default;
-  ~StringPool() = default;
-
-  // Non-copyable, non-movable for pointer stability
-  StringPool(const StringPool&) = delete;
-  StringPool& operator=(const StringPool&) = delete;
-  StringPool(StringPool&&) = delete;
-  StringPool& operator=(StringPool&&) = delete;
-
-  const char* Get(const std::string& str) {
-    // Try with read lock - return immediately if string already exists
-    {
-      std::shared_lock lock(mutex_);
-      auto it = strings_.find(str);
-      if (it != strings_.end()) {
-        return it->c_str();
-      }
-    }
-
-    std::unique_lock lock(mutex_);
-
-    auto [it, inserted] = strings_.emplace(str);
-    return it->c_str();
-  }
-
-  // Get number of unique strings stored.
-  size_t Size() const {
-    std::shared_lock<std::shared_mutex> read_lock(mutex_);
-    return strings_.size();
-  }
-
-  // Check if a string is registered.
-  bool Contains(const std::string& str) const {
-    std::shared_lock<std::shared_mutex> read_lock(mutex_);
-    return strings_.find(str) != strings_.end();
-  }
-
- private:
-  // Map from string to pointer to that same string's internal storage
-  // The pointer points to the key's c_str(), ensuring stability
-  mutable std::shared_mutex mutex_;
-  std::unordered_set<std::string> strings_;
-};
-
-#endif  // PTI_STRING_POOL_H_
diff --git a/sdk/src/utils/utils.h b/sdk/src/utils/utils.h
deleted file mode 100644
index 2ef797cb..00000000
--- a/sdk/src/utils/utils.h
+++ /dev/null
@@ -1,517 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wignored-attributes"
-#endif
-
-#ifndef PTI_UTILS_UTILS_H_
-#define PTI_UTILS_UTILS_H_
-
-#if defined(_WIN32)
-#include <windows.h>
-
-#include <chrono>
-#else /* _WIN32 */
-#include <dlfcn.h>
-#include <sys/syscall.h>
-#include <time.h>
-#include <unistd.h>
-#define HMODULE void*
-#endif /* _WIN32 */
-
-#if defined(_WIN32)
-#define PTI_LIB_PREFIX "pti"
-#else
-#define PTI_LIB_PREFIX "libpti"
-#endif
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/pattern_formatter.h>
-#include <spdlog/sinks/basic_file_sink.h>
-#include <spdlog/sinks/stdout_color_sinks.h>
-#include <spdlog/spdlog.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <limits>
-#include <locale>
-#include <random>
-#include <sstream>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#include "pti_assert.h"
-#include "pti_filesystem.h"
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-
-#define MAX_STR_SIZE 1024
-
-#define BYTES_IN_MBYTES (1024 * 1024)
-
-#define NSEC_IN_USEC 1'000
-#define MSEC_IN_SEC 1'000
-#define NSEC_IN_MSEC 1'000'000
-#define NSEC_IN_SEC 1'000'000'000
-
-namespace utils {
-
-typedef uint64_t (*fptr_get_timestamp_unknown_clock)(void);
-
-// Duplicated from test/utils --- there are some useful methods there that can be pulled here as
-// needed.
-//-----
-template <typename T>
-inline void Zeroize(T& item) {
-  static_assert(std::is_trivially_copyable<T>::value,
-                "Can't zeroize an object that's not trivially copyable");
-  std::memset(&item, 0, sizeof(T));
-}
-//-----
-
-struct Comparator {
-  template <typename T>
-  bool operator()(const T& left, const T& right) const {
-    if (left.second != right.second) {
-      return left.second > right.second;
-    }
-    return left.first > right.first;
-  }
-};
-
-#if defined(__gnu_linux__)
-
-inline uint64_t GetTime(clockid_t id) {
-  timespec ts{0, 0};
-  int status = clock_gettime(id, &ts);
-  PTI_ASSERT(status == 0);
-  return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-}
-#endif
-
-inline uint64_t GetMonotonicRawTime() {
-#if defined(_WIN32)
-  LARGE_INTEGER ticks{};
-  LARGE_INTEGER frequency{};
-  BOOL status = QueryPerformanceFrequency(&frequency);
-  PTI_ASSERT(status != 0);
-  status = QueryPerformanceCounter(&ticks);
-  PTI_ASSERT(status != 0);
-  return ticks.QuadPart * (NSEC_IN_SEC / frequency.QuadPart);
-#else
-  return GetTime(CLOCK_MONOTONIC_RAW);
-#endif
-}
-
-inline uint64_t GetRealTime() {
-#if defined(_WIN32)
-  // convert to ns ticks the proper way
-  return std::chrono::duration_cast<std::chrono::nanoseconds>(
-             std::chrono::system_clock::now().time_since_epoch())
-      .count();
-#else
-  return GetTime(CLOCK_REALTIME);
-#endif
-}
-
-inline int64_t ConversionFactorMonotonicRawToUnknownClock(
-    fptr_get_timestamp_unknown_clock user_provided_get_timestamp) {
-  uint64_t user_final = user_provided_get_timestamp();
-  uint64_t raw_final = GetMonotonicRawTime();
-  constexpr auto kNumberOfIterations = 50;
-  std::array<uint64_t, kNumberOfIterations> raw_start = {};
-  std::array<uint64_t, kNumberOfIterations> raw_end = {};
-  std::array<uint64_t, kNumberOfIterations> user = {};
-
-  int i_at_min = -1;
-  int64_t diff_min = (std::numeric_limits<int64_t>::max)();  // some big number
-  int64_t diff;
-
-  for (int i = 0; i < kNumberOfIterations; i++) {
-    raw_start[i] = GetMonotonicRawTime();
-    user[i] = user_provided_get_timestamp();
-    raw_end[i] = GetMonotonicRawTime();
-    diff = raw_end[i] - raw_start[i];
-    if (diff < diff_min) {
-      diff_min = diff;
-      i_at_min = i;
-    }
-  }
-
-  raw_final = (raw_start[i_at_min] + raw_end[i_at_min]) / 2;
-  user_final = user[i_at_min];
-
-  return (user_final > raw_final) ? static_cast<int64_t>(user_final - raw_final)
-                                  : -static_cast<int64_t>(raw_final - user_final);
-}
-
-inline uint64_t GetTime() { return GetMonotonicRawTime(); }
-
-// if enable_logging is false, the logger is set to console and it is off
-// if enable_loging is true
-//  if logfile is empty, then the logger is set to console and it is on
-//  else logfile is not empty, then the logger is set to log file and it is on
-inline std::shared_ptr<spdlog::logger> GetLogStream(bool enable_logging = false,
-                                                    std::string logfile = std::string()) {
-  std::shared_ptr<spdlog::logger> logger;
-  std::random_device rand_dev;    // uniformly-distributed integer random number generator
-  std::mt19937 prng(rand_dev());  // pseudorandom number generator
-  std::uniform_int_distribution<uint64_t> rand_num(0);  // random number
-
-  try {
-    // Default user logger is to the console and it is off
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::off);
-    logger = std::make_shared<spdlog::logger>("logger_" + fmt::format("{:x}", rand_num(prng)),
-                                              console_sink);
-    if (enable_logging) {
-      if (!logfile.empty()) {
-        // if logfile not empty, then the file is created and the data is logged to it
-        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(logfile, true);
-        logger = std::make_shared<spdlog::logger>(
-            "file_logger_" + fmt::format("{:x}", rand_num(prng)), file_sink);
-      } else {
-        // the logging is enabled to the console
-        console_sink->set_level(spdlog::level::debug);
-        logger = std::make_shared<spdlog::logger>("logger_" + fmt::format("{:x}", rand_num(prng)),
-                                                  console_sink);
-      }
-    }
-    auto format = std::make_unique<spdlog::pattern_formatter>(
-        "%v", spdlog::pattern_time_type::local, std::string(""));  // disable eol
-    logger->set_formatter(std::move(format));
-    spdlog::register_logger(logger);
-
-  } catch (const spdlog::spdlog_ex& exception) {
-    std::cerr << "Failed to initialize log file: " << exception.what() << std::endl;
-  }
-  return logger;
-}
-
-inline pti::utils::filesystem::path CreateTempDirectory() {
-  auto tmp_dir = pti::utils::filesystem::temp_directory_path();
-  std::random_device rand_dev;    // uniformly-distributed integer random number generator
-  std::mt19937 prng(rand_dev());  // pseudorandom number generator
-  std::uniform_int_distribution<uint64_t> rand_num(0);  // random number
-  pti::utils::filesystem::path path;
-  std::string dir_name = "pti_" + std::to_string(rand_num(prng));
-  path = tmp_dir / dir_name;
-  pti::utils::filesystem::create_directory(path);
-
-  return path;
-}
-
-inline std::string GetFilePath(std::string_view filename) {
-  auto pos = filename.find_last_of("/\\");
-  if (pos == std::string_view::npos) {
-    return "";
-  }
-
-  return std::string{filename.substr(0, pos + 1)};
-}
-
-inline std::string GetExecutablePath() {
-  char buffer[MAX_STR_SIZE] = {0};
-#if defined(_WIN32)
-  DWORD status = GetModuleFileNameA(nullptr, buffer, MAX_STR_SIZE);
-  PTI_ASSERT(status > 0);
-#else
-  ssize_t status = readlink("/proc/self/exe", buffer, MAX_STR_SIZE);
-  PTI_ASSERT(status > 0);
-#endif
-  return GetFilePath(buffer);
-}
-
-inline std::string GetExecutableName() {
-  char buffer[MAX_STR_SIZE] = {0};
-#if defined(_WIN32)
-  DWORD status = GetModuleFileNameA(nullptr, buffer, MAX_STR_SIZE);
-  PTI_ASSERT(status > 0);
-#else
-  ssize_t status = readlink("/proc/self/exe", buffer, MAX_STR_SIZE);
-  PTI_ASSERT(status > 0);
-#endif
-  std::string path(buffer);
-  return path.substr(path.find_last_of("/\\") + 1);
-}
-
-inline std::vector<uint8_t> LoadBinaryFile(const std::string& path) {
-  std::vector<uint8_t> binary;
-  std::ifstream stream(path, std::ios::in | std::ios::binary);
-  if (!stream.good()) {
-    return binary;
-  }
-
-  stream.seekg(0, std::ifstream::end);
-  size_t size = stream.tellg();
-  stream.seekg(0, std::ifstream::beg);
-  if (size == 0) {
-    return binary;
-  }
-
-  binary.resize(size);
-  stream.read(reinterpret_cast<char*>(binary.data()), size);
-  return binary;
-}
-
-inline void SetEnv(const char* name, const char* value) {
-  PTI_ASSERT(name != nullptr);
-  PTI_ASSERT(value != nullptr);
-
-  int status = 0;
-#if defined(_WIN32)
-  std::string str = std::string(name) + "=" + value;
-  status = _putenv(str.c_str());
-#else
-  status = setenv(name, value, 1);
-#endif
-  PTI_ASSERT(status == 0);
-}
-
-// Returns:  -1 -- is env not set; 1 if set to 1; 0 otherwise.
-inline int32_t IsSetEnv(const char* name) {
-  PTI_ASSERT(name != nullptr);
-  int32_t env_value = -1;
-#if defined(_WIN32)
-  char* value = nullptr;
-  errno_t status = _dupenv_s(&value, nullptr, name);
-  PTI_ASSERT(status == 0);
-  if (value == nullptr) {
-    return env_value;
-  } else if (std::strcmp(value, "ON") == 0) {
-    return 1;
-  } else if (std::strcmp(value, "OFF") == 0) {
-    return 0;
-  }
-  try {
-    env_value = std::stoi(value);
-  } catch (std::invalid_argument const& /*ex*/) {
-    env_value = 1;  // fallback to default
-  } catch (std::out_of_range const& /*ex*/) {
-    env_value = 1;  // fallback to default
-  }
-  free(value);
-  if (env_value == 1) return 1;
-  return 0;
-#else
-  const char* value = getenv(name);
-  if (value == nullptr) {
-    return env_value;
-  } else if (std::strcmp(value, "ON") == 0) {
-    return 1;
-  } else if (std::strcmp(value, "OFF") == 0) {
-    return 0;
-  }
-  try {
-    env_value = std::stoi(value);
-  } catch (std::invalid_argument const& /*ex*/) {
-    env_value = 1;  // fallback to default
-  } catch (std::out_of_range const& /*ex*/) {
-    env_value = 1;  // fallback to default
-  }
-  if (env_value == 1) return 1;
-  return 0;
-#endif
-}
-
-inline std::string GetEnv(const char* name) {
-  PTI_ASSERT(name != nullptr);
-#if defined(_WIN32)
-  char* value = nullptr;
-  errno_t status = _dupenv_s(&value, nullptr, name);
-  PTI_ASSERT(status == 0);
-  if (value == nullptr) {
-    return std::string();
-  }
-  std::string result(value);
-  free(value);
-  return result;
-#else
-  const char* value = getenv(name);
-  if (value == nullptr) {
-    return std::string();
-  }
-  return std::string(value);
-#endif
-}
-
-inline uint32_t GetPid() {
-#if defined(_WIN32)
-  return GetCurrentProcessId();
-#else
-  return getpid();
-#endif
-}
-
-inline uint32_t GetTid() {
-#if defined(_WIN32)
-  return GetCurrentThreadId();
-#else
-#ifdef SYS_gettid
-  return static_cast<uint32_t>(syscall(SYS_gettid));
-#else
-#error "SYS_gettid is unavailable on this system"
-#endif
-#endif
-}
-
-inline size_t LowerBound(const std::vector<uint64_t>& data, uint64_t value) {
-  size_t start = 0;
-  size_t end = data.size();
-  while (start < end) {
-    size_t middle = (start + end) / 2;
-    if (value <= data[middle]) {
-      end = middle;
-    } else {
-      start = middle + 1;
-    }
-  }
-  return start;
-}
-
-inline size_t UpperBound(const std::vector<uint64_t>& data, uint64_t value) {
-  size_t start = 0;
-  size_t end = data.size();
-  while (start < end) {
-    size_t middle = (start + end) / 2;
-    if (value >= data[middle]) {
-      start = middle + 1;
-    } else {
-      end = middle;
-    }
-  }
-  return start;
-}
-
-#if defined(_WIN32)
-inline std::string GetDllPath(HMODULE dll_addr) {
-  std::array<CHAR, MAX_STR_SIZE> buffer{};
-  auto status =
-      GetModuleFileNameA(dll_addr, static_cast<LPSTR>(std::data(buffer)), std::size(buffer));
-  return status ? std::string{std::data(buffer), status} : std::string{};
-}
-#endif
-
-template <typename T>
-inline std::string GetPathToSharedObject(T address) {
-  static_assert(std::is_pointer<T>::value && !std::is_same<T, const char*>::value,
-                "Expecting a function pointer");
-#if defined(_WIN32)
-  HMODULE dll_addr = nullptr;
-
-  auto got_module = GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-                                       reinterpret_cast<LPCSTR>(address), &dll_addr);
-  if (!got_module) {
-    return std::string{};
-  }
-
-  return GetDllPath(dll_addr);
-
-#else
-  Dl_info info{nullptr, nullptr, nullptr, nullptr};
-  auto status = dladdr(reinterpret_cast<const void*>(address), &info);
-  PTI_ASSERT(status != 0);
-  return std::string{info.dli_fname};
-#endif
-}
-
-#if defined(_WIN32)
-template <>
-inline std::string GetPathToSharedObject(HMODULE address) {
-  return GetDllPath(address);
-}
-
-template <>
-inline std::string GetPathToSharedObject(const char* name) {
-  HMODULE dll_addr = GetModuleHandleA(name);
-  if (!dll_addr) {
-    return std::string{};
-  }
-  return GetPathToSharedObject(dll_addr);
-}
-
-#endif
-
-inline HMODULE LoadLibrary(const char* lib_name) {
-#if defined(_WIN32)
-  return LoadLibraryExA(lib_name, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
-#else  /* _WIN32 */
-  return dlopen(lib_name, RTLD_LAZY | RTLD_LOCAL);
-#endif /* _WIN32 */
-}
-
-inline void UnloadLibrary(HMODULE lib_handle) {
-#if defined(_WIN32)
-  FreeLibrary(lib_handle);
-#else  /* _WIN32 */
-  dlclose(lib_handle);
-#endif /* _WIN32 */
-}
-
-inline void* GetFunctionPtr(HMODULE lib_handle, const char* func_name) {
-#if defined(_WIN32)
-  return reinterpret_cast<void*>(GetProcAddress(lib_handle, func_name));
-#else  /* _WIN32 */
-  return dlsym(lib_handle, func_name);
-#endif /* _WIN32 */
-}
-
-inline std::pair<bool, bool> IsSubscriberToXPTI() {
-  auto current_xpti_subscriber = utils::GetEnv("XPTI_SUBSCRIBERS");
-  bool is_unitrace = current_xpti_subscriber.find("unitrace") != std::string::npos;
-
-  if (current_xpti_subscriber.empty()) {
-    return {false, is_unitrace};
-  }
-
-  // NOTE: This is not a 100% bulletproof solution, but a practical one.
-  // In rare cases, a "foreign" subscriber such as libpti_some_another.so
-  // might be incorrectly recognized as PTI.
-  if (current_xpti_subscriber.find(PTI_LIB_PREFIX) != std::string::npos) {
-    return {false, is_unitrace};
-  }
-
-  // It's a real foreign subscriber (not PTI)
-  return {true, is_unitrace};
-}
-
-inline void SetGlobalSpdLogPattern() {
-  // https://github.com/gabime/spdlog/wiki/3.-Custom-formatting
-  spdlog::set_pattern("PTI:[%H:%M][%^-%l-%$]%P:%t %s:%# %v");
-}
-
-// Copied from samples_utilities - useful for logging
-//
-// Helper class and function: formats an int with thousands separator
-// e.g. 1234567890 -> 1'234'567'890
-// when manually comparing timestamps in tests
-class ApostropheNumpunct : public std::numpunct<char> {
- protected:
-  char do_thousands_sep() const override { return '\''; }
-  std::string do_grouping() const override { return "\3"; }
-};
-
-template <typename T>
-inline std::string AposFormat(T value) {
-  static_assert(std::is_unsigned<T>::value, "Unsigned integer type required");
-  std::ostringstream oss;
-  static std::locale apostrophe_locale(std::locale::classic(), new ApostropheNumpunct);
-  oss.imbue(apostrophe_locale);
-  oss << value;
-  return oss.str();
-}
-
-}  // namespace utils
-
-#endif  // PTI_UTILS_UTILS_H_
diff --git a/sdk/src/utils/ze_utils.h b/sdk/src/utils/ze_utils.h
deleted file mode 100644
index 667051ad..00000000
--- a/sdk/src/utils/ze_utils.h
+++ /dev/null
@@ -1,715 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_UTILS_ZE_UTILS_H_
-#define PTI_UTILS_ZE_UTILS_H_
-
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <pti/pti_driver_levelzero_api_ids.h>
-
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cstring>
-#include <iomanip>
-#include <limits>
-#include <memory>
-#include <optional>
-#include <sstream>
-#include <string>
-#include <string_view>
-#include <unordered_set>
-#include <vector>
-
-#include "demangle.h"
-#include "overhead_kinds.h"
-#include "pti_assert.h"
-
-namespace utils {
-namespace ze {
-
-inline constexpr static uint32_t kIntelVendorId = 0x8086;
-inline constexpr static uint32_t kBmgIpVersion = 0x05004000;
-inline constexpr std::string_view kCounterEventExtensionName = ZE_EVENT_POOL_COUNTER_BASED_EXP_NAME;
-
-struct MemDeleter;
-using TimestampBuffer = std::unique_ptr<_ze_kernel_timestamp_result_t, MemDeleter>;
-
-inline std::vector<ze_driver_handle_t> GetDriverList() {
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t driver_count = 0;
-  overhead::Init();
-  status = zeDriverGet(&driver_count, nullptr);
-  overhead_fini(zeDriverGet_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (driver_count == 0) {
-    return std::vector<ze_driver_handle_t>();
-  }
-
-  std::vector<ze_driver_handle_t> driver_list(driver_count);
-  overhead::Init();
-  status = zeDriverGet(&driver_count, driver_list.data());
-  overhead_fini(zeDriverGet_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return driver_list;
-}
-
-inline std::vector<ze_driver_extension_properties_t> GetDriverExtensions(
-    ze_driver_handle_t driver) {
-  PTI_ASSERT(driver != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t extension_count = 0;
-
-  {
-    overhead::ScopedOverheadCollector overhead_collector(zeDriverGetExtensionProperties_id);
-    status = zeDriverGetExtensionProperties(driver, &extension_count, nullptr);
-  }
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (extension_count == 0) {
-    return std::vector<ze_driver_extension_properties_t>();
-  }
-
-  std::vector<ze_driver_extension_properties_t> extension_list(extension_count);
-
-  overhead::ScopedOverheadCollector overhead_collector(zeDriverGetExtensionProperties_id);
-  status = zeDriverGetExtensionProperties(driver, &extension_count, extension_list.data());
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return extension_list;
-}
-
-inline bool IsDriverExtensionSupported(ze_driver_handle_t driver, std::string_view extension_name) {
-  const auto extensions = GetDriverExtensions(driver);
-  return std::any_of(extensions.cbegin(), extensions.cend(),
-                     [&](const ze_driver_extension_properties_t& extension) {
-                       return std::string_view(extension.name) == extension_name;
-                     });
-}
-
-inline void* GetExtensionFunctionAddr(ze_driver_handle_t driver, const char* function_name) {
-  PTI_ASSERT(driver != nullptr);
-  PTI_ASSERT(function_name != nullptr);
-  void* function_addr = nullptr;
-  overhead::ScopedOverheadCollector overhead_collector(zeDriverGetExtensionFunctionAddress_id);
-  ze_result_t status = zeDriverGetExtensionFunctionAddress(driver, function_name, &function_addr);
-  if (status != ZE_RESULT_SUCCESS) {
-    return nullptr;
-  }
-  return function_addr;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList(ze_driver_handle_t driver) {
-  PTI_ASSERT(driver != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t device_count = 0;
-  overhead::Init();
-  status = zeDeviceGet(driver, &device_count, nullptr);
-  overhead_fini(zeDriverGet_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> device_list(device_count);
-  overhead::Init();
-  status = zeDeviceGet(driver, &device_count, device_list.data());
-  overhead_fini(zeDriverGet_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList(
-    const std::vector<ze_driver_handle_t>& driver_list) {
-  std::vector<ze_device_handle_t> device_list;
-  for (auto* driver : driver_list) {
-    for (auto* device : utils::ze::GetDeviceList(driver)) {
-      device_list.push_back(device);
-    }
-  }
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList() { return GetDeviceList(GetDriverList()); }
-
-// Remove duplicate device handles while preserving discovery order (O(n) using unordered_set).
-// The same physical device can be reported by more than one driver handle, so any code that
-// enumerates devices across all drivers must deduplicate before using the result as a set.
-inline void DedupDeviceList(std::vector<ze_device_handle_t>& device_list) {
-  std::unordered_set<ze_device_handle_t> seen;
-  auto end =
-      std::remove_if(device_list.begin(), device_list.end(),
-                     [&seen](ze_device_handle_t device) { return !seen.insert(device).second; });
-  device_list.erase(end, device_list.end());
-}
-
-// Enumerate the devices of the given drivers with duplicates removed. Prefer this over calling
-// GetDeviceList() followed by DedupDeviceList() -- callers that need a device *set* almost always
-// want both steps, and returning by value keeps the deduplication from being forgotten.
-inline std::vector<ze_device_handle_t> GetUniqueDeviceList(
-    const std::vector<ze_driver_handle_t>& driver_list) {
-  std::vector<ze_device_handle_t> device_list = GetDeviceList(driver_list);
-  DedupDeviceList(device_list);
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetUniqueDeviceList() {
-  return GetUniqueDeviceList(GetDriverList());
-}
-
-inline std::vector<ze_device_handle_t> GetSubDeviceList(ze_device_handle_t device) {
-  PTI_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t sub_device_count = 0;
-  overhead::Init();
-  status = zeDeviceGetSubDevices(device, &sub_device_count, nullptr);
-  overhead_fini(zeDeviceGetSubDevices_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (sub_device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> sub_device_list(sub_device_count);
-  overhead::Init();
-  status = zeDeviceGetSubDevices(device, &sub_device_count, sub_device_list.data());
-  overhead_fini(zeDeviceGetSubDevices_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return sub_device_list;
-}
-
-inline ze_driver_handle_t GetGpuDriver(std::size_t pti_device_id) {
-  std::vector<ze_driver_handle_t> driver_list;
-
-  for (auto* driver : GetDriverList()) {
-    for (auto* device : GetDeviceList(driver)) {
-      ze_device_properties_t props;
-      std::memset(&props, 0, sizeof(props));
-      props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-      props.pNext = nullptr;
-      overhead::Init();
-      ze_result_t status = zeDeviceGetProperties(device, &props);
-      overhead_fini(zeDeviceGetProperties_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        driver_list.push_back(driver);
-      }
-    }
-  }
-
-  if (driver_list.empty()) {
-    return nullptr;
-  }
-
-  if (pti_device_id >= driver_list.size()) {
-    return nullptr;
-  }
-
-  return driver_list[pti_device_id];
-}
-
-inline ze_device_handle_t GetGpuDevice(std::size_t pti_device_id) {
-  std::vector<ze_device_handle_t> device_list;
-
-  for (auto* driver : GetDriverList()) {
-    for (auto* device : GetDeviceList(driver)) {
-      ze_device_properties_t props;
-      std::memset(&props, 0, sizeof(props));
-      props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-      props.pNext = nullptr;
-      overhead::Init();
-      ze_result_t status = zeDeviceGetProperties(device, &props);
-      overhead_fini(zeDeviceGetProperties_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        device_list.push_back(device);
-      }
-    }
-  }
-
-  if (device_list.empty()) {
-    return nullptr;
-  }
-
-  if (pti_device_id >= device_list.size()) {
-    return nullptr;
-  }
-
-  return device_list[pti_device_id];
-}
-
-inline ze_device_handle_t GetGpuDevice(const std::vector<ze_driver_handle_t>& drivers,
-                                       std::size_t pti_device_id) {
-  std::vector<ze_device_handle_t> device_list;
-
-  for (auto* driver : drivers) {
-    for (auto* device : GetDeviceList(driver)) {
-      ze_device_properties_t props;
-      std::memset(&props, 0, sizeof(props));
-      props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-      props.pNext = nullptr;
-      overhead::Init();
-      ze_result_t status = zeDeviceGetProperties(device, &props);
-      overhead_fini(zeDeviceGetProperties_id);
-      PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        device_list.push_back(device);
-      }
-    }
-  }
-
-  if (device_list.empty()) {
-    return nullptr;
-  }
-
-  if (pti_device_id >= device_list.size()) {
-    return nullptr;
-  }
-
-  return device_list[pti_device_id];
-}
-
-inline ze_device_handle_t GetGpuDevice(std::size_t pti_device_id, std::size_t pti_sub_device_id) {
-  auto* device_handle = GetGpuDevice(pti_device_id);
-
-  if (!device_handle) {
-    return nullptr;
-  }
-
-  std::vector<ze_device_handle_t> sub_device_list = GetSubDeviceList(device_handle);
-
-  if (sub_device_list.empty()) {
-    return device_handle;
-  }
-
-  if (pti_sub_device_id >= sub_device_list.size()) {
-    return nullptr;
-  }
-
-  return sub_device_list[pti_sub_device_id];
-}
-
-inline ze_context_handle_t GetContext(ze_driver_handle_t driver) {
-  PTI_ASSERT(driver != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_context_handle_t context = nullptr;
-  ze_context_desc_t context_desc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-  overhead::Init();
-  status = zeContextCreate(driver, &context_desc, &context);
-  overhead_fini(zeContextCreate_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  return context;
-}
-
-inline std::string GetDeviceName(ze_device_handle_t device) {
-  PTI_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-  props.pNext = nullptr;
-  overhead::Init();
-  status = zeDeviceGetProperties(device, &props);
-  overhead_fini(zeDeviceGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  return static_cast<char*>(props.name);
-}
-
-inline std::string GetMetricTypedValue(const zet_typed_value_t& typed_value,
-                                       uint8_t precision = 2) {
-  std::stringstream stream;
-  switch (typed_value.type) {
-    case ZET_VALUE_TYPE_UINT32:
-      return std::to_string(typed_value.value.ui32);
-    case ZET_VALUE_TYPE_UINT64:
-      return std::to_string(typed_value.value.ui64);
-    case ZET_VALUE_TYPE_FLOAT32:
-      stream << std::fixed << std::setprecision(precision) << typed_value.value.fp32;
-      return stream.str();
-    case ZET_VALUE_TYPE_FLOAT64:
-      stream << std::fixed << std::setprecision(precision) << typed_value.value.fp64;
-      return stream.str();
-    case ZET_VALUE_TYPE_BOOL8:
-      return std::to_string(static_cast<uint32_t>(typed_value.value.b8));
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline uint32_t GetMetricCount(zet_metric_group_handle_t group) {
-  PTI_ASSERT(group != nullptr);
-
-  zet_metric_group_properties_t group_props;
-  std::memset(&group_props, 0, sizeof(group_props));
-  group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-  ze_result_t status = zetMetricGroupGetProperties(group, &group_props);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return group_props.metricCount;
-}
-
-inline std::string GetMetricUnits(const char* units) {
-  PTI_ASSERT(units != nullptr);
-
-  std::string result = units;
-  if (result.find("null") != std::string::npos) {
-    result = "";
-  } else if (result.find("percent") != std::string::npos) {
-    result = "%";
-  }
-
-  return result;
-}
-
-inline std::vector<std::string> GetMetricList(zet_metric_group_handle_t group,
-                                              bool add_units = true) {
-  PTI_ASSERT(group != nullptr);
-
-  uint32_t metric_count = GetMetricCount(group);
-  PTI_ASSERT(metric_count > 0);
-
-  std::vector<zet_metric_handle_t> metric_list(metric_count);
-  ze_result_t status = zetMetricGet(group, &metric_count, metric_list.data());
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  PTI_ASSERT(metric_count == metric_list.size());
-
-  std::vector<std::string> name_list;
-  name_list.reserve(metric_list.size());
-  for (auto metric : metric_list) {
-    zet_metric_properties_t metric_props{};
-    metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-    metric_props.pNext = nullptr;
-
-    status = zetMetricGetProperties(metric, &metric_props);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    std::string name = static_cast<const char*>(metric_props.name);
-    std::string units = GetMetricUnits(static_cast<const char*>(metric_props.resultUnits));
-    if (add_units && !units.empty()) {
-      name += "[" + units + "]";
-    }
-    name_list.emplace_back(std::move(name));
-  }
-
-  return name_list;
-}
-
-inline size_t GetMetricId(const std::vector<std::string>& metric_list,
-                          const std::string_view metric_name) {
-  PTI_ASSERT(!metric_list.empty());
-  PTI_ASSERT(!metric_name.empty());
-
-  for (size_t i = 0; i < metric_list.size(); ++i) {
-    if (metric_list[i].find(metric_name) == 0) {
-      return i;
-    }
-  }
-
-  return metric_list.size();
-}
-
-/* Find all metric groups for given device regardless of type
- *
- * @param[in] device Target device
- * @param[out] metric_groups Vector of metric groups found
- */
-inline void FindMetricGroups(ze_device_handle_t device,
-                             std::vector<zet_metric_group_handle_t>& metric_groups) {
-  PTI_ASSERT(device != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  uint32_t group_count = 0;
-  status = zetMetricGroupGet(device, &group_count, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  if (group_count == 0) {
-    return;
-  }
-
-  std::vector<zet_metric_group_handle_t> group_list(group_count, nullptr);
-  status = zetMetricGroupGet(device, &group_count, group_list.data());
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  for (uint32_t i = 0; i < group_count; ++i) {
-    metric_groups.push_back(group_list[i]);
-  }
-}
-
-inline size_t GetKernelMaxSubgroupSize(ze_kernel_handle_t kernel) {
-  PTI_ASSERT(kernel != nullptr);
-  ze_kernel_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  overhead::Init();
-  ze_result_t status = zeKernelGetProperties(kernel, &props);
-  overhead_fini(zeKernelGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.maxSubgroupSize;
-}
-
-inline std::string GetKernelName(ze_kernel_handle_t kernel, bool demangle = false) {
-  PTI_ASSERT(kernel != nullptr);
-
-  size_t size = 0;
-  overhead::Init();
-  ze_result_t status = zeKernelGetName(kernel, &size, nullptr);
-  overhead_fini(zeKernelGetName_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  PTI_ASSERT(size > 0);
-
-  std::vector<char> name(size);
-  overhead::Init();
-  status = zeKernelGetName(kernel, &size, name.data());
-  overhead_fini(zeKernelGetName_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  PTI_ASSERT(name[size - 1] == '\0');
-
-  if (demangle) {
-    return utils::Demangle(name.data());
-  }
-  return std::string(name.begin(), name.end() - 1);
-}
-
-inline ze_result_t GetDeviceTimestamps(ze_device_handle_t device, uint64_t* host_timestamp,
-                                       uint64_t* device_timestamp) {
-  PTI_ASSERT(device != nullptr);
-  PTI_ASSERT(host_timestamp != nullptr);
-  PTI_ASSERT(device_timestamp != nullptr);
-  overhead::Init();
-  ze_result_t status = zeDeviceGetGlobalTimestamps(device, host_timestamp, device_timestamp);
-  overhead_fini(zeDeviceGetGlobalTimestamps_id);
-  return status;
-}
-
-inline uint64_t GetDeviceTimerFrequency(ze_device_handle_t device) {
-  PTI_ASSERT(device != nullptr);
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  props.pNext = nullptr;
-  overhead::Init();
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  overhead_fini(zeDeviceGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.timerResolution;
-}
-
-inline uint64_t GetDeviceTimestampMask(ze_device_handle_t device) {
-  PTI_ASSERT(device != nullptr);
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  props.pNext = nullptr;
-  overhead::Init();
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  overhead_fini(zeDeviceGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return ((props.kernelTimestampValidBits == 64)
-              ? (std::numeric_limits<uint64_t>::max)()
-              : ((1ULL << props.kernelTimestampValidBits) - 1ULL));
-}
-
-inline uint64_t GetMetricTimestampMask(ze_device_handle_t device) {
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  overhead::Init();
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  overhead_fini(zeDeviceGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  uint32_t devicemask = (props.deviceId & 0xFF00);
-  if ((devicemask == 0x5600) || (devicemask == 0x4F00) || (devicemask == 0x0B00)) {
-    return (1ull << (props.kernelTimestampValidBits - 1)) - 1ull;
-  } else {
-    return ((props.kernelTimestampValidBits == 64)
-                ? (std::numeric_limits<uint64_t>::max)()
-                : ((1ull << props.kernelTimestampValidBits) - 1ull));
-  }
-}
-
-inline ze_api_version_t GetDriverVersion(ze_driver_handle_t driver) {
-  PTI_ASSERT(driver != nullptr);
-
-  ze_api_version_t version = ZE_API_VERSION_FORCE_UINT32;
-  overhead::Init();
-  ze_result_t status = zeDriverGetApiVersion(driver, &version);
-  overhead_fini(zeDriverGetApiVersion_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return version;
-}
-
-inline bool GetDeviceTimerFrequency_TimestampMask_UUID(ze_device_handle_t device,
-                                                       uint64_t& timer_frequency,
-                                                       uint64_t& timestamp_mask,
-                                                       ze_device_uuid_t& uuid) {
-  PTI_ASSERT(device != nullptr);
-
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  props.pNext = nullptr;
-  overhead::Init();
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  overhead_fini(zeDeviceGetProperties_id);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  timer_frequency = props.timerResolution;
-  timestamp_mask = (props.kernelTimestampValidBits == 64)
-                       ? (std::numeric_limits<uint64_t>::max)()
-                       : ((1ULL << props.kernelTimestampValidBits) - 1ULL);
-  std::copy_n(props.uuid.id, ZE_MAX_DEVICE_UUID_SIZE, uuid.id);
-  return true;
-}
-
-inline bool GetDeviceUuid(ze_device_handle_t device, uint8_t* uuid, bool measure_overhead = false) {
-  PTI_ASSERT(device != nullptr);
-
-  ze_device_properties_t props;
-  std::memset(&props, 0, sizeof(props));
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  props.pNext = nullptr;
-  if (measure_overhead) {
-    overhead::Init();
-  }
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  if (measure_overhead) {
-    overhead_fini(zeDeviceGetProperties_id);
-  }
-  if (status != ZE_RESULT_SUCCESS) {
-    return false;
-  }
-  std::copy_n(props.uuid.id, ZE_MAX_DEVICE_UUID_SIZE, uuid);
-  return true;
-}
-
-inline ze_api_version_t GetVersion(const std::vector<ze_driver_handle_t>& driver_list) {
-  if (driver_list.empty()) {
-    return ZE_API_VERSION_FORCE_UINT32;
-  }
-  return GetDriverVersion(driver_list.front());
-}
-
-inline ze_api_version_t GetVersion() {
-  auto driver_list = GetDriverList();
-  return GetVersion(driver_list);
-}
-
-inline std::optional<zel_version_t> GetLoaderVersion() {
-  constexpr std::string_view kLoaderComponentName = "loader";
-  size_t number_of_components = 0;
-  auto status = zelLoaderGetVersions(&number_of_components, nullptr);
-  if (number_of_components == 0 || status != ZE_RESULT_SUCCESS) {
-    return std::nullopt;
-  }
-
-  std::vector<zel_component_version_t> versions(number_of_components);
-
-  status = zelLoaderGetVersions(&number_of_components, versions.data());
-  if (status != ZE_RESULT_SUCCESS) {
-    return std::nullopt;
-  }
-
-  for (const auto& component_version : versions) {
-    if (!std::strncmp(component_version.component_name, kLoaderComponentName.data(),
-                      kLoaderComponentName.size())) {
-      return component_version.component_lib_version;
-    }
-  }
-
-  return std::nullopt;
-}
-
-inline std::optional<uint32_t> GetGpuDeviceIpVersion(ze_device_handle_t device) {
-  ze_device_ip_version_ext_t ip_version_ext_props{};
-  ip_version_ext_props.stype = ZE_STRUCTURE_TYPE_DEVICE_IP_VERSION_EXT;
-  ip_version_ext_props.pNext = nullptr;
-
-  ze_device_properties_t props{};
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  props.pNext = &ip_version_ext_props;
-
-  auto status = zeDeviceGetProperties(device, &props);
-  if (status != ZE_RESULT_SUCCESS || props.type != ZE_DEVICE_TYPE_GPU ||
-      props.vendorId != kIntelVendorId) {
-    return std::nullopt;
-  }
-
-  return static_cast<ze_device_ip_version_ext_t*>(props.pNext)->ipVersion;
-}
-
-inline std::optional<ze_driver_properties_t> GetDriverProperties(ze_driver_handle_t driver) {
-  ze_driver_properties_t properties{};
-  properties.stype = ZE_STRUCTURE_TYPE_DRIVER_PROPERTIES;
-  properties.pNext = nullptr;
-  auto status = zeDriverGetProperties(driver, &properties);
-  if (status != ZE_RESULT_SUCCESS) {
-    return std::nullopt;
-  }
-  return properties;
-}
-
-inline bool ContainsDeviceWithAtLeastIpVersion(const std::vector<ze_driver_handle_t>& driver_list,
-                                               uint32_t ip_version) {
-  const auto device_list = GetDeviceList(driver_list);
-  return std::any_of(std::cbegin(device_list), std::cend(device_list),
-                     [ip_version](ze_device_handle_t device) {
-                       const auto dev_ip_version = GetGpuDeviceIpVersion(device);
-                       return dev_ip_version && *dev_ip_version >= ip_version;
-                     });
-}
-
-struct MemDeleter {
-  ze_context_handle_t ctx = nullptr;
-  void operator()(void* ptr) const {
-    if (ctx && ptr) {
-      overhead::ScopedOverheadCollector overhead_collector(zeMemFree_id);
-      zeMemFree(ctx, ptr);
-    }
-  }
-};
-
-inline TimestampBuffer MakeTimestampBuffer(ze_context_handle_t ctx, size_t count) {
-  assert(ctx != nullptr);
-  assert(count != 0);
-  void* timestamps = nullptr;
-
-  // Align to cache line. It must also be multiple of `ze_kernel_timestamp_result_t` size, according
-  // to Level Zero specification
-  constexpr size_t kAlignment = 64;
-  static_assert(kAlignment % sizeof(ze_kernel_timestamp_result_t) == 0);
-
-  const ze_host_mem_alloc_desc_t alloc_desc{ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr, 0};
-  ze_result_t result = ZE_RESULT_SUCCESS;
-
-  {
-    overhead::ScopedOverheadCollector overhead_collector(zeMemAllocHost_id);
-    result = zeMemAllocHost(ctx, &alloc_desc, count * sizeof(ze_kernel_timestamp_result_t),
-                            kAlignment, &timestamps);
-  }
-  if (result == ZE_RESULT_SUCCESS) {
-    return TimestampBuffer{static_cast<ze_kernel_timestamp_result_t*>(timestamps), MemDeleter{ctx}};
-  }
-  return TimestampBuffer{nullptr};
-}
-
-}  // namespace ze
-}  // namespace utils
-
-#endif  // PTI_UTILS_ZE_UTILS_H_
diff --git a/sdk/src/view_buffer.h b/sdk/src/view_buffer.h
deleted file mode 100644
index e91599ed..00000000
--- a/sdk/src/view_buffer.h
+++ /dev/null
@@ -1,354 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-// LICENSE HERE
-
-#ifndef SRC_VIEW_BUFFER_H_
-#define SRC_VIEW_BUFFER_H_
-
-#include <assert.h>
-
-#include <array>
-#include <condition_variable>
-#include <cstring>
-#include <mutex>
-#include <optional>
-#include <queue>
-#include <type_traits>
-#include <unordered_map>
-#include <utility>
-
-namespace pti {
-namespace view {
-namespace utilities {
-template <typename U = unsigned char>
-struct ViewRecordBuffer {
- public:
-  using UnderlyingType = U;
-  using SizeType = std::size_t;
-
-  ViewRecordBuffer() = default;
-
-  constexpr explicit ViewRecordBuffer(UnderlyingType* buffer, SizeType size,
-                                      SizeType start_position)
-      : buf_(buffer), size_(size), pos_(start_position) {}
-
-  ViewRecordBuffer(const ViewRecordBuffer&) = delete;
-  ViewRecordBuffer& operator=(const ViewRecordBuffer&) = delete;
-
-  ViewRecordBuffer(ViewRecordBuffer&& other)
-      : buf_(std::exchange(other.buf_, nullptr)),
-        size_(std::exchange(other.size_, 0)),
-        pos_(std::exchange(other.pos_, 0)) {}
-
-  ViewRecordBuffer& operator=(ViewRecordBuffer&& other) noexcept {
-    if (this != &other) {
-      std::swap(other.buf_, buf_);  // keep ptr to data around
-      size_ = std::exchange(other.size_, 0);
-      pos_ = std::exchange(other.pos_, 0);
-    }
-    return *this;
-  }
-
-  ~ViewRecordBuffer() = default;
-
-  inline void Refresh(UnderlyingType* buffer, SizeType size) {
-    buf_ = buffer;
-    pos_ = 0;
-    size_ = size;
-  }
-
-  // Return the buffer pointer to the inserted record
-  template <typename T>
-  inline UnderlyingType* Insert(const T& view_record) {
-    static_assert(std::is_trivially_copyable<T>::value,
-                  "One can only insert trivially copyable types into the "
-                  "ViewBuffer (view records)");
-    assert(!IsNull());
-    assert(FreeBytes() >= sizeof(T));
-    auto* inserted_record = buf_ + pos_;
-    std::memcpy(inserted_record, &view_record, sizeof(T));
-    pos_ += sizeof(T);
-    return inserted_record;
-  }
-
-  template <typename T>
-  inline T* Peek() const {
-    return Peek<T>(nullptr, 0);
-  }
-
-  template <typename T>
-  inline T* Peek(T* element) const {
-    return Peek<T>(element, 0);
-  }
-
-  template <typename T>
-  inline T* Peek(SizeType loc) const {
-    return Peek<T>(nullptr, loc);
-  }
-
-  /**
-   * @brief Peek inside the buffer and view the next element
-   *
-   * @param element (optional) pointer to current element IN the buffer. If
-   * nullptr or unspecified, starts at beginning of buffer
-   * @param loc (optional) location of next element. If unspecified or 0,
-   * return current element in buffer.
-   * @return a pointer to an element inside the buffer, nullptr at end of buffer
-   */
-  template <typename T>
-  inline T* Peek(T* element, SizeType loc) const {
-    auto* buffer_window = element ? reinterpret_cast<UnderlyingType*>(element) : buf_;
-    auto* peek_element = buffer_window + loc;
-    if (peek_element == GetRecordsEnd()) {
-      peek_element = nullptr;
-    }
-    return reinterpret_cast<T*>(peek_element);
-  }
-
-  inline bool IsNull() const { return (!buf_ || !size_); }
-
-  constexpr UnderlyingType* GetBuffer() { return buf_; }
-
-  constexpr UnderlyingType* GetBuffer() const { return buf_; }
-
-  constexpr SizeType GetBufferSize() const { return size_; }
-  constexpr UnderlyingType* GetBufferEnd() { return buf_ + size_; }
-
-  constexpr SizeType GetValidBytes() const { return pos_; }
-
-  constexpr UnderlyingType* GetRecordsEnd() { return buf_ + pos_; }
-
-  constexpr UnderlyingType* GetRecordsEnd() const { return buf_ + pos_; }
-
-  constexpr SizeType FreeBytes() const {
-    assert(size_ - pos_ >= 0);
-    return size_ - pos_;
-  }
-
-  template <typename T>
-  constexpr bool BufferFull() const {
-    static_assert(std::is_trivially_copyable<T>::value,
-                  "One can only insert trivially copyable types into the "
-                  "ViewBuffer (view records)");
-    return sizeof(T) >= FreeBytes();
-  }
-
-  friend void Swap(ViewRecordBuffer& lhs, ViewRecordBuffer& rhs) { std::swap(lhs, rhs); }
-
- private:
-  UnderlyingType* buf_ = nullptr;
-  SizeType size_ = 0;
-  SizeType pos_ = 0;
-};
-
-template <typename T>
-struct ViewRecordBufferQueue {
- public:
-  ViewRecordBufferQueue() = default;
-  explicit ViewRecordBufferQueue(std::size_t depth) : buffer_depth_(depth) {}
-  ViewRecordBufferQueue& operator=(const ViewRecordBufferQueue&) = delete;
-  ViewRecordBufferQueue& operator=(ViewRecordBufferQueue&& other) = delete;
-  ViewRecordBufferQueue(const ViewRecordBufferQueue&) = delete;
-  ViewRecordBufferQueue(ViewRecordBufferQueue&& other) = delete;
-
-  inline void Push(T&& buffer) {
-    std::unique_lock<std::mutex> buffer_lock(buffer_queue_mtx_);
-    if (buffer_depth_.has_value()) {
-      buffer_available_.wait(buffer_lock, [this] { return buffer_queue_.size() < buffer_depth_; });
-    }
-    buffer_queue_.push(std::move(buffer));
-    buffer_lock.unlock();
-    buffer_available_.notify_one();
-  }
-
-  inline T Pop() {
-    std::unique_lock<std::mutex> buffer_lock(buffer_queue_mtx_);
-    buffer_available_.wait(buffer_lock, [this] { return !buffer_queue_.empty(); });
-    auto buffer = std::move(buffer_queue_.front());
-    buffer_queue_.pop();
-    buffer_lock.unlock();
-    buffer_available_.notify_all();
-
-    return buffer;
-  }
-
-  template <typename Condition>
-  inline void WaitUntilEmptyOr(const Condition& cond) {
-    std::unique_lock<std::mutex> buffer_lock(buffer_queue_mtx_);
-    buffer_available_.wait(buffer_lock, [this, &cond] { return buffer_queue_.empty() || cond; });
-  }
-
-  inline std::size_t Size() {
-    std::lock_guard<std::mutex> buffer_lock(buffer_queue_mtx_);
-    return std::size(buffer_queue_);
-  }
-
-  inline void ResetBufferDepth() {
-    std::lock_guard<std::mutex> buffer_lock(buffer_queue_mtx_);
-    buffer_depth_.reset();
-  }
-
-  inline void SetBufferDepth(std::size_t depth) {
-    std::lock_guard<std::mutex> buffer_lock(buffer_queue_mtx_);
-    buffer_depth_ = depth;
-  }
-
-  ~ViewRecordBufferQueue() = default;
-
- private:
-  std::queue<T> buffer_queue_;
-  mutable std::mutex buffer_queue_mtx_;
-  std::condition_variable buffer_available_;
-  std::optional<std::size_t> buffer_depth_;
-};
-
-/**
- * \internal
- * \brief A hash map class with a mutex. Thread safety not guaranteed.
- *
- * This is not a perfect abstraction. It may not make complete sense. There are
- * several places we want something like this though. If you add a member
- * function to this, please note whether it is thread safe or not.
- * User beware.
- * Functions not thread safe,
- * - `operator[]`
- * - `ForEach`
- * TODO(matthew.schilling@intel.com): Boost? TBB? Make more robust?
- */
-template <typename KeyT, typename ValueT>
-struct GuardedUnorderedMap {
- public:
-  GuardedUnorderedMap() = default;
-  GuardedUnorderedMap& operator=(const GuardedUnorderedMap&) = delete;
-  GuardedUnorderedMap& operator=(GuardedUnorderedMap&& other) = delete;
-  GuardedUnorderedMap(const GuardedUnorderedMap&) = delete;
-  GuardedUnorderedMap(GuardedUnorderedMap&& other) = delete;
-  ~GuardedUnorderedMap() = default;
-
-  /**
-   * \internal
-   * Locked pass through to operator[]
-   *
-   * \param key a key to a hash map
-   * \return reference to element in map associated with that key.
-   *
-   * \warning  NOT thread safe
-   */
-  template <typename T>
-  inline auto& operator[](T&& key) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    return hash_table_[std::forward<T>(key)];
-  }
-
-  /**
-   * \internal
-   * Add an element to a hash map without providing a reference.
-   *
-   * \param key a key to a hash map
-   * \param value to add to a hash map
-   *
-   */
-  inline void Add(const KeyT& key, const ValueT& val) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    hash_table_[key] = val;
-  }
-
-  /**
-   * \internal
-   * Erase an element in a hash map
-   *
-   * \param key a key to a hash map
-   *
-   */
-  inline void Erase(const KeyT& key) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    hash_table_.erase(key);
-  }
-
-  /**
-   * \internal
-   * Check whether map is empty
-   *
-   * \param key a key to a hash map
-   *
-   */
-  bool Empty() const {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    return hash_table_.empty();
-  }
-
-  /**
-   * \internal
-   * Try to find an element in a map
-   *
-   * \param key a key to a hash map
-   * \return std::optional copy of element
-   *
-   * \warning returns a COPY otherwise would not be thread safe
-   *
-   */
-  inline std::optional<ValueT> TryFindElement(const KeyT& key) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    if (hash_table_.find(key) != hash_table_.end()) {
-      return hash_table_[key];
-    }
-    return std::nullopt;
-  }
-
-  /**
-   * \internal
-   * Try to find an element in a map
-   *
-   * \param key a key to a hash map
-   * \return std::optional of element (move)
-   *
-   * \warning returns by VALUE otherwise would not be thread safe
-   *
-   */
-  inline std::optional<ValueT> TryTakeElement(const KeyT& key) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    if (hash_table_.find(key) != hash_table_.end()) {
-      return std::move(hash_table_[key]);
-    }
-    return std::nullopt;
-  }
-
-  /**
-   * \internal
-   * Iterates over map and calls a callable the user provides.
-   *
-   * This function is for iterating over the map while holding the lock. This
-   * prevents the iterators from being invalidated.
-   *
-   * \param a_callable user provided callable (lambda, functor, function)
-   *
-   * \warning NOT thread safe (user parameters can be references)
-   *
-   */
-  template <typename Callable>
-  inline void ForEach(Callable&& a_callable) {
-    std::lock_guard<std::mutex> lock_table(hash_table_mtx_);
-    auto user_callable = std::forward<Callable>(a_callable);
-    for (auto&& [key, value] : hash_table_) {
-      user_callable(key, value);
-    }
-  }
-
- private:
-  std::unordered_map<KeyT, ValueT> hash_table_;
-  mutable std::mutex hash_table_mtx_;
-};
-
-using ViewBuffer = ViewRecordBuffer<unsigned char>;
-using ViewBufferQueue = ViewRecordBufferQueue<ViewBuffer>;
-template <typename KeyT>
-using ViewBufferTable = GuardedUnorderedMap<KeyT, ViewBuffer>;
-
-}  // namespace utilities
-}  // namespace view
-}  // namespace pti
-
-#endif  // SRC_VIEW_BUFFER_H_
diff --git a/sdk/src/view_handler.h b/sdk/src/view_handler.h
deleted file mode 100644
index 5ab26490..00000000
--- a/sdk/src/view_handler.h
+++ /dev/null
@@ -1,1456 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_API_VIEW_HANDLER_H_
-#define SRC_API_VIEW_HANDLER_H_
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/common.h>
-#include <spdlog/spdlog.h>
-
-#include <atomic>
-#include <cstddef>
-#include <cstdio>
-#include <cstring>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-
-#include "consumer_thread.h"
-#include "default_buffer_callbacks.h"
-#include "pti/pti_view.h"
-#include "pti_api_ids_state_maps.h"
-#include "sycl/sycl_core_apis.h"
-
-#if defined(PTI_TRACE_SYCL)
-#include "sycl_collector.h"
-#endif
-
-#include "itt_collector.h"
-#include "overhead_kinds.h"
-#include "pti_string_pool.h"
-#include "unikernel.h"
-#include "utils.h"
-#include "view_buffer.h"
-#include "view_helpers.h"
-#include "view_record_info.h"
-#include "ze_collector.h"
-
-using AskForBufferEvent = std::function<void(unsigned char**, size_t*)>;
-using ReturnBufferEvent = std::function<void(unsigned char*, size_t, size_t)>;
-
-inline void BarrierExecEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void BarrierMemEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void FenceSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void EventSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void CommandListSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void CommandQueueSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void DeviceSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void UnknownSynchEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void ZeDriverEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void SyclRuntimeEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void OverheadCollectionEvent(void* data, const ZeKernelCommandExecutionRecord& rec);
-
-inline void ZeKernelStagesCallback(void* data,
-                                   std::vector<ZeKernelCommandExecutionRecord>& kcexecrec);
-
-inline void ZeApiCallsCallback(void* data, ZeKernelCommandExecutionRecord& rec);
-inline void CommunicationEvent(void* data, CommunicationRecord& rec);
-
-inline void SyclRuntimeViewCallback(void* data, ZeKernelCommandExecutionRecord& rec);
-inline void OverheadCollectionCallback(void* data, ZeKernelCommandExecutionRecord& rec);
-
-inline void GetDeviceId(char* buf, const ze_pci_ext_properties_t& pci_prop_);
-
-enum class InternalResult {
-  kStatusSuccess = 0,
-  kStatusViewNotEnabled = 1,  //!< status due to a pti_view_kind not enabled
-};
-
-inline static constexpr std::array kPtiClassLzHostSynchOpApis{
-    pti_api_id_driver_levelzero::zeFenceHostSynchronize_id,
-    pti_api_id_driver_levelzero::zeEventHostSynchronize_id,
-    pti_api_id_driver_levelzero::zeCommandQueueSynchronize_id,
-    pti_api_id_driver_levelzero::zeCommandListHostSynchronize_id,
-    pti_api_id_driver_levelzero::zeDeviceSynchronize_id,
-};
-
-inline static constexpr std::array kPtiClassLzGpuOpsCoreApis{
-    pti_api_id_driver_levelzero::zeCommandListAppendBarrier_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendMemoryRangesBarrier_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendMemoryCopy_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendMemoryFill_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendMemoryCopyRegion_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendMemoryCopyFromContext_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopy_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopyRegion_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopyToMemory_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopyToMemoryExt_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopyFromMemory_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendImageCopyFromMemoryExt_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernel_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithArguments_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithParameters_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchCooperativeKernel_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelIndirect_id,
-    pti_api_id_driver_levelzero::zeCommandListAppendLaunchMultipleKernelsIndirect_id,
-    pti_api_id_driver_levelzero::zeCommandListImmediateAppendCommandListsExp_id,
-    pti_api_id_driver_levelzero::zeCommandQueueExecuteCommandLists_id,
-};
-
-inline constexpr size_t kPtiViewKindCount = 13;
-
-template <typename T, typename M>
-inline void EnableAllIndividualApis(M& mtx, T& map) {
-  const std::lock_guard<std::mutex> lock(mtx);
-  for (auto& [k, v] : map) {
-    v = 1;
-  }
-}
-
-template <typename T, typename M>
-inline void DisableAllIndividualApis(M& mtx, T& map) {
-  const std::lock_guard<std::mutex> lock(mtx);
-  for (auto& [k, v] : map) {
-    v = 0;
-  }
-}
-
-inline void ResetTracingStateToAllDisabled(pti_api_group_id type) {
-  SPDLOG_DEBUG("In {}, pti_group:  {}", __func__, static_cast<uint32_t>(type));
-  switch (type) {
-    case pti_api_group_id::PTI_API_GROUP_SYCL: {
-      DisableAllIndividualApis(sycl_set_granularity_map_mtx, pti_api_id_runtime_sycl_state);
-      break;
-    }
-    case pti_api_group_id::PTI_API_GROUP_LEVELZERO: {
-      DisableAllIndividualApis(levelzero_set_granularity_map_mtx,
-                               pti_api_id_driver_levelzero_state);
-      break;
-    }
-    case pti_api_group_id::PTI_API_GROUP_OPENCL:
-    case pti_api_group_id::PTI_API_GROUP_ALL:  // for now no internal call for clearing all
-                                               // groups is needed.
-    case pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_LEVELZERO:
-    case pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_OPENCL:
-    case pti_api_group_id::PTI_API_GROUP_RESERVED:
-    default: {
-      break;
-    }
-  }
-}
-
-// Non-class specific: Enable/Disable specific API specified by api_id within the api_group_id.
-// Only specific types reach here -- group_all has already been accounted for in the caller.
-inline pti_result SetApiTracingState(pti_api_group_id type, uint32_t api_id, uint32_t enable) {
-  uint32_t new_value = (enable ? 1 : 0);
-  try {
-    switch (type) {
-      case pti_api_group_id::PTI_API_GROUP_SYCL: {
-        SPDLOG_DEBUG("In Sycl {}, pti_group:  {}, api_id: {}, enable?: {}", __FUNCTION__,
-                     static_cast<uint32_t>(type), static_cast<uint32_t>(api_id), new_value);
-        const std::lock_guard<std::mutex> lock(sycl_set_granularity_map_mtx);
-        if (pti_api_id_runtime_sycl_state.find(api_id) != pti_api_id_runtime_sycl_state.end()) {
-          pti_api_id_runtime_sycl_state[api_id] = new_value;
-        } else {
-          return pti_result::PTI_ERROR_BAD_API_ID;
-        }
-      }; break;
-      case pti_api_group_id::PTI_API_GROUP_LEVELZERO: {
-        SPDLOG_DEBUG("In Lz {}, pti_group:  {}, api_id: {}, enable?: {}", __FUNCTION__,
-                     static_cast<uint32_t>(type), static_cast<uint32_t>(api_id), new_value);
-        const std::lock_guard<std::mutex> lock(levelzero_set_granularity_map_mtx);
-        if (pti_api_id_driver_levelzero_state.find(api_id) !=
-            pti_api_id_driver_levelzero_state.end()) {
-          pti_api_id_driver_levelzero_state[api_id] = new_value;
-        } else {
-          return pti_result::PTI_ERROR_BAD_API_ID;
-        }
-      }; break;
-      case pti_api_group_id::PTI_API_GROUP_OPENCL: {
-        return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-      }; break;
-      case pti_api_group_id::PTI_API_GROUP_ALL:  // keep compiler happy -- if this cause of error
-                                                 // check caller.
-      case pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_LEVELZERO:
-      case pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_OPENCL:
-      case pti_api_group_id::PTI_API_GROUP_RESERVED: {
-        return pti_result::PTI_ERROR_BAD_ARGUMENT;
-      }; break;
-    }
-  } catch (const std::out_of_range&) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  } catch (const std::exception& e) {
-    SPDLOG_ERROR("Unknown exception caught in {}: {}", __FUNCTION__, e.what());
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-  return PTI_SUCCESS;
-}
-
-inline static std::atomic<bool> external_collection_enabled = false;
-
-struct PtiViewRecordHandler {
- public:
-  using ViewBuffer = pti::view::utilities::ViewBuffer;
-  using ViewBufferQueue = pti::view::utilities::ViewBufferQueue;
-  using ViewBufferTable = pti::view::utilities::ViewBufferTable<uint32_t>;
-
-  PtiViewRecordHandler()
-      : get_new_buffer_(pti::view::defaults::DefaultBufferAllocation),
-        deliver_buffer_(pti::view::defaults::DefaultRecordParser),
-        user_provided_ts_func_ptr_(utils::GetRealTime) {
-    // initially set logging level to warn
-    // need to use warnings very carefully, only when absolutely necessary
-    // as on Windows encountered it is INFO (taken from compiler define) by default (?)
-    spdlog::set_level(spdlog::level::warn);
-    // Read Logging level required
-    // set environment variable PTILOG_LEVEL=<level>, where level=TRACE/DEBUG/INFO..
-    // Logs appear only when PTI_ENABLE_LOGGING=ON => SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE
-    auto env_string = utils::GetEnv("PTILOG_LEVEL");
-    if (!env_string.empty()) {
-      spdlog::cfg::helpers::load_levels(env_string);
-    }
-    utils::SetGlobalSpdLogPattern();
-
-    if (!collector_) {
-      CollectorOptions collector_options{};
-      // TODO(PTI): Implement this better:
-      // this line here is from the beginning,
-      // and it is wrong as for simple API tracing - no need to trace GPU ops
-      // (too much overhead)
-      // However, dealing with it requires cross-thread synchronization
-      collector_options.kernel_tracing = true;
-      collector_ = ZeCollector::Create(&view_state_.state_, collector_options,
-                                       ZeKernelStagesCallback, ZeApiCallsCallback, nullptr);
-#if defined(PTI_CCL_ITT_COMPILE)
-      IttCollector::Instance().SetCallback(CommunicationEvent);
-#endif  // PTI_CCL_ITT_COMPILE
-
-      overhead::SetOverheadCallback(OverheadCollectionCallback);
-      // Get timevalue in nanoseconds for frequency of sync between clock sources
-      // (clock_monotonic_raw and by default clock_realtime)
-      //   Default is 1millisecond --- we allow any value closely bounded by 1second to
-      //   1microsecond.
-      const auto sync_env_string = utils::GetEnv("PTI_CONV_CLOCK_SYNC_TIME_NS");
-      if (!sync_env_string.empty()) {
-        try {
-          const int64_t sync_env_value = std::stoi(sync_env_string);
-          if (sync_env_value >= NSEC_IN_USEC &&
-              sync_env_value <= NSEC_IN_SEC) {    // are we within 1micro to 1sec bounds?
-            sync_clocks_every_ = sync_env_value;  // reset it.
-          }
-
-        } catch (std::invalid_argument const& /*ex*/) {
-          sync_clocks_every_ = kDefaultSyncTime;  // default conversion sync time -- 1 ms.
-        } catch (std::out_of_range const& /*ex*/) {
-          sync_clocks_every_ = kDefaultSyncTime;  // default conversion sync time -- 1 ms.
-        }
-      }
-      timestamp_of_last_ts_shift_ = utils::GetTime();  // CLOCK_MONOTONIC_RAW or equivalent
-      SPDLOG_INFO("\tClock Sync time (ns) set at: {}", sync_clocks_every_);
-      ts_shift_ = utils::ConversionFactorMonotonicRawToUnknownClock(user_provided_ts_func_ptr_);
-    }
-  }
-
-  PtiViewRecordHandler(const PtiViewRecordHandler&) = delete;
-  PtiViewRecordHandler& operator=(const PtiViewRecordHandler&) = delete;
-  PtiViewRecordHandler(PtiViewRecordHandler&&) = delete;
-  PtiViewRecordHandler& operator=(PtiViewRecordHandler&&) = delete;
-
-  void CleanUp() {
-    if (!deinit_) {
-      try {
-        overhead::overhead_collection_enabled = false;
-        DisableTracing();
-      } catch ([[maybe_unused]] const std::exception& e) {
-        SPDLOG_ERROR("Exception caught in {}: {}", __FUNCTION__, e.what());
-      } catch (...) {
-        SPDLOG_ERROR("Unknown Exception in {}", __FUNCTION__);
-      }
-      if (collector_) {
-#if !defined(_WIN32)
-        collector_->DisableTracer();
-#endif
-        // TODO(PTI-446): Add a public function to manually release the collector and reset any PTI
-        // resources. E.g., ptiViewShutdown, ptiShutdown, or something like that.
-        // Use static pointer to avoid leak detectors complaining.
-        [[maybe_unused]] static auto* const released_collector = collector_.release();
-      }
-      deinit_ = true;
-    }
-  }
-
-  virtual ~PtiViewRecordHandler() { CleanUp(); }
-
-  inline pti_result FlushBuffers() {
-    auto result = consumer_.Push([this]() mutable {
-      view_buffers_.ForEach([this](const auto&, auto&& buffer) {
-        if (!buffer.IsNull()) {
-          DeliverBuffer(std::move(buffer));
-        }
-      });
-    });
-
-    result.wait();
-
-    return PTI_SUCCESS;
-  }
-
-  template <typename T>
-  inline void InsertRecord(const T& view_record, uint32_t thread_id) {
-    static_assert(std::is_trivially_copyable<T>::value,
-                  "One can only insert trivially copyable types into the "
-                  "ViewBuffer (view records)");
-    const std::lock_guard<std::mutex> lock(insert_record_mtx_);
-    auto& buffer = view_buffers_[thread_id];
-
-    // If buffer is null, or if buffer does not have space for at least one record of the largest
-    if (buffer.IsNull()) {
-      RequestNewBuffer(buffer);
-    }
-
-    if (buffer.FreeBytes() >= sizeof(T)) {
-      buffer.Insert(view_record);
-    } else {
-      // This should never happen since we ensure the buffer can at least fit the largest record,
-      // but just in case.
-      SPDLOG_ERROR(
-          "Record of size {} bytes is large to fit in the buffer of size {} bytes. Record "
-          "dropped.",
-          sizeof(T), buffer.FreeBytes());
-    }
-
-    static_assert(SizeOfLargestViewRecord() != 0, "Largest record not available at compile time");
-    if (buffer.FreeBytes() >= SizeOfLargestViewRecord()) {
-      // There's space to insert more records. No need for swap.
-      return;
-    }
-    // Per-flush atomic provides the release/acquire happens-before edge between the
-    // producer's buffer writes and the consumer's reads. Each flush gets its own instance
-    // so concurrent flushes from different threads are independent. The queue mutex alone
-    // does not cover the buffer memory, which is accessed via a pointer copied independently
-    // into the lambda.
-    auto handoff = std::make_unique<std::atomic<unsigned char*>>(nullptr);
-    handoff->store(buffer.GetBuffer(), std::memory_order_release);
-    consumer_.PushAndForget(
-        [this, buffer = std::move(buffer), handoff = std::move(handoff)]() mutable {
-          (void)handoff->load(std::memory_order_acquire);
-          if (!buffer.IsNull()) {
-            DeliverBuffer(std::move(buffer));
-          }
-        });
-  }
-
-  inline pti_result RegisterTimestampCallback(pti_fptr_get_timestamp get_timestamp) {
-    if (!get_timestamp) return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    const std::lock_guard<std::mutex> lock(timestamp_api_mtx_);
-    user_provided_ts_func_ptr_ = get_timestamp;
-    timestamp_of_last_ts_shift_ = utils::GetTime();  // CLOCK_MONOTONIC_RAW or equivalent
-    ts_shift_ = utils::ConversionFactorMonotonicRawToUnknownClock(user_provided_ts_func_ptr_);
-    return pti_result::PTI_SUCCESS;
-  }
-
-  inline pti_result RegisterBufferCallbacks(AskForBufferEvent&& get_new_buf,
-                                            ReturnBufferEvent&& return_new_buf) {
-    pti_result result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-    auto get_new_buffer = std::move(get_new_buf);
-    auto deliver_buffer = std::move(return_new_buf);
-    if (!get_new_buffer || !deliver_buffer) {
-      // Keep using default callbacks
-      return result;
-    }
-
-    unsigned char* raw_buffer = nullptr;
-    std::size_t raw_buffer_size = 0;
-    get_new_buffer(&raw_buffer, &raw_buffer_size);
-
-    if (raw_buffer_size < SizeOfLargestViewRecord() || !raw_buffer) {
-      // Keep using default callbacks
-      result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-      deliver_buffer(raw_buffer, raw_buffer_size, 0);
-    } else {
-      // User callback is fine, keep memory they gave us
-      result = pti_result::PTI_SUCCESS;
-    }
-
-    if (result == pti_result::PTI_SUCCESS) {
-      // Use user-defined callbacks
-      {
-        std::lock_guard<std::mutex> cb_lock(get_new_buffer_mtx_);
-        get_new_buffer_ = std::move(get_new_buffer);
-      }
-      {
-        std::lock_guard<std::mutex> cb_lock(deliver_buffer_mtx_);
-        deliver_buffer_ = std::move(deliver_buffer);
-      }
-    } else {
-      get_new_buffer_(&raw_buffer, &raw_buffer_size);
-    }
-
-    uint32_t tid = utils::GetTid();
-    auto buffer_to_replace = view_buffers_.TryTakeElement(tid);
-
-    if (buffer_to_replace) {
-      DeliverBuffer(std::move(*buffer_to_replace));
-    }
-
-    view_buffers_[tid].Refresh(raw_buffer, raw_buffer_size);
-    callbacks_set_ = true;
-
-    return result;
-  }
-
-  void EnableAllRuntimeApisWithoutGranularity() {
-    const std::lock_guard<std::mutex> lock(map_granularity_set_mtx_);
-    EnableAllIndividualApis(sycl_set_granularity_map_mtx, pti_api_id_runtime_sycl_state);
-    map_granularity_set_[pti_api_group_id::PTI_API_GROUP_SYCL] = false;
-  }
-
-  void EnableAllDriverApisWithoutGranularity() {
-    const std::lock_guard<std::mutex> lock(map_granularity_set_mtx_);
-    EnableAllIndividualApis(levelzero_set_granularity_map_mtx, pti_api_id_driver_levelzero_state);
-    map_granularity_set_[pti_api_group_id::PTI_API_GROUP_LEVELZERO] = false;
-    map_granularity_set_[pti_api_group_id::PTI_API_GROUP_OPENCL] = false;
-  }
-
-  inline bool IsValidViewKind(pti_view_kind view_kind) {
-    bool valid = true;
-    if ((view_kind == pti_view_kind::PTI_VIEW_INVALID) ||
-        (view_kind == pti_view_kind::PTI_VIEW_RESERVED) ||
-        (static_cast<uint32_t>(view_kind) >= kPtiViewKindCount)) {
-      valid = false;
-    }
-    return valid;
-  }
-
-  inline pti_result Enable(pti_view_kind type) {
-    if (!callbacks_set_) {
-      return pti_result::PTI_ERROR_NO_CALLBACKS_SET;
-    }
-    auto result = pti_result::PTI_SUCCESS;
-    bool collection_enabled = collection_enabled_;
-    bool l0_collection_type = ((type == pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY) ||
-                               (type == pti_view_kind::PTI_VIEW_DRIVER_API) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P));
-
-    //
-    // TBD --- implement and remove the checks for below pti_view_kinds
-    //
-    if (type == pti_view_kind::PTI_VIEW_DEVICE_CPU_KERNEL) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    if (type == pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD) {
-      overhead::overhead_collection_enabled = true;
-    }
-
-    if (type == pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION) {
-      external_collection_enabled = true;
-    }
-
-    if (!IsValidViewKind(type)) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-
-    if (type == pti_view_kind::PTI_VIEW_RUNTIME_API) {
-#if defined(PTI_TRACE_SYCL)
-      if (GetApiViewState(pti_view_kind::PTI_VIEW_RUNTIME_API) == false) {
-        SyclCollector::Instance().SetCallback(SyclRuntimeViewCallback);
-        EnableAllRuntimeApisWithoutGranularity();
-        SyclCollector::Instance().EnableTracing();
-        collection_enabled = true;
-      }
-#else
-      SPDLOG_DEBUG(
-          "Sycl tracing activated, but the library has not been compiled with "
-          "-DPTI_TRACE_SYCL");
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-#endif
-    }
-
-#if defined(PTI_CCL_ITT_COMPILE)
-    if (type == pti_view_kind::PTI_VIEW_COMMUNICATION) {
-      if (!IttCollector::Instance().IsAvailable()) {
-        return pti_result::PTI_ERROR_COLLECTOR_UNAVAILABLE;
-      }
-      IttCollector::Instance().SetCallback(CommunicationEvent);
-      IttCollector::Instance().EnableTrace();
-      collection_enabled = true;
-    }
-#endif  // PTI_CCL_ITT_COMPILE
-
-    if (collector_) {
-      collection_enabled = true;
-      if (l0_collection_type) {
-        auto it = map_view_kind_enabled.find(type);
-        // We need to ensure we have enabled all to fire since we will be EnableTracing() for
-        // collector in this scope
-        if ((type == pti_view_kind::PTI_VIEW_DRIVER_API) &&
-            (it == map_view_kind_enabled.cend() || !map_view_kind_enabled[type])) {
-          EnableAllDriverApisWithoutGranularity();
-        }
-        if (it == map_view_kind_enabled.cend() || !map_view_kind_enabled[type]) {
-          map_view_kind_enabled[type] = true;
-          collector_->EnableTracing();
-        }
-        if (type == pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION) {
-          collector_->SetCollectorOptionSynchronization();
-        }
-        if (type == pti_view_kind::PTI_VIEW_DRIVER_API) {
-          collector_->SetCollectorOptionApiCalls();
-        }
-      }
-    }
-
-    collection_enabled_ = collection_enabled;
-
-    if (!collection_enabled_) {
-      return pti_result::PTI_ERROR_NOT_IMPLEMENTED;
-    }
-
-    try {
-      if (type != pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION) {
-        SetApiViewState(type, true);
-
-        // Note: at this point EnableTracing on collector may be on and we maybe in granular mode.
-        // We hit the below reset of granular enables in case we have in Multithread scenario where
-        // the overall flow is:
-        //    --- start off with enable pti_view_driver_api --- setup granularity to override all
-        //    --- some thread later resets to all via enable driver_api
-        if (type == pti_view_kind::PTI_VIEW_DRIVER_API) {
-          EnableAllDriverApisWithoutGranularity();
-        }
-      }
-    } catch (const std::out_of_range&) {
-      result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-    return result;
-  }
-
-  inline pti_result Disable(pti_view_kind type) {
-    pti_result result = pti_result::PTI_SUCCESS;
-    bool l0_collection_type = ((type == pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY) ||
-                               (type == pti_view_kind::PTI_VIEW_DRIVER_API) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION) ||
-                               (type == pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P));
-
-    if (type == pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD) {
-      overhead::overhead_collection_enabled = false;
-    }
-    if (type == pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION) {
-      external_collection_enabled = false;
-    }
-
-    if (type == pti_view_kind::PTI_VIEW_RUNTIME_API) {
-#if defined(PTI_TRACE_SYCL)
-      SyclCollector::Instance().DisableTracing();
-#endif
-    }
-#if defined(PTI_CCL_ITT_COMPILE)
-    if (type == pti_view_kind::PTI_VIEW_COMMUNICATION) {
-      IttCollector::Instance().DisableTrace();
-    }
-#endif  // PTI_CCL_ITT_COMPILE
-    if (type == pti_view_kind::PTI_VIEW_INVALID) {
-      return pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-    if (collector_) {
-      if (l0_collection_type) {
-        auto it = map_view_kind_enabled.find(type);
-        if (it != map_view_kind_enabled.cend() && map_view_kind_enabled[type]) {
-          map_view_kind_enabled[type] = false;
-          collector_->DisableTracing();
-        }
-        if (type == pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION) {
-          collector_->UnSetCollectorOptionSynchronization();
-        }
-        if (type == pti_view_kind::PTI_VIEW_DRIVER_API) {
-          collector_->UnSetCollectorOptionApiCalls();
-        }
-      }
-    }
-
-    try {
-      if (type != pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION) {
-        SetApiViewState(type, false);
-      }
-    } catch (const std::out_of_range&) {
-      result = pti_result::PTI_ERROR_BAD_ARGUMENT;
-    }
-    if (!IsAnyViewEnabled()) {
-      DisableTracing();
-    }
-    return result;
-  }
-
-  inline pti_result PushExternalKindId(pti_view_external_kind external_kind, uint64_t external_id) {
-    pti_result result = pti_result::PTI_SUCCESS;
-    SPDLOG_TRACE("In {}, ext_id: {}, ext_kind: {}", __FUNCTION__, external_id,
-                 static_cast<uint32_t>(external_kind));
-
-    pti_view_record_external_correlation record{};
-    record._external_id = external_id;
-    record._external_kind = external_kind;
-    thread_local_map_ext_corrid_vectors[{external_kind}].push(record);
-
-    return result;
-  }
-
-  inline pti_result PopExternalKindId(pti_view_external_kind external_kind,
-                                      uint64_t* p_external_id) {
-    auto result = pti_result::PTI_SUCCESS;
-    auto it = thread_local_map_ext_corrid_vectors.find({external_kind});
-    if (it != thread_local_map_ext_corrid_vectors.cend()) {
-      // Optimization: Only copy full record if we'll need it for deferred_erase (rare case)
-      // Check before pop if stack will be empty AND we're in subscriber callback
-      const bool will_need_full_record =
-          (it->second.size() == 1) && thread_local_is_within_subscriber_callback;
-
-      if (will_need_full_record) {
-        // RARE case: Make full copy for deferred_erase
-        const auto ext_record = it->second.top();
-        SPDLOG_TRACE("In {}, ext_id: {} ext_kind: {}", __FUNCTION__, ext_record._external_id,
-                     static_cast<uint32_t>(external_kind));
-        if (p_external_id != nullptr) {
-          *p_external_id = ext_record._external_id;
-        }
-        it->second.pop();
-        SPDLOG_TRACE("In {}, Deferring erase of External Kind: {}, id: {}", __func__,
-                     static_cast<uint32_t>(external_kind), ext_record._external_id);
-        thread_local_map_ext_corrid_vectors_deferred_erase[{external_kind}].push(ext_record);
-        thread_local_map_ext_corrid_vectors.erase(it);
-      } else {
-        // TYPICAL case: Only extract the ID field we need (avoids copying full record)
-        const uint64_t external_id = it->second.top()._external_id;
-        SPDLOG_TRACE("In {}, ext_id: {} ext_kind: {}", __FUNCTION__, external_id,
-                     static_cast<uint32_t>(external_kind));
-        if (p_external_id != nullptr) {
-          *p_external_id = external_id;
-        }
-        it->second.pop();
-        if (it->second.empty()) {
-          thread_local_map_ext_corrid_vectors.erase(it);
-        }
-      }
-    } else {
-      SPDLOG_TRACE("In {}, External ID Queue is empty", __FUNCTION__);
-      result = pti_result::PTI_ERROR_EXTERNAL_ID_QUEUE_EMPTY;
-    }
-    return result;
-  }
-
-  inline const char* InsertKernel(const std::string& name) {
-    // Store each distinct name once, return a stable pointer.
-    return kernel_name_storage_.Get(name);
-  }
-
-  // Given enable or disable new value; the array of apis in class - class_ops; and the state_map.
-  //   -- set the state of the api to the new_value for all apis in the class_ops array.
-  template <typename T, size_t N>
-  inline void SetGranularApis(uint32_t new_value, const std::array<T, N>& class_ops,
-                              std::unordered_map<uint32_t, uint32_t>& state_map,
-                              std::string_view class_name) {
-    for (const auto& id : class_ops) {
-      auto it = state_map.find(id);
-      if (it != state_map.end()) {
-        it->second = new_value;
-      } else {
-        SPDLOG_WARN(
-            "SetGranularApis: class '{}' contains api_id {} not defined in the overall API list",
-            class_name, static_cast<uint32_t>(id));
-      }
-    }
-  }
-
-  // Overload for SyclCoreApi arrays — extracts the id field from each entry.
-  template <size_t N>
-  inline void SetGranularApis(uint32_t new_value, const std::array<SyclCoreApi, N>& class_ops,
-                              std::unordered_map<uint32_t, uint32_t>& state_map,
-                              std::string_view class_name) {
-    for (const auto& entry : class_ops) {
-      const auto id = static_cast<uint32_t>(entry.id);
-      auto it = state_map.find(id);
-      if (it != state_map.end()) {
-        it->second = new_value;
-      } else {
-        SPDLOG_WARN(
-            "SetGranularApis: class '{}' contains api_id {} not defined in the overall API list",
-            class_name, id);
-      }
-    }
-  }
-
-  // TODO - Assumes only Sycl runtime frontend -- extend this as we add more runtimes.
-  // enables/disables (per new_value) class specific apis as defined by pti_class for tracing.
-  inline pti_result SetRuntimeClassSpecificGranularIds(uint32_t new_value,
-                                                       pti_api_class pti_class) {
-    SPDLOG_TRACE("In {}, class: {}", __FUNCTION__, static_cast<uint32_t>(pti_class));
-    switch (pti_class) {
-      case pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE: {
-        const std::lock_guard<std::mutex> lock{sycl_set_granularity_map_mtx};
-        SetGranularApis(new_value, kSyclCoreApis, pti_api_id_runtime_sycl_state,
-                        "PTI_API_CLASS_GPU_OPERATION_CORE");
-        break;
-      }
-      case pti_api_class::PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION:  // Does not apply to
-                                                                         // runtime
-      case pti_api_class::PTI_API_CLASS_ALL:
-      default:
-        break;
-    }
-    return PTI_SUCCESS;
-  }
-
-  // TODO - Assumes only Lz backend -- extend this as we add more backends.
-  // enables/disables (per new_value) class specific apis as defined by pti_class for tracing.
-  inline pti_result SetDriverClassSpecificGranularIds(uint32_t new_value, pti_api_class pti_class) {
-    SPDLOG_TRACE("In {}, class: {}", __FUNCTION__, static_cast<uint32_t>(pti_class));
-    switch (pti_class) {
-      case pti_api_class::PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION: {
-        const std::lock_guard<std::mutex> lock(levelzero_set_granularity_map_mtx);
-        SetGranularApis(new_value, kPtiClassLzHostSynchOpApis, pti_api_id_driver_levelzero_state,
-                        "PTI_API_CLASS_HOST_OPERATION_SYNCHRONIZATION");
-        break;
-      }
-      case pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE: {
-        const std::lock_guard<std::mutex> lock(levelzero_set_granularity_map_mtx);
-        SetGranularApis(new_value, kPtiClassLzGpuOpsCoreApis, pti_api_id_driver_levelzero_state,
-                        "PTI_API_CLASS_GPU_OPERATION_CORE");
-        break;
-      }
-      case pti_api_class::PTI_API_CLASS_ALL:
-      default:
-        break;
-    }
-    return PTI_SUCCESS;
-  }
-
-  inline void CheckAndSetGranularity(pti_api_group_id pti_group) {
-    // TODO: potentially long scope of lock, could cause errors.
-    const std::lock_guard<std::mutex> lock(map_granularity_set_mtx_);
-
-    auto granularity_set_it = map_granularity_set_.find(pti_group);
-
-    if (granularity_set_it == map_granularity_set_.end() || !granularity_set_it->second) {
-      ResetTracingStateToAllDisabled(pti_group);
-      map_granularity_set_[pti_group] = true;
-    }
-  }
-
-  inline pti_result CheckGranularityAndSetState(pti_api_group_id pti_group, uint32_t api_id,
-                                                uint32_t enable) {
-    CheckAndSetGranularity(pti_group);
-    return SetApiTracingState(pti_group, api_id, enable);
-  }
-
-  //  Resets the granularity if not set, then sets state for this group per class apis input.
-  inline pti_result ProcessGroupForDriverPerClass(pti_api_group_id& pti_group, uint32_t new_value,
-                                                  pti_api_class& pti_class) {
-    SPDLOG_DEBUG("In {}, pti_group:  {}, pti_class: {}", __FUNCTION__,
-                 static_cast<uint32_t>(pti_group), static_cast<uint32_t>(pti_class));
-    CheckAndSetGranularity(pti_group);
-    return SetDriverClassSpecificGranularIds(new_value, pti_class);
-  }
-
-  //  Resets the granularity if not set, then sets state for this group per class apis input.
-  inline pti_result ProcessGroupForRuntimePerClass(pti_api_group_id& pti_group, uint32_t new_value,
-                                                   pti_api_class& pti_class) {
-    SPDLOG_DEBUG("In {}, pti_group:  {}, pti_class: {}", __FUNCTION__,
-                 static_cast<uint32_t>(pti_group), static_cast<uint32_t>(pti_class));
-    CheckAndSetGranularity(pti_group);
-    return SetRuntimeClassSpecificGranularIds(new_value, pti_class);
-  }
-
-  inline pti_result GetState() { return view_state_.GetState(); }
-  inline void SetState(pti_result new_state) { view_state_.SetState(new_state); }
-
-  inline pti_result GPULocalAvailable() {
-    if (collector_) {
-      if (collector_->IsIntrospectionCapable() && collector_->IsDynamicTracingCapable()) {
-        return pti_result::PTI_SUCCESS;
-      }
-      return pti_result::PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED;
-    }
-    return pti_result::PTI_ERROR_INTERNAL;
-  }
-  inline uint64_t GetUserTimestamp() { return (*user_provided_ts_func_ptr_.load())(); }
-
-  inline int64_t GetTimeShift() {
-    const std::lock_guard<std::mutex> lock(timestamp_api_mtx_);
-
-    uint64_t now = utils::GetTime();  // CLOCK_MONOTONIC_RAW or equivalent
-    if ((now - timestamp_of_last_ts_shift_) > sync_clocks_every_) {
-      timestamp_of_last_ts_shift_ = utils::GetTime();  // CLOCK_MONOTONIC_RAW or equivalent
-      ts_shift_ = utils::ConversionFactorMonotonicRawToUnknownClock(user_provided_ts_func_ptr_);
-    }
-    return ts_shift_;
-  }
-
-  // Callback API
-  // Multiple subscriber support with ID-based management
-  inline pti_result CallbackSubscribe(pti_callback_subscriber_handle* subscriber,
-                                      pti_callback_function callback, void* user_data) {
-    if (subscriber == nullptr || callback == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    // Limitation (hopefully temporal) Callbacks only supported when kernel tracing is ON
-    if (collector_ && collector_->IsTracingOn() &&
-        collector_->GetCollectorOptions().kernel_tracing) {
-      auto subscriber_handle = collector_->AddCallbackSubscriber(callback, user_data);
-      if (subscriber_handle == nullptr) {
-        SPDLOG_ERROR("Failed to add callback subscriber");
-        return PTI_ERROR_INTERNAL;
-      }
-      *subscriber = subscriber_handle;
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_NO_GPU_VIEWS_ENABLED;
-  }
-
-  inline pti_result CallbackUnsubscribe(pti_callback_subscriber_handle subscriber_handle) {
-    if (subscriber_handle == nullptr) {
-      return PTI_ERROR_BAD_ARGUMENT;
-    }
-    if (collector_) {
-      auto result = collector_->RemoveCallbackSubscriber(subscriber_handle);
-      if (result != pti_result::PTI_SUCCESS) {
-        SPDLOG_ERROR("Failed to unsubscribe callback: {}", static_cast<uint32_t>(result));
-        return result;
-      }
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_INTERNAL;
-  }
-
-  inline pti_result CallbackEnableDomain(pti_callback_subscriber_handle subscriber,
-                                         pti_callback_domain domain, uint32_t enter_cb,
-                                         uint32_t exit_cb) {
-    if (collector_) {
-      auto result = collector_->EnableCallbackDomain(subscriber, domain, enter_cb, exit_cb);
-      if (result != pti_result::PTI_SUCCESS) {
-        SPDLOG_ERROR("Failed to enable domain: {}", static_cast<uint32_t>(result));
-        return result;
-      }
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_INTERNAL;
-  }
-
-  inline pti_result CallbackDisableDomain(pti_callback_subscriber_handle subscriber,
-                                          pti_callback_domain domain) {
-    if (collector_) {
-      auto result = collector_->DisableCallbackDomain(subscriber, domain);
-      if (result != pti_result::PTI_SUCCESS) {
-        SPDLOG_ERROR("Failed to disable domain: {}", static_cast<uint32_t>(result));
-        return result;
-      }
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_INTERNAL;
-  }
-
-  inline pti_result CallbackDisableAllDomains(pti_callback_subscriber_handle subscriber) {
-    if (collector_) {
-      auto result = collector_->DisableAllCallbackDomains(subscriber);
-      if (result != pti_result::PTI_SUCCESS) {
-        SPDLOG_ERROR("Failed to disable all domains: {}", static_cast<uint32_t>(result));
-        return result;
-      }
-      return PTI_SUCCESS;
-    }
-    return PTI_ERROR_INTERNAL;
-  }
-
- private:
-  inline void RequestNewBuffer(pti::view::utilities::ViewBuffer& buffer) {
-    unsigned char* raw_buffer = nullptr;
-    std::size_t buffer_size = 0;
-    {
-      std::lock_guard<std::mutex> cb_lock(get_new_buffer_mtx_);
-      get_new_buffer_(&raw_buffer, &buffer_size);
-    }
-    buffer.Refresh(raw_buffer, buffer_size);
-  }
-
-  inline void DeliverBuffer(pti::view::utilities::ViewBuffer&& buffer) {
-    auto buffer_to_deliver = std::move(buffer);
-    {
-      std::lock_guard<std::mutex> cb_lock(deliver_buffer_mtx_);
-      if (buffer_to_deliver.GetBuffer()) {
-        deliver_buffer_(buffer_to_deliver.GetBuffer(), buffer_to_deliver.GetBufferSize(),
-                        buffer_to_deliver.GetValidBytes());
-      }
-    }
-  }
-
-  inline void DisableTracing() {
-#if defined(PTI_TRACE_SYCL)
-    SyclCollector::Instance().DisableTracing();
-#endif
-    collection_enabled_ = false;
-  }
-  std::unique_ptr<ZeCollector> collector_ = nullptr;
-  std::atomic<bool> collection_enabled_ = false;
-  // Internal PTI state.
-  // If abnormal situation happens - this variable will be set the corresponding value
-  ViewState& view_state_ = ViewStateInstance();
-  std::atomic<bool> callbacks_set_ = false;
-  AskForBufferEvent get_new_buffer_;
-  ReturnBufferEvent deliver_buffer_;
-  mutable std::mutex get_new_buffer_mtx_;
-  mutable std::mutex deliver_buffer_mtx_;
-  mutable std::mutex timestamp_api_mtx_;
-  mutable std::mutex insert_record_mtx_;  // protecting writing to buffers, as different threads
-                                          // might be writing to the same buffer
-  mutable std::mutex map_granularity_set_mtx_;
-
-  StringPool kernel_name_storage_;
-  ViewBufferTable view_buffers_;
-  pti::view::BufferConsumer consumer_ = {};  // Starts thread
-  std::atomic<pti_fptr_get_timestamp> user_provided_ts_func_ptr_ = nullptr;
-  int64_t ts_shift_ = 0;  // conversion factor for switching from default clock to user provided
-                          // one(defaults to monotonic raw)
-  uint64_t timestamp_of_last_ts_shift_ = 0;  // every 1 second we recalculate time_shift_
-  inline static constexpr auto kDefaultSyncTime = 1'000'000ULL;
-  uint64_t sync_clocks_every_ =
-      kDefaultSyncTime;  // time in nanoseconds, sync every millisecond by default --- this can be
-                         // overridden by the env variable PTI_CONV_CLOCK_SYNC_TIME_NS.
-  std::atomic<bool> deinit_ = false;
-
-  std::map<pti_api_group_id, std::atomic<bool>>
-      map_granularity_set_;  // Are we in granular (individual api) mode for this api_group?
-};
-
-// Required to access buffer from ze_collector callbacks
-inline static auto& Instance() {
-  static PtiViewRecordHandler data_container{};
-  return data_container;
-}
-
-inline pti_result GetNextRecord(uint8_t* buffer, size_t valid_bytes,
-                                pti_view_record_base** record) {
-  if (!record) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  pti::view::utilities::ViewBuffer view_buffer(buffer, valid_bytes, valid_bytes);
-
-  if (view_buffer.IsNull() || !view_buffer.GetValidBytes()) {
-    return pti_result::PTI_STATUS_END_OF_BUFFER;
-  }
-
-  auto* current_record = *record;
-
-  // User passed a nullptr for the record. Give them the first record.
-  if (!current_record) {
-    *record = view_buffer.Peek<pti_view_record_base>();
-    return pti_result::PTI_SUCCESS;
-  }
-
-  auto next_element_loc = GetViewSize(current_record->_view_kind);
-
-  // Found invalid record
-  if (next_element_loc == SIZE_MAX) {
-    return pti_result::PTI_ERROR_BAD_ARGUMENT;
-  }
-
-  auto* next_element_ptr = view_buffer.Peek(*record, next_element_loc);
-
-  if (!next_element_ptr) {
-    return pti_result::PTI_STATUS_END_OF_BUFFER;
-  }
-
-  *record = next_element_ptr;
-
-  return pti_result::PTI_SUCCESS;
-}
-
-template <typename T>
-inline void SetMemFillType(T& mem_record, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, memory route: {}", __FUNCTION__,
-               rec.memory_route_.GetCompactStringForTypes());
-  mem_record._mem_type = rec.memory_route_.dst_type;
-}
-
-template <typename T>
-inline void SetMemCopyType(T& mem_record, const ZeKernelCommandExecutionRecord& rec) {
-  mem_record._memcpy_type = rec.memory_route_.GetMemcpyType();
-  mem_record._mem_src = rec.memory_route_.src_type;
-  mem_record._mem_dst = rec.memory_route_.dst_type;
-}
-
-inline void GetDeviceId(char* buf, const ze_pci_ext_properties_t& pci_prop_) {
-  // determined by pti_view_record_kernel _pci_address
-  constexpr auto kMaxDeviceIdLength = PTI_MAX_PCI_ADDRESS_SIZE;
-  std::snprintf(buf, kMaxDeviceIdLength, "%x:%x:%x.%x", pci_prop_.address.domain,
-                pci_prop_.address.bus, pci_prop_.address.device, pci_prop_.address.function);
-}
-
-inline void GenerateExternalCorrelationRecords(const ZeKernelCommandExecutionRecord& rec) {
-  // Process active external correlation stacks
-  for (const auto& kv : thread_local_map_ext_corrid_vectors) {
-    const auto& stack = kv.second;
-    auto ext_record = stack.top();  // copy for modification
-    ext_record._correlation_id = rec.cid_;
-    ext_record._view_kind._view_kind = pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION;
-    Instance().InsertRecord(ext_record, rec.tid_);
-  }
-
-  // Process deferred-erase external correlation stacks
-  for (const auto& kv : thread_local_map_ext_corrid_vectors_deferred_erase) {
-    const auto& stack = kv.second;
-    if (stack.empty()) {
-      continue;
-    }
-    // PTI-457: a kind that has been given a live id again is already reported by
-    // the loop above. Emitting the popped id as well labels one operation with
-    // two conflicting external ids, and the consumer keeps an arbitrary one.
-    if (thread_local_map_ext_corrid_vectors.count(kv.first) != 0) {
-      continue;
-    }
-    auto ext_record = stack.top();  // copy for modification
-    ext_record._correlation_id = rec.cid_;
-    ext_record._view_kind._view_kind = pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION;
-    SPDLOG_TRACE("In {}, processing deferred ext records pop - External Kind: {}, id: {}", __func__,
-                 static_cast<uint32_t>(ext_record._external_kind), ext_record._external_id);
-    Instance().InsertRecord(ext_record, rec.tid_);
-  }
-  thread_local_map_ext_corrid_vectors_deferred_erase.clear();
-}
-
-template <typename T>
-inline void SetMemCpyIds(T& record, const ZeKernelCommandExecutionRecord& rec) {
-  if (rec.device_ != nullptr) {
-    GetDeviceId(record._pci_address, rec.pci_prop_);
-    std::copy_n(rec.src_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._device_uuid);
-    SetMemCopyType<T>(record, rec);
-    return;
-  }
-
-  if (rec.dst_device_ != nullptr) {
-    GetDeviceId(record._pci_address, rec.dst_pci_prop_);
-  } else {
-    memset(record._pci_address, 0, PTI_MAX_PCI_ADDRESS_SIZE);
-  }
-
-  std::copy_n(rec.dst_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._device_uuid);
-  SetMemCopyType<T>(record, rec);
-}
-
-template <typename T>
-inline void SetMemCpyIdsP2P(T& record, const ZeKernelCommandExecutionRecord& rec) {
-  if (rec.device_ != nullptr)
-    GetDeviceId(record._src_pci_address, rec.pci_prop_);
-  else
-    memset(record._src_pci_address, 0, PTI_MAX_PCI_ADDRESS_SIZE);
-  if (rec.dst_device_ != nullptr)
-    GetDeviceId(record._dst_pci_address, rec.dst_pci_prop_);
-  else
-    memset(record._dst_pci_address, 0, PTI_MAX_PCI_ADDRESS_SIZE);
-
-  std::copy_n(rec.src_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._src_uuid);
-  std::copy_n(rec.dst_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._dst_uuid);
-  SetMemCopyType<T>(record, rec);
-}
-
-template <typename T>
-inline void DoCommonMemCopy(T& record, const ZeKernelCommandExecutionRecord& rec) {
-  utils::Zeroize(record);
-
-  int64_t ts_shift = Instance().GetTimeShift();
-
-  record._append_timestamp = ApplyTimeShift(rec.append_time_, ts_shift);
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._submit_timestamp = ApplyTimeShift(rec.submit_time_, ts_shift);
-  record._queue_handle = rec.queue_;
-  record._sycl_queue_id = rec.sycl_queue_id_;
-  record._context_handle = rec.context_;
-  record._bytes = rec.bytes_xfered_;
-
-  // We're storing it in a kernel map so this shouldn't go out of scope
-  record._name = Instance().InsertKernel(rec.name_);
-  record._thread_id = rec.tid_;
-  record._mem_op_id = rec.kid_;
-  record._correlation_id = rec.cid_;
-  record._engine_ordinal = rec.engine_ordinal_;
-  record._engine_index = rec.engine_index_;
-}
-
-inline void MemCopyP2PEvent(const ZeKernelCommandExecutionRecord& rec) {
-  pti_view_record_memory_copy_p2p_v2 record;
-  DoCommonMemCopy(record, rec);
-  SetMemCpyIdsP2P(record, rec);
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P;
-  record._src_device_handle = static_cast<pti_device_handle_t>(rec.device_);
-  record._dst_device_handle = static_cast<pti_device_handle_t>(rec.dst_device_);
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void MemCopyEvent(const ZeKernelCommandExecutionRecord& rec) {
-  pti_view_record_memory_copy_v2 record;
-  DoCommonMemCopy(record, rec);
-  SetMemCpyIds(record, rec);
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY;
-  record._device_handle = static_cast<pti_device_handle_t>(rec.device_);
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void MemFillEvent(const ZeKernelCommandExecutionRecord& rec) {
-  pti_view_record_memory_fill_v2 record;
-  utils::Zeroize(record);
-
-  int64_t ts_shift = Instance().GetTimeShift();
-
-  record._append_timestamp = ApplyTimeShift(rec.append_time_, ts_shift);
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._submit_timestamp = ApplyTimeShift(rec.submit_time_, ts_shift);
-  record._queue_handle = rec.queue_;
-  record._sycl_queue_id = rec.sycl_queue_id_;
-  record._context_handle = rec.context_;
-  record._bytes = rec.bytes_xfered_;
-  record._value_for_set = rec.value_set_;
-
-  // We're storing it in a kernel map so this shouldn't go out of scope
-  record._name = Instance().InsertKernel(rec.name_);
-  record._thread_id = rec.tid_;
-  record._mem_op_id = rec.kid_;
-  record._correlation_id = rec.cid_;
-
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL;
-
-  GetDeviceId(record._pci_address, rec.pci_prop_);
-  SetMemFillType(record, rec);
-
-  // for MemoryFill op the reported device is the destination device, where fill happens
-  std::copy_n(rec.dst_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._device_uuid);
-
-  record._device_handle = static_cast<pti_device_handle_t>(rec.device_);
-  record._engine_ordinal = rec.engine_ordinal_;
-  record._engine_index = rec.engine_index_;
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void OverheadCollectionEvent(void* data, const ZeKernelCommandExecutionRecord& /*rec*/) {
-  int64_t ts_shift = Instance().GetTimeShift();
-  auto* overhead_record = static_cast<pti_view_record_overhead*>(data);
-  overhead_record->_overhead_start_timestamp_ns =
-      ApplyTimeShift(overhead_record->_overhead_start_timestamp_ns, ts_shift);
-  overhead_record->_overhead_end_timestamp_ns =
-      ApplyTimeShift(overhead_record->_overhead_end_timestamp_ns, ts_shift);
-  Instance().InsertRecord(*overhead_record, overhead_record->_overhead_thread_id);
-}
-
-inline void SyclRuntimeEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  pti_view_record_api record{};
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_RUNTIME_API;
-  record._api_group = pti_api_group_id::PTI_API_GROUP_SYCL;
-
-  int64_t ts_shift = Instance().GetTimeShift();
-
-  if (external_collection_enabled) {
-    GenerateExternalCorrelationRecords(rec);
-  }
-
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._thread_id = rec.tid_;
-  record._process_id = rec.pid_;
-  record._correlation_id = rec.cid_;
-  record._api_id = rec.callback_id_;
-  record._return_code = rec.result_;
-  // record._name = rec.sycl_func_name_;
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, record._correlation_id);
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void CommonSynchEvent(pti_view_record_synchronization& record,
-                             const ZeKernelCommandExecutionRecord& rec) {
-  int64_t ts_shift = Instance().GetTimeShift();
-
-  record._api_group = pti_api_group_id::PTI_API_GROUP_LEVELZERO;
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._thread_id = rec.tid_;
-  record._correlation_id = rec.cid_;
-  record._queue_handle = rec.queue_;
-  record._context_handle = rec.context_;
-  record._api_id = rec.callback_id_;
-  record._event_handle = rec.event_;
-  record._number_wait_events = rec.num_wait_events_;
-  record._return_code = static_cast<uint32_t>(rec.result_);
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void EventSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type = pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_EVENT;
-  CommonSynchEvent(record, rec);
-}
-
-inline void FenceSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type = pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_FENCE;
-  CommonSynchEvent(record, rec);
-}
-
-inline void CommandListSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type =
-      pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_LIST;
-  CommonSynchEvent(record, rec);
-}
-
-inline void CommandQueueSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type =
-      pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_QUEUE;
-  CommonSynchEvent(record, rec);
-}
-
-inline void DeviceSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type = pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_DEVICE;
-  CommonSynchEvent(record, rec);
-}
-
-inline void UnknownSynchEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type = pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_UNKNOWN;
-  CommonSynchEvent(record, rec);
-}
-
-inline void BarrierExecEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type =
-      pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_EXECUTION;
-  CommonSynchEvent(record, rec);
-}
-
-inline void BarrierMemEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, corr_id: {}", __FUNCTION__, rec.cid_);
-  pti_view_record_synchronization record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION;
-  record._synch_type =
-      pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_MEMORY;
-  CommonSynchEvent(record, rec);
-}
-
-inline void KernelEvent(const ZeKernelCommandExecutionRecord& rec) {
-  pti_view_record_kernel_v2 record;
-  // Note: no need to call  GenerateExternalCorrelationRecords(rec)
-  // as there records go only with runtime API records and not with GPU kernels, memory ops..
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL;
-
-  int64_t ts_shift = Instance().GetTimeShift();
-  record._append_timestamp = ApplyTimeShift(rec.append_time_, ts_shift);
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._submit_timestamp = ApplyTimeShift(rec.submit_time_, ts_shift);
-  record._queue_handle = rec.queue_;
-  record._context_handle = rec.context_;
-
-  // We're storing it in a kernel map so this shouldn't go out of scope
-  record._name = Instance().InsertKernel(rec.name_);
-  record._thread_id = rec.tid_;
-  record._kernel_id = rec.kid_;
-  record._correlation_id = rec.cid_;
-
-  // source file name and line info is collected when SYCL tracing is enabled
-  record._source_file_name = Instance().InsertKernel(rec.source_file_name_);
-  record._source_line_number =
-      rec.source_line_number_ != UINT32_MAX ? rec.source_line_number_ : 0ULL;
-
-  record._sycl_node_id = rec.sycl_node_id_;
-  record._sycl_queue_id = rec.sycl_queue_id_;
-  record._sycl_invocation_id = rec.sycl_invocation_id_;
-  record._sycl_enqk_begin_timestamp = ApplyTimeShift(rec.sycl_enqk_begin_time_, ts_shift);
-  record._sycl_task_begin_timestamp = ApplyTimeShift(rec.sycl_task_begin_time_, ts_shift);
-
-  // Update PCI and UUID info here
-  GetDeviceId(record._pci_address, rec.pci_prop_);
-  std::copy_n(rec.src_device_uuid, PTI_MAX_DEVICE_UUID_SIZE, record._device_uuid);
-
-  record._device_handle = static_cast<pti_device_handle_t>(rec.device_);
-  record._engine_ordinal = rec.engine_ordinal_;
-  record._engine_index = rec.engine_index_;
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void ZeDriverEvent(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, external_corr_enabled: {}, api_id: {}", __func__,
-               external_collection_enabled.load(), rec.callback_id_);
-  if (external_collection_enabled) {
-    GenerateExternalCorrelationRecords(rec);
-  }
-  pti_view_record_api record;
-  record._view_kind._view_kind = pti_view_kind::PTI_VIEW_DRIVER_API;
-
-  int64_t ts_shift = Instance().GetTimeShift();
-
-  record._api_group = pti_api_group_id::PTI_API_GROUP_LEVELZERO;
-  record._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-  record._thread_id = rec.tid_;
-  record._process_id = rec.pid_;
-  record._api_id = rec.callback_id_;
-  record._return_code = static_cast<uint32_t>(rec.result_);
-  record._correlation_id = rec.cid_;
-  Instance().InsertRecord(record, record._thread_id);
-}
-
-inline void SyclRuntimeViewCallback(void* data, ZeKernelCommandExecutionRecord& rec) {
-  if (GetApiViewState(pti_view_kind::PTI_VIEW_RUNTIME_API)) {
-    SyclRuntimeEvent(data, rec);
-  }
-}
-
-inline void OverheadCollectionCallback(void* data, ZeKernelCommandExecutionRecord& rec) {
-  if (GetApiViewState(pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD)) {
-    OverheadCollectionEvent(data, rec);
-  }
-}
-
-inline void ZeKernelRecordHandler(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, callback_id: {}, name: {}", __func__, rec.callback_id_, rec.name_);
-  if (GetApiViewState(pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL)) {
-    KernelEvent(rec);
-  }
-}
-
-inline void ZeMemRecordHandler(void* /*data*/, const ZeKernelCommandExecutionRecord& rec) {
-  SPDLOG_TRACE("In {}, callback_id: {}, name: {}", __func__, rec.callback_id_, rec.name_);
-  if (rec.callback_id_ == pti_api_id_driver_levelzero::zeCommandListAppendMemoryFill_id) {
-    if (GetApiViewState(pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL)) {
-      MemFillEvent(rec);
-    }
-  } else {
-    if (rec.name_.find("P2P)") != std::string::npos) {
-      if (GetApiViewState(pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P)) {
-        MemCopyP2PEvent(rec);
-      }
-    } else {
-      if (GetApiViewState(pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY)) {
-        MemCopyEvent(rec);
-      }
-    }
-  }
-}
-
-inline void ZeCommandRecordHandler(void* data, const ZeKernelCommandExecutionRecord& rec) {
-  if (!GetApiViewState(pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION)) {
-    // view is not enabled hence no processing is required.
-    return;
-  }
-  switch (rec.callback_id_) {
-    case pti_api_id_driver_levelzero::zeCommandListAppendBarrier_id:
-      BarrierExecEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeCommandListAppendMemoryRangesBarrier_id:
-      BarrierMemEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeFenceHostSynchronize_id:
-      FenceSynchEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeEventHostSynchronize_id:
-      EventSynchEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeCommandListHostSynchronize_id:
-      CommandListSynchEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeCommandQueueSynchronize_id:
-      CommandQueueSynchEvent(data, rec);
-      break;
-    case pti_api_id_driver_levelzero::zeDeviceSynchronize_id:
-      DeviceSynchEvent(data, rec);
-      break;
-    default:
-      UnknownSynchEvent(data, rec);
-      break;
-  }
-}
-
-inline void ZeKernelStagesCallback(void* data,
-                                   std::vector<ZeKernelCommandExecutionRecord>& kcexecrec) {
-  for (const auto& rec : kcexecrec) {
-    switch (rec.command_type_) {
-      case KernelCommandType::kMemory:
-        ZeMemRecordHandler(data, rec);
-        break;
-      case KernelCommandType::kKernel:
-        ZeKernelRecordHandler(data, rec);
-        break;
-      case KernelCommandType::kCommand:
-        ZeCommandRecordHandler(data, rec);
-        break;
-      default:
-        ZeKernelRecordHandler(data, rec);
-        break;
-    }
-  }
-}
-
-inline void ZeApiCallsCallback([[maybe_unused]] void* data,
-                               [[maybe_unused]] ZeKernelCommandExecutionRecord& rec) {
-  if (GetApiViewState(pti_view_kind::PTI_VIEW_DRIVER_API)) {
-    ZeDriverEvent(data, rec);
-  }
-}
-
-#if defined(PTI_CCL_ITT_COMPILE)
-inline void CommunicationEvent([[maybe_unused]] void* data, CommunicationRecord& rec) {
-  pti_view_record_comms record_comms = {};
-  record_comms._view_kind._view_kind = pti_view_kind::PTI_VIEW_COMMUNICATION;
-
-  record_comms._process_id = rec.pid_;
-  record_comms._thread_id = rec.tid_;
-
-  int64_t ts_shift = Instance().GetTimeShift();
-  record_comms._start_timestamp = ApplyTimeShift(rec.start_time_, ts_shift);
-  record_comms._end_timestamp = ApplyTimeShift(rec.end_time_, ts_shift);
-
-  record_comms._send_size = rec.send_size_;
-  record_comms._recv_size = rec.recv_size_;
-  record_comms._communicator_id = rec.communicator_id_;
-
-  record_comms._name = rec.name_;
-
-  Instance().InsertRecord(record_comms, rec.tid_);
-}
-#endif  // PTI_CCL_ITT_COMPILE
-#endif  // SRC_API_VIEW_HANDLER_H_
diff --git a/sdk/src/view_helpers.h b/sdk/src/view_helpers.h
deleted file mode 100644
index fcdf480c..00000000
--- a/sdk/src/view_helpers.h
+++ /dev/null
@@ -1,94 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_VIEW_HELPERS_H_
-#define SRC_VIEW_HELPERS_H_
-
-#include <spdlog/spdlog.h>
-
-#include <array>
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <stdexcept>
-
-#include "pti/pti_view.h"
-#include "view_record_info.h"
-
-struct ViewState {
-  std::atomic<pti_result> state_{pti_result::PTI_SUCCESS};
-  void SetState(pti_result s) { state_.store(s); }
-  pti_result GetState() const { return state_.load(); }
-};
-
-inline ViewState& ViewStateInstance() {
-  static ViewState inst;
-  return inst;
-}
-
-inline std::array<std::atomic<bool>, kSizeOfViewRecordTable> list_of_api_view_state{};
-
-inline void SetApiViewState(pti_view_kind view_kind, bool enabled) {
-  if (!IsPtiViewKindValid(view_kind)) {
-    SPDLOG_WARN("Invalid or reserved view kind: {}", static_cast<uint32_t>(view_kind));
-    return;
-  }
-  list_of_api_view_state[static_cast<uint32_t>(view_kind)].store(enabled,
-                                                                 std::memory_order_release);
-}
-
-inline bool GetApiViewState(pti_view_kind view_kind) {
-  if (!IsPtiViewKindValid(view_kind)) {
-    SPDLOG_WARN("Invalid or reserved view kind: {}", static_cast<uint32_t>(view_kind));
-    return false;
-  }
-  return list_of_api_view_state[static_cast<uint32_t>(view_kind)].load(std::memory_order_acquire);
-}
-
-inline bool IsAnyViewEnabled() {
-  for (const auto& state : list_of_api_view_state) {
-    if (state.load(std::memory_order_acquire)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-inline uint64_t ApplyTimeShift(uint64_t timestamp, int64_t time_shift) {
-  uint64_t out_ts = 0;
-  if (timestamp == 0) {
-    // this could happen if some collections disabled so not collected timestamps
-    // (e.g. task_enqueue.. ) might be zeros
-    SPDLOG_DEBUG("Timestamp is 0 when shifting time domains: TS: {}, time_shift: {}", timestamp,
-                 time_shift);
-    return 0;
-  }
-  try {
-    if (time_shift < 0) {
-      if (timestamp < static_cast<uint64_t>(-time_shift)) {  // underflow?
-        SPDLOG_WARN(
-            "Timestamp underflow detected when shifting time domains: TS: {}, "
-            "time_shift: {}",
-            timestamp, time_shift);
-        throw std::out_of_range("Timestamp underflow detected");
-      }
-      out_ts = timestamp - static_cast<uint64_t>(-time_shift);
-    } else {
-      if ((UINT64_MAX - timestamp) < static_cast<uint64_t>(time_shift)) {  // overflow?
-        SPDLOG_WARN(
-            "Timestamp overflow detected when shifting time domains: TS: {}, "
-            "time_shift: {}",
-            timestamp, time_shift);
-        throw std::out_of_range("Timestamp overflow detected");
-      }
-      out_ts = timestamp + static_cast<uint64_t>(time_shift);
-    }
-  } catch (const std::out_of_range&) {
-    ViewStateInstance().SetState(pti_result::PTI_ERROR_BAD_TIMESTAMP);
-  }
-  return out_ts;
-}
-
-#endif  // SRC_VIEW_HELPERS_H_
diff --git a/sdk/src/view_record_info.h b/sdk/src/view_record_info.h
deleted file mode 100644
index 1e1c1ad2..00000000
--- a/sdk/src/view_record_info.h
+++ /dev/null
@@ -1,89 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_VIEW_RECORD_INFO_
-#define SRC_VIEW_RECORD_INFO_
-
-#include <array>
-#include <cstddef>
-
-#include "pti/pti_view.h"
-
-inline constexpr auto kReserved = 0;
-inline constexpr auto kSizeOfViewRecordTable = 13;
-
-// kViewSizeLookUpTable
-//
-// Table of view record enum identifiers to their size. The spot in the
-// array corresponds to the underlying value of a member of the
-// pti_view_kind enum.
-//
-// clang-format off
-inline constexpr std::array<std::size_t, kSizeOfViewRecordTable> kViewSizeLookupTable{
-    kReserved,                                        // PTI_VIEW_INVALID
-    sizeof(pti_view_record_kernel_v2),                // PTI_VIEW_DEVICE_GPU_KERNEL
-    kReserved,                                        // PTI_VIEW_DEVICE_CPU_KERNEL
-    sizeof(pti_view_record_api),                      // PTI_VIEW_LEVEL_ZERO_CALLS
-    kReserved,                                        // PTI_VIEW_RESERVED
-    sizeof(pti_view_record_overhead),                 // PTI_VIEW_COLLECTION_OVERHEAD
-    sizeof(pti_view_record_api),                      // PTI_VIEW_SYCL_RUNTIME_CALLS
-    sizeof(pti_view_record_external_correlation),     // PTI_VIEW_EXTERNAL_CORRELATION
-    sizeof(pti_view_record_memory_copy_v2),           // PTI_VIEW_DEVICE_GPU_MEM_COPY
-    sizeof(pti_view_record_memory_fill_v2),           // PTI_VIEW_DEVICE_GPU_MEM_FILL
-    sizeof(pti_view_record_memory_copy_p2p_v2),       // PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P
-    sizeof(pti_view_record_synchronization),          // PTI_VIEW_DEVICE_SYNCHRONIZATION
-    sizeof(pti_view_record_comms),                    // PTI_VIEW_COMMUNICATION
-};
-
-// clang-format on
-
-// SizeOfLargestViewRecord()
-//
-// Calculated at compile time (since we know all the records and their sizes)
-//
-// @return size of largest view record
-inline constexpr auto SizeOfLargestViewRecord() {
-  auto largest_record_size = kViewSizeLookupTable.front();
-
-  for (const auto& record_size : kViewSizeLookupTable) {
-    if (largest_record_size < record_size) {
-      largest_record_size = record_size;
-    }
-  }
-  return largest_record_size;
-}
-
-// GetViewSize()
-//
-// Convert pti_view_kind enum to actual size of record.
-//
-// @param view_kind pti_view_kind enum value
-// @return size of record corresponding to view_kind
-inline auto GetViewSize(pti_view_kind view_kind) {
-  const auto view_kind_index = static_cast<std::size_t>(view_kind);
-  if (view_kind_index >= std::size(kViewSizeLookupTable)) {
-    return SIZE_MAX;
-  }
-
-  const auto view_size = kViewSizeLookupTable[view_kind_index];
-  if (view_size == kReserved) {
-    return SIZE_MAX;
-  }
-
-  return view_size;
-}
-
-// IsPtiViewKindValid()
-//
-// Returns true when view_kind has a positive record size,
-// i.e. it is a view kind that can be enabled/disabled.
-//
-// @param view_kind pti_view_kind enum value
-// @return true if view_kind is valid and enabled-able
-inline bool IsPtiViewKindValid(pti_view_kind view_kind) {
-  return GetViewSize(view_kind) != SIZE_MAX;
-}
-
-#endif  // SRC_VIEW_RECORD_INFO_
diff --git a/sdk/src/xpti_adapter.cc b/sdk/src/xpti_adapter.cc
deleted file mode 100644
index bac6b7d8..00000000
--- a/sdk/src/xpti_adapter.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <spdlog/cfg/env.h>
-#include <spdlog/common.h>
-#include <spdlog/spdlog.h>
-
-#include "pti_lib_handler.h"
-#include "utils/platform_strings.h"
-#include "utils/utils.h"
-
-class GlobalSyclInitializer {
- public:
-  // variables to store if XPTI is subscribed by some other subscriber
-  // and if this subscriber is likely unitrace
-  inline static bool foreign_subscriber_ = false;
-  inline static bool likely_unitrace_subscriber_ = false;
-
-  inline static bool Initialize() {
-    // initialize spdlog before any other code for libpti_view
-    spdlog::set_level(spdlog::level::off);
-
-    auto env_string = ::utils::GetEnv("PTILOG_LEVEL");
-    if (!env_string.empty()) {
-      spdlog::cfg::helpers::load_levels(env_string);
-    }
-    ::utils::SetGlobalSpdLogPattern();
-
-    // respecting another XPTI subscriber:
-    // if someone already subscribed (e.g. might be that the app runs under unitrace) -
-    // we do not subscribe for XPTI
-    std::tie(foreign_subscriber_, likely_unitrace_subscriber_) = utils::IsSubscriberToXPTI();
-    if (!foreign_subscriber_) {
-      utils::SetEnv("XPTI_SUBSCRIBERS", utils::GetPathToSharedObject(Initialize).c_str());
-      utils::SetEnv("XPTI_FRAMEWORK_DISPATCHER", pti::strings::kXptiLibName);
-      utils::SetEnv("XPTI_TRACE_ENABLE", "1");
-
-      utils::SetEnv("UR_ENABLE_LAYERS", "UR_LAYER_TRACING");
-    }
-    return true;
-  }
-
-  inline static bool result_ = Initialize();
-};
-
-std::pair<bool, bool> IsForeignXPTISubscriber() {
-  return {GlobalSyclInitializer::foreign_subscriber_,
-          GlobalSyclInitializer::likely_unitrace_subscriber_};
-}
-
-void xptiTraceInit(unsigned int major_version, unsigned int minor_version, const char* version_str,
-                   const char* stream_name) {
-  if (!pti::PtiLibHandler::Instance().xptiTraceInit_) {
-    return;
-  }
-  pti::PtiLibHandler::Instance().xptiTraceInit_(major_version, minor_version, version_str,
-                                                stream_name);
-}
-
-void xptiTraceFinish(const char* /*stream_name*/) {}
-
-bool xptiQuerySubscriberStreamDetailLevel(const char* stream_name,
-                                          xpti::stream_detail_level_t* level) {
-  if (!pti::PtiLibHandler::Instance().xptiQuerySubscriberStreamDetailLevel_) {
-    return false;
-  }
-  return pti::PtiLibHandler::Instance().xptiQuerySubscriberStreamDetailLevel_(stream_name, level);
-}
diff --git a/sdk/src/xpti_adapter.h b/sdk/src/xpti_adapter.h
deleted file mode 100644
index 27eef45a..00000000
--- a/sdk/src/xpti_adapter.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef SRC_XPTI_ADAPTER_H_
-#define SRC_XPTI_ADAPTER_H_
-
-#include <cstdint>
-
-#if defined(_WIN32)
-#define PTI_XPTI_HOOK_VISIBILITY __declspec(dllexport)
-#else
-#define PTI_XPTI_HOOK_VISIBILITY __attribute__((visibility("default")))
-#endif
-
-// Forward declare xpti namespace and enum to avoid requiring xpti headers
-namespace xpti {
-enum class stream_detail_level_t : uint8_t;
-}  // namespace xpti
-
-extern "C" {
-PTI_XPTI_HOOK_VISIBILITY void xptiTraceInit(unsigned int major_version, unsigned int minor_version,
-                                            const char* version_str, const char* stream_name);
-
-PTI_XPTI_HOOK_VISIBILITY void xptiTraceFinish(const char* stream_name);  // NOLINT
-
-PTI_XPTI_HOOK_VISIBILITY bool xptiQuerySubscriberStreamDetailLevel(
-    const char* stream_name, xpti::stream_detail_level_t* level);
-}
-
-std::pair<bool, bool> IsForeignXPTISubscriber();
-
-#endif  // SRC_XPTI_ADAPTER_H_
diff --git a/sdk/test/CMakeLists.txt b/sdk/test/CMakeLists.txt
deleted file mode 100644
index 15f5aead..00000000
--- a/sdk/test/CMakeLists.txt
+++ /dev/null
@@ -1,1426 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-include(macros)
-include(add_spirv)
-
-RemoveNDebugFlag() # For SYCL Function Name
-CheckExperimentalFilesystem()
-CheckIfSyclIsAvailable()
-GetGTest()
-
-enable_testing()
-
-message(STATUS "Configuring tests")
-
-include(GoogleTest)
-
-if (NOT TARGET fmt::fmt)
-  message(FATAL_ERROR "fmt::fmt target not found. GetSpdlog() should have been called in the main CMakeLists.txt")
-endif()
-
-if (NOT TARGET spdlog::spdlog)
-  find_package(spdlog REQUIRED)
-endif()
-
-# Detects whether the system Level Zero loader exports zetDeviceEnableMetricsExp
-# and zetDeviceDisableMetricsExp. On Linux uses check_library_exists against
-# libze_loader.so; on Windows uses dumpbin /EXPORTS against ze_loader.dll in
-# System32. Sets HAVE_ZET_DEVICE_METRIC_API=TRUE if both symbols are present.
-# Must be called after LevelZero::level-zero target is available.
-DetectSystemLevelZeroMetricApi()
-
-# Metric tests enable metrics at runtime through ptiMetricsEnable(). When the system
-# loader does not export the on-demand APIs, that call cannot work and the tests need
-# ZET_ENABLE_METRICS=1 in the environment instead -- the L0 loader latches this variable
-# at zeInit(), so it must come from ctest rather than from inside the test process.
-# Kept as a list so that no empty ENVIRONMENT entry is passed when the APIs are present.
-set(PTI_METRIC_TEST_PROPS "")
-if(NOT HAVE_ZET_DEVICE_METRIC_API)
-  list(APPEND PTI_METRIC_TEST_PROPS ENVIRONMENT "ZET_ENABLE_METRICS=1")
-endif()
-
-if (NOT TARGET unified-runtime::loader)
-  find_package(unified-runtime)
-endif()
-
-if (NOT TARGET Xpti::xpti)
-  find_package(Xpti)
-endif()
-
-if (NOT TARGET unified-runtime::loader)
-  message(STATUS "The Unified Runtime could not be found. Unified Runtime"
-                 " specific tests will not be built.")
-endif()
-
-if (NOT TARGET Xpti::xpti)
-  message(STATUS "Xpti could not be found. Xpti specific tests will not be"
-                 " built.")
-endif()
-
-if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
-  set(PTI_TOP_LEVEL_TEST_BIN_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
-else()
-  set(PTI_TOP_LEVEL_TEST_BIN_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-endif()
-
-# Multi-config generators not supported yet, this is an incomplete bandage.
-get_property(PTI_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-
-if(PTI_IS_MULTI_CONFIG)
-  string(APPEND PTI_TOP_LEVEL_TEST_BIN_DIR "/${CMAKE_BUILD_TYPE}")
-endif()
-
-set(PTI_TOP_LEVEL_TEST_BIN_DIR "${PTI_TOP_LEVEL_TEST_BIN_DIR}" CACHE INTERNAL
-  "Top-level test binary directory.")
-
-# Dependency pre-load tests. libld_dependency_preload_test.cc documents the layout
-# these libraries make up: the test executable stands in for the PTI interface
-# library and the "core" stubs in preload_stage/pti for the PTI Core library.
-#
-# Linux only: what this exercises is ELF specific - resolution by soname, $ORIGIN
-# based RUNPATH, and the loader error text MissingSonameFromLoaderError parses.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  set(PTI_PRELOAD_STAGE_DIR "${CMAKE_CURRENT_BINARY_DIR}/preload_stage")
-
-  # Builds synthetic library pti_preload_<id> from libld_preload_stub.c.
-  # OUTPUT_DIR controls its location; NEEDS <id> and ALSO_NEEDS <id> add DT_NEEDED dependencies.
-  # Only ORIGIN_RUNPATH gives it RUNPATH $ORIGIN; other stubs have no RPATH.
-  function(AddPreloadStub id)
-    cmake_parse_arguments(STUB "UNDEFINED_SYMBOL;ORIGIN_RUNPATH" "OUTPUT_DIR;NEEDS;ALSO_NEEDS" "" ${ARGN})
-
-    set(stub_target "pti_preload_${id}")
-    add_library(${stub_target} SHARED "${CMAKE_CURRENT_SOURCE_DIR}/libld_preload_stub.c")
-    target_compile_definitions(${stub_target} PRIVATE "PRELOAD_STUB_NAME=${id}")
-
-    set(stub_install_rpath "")
-    if(STUB_ORIGIN_RUNPATH)
-      set(stub_install_rpath "$ORIGIN")
-    endif()
-    set_target_properties(
-      ${stub_target}
-      PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${STUB_OUTPUT_DIR}"
-                 # Overrides CMAKE_BUILD_RPATH. Most stubs must leave their
-                 # dependencies unresolved so the pre-load path can recover them.
-                 BUILD_WITH_INSTALL_RPATH ON
-                 INSTALL_RPATH "${stub_install_rpath}")
-
-    # Same reason the product libraries do this: keep the Intel compiler's runtime
-    # libraries off DT_NEEDED, so a stub cannot fail over a dependency the test
-    # never set up.
-    target_compile_options(${stub_target} PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-    target_link_options(${stub_target} PRIVATE ${PTI_INTEL_LLVM_EXCLUDE_LIBS})
-
-    if(STUB_NEEDS)
-      target_compile_definitions(${stub_target} PRIVATE "PRELOAD_STUB_NEEDS=${STUB_NEEDS}")
-      target_link_libraries(${stub_target} PRIVATE "pti_preload_${STUB_NEEDS}")
-    endif()
-
-    if(STUB_ALSO_NEEDS)
-      target_compile_definitions(${stub_target} PRIVATE "PRELOAD_STUB_ALSO_NEEDS=${STUB_ALSO_NEEDS}")
-      target_link_libraries(${stub_target} PRIVATE "pti_preload_${STUB_ALSO_NEEDS}")
-    endif()
-
-    if(STUB_UNDEFINED_SYMBOL)
-      target_compile_definitions(${stub_target} PRIVATE PRELOAD_STUB_UNDEFINED_SYMBOL)
-    endif()
-
-    add_dependencies(libld_dependency_preload_test ${stub_target})
-  endfunction()
-
-  add_executable(libld_dependency_preload_test libld_dependency_preload_test.cc)
-
-  target_include_directories(
-    libld_dependency_preload_test
-    PRIVATE "${PROJECT_SOURCE_DIR}/src"
-            "${PROJECT_SOURCE_DIR}/src/utils"
-            "${PROJECT_SOURCE_DIR}/include"
-            ${PROJECT_BINARY_DIR}
-            "${PROJECT_BINARY_DIR}/include")
-
-  target_link_libraries(libld_dependency_preload_test PRIVATE GTest::gtest_main spdlog::spdlog
-    ${CMAKE_DL_LIBS} ${FS_LIB})
-
-  # The trace log is what makes a failure here readable. Compiling the macros in is
-  # only half of it; the test raises the runtime level, see LogLevelFromEnvironment.
-  target_compile_definitions(libld_dependency_preload_test PRIVATE
-    SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
-
-  set_target_properties(
-    libld_dependency_preload_test
-    PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${PTI_PRELOAD_STAGE_DIR}"
-               # Stands in for the interface library's RUNPATH, which is what makes
-               # the loader's search reach the stage directory and nothing above it.
-               BUILD_WITH_INSTALL_RPATH ON
-               INSTALL_RPATH "$ORIGIN")
-
-  # Where the Core library is deployed, also the 1st fallback search directory.
-  set(PTI_PRELOAD_CORE_DIR "${PTI_PRELOAD_STAGE_DIR}/${PTI_MODULE_SUBDIR}")
-
-  # Next to the test executable, so the loader's own search reaches it through
-  # RUNPATH $ORIGIN. This is the wheel's case.
-  AddPreloadStub(dep_bysoname OUTPUT_DIR "${PTI_PRELOAD_STAGE_DIR}")
-  # Next to the core libraries instead: in a fallback search directory but outside
-  # RUNPATH, so only naming the file outright reaches it.
-  AddPreloadStub(dep_byfullpath OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}")
-  # A dependency of a dependency: reachable, but not before chain_tail is.
-  AddPreloadStub(dep_chain_tail OUTPUT_DIR "${PTI_PRELOAD_STAGE_DIR}")
-  AddPreloadStub(dep_chain_head OUTPUT_DIR "${PTI_PRELOAD_STAGE_DIR}" NEEDS dep_chain_tail)
-  # Reachable neither way.
-  AddPreloadStub(dep_unreachable OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/preload_unreachable")
-  # Recovery pre-loads tail, then head. Core's other direct dependency remains unreachable.
-  AddPreloadStub(dep_cleanup_tail OUTPUT_DIR "${PTI_PRELOAD_STAGE_DIR}")
-  AddPreloadStub(dep_cleanup_head OUTPUT_DIR "${PTI_PRELOAD_STAGE_DIR}" NEEDS dep_cleanup_tail)
-  AddPreloadStub(dep_cleanup_missing OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/preload_unreachable")
-
-  # Stand-ins for the PTI Core library, one per dependency shape above.
-  AddPreloadStub(core_bysoname OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}" NEEDS dep_bysoname)
-  AddPreloadStub(core_byfullpath OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}" NEEDS dep_byfullpath)
-  AddPreloadStub(core_chain OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}" NEEDS dep_chain_head)
-  AddPreloadStub(core_unreachable OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}" NEEDS dep_unreachable)
-  AddPreloadStub(core_cleanup_failure OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}"
-                 NEEDS dep_cleanup_head ALSO_NEEDS dep_cleanup_missing)
-  AddPreloadStub(core_undefined OUTPUT_DIR "${PTI_PRELOAD_CORE_DIR}" UNDEFINED_SYMBOL)
-
-  # Ordinary ELF resolution case: the synthetic Core and its dependency share a
-  # directory, and Core alone carries RUNPATH $ORIGIN.
-  set(PTI_ORIGIN_STAGE_DIR "${CMAKE_CURRENT_BINARY_DIR}/origin_stage")
-  AddPreloadStub(dep_origin OUTPUT_DIR "${PTI_ORIGIN_STAGE_DIR}")
-  AddPreloadStub(core_origin OUTPUT_DIR "${PTI_ORIGIN_STAGE_DIR}" NEEDS dep_origin ORIGIN_RUNPATH)
-
-  add_executable(libld_origin_test libld_origin_test.cc)
-  add_dependencies(libld_origin_test pti_preload_core_origin)
-  target_compile_definitions(
-    libld_origin_test
-    PRIVATE PTI_ORIGIN_CORE_LIBRARY_PATH="$<TARGET_FILE:pti_preload_core_origin>")
-  target_link_libraries(libld_origin_test PRIVATE GTest::gtest_main ${CMAKE_DL_LIBS})
-
-  gtest_discover_tests(
-    libld_dependency_preload_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-       LABELS "unit"
-       LABELS "libload")
-endif()
-
-if (TARGET LevelZero::level-zero)
-  add_executable(ze_event_manager_tests ze_event_manager_tests.cc)
-  target_include_directories(
-    ze_event_manager_tests
-    PUBLIC "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src"
-            "${PROJECT_SOURCE_DIR}/src/utils"
-            "${PROJECT_SOURCE_DIR}/include"
-            ${PROJECT_BINARY_DIR}
-            "${PROJECT_BINARY_DIR}/include"
-  )
-
-  target_link_libraries(ze_event_manager_tests PUBLIC GTest::gmock
-     GTest::gtest_main LevelZero::level-zero spdlog::spdlog fmt::fmt)
-
-   gtest_discover_tests(
-      ze_event_manager_tests
-      DISCOVERY_TIMEOUT 60
-      PROPERTIES LABELS "unit")
-
-  add_executable(ze_kernel_name_cache_test ze_kernel_name_cache_test.cc)
-  target_include_directories(
-    ze_kernel_name_cache_test
-    PUBLIC "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src"
-            "${PROJECT_SOURCE_DIR}/src/utils"
-            "${PROJECT_SOURCE_DIR}/include"
-            ${PROJECT_BINARY_DIR}
-            "${PROJECT_BINARY_DIR}/include")
-
-  target_link_libraries(ze_kernel_name_cache_test PUBLIC
-    GTest::gtest_main LevelZero::level-zero spdlog::spdlog fmt::fmt)
-
-  gtest_discover_tests(
-    ze_kernel_name_cache_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "unit")
-
-  add_executable(pti_string_pool_test pti_string_pool_test.cc)
-  target_include_directories(
-    pti_string_pool_test
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_link_libraries(pti_string_pool_test PUBLIC GTest::gtest_main)
-
-  gtest_discover_tests(
-    pti_string_pool_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "unit")
-
-  add_executable(local_ze_collection_suite local_ze_collection_fixture.cc)
-
-  target_include_directories(
-    local_ze_collection_suite
-    PUBLIC  "${PROJECT_SOURCE_DIR}/include"
-            "${PROJECT_SOURCE_DIR}/src"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_link_libraries(local_ze_collection_suite PUBLIC GTest::gmock
-     GTest::gtest_main LevelZero::level-zero LevelZero::level-zero-ext spdlog::spdlog Pti::pti_view)
-
-  add_spirv(local_ze_collection_suite gemm)
-
-  gtest_discover_tests(
-      local_ze_collection_suite
-      DISCOVERY_TIMEOUT 60
-      PROPERTIES LABELS "functional")
-endif()
-
-if(HAVE_SYCL)
-  add_executable(dpcgemm_suite main_dpcgemm_fixture.cc)
-  target_include_directories(
-    dpcgemm_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-           "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(dpcgemm_suite PUBLIC -fsycl)
-  target_link_options(dpcgemm_suite PUBLIC -fsycl)
-  target_compile_definitions(dpcgemm_suite PUBLIC PTI_LEVEL_ZERO=1)
-  target_link_libraries(dpcgemm_suite PUBLIC spdlog::spdlog Pti::pti_view
-    GTest::gtest_main LevelZero::level-zero fmt::fmt)
-
-  add_executable(classapi_suite main_classapi_fixture.cc)
-  target_include_directories(
-    classapi_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-           "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-
-  target_compile_options( classapi_suite PUBLIC -fsycl)
-  target_link_options(classapi_suite PUBLIC -fsycl)
-  target_compile_definitions(classapi_suite PUBLIC PTI_LEVEL_ZERO=1)
-  target_link_libraries(classapi_suite PUBLIC spdlog::spdlog Pti::pti_view GTest::gtest_main LevelZero::level-zero)
-
-  add_executable(vecsqadd_suite main_vecsqadd_fixture.cc)
-  target_include_directories(
-    vecsqadd_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(
-    vecsqadd_suite
-    PUBLIC -fsycl)
-
-  target_link_options(vecsqadd_suite PUBLIC -fsycl)
-
-  target_compile_definitions(vecsqadd_suite PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(vecsqadd_suite PUBLIC spdlog::spdlog Pti::pti_view
-    GTest::gtest_main)
-
-  add_executable(vecsqadd_metrics_suite metrics_vecsqadd_fixture.cc)
-  target_include_directories(
-    vecsqadd_metrics_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-
-            "${PROJECT_SOURCE_DIR}/samples/samples_utilities")
-
-  target_compile_options(
-    vecsqadd_metrics_suite
-    PUBLIC -fsycl)
-
-  target_link_options(vecsqadd_metrics_suite PUBLIC -fsycl)
-
-  target_compile_definitions(vecsqadd_metrics_suite PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(vecsqadd_metrics_suite PUBLIC spdlog::spdlog
-    GTest::gtest_main Pti::pti_view ${FS_LIB})
-
-  # Metric enable/disable tests. These exercise the on-demand ptiMetricsEnable path and
-  # skip themselves when ZET_ENABLE_METRICS=1 is set, so they deliberately do not get
-  # ${PTI_METRIC_TEST_PROPS}.
-  add_executable(metric_enable_disable_test metric_enable_disable_test.cc)
-  target_include_directories(
-    metric_enable_disable_test
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_definitions(metric_enable_disable_test PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(metric_enable_disable_test PUBLIC spdlog::spdlog
-    GTest::gtest_main Pti::pti_view LevelZero::level-zero)
-
-  gtest_discover_tests(
-    metric_enable_disable_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "unit")
-
-
-
-
-  add_executable(metrics_scope_gemm_suite metrics_scope_gemm.cc)
-  target_include_directories(
-    metrics_scope_gemm_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-
-            "${PROJECT_SOURCE_DIR}/samples/samples_utilities")
-
-  target_compile_options(
-    metrics_scope_gemm_suite
-    PUBLIC -fsycl)
-
-  target_link_options(metrics_scope_gemm_suite PUBLIC -fsycl)
-
-  target_compile_definitions(metrics_scope_gemm_suite PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(metrics_scope_gemm_suite PUBLIC spdlog::spdlog
-    GTest::gtest_main Pti::pti_view LevelZero::level-zero LevelZero::level-zero-ext ${FS_LIB})
-
-  add_executable(metrics_scope_buffer_handler_suite metrics_scope_buffer_handler.cc)
-  target_include_directories(
-    metrics_scope_buffer_handler_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_link_libraries(metrics_scope_buffer_handler_suite PUBLIC spdlog::spdlog
-    GTest::gtest_main Pti::pti_view ${FS_LIB})
-
-  add_executable(metrics_scope_parallel metrics_scope_parallel.cc)
-  target_include_directories(
-    metrics_scope_parallel
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-
-            "${PROJECT_SOURCE_DIR}/samples/samples_utilities")
-
-  target_compile_options(
-    metrics_scope_parallel
-    PUBLIC -fsycl)
-
-  target_link_options(metrics_scope_parallel PUBLIC -fsycl)
-
-  target_compile_definitions(metrics_scope_parallel PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(metrics_scope_parallel PUBLIC spdlog::spdlog
-    GTest::gtest_main Pti::pti_view ${FS_LIB})
-
-
-  if(PTI_BUILD_SAMPLES AND TARGET metrics_scope)
-    add_test(NAME metrics_scope_multiprocess
-      COMMAND ${Python_EXECUTABLE}
-        ${CMAKE_CURRENT_SOURCE_DIR}/test_metrics_scope_multiprocess.py
-        --sample-binary $<TARGET_FILE:metrics_scope>)
-    set_tests_properties(metrics_scope_multiprocess PROPERTIES
-      ENVIRONMENT ZET_ENABLE_METRICS=1
-      # 77 is the GNU Autotools / CTest convention for "test skipped".
-      SKIP_RETURN_CODE 77
-      TIMEOUT 360
-      LABELS "functional;metrics;hw-metrics-scope;multiprocess")
-  endif()
-
-  # Add the multi-threaded test
-  add_executable(
-    multi_thread_metrics_suite
-    metrics_multi_thread.cc)
-  target_include_directories(
-    multi_thread_metrics_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-            "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-            "${PROJECT_SOURCE_DIR}/samples/samples_utilities")
-
-  target_compile_options(
-    multi_thread_metrics_suite
-    PUBLIC -fsycl)
-
-  target_link_options(multi_thread_metrics_suite PUBLIC -fsycl)
-
-  target_compile_definitions(multi_thread_metrics_suite PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(multi_thread_metrics_suite PUBLIC spdlog::spdlog
-    Threads::Threads GTest::gtest_main Pti::pti_view ${FS_LIB})
-
-  add_executable(no_kernel_overlap no_kernel_overlap.cc)
-  target_include_directories(
-    no_kernel_overlap
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(
-    no_kernel_overlap
-    PUBLIC -fsycl)
-
-  target_link_options(no_kernel_overlap PUBLIC -fsycl)
-
-  target_compile_definitions(no_kernel_overlap PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(no_kernel_overlap PUBLIC spdlog::spdlog Pti::pti_view
-      GTest::gtest_main fmt::fmt)
-
-  add_executable(startstop_suite main_startstop_fixture.cc)
-  target_include_directories(
-    startstop_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(
-    startstop_suite
-    PUBLIC -fsycl)
-
-  target_link_options(startstop_suite PUBLIC -fsycl)
-
-  target_compile_definitions(startstop_suite PUBLIC PTI_LEVEL_ZERO=1)
-
-  target_link_libraries(startstop_suite PUBLIC spdlog::spdlog Pti::pti_view
-      GTest::gtest_main)
-
-  add_executable(mem_ops_test mem_ops_test.cc)
-
-  target_include_directories(
-    mem_ops_test
-    PUBLIC "${PROJECT_BINARY_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(mem_ops_test PRIVATE -fsycl)
-
-  target_link_options(mem_ops_test PRIVATE -fsycl)
-
-  target_link_libraries(mem_ops_test PUBLIC spdlog::spdlog Pti::pti_view
-    GTest::gtest_main GTest::gmock
-    LevelZero::level-zero)
-
-  add_executable(sycl_queue_id sycl_queue_id.cc)
-
-  target_include_directories(
-    sycl_queue_id
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(sycl_queue_id PRIVATE -fsycl)
-  target_link_options(sycl_queue_id PRIVATE -fsycl)
-
-  target_link_libraries(sycl_queue_id PUBLIC spdlog::spdlog Pti::pti_view
-    GTest::gtest_main)
-
-  add_executable(sycl_experimental_tests sycl_experimental_tests.cc)
-
-  target_include_directories(
-    sycl_experimental_tests
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(sycl_experimental_tests PRIVATE -fsycl)
-  target_link_options(sycl_experimental_tests PRIVATE -fsycl)
-
-  target_link_libraries(sycl_experimental_tests PUBLIC Pti::pti_view GTest::gtest_main)
-
-  add_executable(zegemm_suite main_zegemm_fixture.cc)
-
-  target_include_directories(
-    zegemm_suite
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(zegemm_suite  PUBLIC -fsycl)
-  target_link_options(zegemm_suite PUBLIC -fsycl)
-
-  target_link_libraries(zegemm_suite PUBLIC spdlog::spdlog Pti::pti_view
-                                            GTest::gtest_main
-                                            GTest::gmock
-                                            LevelZero::level-zero
-                                            ${FS_LIB})
-  add_spirv(zegemm_suite gemm)
-
-  add_executable(init_tests init_tests.cc)
-
-  target_include_directories(
-    init_tests
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(init_tests PUBLIC -fsycl)
-  target_link_options(init_tests PUBLIC -fsycl)
-
-  target_link_libraries(init_tests PUBLIC spdlog::spdlog Pti::pti_view
-                                            GTest::gtest_main
-                                            GTest::gmock
-                                            LevelZero::level-zero
-                                            ${FS_LIB})
-
-  add_executable(multi_threaded_submission multi_threaded_submission.cc)
-
-  target_include_directories(
-    multi_threaded_submission
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(multi_threaded_submission PRIVATE -fsycl)
-  target_link_options(multi_threaded_submission PRIVATE -fsycl)
-
-  target_link_libraries(multi_threaded_submission PUBLIC spdlog::spdlog Pti::pti_view GTest::gtest_main
-                                            LevelZero::level-zero)
-
-  add_executable(callback_api_test callback_api_test.cc)
-
-  target_include_directories(
-    callback_api_test
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero")
-
-  target_compile_options(callback_api_test PUBLIC -fsycl)
-  target_link_options(callback_api_test PUBLIC -fsycl)
-
-  target_link_libraries(callback_api_test PUBLIC GTest::gtest_main spdlog::spdlog
-                                          PRIVATE Pti::pti_view LevelZero::level-zero)
-
-  add_executable(callback_kernel_lifecycle_test callback_kernel_lifecycle_test.cc)
-
-  target_include_directories(
-    callback_kernel_lifecycle_test
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-        "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-      PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(callback_kernel_lifecycle_test PUBLIC -fsycl)
-  target_link_options(callback_kernel_lifecycle_test PUBLIC -fsycl)
-
-  target_link_libraries(callback_kernel_lifecycle_test
-    PUBLIC GTest::gtest_main spdlog::spdlog
-    PRIVATE Pti::pti_view LevelZero::level-zero)
-
-  add_spirv(callback_kernel_lifecycle_test gemm)
-
-  add_executable(dpc_gemm_threaded_profiled perf_dpc_gemm_threaded.cc)
-  add_executable(dpc_gemm_threaded_baseline perf_dpc_gemm_threaded.cc)
-  add_executable(dpc_gemm_threaded_linkonly perf_dpc_gemm_threaded.cc)
-  add_executable(dpc_gemm_threaded_prof_print perf_dpc_gemm_threaded.cc)
-  add_executable(pc_sampling_perf_profiled perf_pc_sampling.cc
-    "${PROJECT_SOURCE_DIR}/samples/pc_sampling/pc_sampling_client.cc")
-  add_executable(pc_sampling_perf_baseline perf_pc_sampling.cc)
-
-  target_include_directories(
-    dpc_gemm_threaded_profiled
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-         "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_include_directories(
-    dpc_gemm_threaded_prof_print
-    PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-         "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_include_directories(
-    pc_sampling_perf_profiled
-    PUBLIC "${CMAKE_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-           "${PROJECT_SOURCE_DIR}/samples/pc_sampling"
-           "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-           "${PROJECT_SOURCE_DIR}/src/utils")
-
-  target_compile_options(dpc_gemm_threaded_profiled PRIVATE -fsycl)
-  target_compile_options(dpc_gemm_threaded_baseline PRIVATE -fsycl)
-  target_compile_options(dpc_gemm_threaded_linkonly PRIVATE -fsycl)
-  target_compile_options(dpc_gemm_threaded_prof_print PRIVATE -fsycl)
-  target_compile_options(pc_sampling_perf_profiled PRIVATE -fsycl)
-  target_compile_options(pc_sampling_perf_baseline PRIVATE -fsycl)
-
-  target_compile_definitions(dpc_gemm_threaded_baseline PRIVATE NO_PTI)
-  target_compile_definitions(dpc_gemm_threaded_linkonly PRIVATE NO_PTI)
-  target_compile_definitions(dpc_gemm_threaded_prof_print PRIVATE  RECORD_PARSE_AND_PRINT)
-  target_compile_definitions(pc_sampling_perf_profiled PRIVATE PC_SAMPLING)
-
-  target_link_options(dpc_gemm_threaded_profiled PRIVATE -fsycl)
-  target_link_options(dpc_gemm_threaded_baseline PRIVATE -fsycl)
-  target_link_options(dpc_gemm_threaded_linkonly PRIVATE -fsycl)
-  target_link_options(dpc_gemm_threaded_prof_print PRIVATE -fsycl)
-  target_link_options(pc_sampling_perf_profiled PRIVATE -fsycl)
-  target_link_options(pc_sampling_perf_baseline PRIVATE -fsycl)
-
-  target_link_libraries(dpc_gemm_threaded_profiled PUBLIC spdlog::spdlog
-    Threads::Threads Pti::pti_view)
-
-  target_link_libraries(dpc_gemm_threaded_linkonly PUBLIC spdlog::spdlog
-    Threads::Threads Pti::pti_view)
-
-  target_link_libraries(dpc_gemm_threaded_baseline PUBLIC Threads::Threads)
-
-  target_link_libraries(dpc_gemm_threaded_prof_print PUBLIC spdlog::spdlog
-    Threads::Threads Pti::pti_view)
-
-  target_link_libraries(pc_sampling_perf_profiled PUBLIC spdlog::spdlog
-    Threads::Threads Pti::pti_view)
-
-  target_link_libraries(pc_sampling_perf_baseline PUBLIC Threads::Threads)
-
-  gtest_discover_tests(
-    dpcgemm_suite
-    DISCOVERY_TIMEOUT 60
-    TEST_PREFIX "RuntimeOpsUnset"
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    dpcgemm_suite
-    DISCOVERY_TIMEOUT 60
-    TEST_PREFIX "RuntimeOpsSetOff"
-    PROPERTIES ENVIRONMENT PTI_VIEW_RUNTIME_API=0
-    PROPERTIES ENVIRONMENT PTI_VIEW_DRIVER_API=0
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    dpcgemm_suite
-    DISCOVERY_TIMEOUT 60
-    TEST_PREFIX "RuntimeOpsSetOn"
-    PROPERTIES ENVIRONMENT PTI_VIEW_RUNTIME_API=1
-    PROPERTIES ENVIRONMENT PTI_VIEW_DRIVER_API=1
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    mem_ops_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES ENVIRONMENT "ONEAPI_DEVICE_SELECTOR=level_zero:*,*.*"
-    PROPERTIES LABELS "functional" )
-
-  gtest_discover_tests(
-    classapi_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    vecsqadd_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    vecsqadd_metrics_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-       ${PTI_METRIC_TEST_PROPS}
-       LABELS "functional"
-       LABELS "metrics"
-       LABELS "hw-metrics")
-
-  # Add the multi-threaded metrics vecsqadd test
-  gtest_discover_tests(
-    multi_thread_metrics_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-        ${PTI_METRIC_TEST_PROPS}
-        TIMEOUT 20
-        LABELS "functional"
-        LABELS "metrics"
-        LABELS "hw-metrics-multi-thread")
-
-  gtest_discover_tests(
-    metrics_scope_gemm_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-       ${PTI_METRIC_TEST_PROPS}
-       LABELS "functional"
-       LABELS "metrics"
-       LABELS "hw-metrics-scope")
-
-  gtest_discover_tests(
-    metrics_scope_buffer_handler_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-       LABELS "functional"
-       LABELS "metrics"
-       LABELS "hw-metrics-scope"
-       LABELS "buffer-handler")
-
-  gtest_discover_tests(
-    metrics_scope_parallel
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-       ${PTI_METRIC_TEST_PROPS}
-       LABELS "functional"
-       LABELS "metrics"
-       LABELS "hw-metrics-scope")
-
-  gtest_discover_tests(
-    sycl_queue_id
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    sycl_experimental_tests
-    DISCOVERY_TIMEOUT 60
-    TEST_SUFFIX "_PTI_COLLECTION_MODE_2_SYCL_UR_USE_LEVEL_ZERO_V2_0"
-    PROPERTIES ENVIRONMENT "PTI_COLLECTION_MODE=2"
-               ENVIRONMENT "SYCL_UR_USE_LEVEL_ZERO_V2=0"
-               TIMEOUT 120
-               LABELS "functional")
-
-  gtest_discover_tests(
-    sycl_experimental_tests
-    DISCOVERY_TIMEOUT 60
-    TEST_SUFFIX "_PTI_COLLECTION_MODE_2_SYCL_UR_USE_LEVEL_ZERO_V2_1"
-    PROPERTIES ENVIRONMENT "PTI_COLLECTION_MODE=2"
-               ENVIRONMENT "SYCL_UR_USE_LEVEL_ZERO_V2=1"
-               TIMEOUT 120
-               LABELS "functional")
-
-  gtest_discover_tests(
-    startstop_suite
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    no_kernel_overlap
-    DISCOVERY_TIMEOUT 60
-    TEST_LIST TIMESTAMPS_CORRECTNESS_LIST
-    PROPERTIES ENVIRONMENT "ONEAPI_DEVICE_SELECTOR=level_zero:*,*.*"
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    zegemm_suite
-    DISCOVERY_TIMEOUT 60
-    TEST_LIST ZEGEMM_SUITE_TEST_LIST
-    PROPERTIES LABELS "unit")
-
-  gtest_discover_tests(
-    init_tests
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES LABELS "unit")
-
-  gtest_discover_tests(
-    multi_threaded_submission
-    DISCOVERY_TIMEOUT 60
-    TEST_LIST TIMESTAMPS_CORRECTNESS_LIST
-    PROPERTIES ENVIRONMENT "ONEAPI_DEVICE_SELECTOR=level_zero:*,*.*"
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    callback_api_test
-    PROPERTIES LABELS "functional")
-
-  gtest_discover_tests(
-    callback_kernel_lifecycle_test
-    PROPERTIES LABELS "functional")
-
-  RequirePythonInterp()
-
-  set(L0_OVERHEAD_THRESHOLD 17)
-  set(LINK_OVERHEAD_THRESHOLD 3)
-  set(PC_SAMPLING_OVERHEAD_THRESHOLD 75)
-  set(METRICS_SCOPE_OVERHEAD_THRESHOLD 25)
-  set(METRICS_SCOPE_MT_OVERHEAD_THRESHOLD 25)
-  if (WIN32)
-    # Timer we use on Windows (as of implementation 02.14.25) has 100 ns resolution,
-    # due to that some functions latency measured as zero, so accumulated overhead is less than on Linux
-    set(L0_OVERHEAD_THRESHOLD 11)
-    # For some reason, on Windows, the link overhead is bigger than on Linux
-    # Need to investigate it - look into UR and XPTI
-    set(LINK_OVERHEAD_THRESHOLD 5)
-  endif()
-
-  # Approximate total runtime budget (seconds) for each performance test,
-  # passed to perf_test.py. The script divides it across all subprocess
-  # invocations to derive a per-process timeout, with a 10s minimum floor,
-  # so the actual worst-case runtime may exceed this value. It is intentionally
-  # approximate: the goal is to bound runaway hangs, not enforce a hard deadline.
-  # No ctest TIMEOUT is set here: perf_test.py spawns subprocesses and is the
-  # only level that can kill them cleanly on timeout. A ctest-level kill would
-  # terminate the Python script but leave the child process orphaned and still
-  # holding GPU resources, which is exactly the hang this mechanism prevents.
-  set(PTI_PERF_TEST_APROXIMATE_TIMEOUT 60)
-
-  set(PTI_PERF_TESTS
-    perf-profiling-overhead
-    perf-prof-gpu-overhead
-    perf-link-overhead
-    perf-overhead-view)
-
-  add_test(
-    NAME perf-profiling-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}" 60 profiled
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-prof-gpu-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}" 32.5 prof-gpu
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-link-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}" ${LINK_OVERHEAD_THRESHOLD} linkonly
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-overhead-view
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}" ${L0_OVERHEAD_THRESHOLD} overhead
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-pc-sampling-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}"
-      ${PC_SAMPLING_OVERHEAD_THRESHOLD} pc-sampling
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-metrics-scope-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}"
-      ${METRICS_SCOPE_OVERHEAD_THRESHOLD} scope
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  add_test(
-    NAME perf-metrics-scope-mt-overhead
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/perf_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}"
-      ${METRICS_SCOPE_MT_OVERHEAD_THRESHOLD} scope-mt
-      ${PTI_PERF_TEST_APROXIMATE_TIMEOUT}
-  )
-
-  set_tests_properties(
-    ${PTI_PERF_TESTS} PROPERTIES
-    LABELS "performance")
-
-  set_tests_properties(
-    perf-metrics-scope-overhead perf-metrics-scope-mt-overhead PROPERTIES
-    ${PTI_METRIC_TEST_PROPS}
-    SKIP_RETURN_CODE 77
-    LABELS "performance;metrics;hw-metrics")
-
-  set_tests_properties(
-    perf-overhead-view PROPERTIES
-    SKIP_RETURN_CODE 77
-    LABELS "performance;functional")
-
-  set_tests_properties(
-    perf-pc-sampling-overhead PROPERTIES
-    ${PTI_METRIC_TEST_PROPS}
-    SKIP_RETURN_CODE 77
-    LABELS "performance;functional;metrics;hw-metrics")
-
-  # Add interoperability test
-  add_test(
-    NAME xpti_interop_test
-    COMMAND ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/xpti_interop_test.py "${PTI_TOP_LEVEL_TEST_BIN_DIR}"
-  )
-  set_tests_properties(
-    xpti_interop_test PROPERTIES LABELS "interop;functional")
-
-endif()
-
-add_subdirectory(graph)
-
-if (HAVE_SYCL AND TARGET unified-runtime::loader)
-
-  if (PTI_BUILD_URGEMM)
-    add_executable(urgemm_suite main_urgemm_fixture.cc)
-
-    target_include_directories(
-      urgemm_suite
-      PUBLIC "${PROJECT_BINARY_DIR}"
-             "${PROJECT_SOURCE_DIR}/include"
-             "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-             "${PROJECT_SOURCE_DIR}/src"
-             "${PROJECT_SOURCE_DIR}/src/levelzero"
-      PRIVATE "${PROJECT_SOURCE_DIR}/src/utils")
-
-    target_compile_options(urgemm_suite  PUBLIC -fsycl)
-    target_link_options(urgemm_suite PUBLIC -fsycl)
-    target_link_libraries(urgemm_suite PUBLIC spdlog::spdlog
-                                            Pti::pti_view
-                                            GTest::gtest_main
-                                            GTest::gmock
-                                            LevelZero::level-zero
-                                            unified-runtime::loader
-                                            ${FS_LIB})
-    gtest_discover_tests(
-      urgemm_suite
-      DISCOVERY_TIMEOUT 60
-      TEST_LIST URGEMM_SUITE_TEST_LIST
-      PROPERTIES LABELS "unit" "sycl" "unified-runtime")
-
-    add_spirv(urgemm_suite gemm)
-  endif()
-
-  RequirePythonInterp()
-
-  get_target_property(UR_HEADER_PATH unified-runtime::loader INTERFACE_INCLUDE_DIRECTORIES)
-
-  if (UR_HEADER_PATH)
-    add_test(
-      NAME validate-sycl-ur-api-ids-test
-      COMMAND ${Python_EXECUTABLE}
-      ${PROJECT_SOURCE_DIR}/test/validate_sycl_api_ids.py --validate --pti-include-dir ${PROJECT_SOURCE_DIR}/include --ur-include-dir "${UR_HEADER_PATH}"
-    )
-
-    set_tests_properties(
-      validate-sycl-ur-api-ids-test PROPERTIES LABELS "interop;functional")
-  endif()
-
-endif()
-
-add_executable(view_record_test view_buffer_test.cc)
-
-target_include_directories(
-  view_record_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-target_link_libraries(view_record_test PUBLIC spdlog::spdlog Pti::pti_view GTest::gtest_main)
-
-get_itt()
-
-add_executable(assert_exception_test assert_exception_test.cc)
-
-target_include_directories(
-  assert_exception_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_BINARY_DIR}/include" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src")
-
-target_link_libraries(assert_exception_test PUBLIC spdlog::spdlog
-  GTest::gtest_main LevelZero::headers)
-
-add_executable(subscribers_unit_test subscribers_unit_test.cc)
-
-target_include_directories(
-  subscribers_unit_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-target_link_libraries(subscribers_unit_test PUBLIC GTest::gtest_main spdlog::spdlog
-                                            PRIVATE Pti::pti_view LevelZero::headers)
-
-add_executable(ze_events_pools_observer_test ze_events_pools_observer_test.cc)
-
-target_include_directories(ze_events_pools_observer_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_BINARY_DIR}/include" "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_SOURCE_DIR}/src" "${PROJECT_SOURCE_DIR}/src/levelzero"
-         "${PROJECT_SOURCE_DIR}/src/sycl" "${PROJECT_SOURCE_DIR}/src/utils")
-
-target_link_libraries(ze_events_pools_observer_test PUBLIC spdlog::spdlog
-                                                    GTest::gtest_main
-                                                   LevelZero::level-zero
-                                                   ${CMAKE_DL_LIBS})
-
-add_executable(view_gpu_local_test view_gpu_local_test.cc)
-
-target_include_directories(
-  view_gpu_local_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include")
-
-target_link_libraries(view_gpu_local_test PUBLIC spdlog::spdlog Pti::pti_view
-  GTest::gtest_main)
-
-add_executable(pc_sampling_basic_test pc_sampling/pc_sampling_basic_test.cc)
-
-target_include_directories(
-  pc_sampling_basic_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${CMAKE_CURRENT_SOURCE_DIR}/pc_sampling")
-
-target_link_libraries(pc_sampling_basic_test PUBLIC spdlog::spdlog Pti::pti_view
-  GTest::gtest_main LevelZero::level-zero LevelZero::level-zero-ext ${FS_LIB})
-
-add_executable(pc_sampling_internal_test pc_sampling/pc_sampling_internal_test.cc)
-
-target_include_directories(
-  pc_sampling_internal_test
-  PUBLIC "${PROJECT_BINARY_DIR}" "${PROJECT_SOURCE_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${CMAKE_CURRENT_SOURCE_DIR}/pc_sampling")
-
-target_link_libraries(pc_sampling_internal_test PUBLIC spdlog::spdlog Pti::pti_view
-GTest::gtest_main LevelZero::level-zero LevelZero::level-zero-ext ${FS_LIB})
-
-set(PTI_PC_SAMPLING_TEST_PROPS ${PTI_METRIC_TEST_PROPS})
-if(PTI_SANITIZER)
-  # Sanitizers can move the GPU ISA heap to an address domain that cannot
-  # currently be correlated with EuStallSampling instruction pointers.
-  list(APPEND PTI_PC_SAMPLING_TEST_PROPS DISABLED TRUE)
-endif()
-
-if(HAVE_SYCL)
-  add_executable(pc_sampling_functional_test pc_sampling/pc_sampling_functional_test.cc)
-
-  target_compile_options(pc_sampling_functional_test PRIVATE -fsycl)
-  target_link_options(pc_sampling_functional_test PRIVATE -fsycl)
-
-  target_link_libraries(pc_sampling_functional_test PUBLIC spdlog::spdlog Pti::pti_view
-    GTest::gtest_main LevelZero::level-zero LevelZero::level-zero-ext ${FS_LIB})
-endif()
-
-add_executable(pti_assert_test pti_assert_test.cc)
-
-target_include_directories(pti_assert_test PUBLIC
-  "${PROJECT_SOURCE_DIR}/src/utils")
-
-target_link_libraries(pti_assert_test PUBLIC GTest::gtest_main GTest::gmock)
-
-gtest_discover_tests(
-  pti_assert_test
-  PROPERTIES LABELS "unit")
-
-add_executable(pti_memory_route_test pti_memory_route_test.cc)
-
-target_include_directories(pti_memory_route_test PUBLIC
-  "${PROJECT_SOURCE_DIR}/src"
-  "${PROJECT_BINARY_DIR}/include"
-  "${PROJECT_SOURCE_DIR}/src/utils"
-  "${PROJECT_SOURCE_DIR}/include")
-
-target_link_libraries(pti_memory_route_test PUBLIC GTest::gtest_main GTest::gmock)
-
-gtest_discover_tests(
-  pti_memory_route_test
-  PROPERTIES LABELS "unit")
-
-gtest_discover_tests(
-  subscribers_unit_test
-  PROPERTIES LABELS "unit")
-
-gtest_discover_tests(
-  ze_events_pools_observer_test
-  DISCOVERY_TIMEOUT 60
-  PROPERTIES LABELS "unit")
-
-gtest_discover_tests(
-  view_record_test
-  DISCOVERY_TIMEOUT 60
-  TEST_LIST VIEW_RECORD_TEST_LIST
-  PROPERTIES LABELS "unit")
-gtest_discover_tests(
-  assert_exception_test
-  DISCOVERY_TIMEOUT 60
-  TEST_LIST ASSERT_EXCEPTION_TEST_LIST
-  PROPERTIES LABELS "unit")
-gtest_discover_tests(
-  view_gpu_local_test
-  DISCOVERY_TIMEOUT 60
-  PROPERTIES LABELS "functional")
-
-gtest_discover_tests(
-  pc_sampling_basic_test
-  DISCOVERY_TIMEOUT 60
-  PROPERTIES
-    ${PTI_PC_SAMPLING_TEST_PROPS}
-    LABELS "unit"
-    LABELS "pc-sampling")
-
-gtest_discover_tests(
-  pc_sampling_internal_test
-  DISCOVERY_TIMEOUT 60
-  PROPERTIES
-    ${PTI_PC_SAMPLING_TEST_PROPS}
-    LABELS "unit"
-    LABELS "metrics"
-    LABELS "hw-metrics"
-    LABELS "pc-sampling")
-
-if(HAVE_SYCL)
-  gtest_discover_tests(
-    pc_sampling_functional_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-      ${PTI_PC_SAMPLING_TEST_PROPS}
-      LABELS "functional"
-      LABELS "metrics"
-      LABELS "hw-metrics"
-      LABELS "pc-sampling")
-endif()
-
-# TODO: Organize this better? Where to put
-# functional tests?
-if(PTI_BUILD_SAMPLES AND TARGET pc_sampling_profiler)
-  add_test(NAME pc_sampling_profiler-usage COMMAND pc_sampling_profiler --help)
-  add_test(NAME pc_sampling_profiler-bad-period
-           COMMAND pc_sampling_profiler --period 0 -- /bin/true)
-  set_tests_properties(
-    pc_sampling_profiler-usage PROPERTIES PASS_REGULAR_EXPRESSION "Usage:" LABELS
-    "unit;samples")
-  set_tests_properties(
-    pc_sampling_profiler-bad-period PROPERTIES WILL_FAIL TRUE LABELS "unit;samples")
-
-  add_executable(pc_sampling_profiler_exit_workload pc_sampling/exit_workload.cc)
-  foreach(exit_mode IN ITEMS exit std-exit quick-exit std-quick-exit)
-    add_test(
-      NAME run-pc_sampling_profiler-${exit_mode}
-      COMMAND
-        ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/pc_sampling/run_sample_test.py
-        --exit $<TARGET_FILE:pc_sampling_profiler>
-        $<TARGET_FILE:pc_sampling_profiler_exit_workload> ${exit_mode})
-    set_tests_properties(
-      run-pc_sampling_profiler-${exit_mode}
-      PROPERTIES ${PTI_PC_SAMPLING_TEST_PROPS} SKIP_RETURN_CODE 77 TIMEOUT 120
-                 LABELS "functional;samples;pc-sampling")
-  endforeach()
-endif()
-
-if(PTI_BUILD_SAMPLES AND TARGET pc_sampling_profiler_l0_gemm)
-  add_test(
-    NAME run-pc_sampling_profiler-l0
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/pc_sampling/run_sample_test.py
-      $<TARGET_FILE:pc_sampling_profiler>
-      $<TARGET_FILE:pc_sampling_profiler_l0_gemm>
-      ${PROJECT_BINARY_DIR}/samples/pc_sampling_profiler/gemm.spv)
-  set_tests_properties(
-    run-pc_sampling_profiler-l0 PROPERTIES ${PTI_PC_SAMPLING_TEST_PROPS} SKIP_RETURN_CODE 77
-    TIMEOUT 120 LABELS "functional;samples;pc-sampling")
-endif()
-
-if(PTI_BUILD_SAMPLES AND TARGET pc_sampling_profiler_gemm)
-  add_test(
-    NAME run-pc_sampling_profiler-sycl
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/pc_sampling/run_sample_test.py
-      --sycl $<TARGET_FILE:pc_sampling_profiler> $<TARGET_FILE:pc_sampling_profiler_gemm>)
-  set_tests_properties(
-    run-pc_sampling_profiler-sycl PROPERTIES ${PTI_PC_SAMPLING_TEST_PROPS} SKIP_RETURN_CODE 77
-    TIMEOUT 360 LABELS "functional;samples;metrics;hw-metrics;pc-sampling")
-endif()
-
-if(PTI_BUILD_SAMPLES AND TARGET pc_sampling_profiler)
-  add_test(
-    NAME run-pc_sampling_profiler-pytorch
-    COMMAND
-      ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/pc_sampling/run_sample_test.py
-      --pytorch $<TARGET_FILE:pc_sampling_profiler> ${Python_EXECUTABLE}
-      ${PROJECT_SOURCE_DIR}/samples/pc_sampling_profiler/pytorch_train.py)
-  set_tests_properties(
-    run-pc_sampling_profiler-pytorch PROPERTIES ${PTI_PC_SAMPLING_TEST_PROPS} SKIP_RETURN_CODE 77
-    TIMEOUT 360 LABELS "functional;samples;metrics;hw-metrics;pc-sampling;pytorch")
-endif()
-
-# Runs all samples
-if(PTI_BUILD_SAMPLES AND HAVE_SYCL)
-  include(ProcessorCount)
-  ProcessorCount(NPROC)
-  if(NOT NPROC LESS_EQUAL 1)
-    math(EXPR TEST_THREADS "${NPROC} / 2" OUTPUT_FORMAT DECIMAL)
-  else()
-    set(TEST_THREADS 2)
-  endif()
-  if(DEFINED PTI_SANITIZER AND PTI_SANITIZER AND TEST_THREADS GREATER 8)
-    set(TEST_THREADS 8)
-  endif()
-  set(MT_AWK_TEST_OUT "${PROJECT_BINARY_DIR}/mt-awk-test.out")
-  set(MT_AWK_TEST_OUT_IMMEDIATE "${PROJECT_BINARY_DIR}/mt-awk-test-immediate.out")
-  add_test(
-    NAME mt-awk-test
-    COMMAND
-      bash -c
-      "$<TARGET_FILE:dpc_gemm_threaded> -t ${TEST_THREADS} > ${MT_AWK_TEST_OUT} &&
-          awk -f ${CMAKE_CURRENT_SOURCE_DIR}/multi_thread_correlation.awk ${MT_AWK_TEST_OUT}"
-  )
-  add_test(
-    NAME mt-awk-test-immediate
-    COMMAND
-      bash -c
-      "$<TARGET_FILE:dpc_gemm_threaded> -t ${TEST_THREADS} > ${MT_AWK_TEST_OUT_IMMEDIATE} &&
-          awk -f ${CMAKE_CURRENT_SOURCE_DIR}/multi_thread_correlation.awk ${MT_AWK_TEST_OUT_IMMEDIATE}"
-  )
-  set_property(TEST mt-awk-test-immediate PROPERTY ENVIRONMENT SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1)
-  set_property(TEST mt-awk-test PROPERTY ENVIRONMENT SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=0)
-
-  if(TEST_THREADS GREATER 16)
-    set_property(TEST mt-awk-test APPEND PROPERTY ENVIRONMENT "UR_L0_USM_RESIDENT=0")
-  endif()
-
-  if (TARGET dlworkload)
-    add_test(NAME run-dlworkload COMMAND dlworkload)
-    set_tests_properties(run-dlworkload PROPERTIES LABELS "functional;samples")
-
-    # Profile Time Difference test for dlworkload
-    add_test(
-      NAME prof-time-diff-dlworkload
-      COMMAND
-        ${Python_EXECUTABLE} ${PROJECT_SOURCE_DIR}/test/prof_time_diff/prof_time_diff.py
-        $<TARGET_FILE:dlworkload>
-        # allow here absolute time difference of 4 us (4000 ns) which should be acceptable
-        # for long running kernels, and for ~ usec duration short ones - this is measurement error
-        -da 4000
-        # skip first 50 kernels as warm-up
-        -s 50
-        # set delta for the second run to 50 us, much smaller than default 300 us
-        -e2 PTI_DEVICE_SYNC_DELTA=50000
-        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-    )
-
-    # TODO(PTI-422): Evaluate flaky test
-    set_tests_properties(
-      prof-time-diff-dlworkload PROPERTIES LABELS "functional;prof-time-diff;quarantine")
-  endif()
-
-  add_test(NAME run-dpc_gemm COMMAND dpc_gemm)
-  add_test(NAME run-onemkl_gemm_exe COMMAND onemkl_gemm_exe)
-  add_test(NAME run-vec_sqadd COMMAND vec_sqadd)
-  add_test(NAME run-iso COMMAND iso3dfd 256 256 256 32 8 64 10 gpu)
-  add_test(NAME run-metrics-iso COMMAND metrics_iso3dfd 256 256 256 32 8 64 10 gpu)
-  add_test(NAME run-callback COMMAND callback)
-  add_test(NAME run-metrics-scope COMMAND metrics_scope)
-  add_test(NAME run-omp_vec_add COMMAND omp_vec_add)
-  add_test(NAME run-metrics-perf COMMAND metrics_perf)
-
-  # TODO(PTI-354): Re-enable test when it stops being flaky or hanging.
-  set_tests_properties(
-    run-metrics-iso PROPERTIES ENVIRONMENT "ZET_ENABLE_METRICS=1" LABELS
-    "functional;samples;metrics;hw-metrics")
-
-  set_tests_properties(
-    mt-awk-test mt-awk-test-immediate run-dpc_gemm run-onemkl_gemm_exe run-vec_sqadd
-    run-iso run-callback PROPERTIES LABELS "functional;samples")
-
-  set_tests_properties(
-    run-metrics-scope PROPERTIES ENVIRONMENT "ZET_ENABLE_METRICS=1" LABELS
-    "functional;samples;metrics;hw-metrics-scope")
-
-  set_tests_properties(
-    run-metrics-perf PROPERTIES ENVIRONMENT "ZET_ENABLE_METRICS=1" LABELS
-    "functional;samples;metrics;hw-metrics-multi-thread")
-
-  # It is enabled only for functional test as there is an issue observed with Intel OpenMP with Address Sanitizer.
-  set_tests_properties(run-omp_vec_add PROPERTIES LABELS "functional;samples")
-
-  # If ze_loader is built (not LevelZero::levelzero because that could be the
-  # system L0), add it to the LD_LIBRARY_PATH for the omp_vec_add
-  # test or there could be a mismatch between PTI and the loader.
-  if(UNIX AND TARGET ze_loader)
-    set_tests_properties(
-      run-omp_vec_add PROPERTIES ENVIRONMENT
-      "LD_LIBRARY_PATH=$<TARGET_FILE_DIR:ze_loader>:$ENV{LD_LIBRARY_PATH}")
-  endif()
-endif()
-
-# ITT collector configuration, collection, and domain-filtering tests.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-  add_subdirectory(itt)
-endif()
-
-# Library-loading tests requiring SYCL.
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND HAVE_SYCL)
-  # Stage a wheel-like layout and test loading Core (libpti.so) through libpti_view.so
-  # without LD_LIBRARY_PATH. Core remains in pti/, while XPTI and required non-system
-  # runtime dependencies are staged beside libpti_view.so.
-  if(TARGET Xpti::xpti AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-    set(PTI_LIB_LOAD_PRELOAD_STAGE_DIR "${CMAKE_CURRENT_BINARY_DIR}/lib_load_preload")
-    set(PTI_LIB_LOAD_PRELOAD_CORE_DIR
-        "${PTI_LIB_LOAD_PRELOAD_STAGE_DIR}/${PTI_MODULE_SUBDIR}")
-
-    add_custom_target(
-      lib_load_stage
-      COMMAND ${CMAKE_COMMAND} -E make_directory "${PTI_LIB_LOAD_PRELOAD_CORE_DIR}"
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:pti_view>"
-              "${PTI_LIB_LOAD_PRELOAD_STAGE_DIR}"
-      COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:pti>"
-              "${PTI_LIB_LOAD_PRELOAD_CORE_DIR}"
-      COMMAND ${CMAKE_COMMAND}
-              "-DPTI_CORE_LIBRARY=$<TARGET_FILE:pti>"
-              "-DPTI_XPTI_LIBRARY=$<TARGET_FILE:Xpti::xpti>"
-              "-DPTI_XPTI_RUNTIME_DIRECTORY=$<TARGET_FILE_DIR:Xpti::xpti>"
-              "-DPTI_PRELOAD_STAGE_DIRECTORY=${PTI_LIB_LOAD_PRELOAD_STAGE_DIR}"
-              -P "${CMAKE_CURRENT_SOURCE_DIR}/cmake/stage_xpti_runtime_dependencies.cmake"
-      DEPENDS pti pti_view
-      VERBATIM)
-
-    add_executable(lib_load_suite lib_load_suite.cc)
-    add_dependencies(lib_load_suite lib_load_stage)
-    target_include_directories(
-      lib_load_suite
-      PRIVATE "${PROJECT_BINARY_DIR}/include" "${PROJECT_SOURCE_DIR}/include")
-    target_compile_definitions(
-      lib_load_suite
-      PRIVATE
-        PTI_PRELOAD_VIEW_LIBRARY_PATH="${PTI_LIB_LOAD_PRELOAD_STAGE_DIR}/$<TARGET_FILE_NAME:pti_view>"
-        PTI_PRELOAD_CORE_LIBRARY_PATH="${PTI_LIB_LOAD_PRELOAD_CORE_DIR}/$<TARGET_FILE_NAME:pti>")
-    # Intentionally does not link against either PTI library.
-    target_link_libraries(lib_load_suite PRIVATE GTest::gtest_main ${CMAKE_DL_LIBS})
-
-    gtest_discover_tests(
-      lib_load_suite
-      DISCOVERY_TIMEOUT 60
-      PROPERTIES
-        ENVIRONMENT "LD_LIBRARY_PATH="
-        LABELS "unit"
-        LABELS "libload")
-  elseif(TARGET Xpti::xpti)
-    message(STATUS "Skipping lib-load preload test: requires CMake 3.16 or newer")
-  endif()
-endif()
-
-# Register this after all other libload tests so default serial CTest output shows it last.
-if(TARGET libld_origin_test)
-  gtest_discover_tests(
-    libld_origin_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-      ENVIRONMENT "LD_LIBRARY_PATH="
-      LABELS "unit"
-      LABELS "libload")
-endif()
-
-if(PTI_FUZZ)
-  add_subdirectory(fuzz)
-endif()
-
-# Symbols exported by libpti(_view).so should be limited to PTI and a few
-# symbols required by XPTI and ITT APIs needed for collection.
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND CMAKE_NM)
-  set(PTI_SYMBOL_TEST_DISABLED
-      "$<NOT:$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>>")
-
-  add_test(NAME pti_view_exported_symbols
-           COMMAND ${CMAKE_NM} -D --defined-only $<TARGET_FILE:Pti::pti_view>)
-  # This regex matches the nm line. The symbol name must begin with a specific
-  # prefix e.g., pti or __itt. If new symbols are added that don't match the
-  # pattern, add the symbol's prefix here (ditto for pti).
-  set_tests_properties(pti_view_exported_symbols PROPERTIES
-    PASS_REGULAR_EXPRESSION "^([0-9a-f]+ (A |[A-Za-z] (pti|__itt|xpti))[^\n]*\n?)+$"
-    DISABLED "${PTI_SYMBOL_TEST_DISABLED}"
-    LABELS "functional;integration;symbols")
-
-  add_test(NAME pti_exported_symbols
-           COMMAND ${CMAKE_NM} -D --defined-only $<TARGET_FILE:Pti::pti>)
-
-  set_tests_properties(pti_exported_symbols PROPERTIES
-    PASS_REGULAR_EXPRESSION
-    "^([0-9a-f]+ (A |[A-Za-z] (pti|Pti|itt|Itt|xpti|_ZN13SyclCollector10TpCallback))[^\n]*\n?)+$"
-    DISABLED "${PTI_SYMBOL_TEST_DISABLED}"
-    LABELS "functional;integration;symbols")
-endif()
diff --git a/sdk/test/assert_exception_test.cc b/sdk/test/assert_exception_test.cc
deleted file mode 100644
index 66de8d24..00000000
--- a/sdk/test/assert_exception_test.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "view_helpers.h"
-
-class AssertExceptionFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override { ViewStateInstance().SetState(pti_result::PTI_SUCCESS); }
-
-  void TearDown() override {}
-};
-
-TEST_F(AssertExceptionFixtureTest, AssertApplyTimeShiftUFValid) {
-  uint64_t aTS = ApplyTimeShift(10, -10);
-  ASSERT_EQ(aTS, 0ULL);
-}
-
-TEST_F(AssertExceptionFixtureTest, AssertApplyTimeShiftUnderflow) {
-  uint64_t aTS = ApplyTimeShift(0, -1);
-  ASSERT_EQ(aTS, 0ULL);
-}
-
-TEST_F(AssertExceptionFixtureTest, AssertApplyTimeShiftOFValid) {
-  uint64_t aTS = ApplyTimeShift(UINT64_MAX - 1, 1);
-  ASSERT_EQ(aTS, UINT64_MAX);
-}
-
-TEST_F(AssertExceptionFixtureTest, AssertApplyTimeShiftOverflow) {
-  uint64_t aTS = ApplyTimeShift(UINT64_MAX, 1);
-  ASSERT_EQ(aTS, 0ULL);
-}
diff --git a/sdk/test/callback_api_test.cc b/sdk/test/callback_api_test.cc
deleted file mode 100644
index 298620fe..00000000
--- a/sdk/test/callback_api_test.cc
+++ /dev/null
@@ -1,2237 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <condition_variable>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <set>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_view.h"
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-// ============================================================================
-// TEST CONSTANTS
-// ============================================================================
-namespace {
-
-// Buffer sizes
-constexpr size_t kViewBufferSize = 100'000;  // 100KB buffer for PTI view records
-
-// Matrix and kernel sizes
-constexpr unsigned kDefaultMatrixSize = 32;  // Default size for test matrices
-constexpr unsigned kSmallMatrixSize = 16;    // Smaller size for rapid tests
-
-// Test iteration counts
-constexpr int kDefaultKernelCount = 5;       // Default number of kernels to launch
-constexpr int kThreadSafetyKernelCount = 8;  // Kernels per thread in thread safety test
-constexpr int kConcurrentSubmissions = 10;   // Submissions per thread in concurrent test
-
-// Thread counts
-constexpr int kDefaultThreadCount = 4;       // Default number of threads
-constexpr int kConcurrentThreadCount = 8;    // Threads for concurrent queue test
-constexpr int kThreadSafetyThreadCount = 6;  // Threads for thread safety test
-
-// External correlation
-constexpr uint64_t kExternalIdStart = 1000;  // Starting external correlation ID
-
-// ============================================================================
-// TEST STRUCTURES
-// ============================================================================
-
-struct pair_hash {
-  std::size_t operator()(const std::pair<pti_backend_ctx_t, pti_device_handle_t>& p) const {
-    uintptr_t a1 = reinterpret_cast<uintptr_t>(p.first);
-    uintptr_t a2 = reinterpret_cast<uintptr_t>(p.second);
-    auto h1 = std::hash<uintptr_t>{}(a1);
-    auto h2 = std::hash<uintptr_t>{}(a2);
-    // Combine the two hashes
-    return h1 ^ (h2 << 1);
-  }
-};
-
-using ContextDeviceDataMap =
-    std::unordered_map<std::pair<pti_backend_ctx_t, pti_device_handle_t>,
-                       std::pair<pti_gpu_operation_kind, uint32_t>, pair_hash>;
-
-// Data structure for external correlation test tracking
-struct ExternalCorrTestData {
-  // Callback tracking
-  std::atomic<uint64_t> next_external_id{kExternalIdStart};
-  std::map<uint32_t, uint64_t>
-      callback_corr_to_external;  // correlation_id -> external_id we pushed
-  std::atomic<int> push_count{0};
-  std::atomic<int> pop_count{0};
-  std::atomic<int> push_errors{0};
-  std::atomic<int> pop_errors{0};
-
-  // View record tracking
-  std::map<uint32_t, uint32_t> view_driver_api_records;   // correlation_id -> api_id
-  std::map<uint32_t, uint32_t> view_runtime_api_records;  // correlation_id -> api_id
-  std::map<uint64_t, uint32_t> view_external_to_corr;     // external_id -> correlation_id
-
-  // Ordering check tracking
-  std::set<uint32_t> external_corr_seen_so_far;  // for ordering check
-  std::set<uint32_t> callback_pushed_corr_ids;   // correlation_ids we pushed in callbacks
-
-  // PTI-457: every external correlation record sharing a (_correlation_id,
-  // _external_kind) pair must carry the same _external_id. If two records
-  // disagree, a consumer cannot tell which id labels the operation and keeps
-  // whichever it happened to see last. The record count itself is not the
-  // invariant -- a single operation may legitimately be reported by more than
-  // one collector path -- but the id they agree on is.
-  std::map<std::pair<uint32_t, uint32_t>, std::set<uint64_t>> ext_ids_per_corr_and_kind;
-  // The id pushed from inside the callback after popping, keyed by correlation
-  // id, so the view records can be checked against what was actually live.
-  std::map<uint32_t, uint64_t> repushed_in_callback;
-  // A failed re-push would leave repushed_in_callback empty and make the checks
-  // below vacuous, so it has to fail the test rather than be ignored.
-  std::atomic<int> repush_errors{0};
-
-  // Violation tracking
-  struct OrderViolation {
-    uint32_t correlation_id;
-    uint32_t api_id;
-  };
-  std::vector<OrderViolation> ordering_violations;
-};
-
-// Data structure for callback tracking (used by most tests)
-struct CallbackData {
-  // View record counters
-  std::atomic<int> view_kernel_count{0};
-  std::atomic<int> view_memcopy_count{0};
-  std::atomic<int> view_memfill_count{0};
-
-  // Callback invocation tracking
-  bool append_complete_all_phases{false};
-  std::atomic<int> enter_count{0};
-  std::atomic<int> exit_count{0};
-  std::atomic<int> total_count{0};
-  std::atomic<int> appended_count{0};
-  std::atomic<int> completed_count{0};
-
-  // Separate counters for APPENDED domain ENTER/EXIT phases
-  std::atomic<int> appended_enter_count{0};
-  std::atomic<int> appended_exit_count{0};
-
-  // Separate counters for COMPLETED domain ENTER/EXIT phases
-  std::atomic<int> completed_enter_count{0};
-  std::atomic<int> completed_exit_count{0};
-
-  // Counters for completed operations by type
-  std::atomic<int> completed_kernel_count{0};
-  std::atomic<int> completed_memcopy_count{0};
-  std::atomic<int> completed_memfill_count{0};
-
-  // Last seen values
-  pti_callback_domain last_domain{PTI_CB_DOMAIN_INVALID};
-  pti_callback_phase last_phase{PTI_CB_PHASE_INVALID};
-  pti_api_group_id last_api_group = PTI_API_GROUP_RESERVED;
-  void* user_data_received{nullptr};
-
-  // Operation type flags
-  std::atomic<bool> kernel_seen{false};
-  std::atomic<bool> memory_op_seen{false};
-
-  // Validation counters
-  std::atomic<bool> all_callbacks_levelzero{true};
-  std::atomic<int> non_levelzero_count{0};
-  std::atomic<int> null_context_count{0};
-  std::atomic<int> reserved_api_id_count{0};
-  std::atomic<int> null_device_handle_count{0};
-
-  // Thread-specific tracking for multi-threaded tests
-  std::mutex thread_map_mutex;
-  std::unordered_map<std::thread::id, int> thread_callback_counts;
-  std::unordered_map<std::thread::id, int> thread_kernel_counts;
-  std::unordered_map<std::thread::id, ContextDeviceDataMap> append_enter_map;
-
-  void RecordThreadCallback() {
-    std::lock_guard<std::mutex> lock(thread_map_mutex);
-    thread_callback_counts[std::this_thread::get_id()]++;
-  }
-
-  void RecordThreadKernel() {
-    std::lock_guard<std::mutex> lock(thread_map_mutex);
-    thread_kernel_counts[std::this_thread::get_id()]++;
-  }
-
-  bool do_external_correlation_test{false};
-  // PTI-457: pop the id pushed on ENTER and immediately push a different one,
-  // all from inside the subscriber callback.
-  bool do_pop_then_push_in_callback{false};
-  ExternalCorrTestData ext_correlation_data{};
-
-  // ============================================================================
-  // Operation ID tracking fields
-  // ============================================================================
-
-  // Uniqueness tracking - separate by operation kind
-  std::mutex operation_id_mutex;
-  std::set<uint64_t> seen_kernel_operation_ids;  // Track uniqueness for kernels
-  std::set<uint64_t> seen_memory_operation_ids;  // Track uniqueness for memory ops
-
-  // Track operation_id to correlation_id mapping to detect true duplicates
-  // (same operation_id used for different operations/correlation_ids)
-  std::map<uint64_t, uint32_t>
-      kernel_id_to_first_corr_id;  // kernel_id -> first correlation_id seen
-  std::map<uint64_t, uint32_t>
-      memory_id_to_first_corr_id;  // mem_op_id -> first correlation_id seen
-
-  // API ID consistency tracking (driver_api_id is stable, name might be empty in ENTER phase)
-  std::map<uint64_t, uint32_t> kernel_id_to_api_id;  // kernel_id -> driver_api_id
-  std::map<uint64_t, uint32_t> memory_id_to_api_id;  // mem_op_id -> driver_api_id
-
-  // Cross-reference between Callback domains (APPENDED vs COMPLETED)
-  std::map<uint64_t, uint32_t> appended_kernel_id_to_corr_id;   // kernel_id -> correlation_id
-  std::map<uint64_t, uint32_t> appended_memory_id_to_corr_id;   // mem_op_id -> correlation_id
-  std::map<uint64_t, uint32_t> completed_kernel_id_to_corr_id;  // kernel_id -> correlation_id
-  std::map<uint64_t, uint32_t> completed_memory_id_to_corr_id;  // mem_op_id -> correlation_id
-
-  // View API tracking (for cross-validation between Callback and View APIs)
-  std::map<uint64_t, uint32_t> view_kernel_id_to_corr_id;  // kernel_id -> correlation_id
-  std::map<uint64_t, uint32_t> view_memop_id_to_corr_id;   // mem_op_id -> correlation_id
-
-  // Validation error counters
-  std::atomic<int> duplicate_kernel_ids{0};
-  std::atomic<int> duplicate_memory_ids{0};
-  std::atomic<int> zero_operation_ids{0};
-  std::atomic<int> kernel_api_id_mismatch{0};
-  std::atomic<int> memory_api_id_mismatch{0};
-  std::atomic<int> view_callback_id_mismatch{0};
-
-  // Lifecycle validation error counters
-  std::atomic<int> completed_without_appended{0};  // Operations completed but never appended
-  std::atomic<int> appended_without_completed{0};  // Operations appended but never completed
-};
-
-// ============================================================================
-// GLOBAL POINTERS
-// ============================================================================
-
-// Global pointers to test data (used by BufferCompleted and other callbacks)
-CallbackData* g_callback_data = nullptr;
-
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-void LaunchMultipleGEMMKernels(sycl::queue& queue, const std::vector<float>& a_vector,
-                               const std::vector<float>& b_vector, std::vector<float>& result,
-                               unsigned size, int repeat_count) {
-  ASSERT_GT(size, 0U);
-  ASSERT_EQ(a_vector.size(), size * size);
-  ASSERT_EQ(b_vector.size(), size * size);
-  ASSERT_EQ(result.size(), size * size);
-
-  try {
-    for (int iter = 0; iter < repeat_count; ++iter) {
-      sycl::buffer<float, 1> a_buf(a_vector.data(), a_vector.size());
-      sycl::buffer<float, 1> b_buf(b_vector.data(), b_vector.size());
-      sycl::buffer<float, 1> c_buf(result.data(), result.size());
-
-      queue.submit([&](sycl::handler& cgh) {
-        auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-        auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-        auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-        cgh.parallel_for<class __TestGEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-          auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-          auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-          auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-          GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-        });
-      });
-    }
-    // Important that wait is outside of the loop to avoid serializing kernel launches
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    FAIL() << "[ERROR] Launching kernel: " << e.what();
-  }
-}
-
-float Check(const std::vector<float>& a, float value) {
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-  return eps / a.size();
-}
-
-// Buffer callback functions for ptiView
-void BufferRequested(unsigned char** buf, size_t* buf_size) {
-  *buf_size = kViewBufferSize;
-  *buf = new unsigned char[*buf_size];
-}
-
-// Buffer completion callback function for ptiView
-// Statistics are collected here for further verification
-void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-  if (!buf || !used_bytes || !buf_size) {
-    if (buf) {
-      delete[] buf;
-    }
-    return;
-  }
-
-  // Parse the buffer to count view records
-  pti_view_record_base* ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Error parsing PTI records" << std::endl;
-      break;
-    }
-
-    // Get pointer to external correlation test data if external correlation testing is enabled
-    auto* external_corr_test_data =
-        (g_callback_data && g_callback_data->do_external_correlation_test)
-            ? &g_callback_data->ext_correlation_data
-            : nullptr;
-
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        auto* kernel_rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
-        if (g_callback_data) {
-          g_callback_data->view_kernel_count++;
-          // Track kernel operation ID from view records and check for duplicates
-          std::lock_guard<std::mutex> lock(g_callback_data->operation_id_mutex);
-          auto [it, inserted] = g_callback_data->view_kernel_id_to_corr_id.insert(
-              {kernel_rec->_kernel_id, kernel_rec->_correlation_id});
-          if (!inserted) {
-            // Duplicate kernel_id in view records - this is an error!
-            g_callback_data->duplicate_kernel_ids++;
-            std::cerr << "ERROR: Duplicate kernel_id " << kernel_rec->_kernel_id
-                      << " in View records (correlation_ids: " << it->second << " vs "
-                      << kernel_rec->_correlation_id << ")" << std::endl;
-          }
-        }
-        std::cout << "View: Kernel " << kernel_rec->_name
-                  << " (corr_id: " << kernel_rec->_correlation_id
-                  << ", op_id: " << kernel_rec->_kernel_id << ")" << std::endl;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        auto* mem_rec = reinterpret_cast<pti_view_record_memory_copy*>(ptr);
-        if (g_callback_data) {
-          g_callback_data->view_memcopy_count++;
-          // Track memory operation ID from view records and check for duplicates
-          std::lock_guard<std::mutex> lock(g_callback_data->operation_id_mutex);
-          auto [it, inserted] = g_callback_data->view_memop_id_to_corr_id.insert(
-              {mem_rec->_mem_op_id, mem_rec->_correlation_id});
-          if (!inserted) {
-            // Duplicate mem_op_id in view records - this is an error!
-            g_callback_data->duplicate_memory_ids++;
-            std::cerr << "ERROR: Duplicate mem_op_id " << mem_rec->_mem_op_id
-                      << " in View records (correlation_ids: " << it->second << " vs "
-                      << mem_rec->_correlation_id << ")" << std::endl;
-          }
-        }
-        std::cout << "View: MemCopy " << mem_rec->_bytes << " bytes"
-                  << " (corr_id: " << mem_rec->_correlation_id << ", op_id: " << mem_rec->_mem_op_id
-                  << ")" << std::endl;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        auto* fill_rec = reinterpret_cast<pti_view_record_memory_fill*>(ptr);
-        if (g_callback_data) {
-          g_callback_data->view_memfill_count++;
-          // Track memory operation ID from view records and check for duplicates
-          std::lock_guard<std::mutex> lock(g_callback_data->operation_id_mutex);
-          auto [it, inserted] = g_callback_data->view_memop_id_to_corr_id.insert(
-              {fill_rec->_mem_op_id, fill_rec->_correlation_id});
-          if (!inserted) {
-            // Duplicate mem_op_id in view records - this is an error!
-            g_callback_data->duplicate_memory_ids++;
-            std::cerr << "ERROR: Duplicate mem_op_id " << fill_rec->_mem_op_id
-                      << " in View records (correlation_ids: " << it->second << " vs "
-                      << fill_rec->_correlation_id << ")" << std::endl;
-          }
-        }
-        std::cout << "View: MemFill " << fill_rec->_bytes << " bytes"
-                  << " (corr_id: " << fill_rec->_correlation_id
-                  << ", op_id: " << fill_rec->_mem_op_id << ")" << std::endl;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        auto* rec = reinterpret_cast<pti_view_record_external_correlation*>(ptr);
-        auto ext_id = rec->_external_id;
-        auto corr_id = rec->_correlation_id;
-
-        if (external_corr_test_data) {
-          external_corr_test_data->view_external_to_corr[ext_id] = corr_id;
-          external_corr_test_data->external_corr_seen_so_far.insert(corr_id);
-          // PTI-457: collect the distinct external ids reported for each
-          // (correlation id, kind) pair. More than one means they conflict.
-          external_corr_test_data
-              ->ext_ids_per_corr_and_kind[{corr_id, static_cast<uint32_t>(rec->_external_kind)}]
-              .insert(ext_id);
-        }
-
-        std::cout << "View: External Correlation (external_id=" << ext_id
-                  << ", correlation_id=" << corr_id << ")" << std::endl;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-        auto corr_id = rec->_correlation_id;
-        auto api_id = rec->_api_id;
-
-        if (external_corr_test_data) {
-          external_corr_test_data->view_driver_api_records[corr_id] = api_id;
-
-          // CHECK: Only for Driver API records whose correlation_id we pushed external correlation
-          // for should we expect to see a preceding external correlation record
-          if (external_corr_test_data->callback_pushed_corr_ids.find(corr_id) !=
-              external_corr_test_data->callback_pushed_corr_ids.end()) {
-            // This is a Driver API we pushed external correlation for
-            if (external_corr_test_data->external_corr_seen_so_far.find(corr_id) ==
-                external_corr_test_data->external_corr_seen_so_far.end()) {
-              // VIOLATION: Driver API appeared without preceding external correlation
-              external_corr_test_data->ordering_violations.push_back({corr_id, api_id});
-              std::cerr << "WARNING: Driver API record (correlation_id=" << corr_id
-                        << ", api_id=" << api_id
-                        << ") has no PRECEDING external correlation record!" << std::endl;
-            }
-          }
-        }
-
-        std::cout << "View: Driver API (api_id=" << api_id << ", correlation_id=" << corr_id << ")"
-                  << std::endl;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-        auto corr_id = rec->_correlation_id;
-        auto api_id = rec->_api_id;
-
-        // Record this Runtime API record (if test data is available)
-        if (external_corr_test_data) {
-          external_corr_test_data->view_runtime_api_records[corr_id] = api_id;
-        }
-
-        std::cout << "View: Runtime API (api_id=" << api_id << ", correlation_id=" << corr_id << ")"
-                  << std::endl;
-        break;
-      }
-      default:
-        // Ignore other record types
-        break;
-    }
-  }
-
-  delete[] buf;
-}
-
-}  // namespace
-
-// ============================================================================
-// Test fixture for Callback API tests
-// ============================================================================
-// class CallbackApiTest : public ::testing::Test {
-class CallbackApiTest : public ::testing::TestWithParam<bool> {
- protected:
-  static void CheckConsistencyAppendedEnterToExit(pti_backend_ctx_t backend_context,
-                                                  const pti_callback_gpu_op_data* gpu_op_data,
-                                                  const pti_gpu_op_details& op_details,
-                                                  CallbackData* data) {
-    // This function is now integrated into the main callback function
-    // to check consistency between APPENDED ENTER and EXIT phases.
-    std::lock_guard<std::mutex> lock(data->thread_map_mutex);
-    if (gpu_op_data->_phase == PTI_CB_PHASE_API_ENTER) {
-      // Store operation kind and correlation ID for this context+device
-      auto& entry = data->append_enter_map[std::this_thread::get_id()];
-      entry[{backend_context, gpu_op_data->_device_handle}] = {op_details._operation_kind,
-                                                               gpu_op_data->_correlation_id};
-
-    } else if (gpu_op_data->_phase == PTI_CB_PHASE_API_EXIT) {
-      auto& entry = data->append_enter_map[std::this_thread::get_id()];
-      // Verify that on Exit phase we had a matching Enter phase
-      auto it = entry.find({backend_context, gpu_op_data->_device_handle});
-      EXPECT_TRUE(it != entry.end()) << "No matching APPENDED ENTER phase found for EXIT phase"
-                                     << " for context-device pair: " << backend_context
-                                     << ", device: " << gpu_op_data->_device_handle;
-
-      EXPECT_TRUE(it->second.first == op_details._operation_kind)
-          << "Mismatched operation kind between APPENDED ENTER and EXIT phases"
-          << " for context-device pair: " << backend_context
-          << ", device: " << gpu_op_data->_device_handle;
-
-      EXPECT_TRUE(it->second.second == gpu_op_data->_correlation_id)
-          << "Mismatched correlation ID between APPENDED ENTER and EXIT phases"
-          << " for context-device pair: " << it->second.second << " vs "
-          << gpu_op_data->_correlation_id;
-    }
-  }
-
-  static void PrintCallBackInfo(const char* domain_name, pti_callback_phase phase,
-                                pti_backend_ctx_t backend_context,
-                                pti_device_handle_t device_handle,
-                                pti_api_group_id driver_api_group_id, uint32_t driver_api_id,
-                                uint32_t correlation_id, uint32_t operation_count,
-                                const pti_gpu_op_details* operation_details) {
-    const char* api_name = nullptr;
-    if (PTI_SUCCESS != ptiViewGetApiIdName(driver_api_group_id, driver_api_id, &api_name)) {
-      api_name = nullptr;
-    }
-
-    std::cout << "Callback: Domain: " << domain_name
-              << ", Phase: " << (phase == PTI_CB_PHASE_API_ENTER ? "ENTER" : "EXIT")
-              << ", Context: " << backend_context << ", Device: " << device_handle
-              << "\t API Group / ID / name " << driver_api_group_id << " / " << driver_api_id
-              << " / " << (api_name ? api_name : "<unknown>")
-              << ", CorrelationID: " << correlation_id << ", OperationCount: " << operation_count
-              << std::endl;
-    if (operation_count > 0 && operation_details) {
-      for (uint32_t i = 0; i < operation_count; ++i) {
-        const auto& op = operation_details[i];
-        std::cout << "  Operation " << i << ": Kind="
-                  << (op._operation_kind == PTI_GPU_OPERATION_KIND_KERNEL
-                          ? "KERNEL"
-                          : (op._operation_kind == PTI_GPU_OPERATION_KIND_MEMORY ? "MEMORY"
-                                                                                 : "OTHER"))
-                  << ", OpID=" << op._operation_id << ", KernelHandle=" << op._kernel_handle
-                  << ", Name=" << (op._name ? op._name : "N/A") << std::endl;
-      }
-    }
-  }
-
-  static void CheckConsistencyCompletedToAppended(pti_backend_ctx_t backend_context,
-                                                  const pti_callback_gpu_op_data* gpu_op_data,
-                                                  CallbackData* data) {
-    std::lock_guard<std::mutex> lock(data->thread_map_mutex);
-    // Note: As completion is an async event,
-    // it could be reported in a different thread than the append
-    bool found = false;
-    for (auto thread_id : data->append_enter_map) {
-      auto& entry = thread_id.second;
-      // Verify that for the Complete domain we have a matching Append Enter phase
-      auto it = entry.find({backend_context, gpu_op_data->_device_handle});
-      if (it != entry.end()) {
-        found = true;
-        break;
-      }
-    }
-    EXPECT_TRUE(found) << "No matching APPENDED ENTER found for COMPLETED"
-                       << " for context-device pair: " << backend_context
-                       << ", device: " << gpu_op_data->_device_handle;
-  }
-
-  static void VerifyOperationIdUniqueness(uint64_t operation_id, pti_gpu_operation_kind kind,
-                                          uint32_t correlation_id, CallbackData* data) {
-    if (operation_id == 0) {
-      data->zero_operation_ids++;
-      std::cerr << "WARNING: Operation ID is zero" << std::endl;
-      return;
-    }
-
-    std::lock_guard<std::mutex> lock(data->operation_id_mutex);
-
-    // Track uniqueness within operation kind space
-    // NOTE: The same operation_id will appear in multiple callbacks:
-    //   - APPENDED ENTER (correlation_id Y)
-    //   - APPENDED EXIT (correlation_id Y)
-    //   - COMPLETED (correlation_id Z - different!)
-    // This is expected. We just track that we've seen this operation_id.
-    // The correlation_id changes between APPENDED and COMPLETED domains.
-    if (kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      auto [it, inserted] = data->seen_kernel_operation_ids.insert(operation_id);
-      if (inserted) {
-        // First time seeing this kernel operation_id - record its first correlation_id
-        data->kernel_id_to_first_corr_id[operation_id] = correlation_id;
-      }
-      // If not inserted, we've seen this operation_id before - this is OK (subsequent phases)
-    } else if (kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      auto [it, inserted] = data->seen_memory_operation_ids.insert(operation_id);
-      if (inserted) {
-        // First time seeing this memory operation_id - record its first correlation_id
-        data->memory_id_to_first_corr_id[operation_id] = correlation_id;
-      }
-      // If not inserted, we've seen this operation_id before - this is OK (subsequent phases)
-    }
-  }
-
-  static void VerifyOperationIdConsistency(uint64_t operation_id, pti_gpu_operation_kind kind,
-                                           uint32_t driver_api_id, CallbackData* data) {
-    std::lock_guard<std::mutex> lock(data->operation_id_mutex);
-
-    // Check driver_api_id consistency within operation kind space
-    // NOTE: We use driver_api_id instead of name because name might be empty in ENTER phase
-    if (kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      auto api_it = data->kernel_id_to_api_id.find(operation_id);
-      if (api_it != data->kernel_id_to_api_id.end()) {
-        if (api_it->second != driver_api_id) {
-          data->kernel_api_id_mismatch++;
-          std::cerr << "ERROR: Kernel driver_api_id mismatch for kernel_id " << operation_id << ": "
-                    << api_it->second << " vs " << driver_api_id << std::endl;
-        }
-      } else {
-        data->kernel_id_to_api_id[operation_id] = driver_api_id;
-      }
-    } else if (kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      auto api_it = data->memory_id_to_api_id.find(operation_id);
-      if (api_it != data->memory_id_to_api_id.end()) {
-        if (api_it->second != driver_api_id) {
-          data->memory_api_id_mismatch++;
-          std::cerr << "ERROR: Memory operation driver_api_id mismatch for mem_op_id "
-                    << operation_id << ": " << api_it->second << " vs " << driver_api_id
-                    << std::endl;
-        }
-      } else {
-        data->memory_id_to_api_id[operation_id] = driver_api_id;
-      }
-    }
-  }
-
-  static void TrackOperationIdMapping(uint64_t operation_id, pti_gpu_operation_kind kind,
-                                      uint32_t correlation_id, bool is_appended,
-                                      CallbackData* data) {
-    std::lock_guard<std::mutex> lock(data->operation_id_mutex);
-
-    if (kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      if (is_appended) {
-        data->appended_kernel_id_to_corr_id[operation_id] = correlation_id;
-      } else {
-        data->completed_kernel_id_to_corr_id[operation_id] = correlation_id;
-      }
-    } else if (kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      if (is_appended) {
-        data->appended_memory_id_to_corr_id[operation_id] = correlation_id;
-      } else {
-        data->completed_memory_id_to_corr_id[operation_id] = correlation_id;
-      }
-    }
-  }
-
-  static void VerifyCompletedWasAppended(uint64_t operation_id, pti_gpu_operation_kind kind,
-                                         CallbackData* data) {
-    std::lock_guard<std::mutex> lock(data->operation_id_mutex);
-
-    if (kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      if (data->appended_kernel_id_to_corr_id.find(operation_id) ==
-          data->appended_kernel_id_to_corr_id.end()) {
-        data->completed_without_appended++;
-        std::cerr << "ERROR: Completed kernel_id " << operation_id
-                  << " was never seen in APPENDED domain" << std::endl;
-      }
-    } else if (kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      if (data->appended_memory_id_to_corr_id.find(operation_id) ==
-          data->appended_memory_id_to_corr_id.end()) {
-        data->completed_without_appended++;
-        std::cerr << "ERROR: Completed mem_op_id " << operation_id
-                  << " was never seen in APPENDED domain" << std::endl;
-      }
-    }
-  }
-
-  static void VerifyAllAppendedCompleted(CallbackData* data) {
-    // Check kernels
-    for (const auto& [kernel_id, corr_id] : data->appended_kernel_id_to_corr_id) {
-      if (data->completed_kernel_id_to_corr_id.find(kernel_id) ==
-          data->completed_kernel_id_to_corr_id.end()) {
-        data->appended_without_completed++;
-        std::cerr << "ERROR: Appended kernel_id " << kernel_id << " (correlation_id " << corr_id
-                  << ") was never COMPLETED" << std::endl;
-      }
-    }
-
-    // Check memory operations
-    for (const auto& [mem_id, corr_id] : data->appended_memory_id_to_corr_id) {
-      if (data->completed_memory_id_to_corr_id.find(mem_id) ==
-          data->completed_memory_id_to_corr_id.end()) {
-        data->appended_without_completed++;
-        std::cerr << "ERROR: Appended mem_op_id " << mem_id << " (correlation_id " << corr_id
-                  << ") was never COMPLETED" << std::endl;
-      }
-    }
-  }
-
-  static void PrintOperationIdStats(CallbackData* data, const std::string& context) {
-    std::cout << "\n=== Operation ID Stats (" << context << ") ===" << std::endl;
-    std::cout << "  Unique kernel IDs (Callback): " << data->seen_kernel_operation_ids.size()
-              << std::endl;
-    std::cout << "  Unique memory IDs (Callback): " << data->seen_memory_operation_ids.size()
-              << std::endl;
-    std::cout << "  Unique kernel IDs (View): " << data->view_kernel_id_to_corr_id.size()
-              << std::endl;
-    std::cout << "  Unique memory IDs (View): " << data->view_memop_id_to_corr_id.size()
-              << std::endl;
-    std::cout << "  Duplicate kernel IDs in View: " << data->duplicate_kernel_ids.load()
-              << std::endl;
-    std::cout << "  Duplicate memory IDs in View: " << data->duplicate_memory_ids.load()
-              << std::endl;
-    std::cout << "  Zero operation IDs: " << data->zero_operation_ids.load() << std::endl;
-    std::cout << "  Kernel API ID mismatches (APPENDED): " << data->kernel_api_id_mismatch.load()
-              << std::endl;
-    std::cout << "  Memory API ID mismatches (APPENDED): " << data->memory_api_id_mismatch.load()
-              << std::endl;
-    std::cout << "  Completed without appended: " << data->completed_without_appended.load()
-              << std::endl;
-    std::cout << "  Appended without completed: " << data->appended_without_completed.load()
-              << std::endl;
-    std::cout << "========================================\n" << std::endl;
-  }
-
-  static void PushOrPopExternalCorrelation(bool is_push, CallbackData* data,
-                                           uint32_t correlation_id) {
-    if (is_push) {
-      // Push external correlation ID
-      uint64_t my_external_id = data->ext_correlation_data.next_external_id.fetch_add(1);
-      auto result = ptiViewPushExternalCorrelationId(
-          pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, my_external_id);
-
-      if (result == PTI_SUCCESS) {
-        data->ext_correlation_data.callback_corr_to_external[correlation_id] = my_external_id;
-        data->ext_correlation_data.callback_pushed_corr_ids.insert(correlation_id);
-        data->ext_correlation_data.push_count++;
-        std::cout << "Callback ENTER: Pushed external_id=" << my_external_id
-                  << " for correlation_id=" << correlation_id << std::endl;
-      } else {
-        data->ext_correlation_data.push_errors++;
-        std::cerr << "ERROR: Push failed with result=" << result << std::endl;
-      }
-    } else {
-      // Pop external correlation ID
-      uint64_t popped_external_id = 0;
-      auto result = ptiViewPopExternalCorrelationId(
-          pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &popped_external_id);
-
-      if (result == PTI_SUCCESS) {
-        data->ext_correlation_data.pop_count++;
-        std::cout << "Callback EXIT: Popped external_id=" << popped_external_id
-                  << " for correlation_id=" << correlation_id << std::endl;
-
-        // Verify popped ID matches what we pushed
-        auto it = data->ext_correlation_data.callback_corr_to_external.find(correlation_id);
-        if (it != data->ext_correlation_data.callback_corr_to_external.end()) {
-          EXPECT_EQ(it->second, popped_external_id)
-              << "Popped external_id doesn't match pushed external_id for correlation_id="
-              << correlation_id;
-        }
-      } else {
-        data->ext_correlation_data.pop_errors++;
-        std::cerr << "ERROR: Pop failed with result=" << result << std::endl;
-      }
-    }
-  }
-
-  // ============================================================================
-  // Helper functions for TestCallback
-  // ============================================================================
-
-  // Validates basic callback parameters common to all domains
-  static void ValidateCallbackParams(CallbackData* data, pti_callback_domain domain,
-                                     pti_api_group_id api_group_id, uint32_t driver_api_id,
-                                     pti_backend_ctx_t context) {
-    if (api_group_id != PTI_API_GROUP_LEVELZERO) {
-      data->all_callbacks_levelzero = false;
-      data->non_levelzero_count++;
-      std::cerr << "WARNING: Non-Level Zero API group: " << api_group_id << " (expected "
-                << PTI_API_GROUP_LEVELZERO << ", domain: " << domain << ")" << std::endl;
-    }
-
-    constexpr uint32_t RESERVED_DRIVER_LEVELZERO_ID = 0;
-    if (driver_api_id == RESERVED_DRIVER_LEVELZERO_ID) {
-      data->reserved_api_id_count++;
-      std::cerr << "WARNING: Reserved driver_api_id: " << driver_api_id << " (domain: " << domain
-                << ")" << std::endl;
-    }
-
-    if (context == nullptr) {
-      data->null_context_count++;
-      std::cerr << "WARNING: Null backend_context (domain: " << domain << ")" << std::endl;
-    }
-  }
-
-  // Validates GPU operation data
-  static void ValidateGpuOpData(CallbackData* data, pti_callback_gpu_op_data* gpu_op_data,
-                                const char* domain_name) {
-    if (gpu_op_data->_device_handle == nullptr) {
-      data->null_device_handle_count++;
-      std::cerr << "WARNING: " << domain_name << " callback with null device_handle" << std::endl;
-    }
-  }
-
-  // Handles phase-specific logic for APPENDED domain
-  static void HandlePhaseAppended(CallbackData* data, pti_callback_gpu_op_data* gpu_op_data) {
-    // removed from below CheckCommandListProperties(gpu_op_data->_cmd_list_properties)
-    // as immediate passed to queue creation per spec is just a hint
-    // and runtime might decide to ignore it
-
-    if (gpu_op_data->_phase == PTI_CB_PHASE_API_ENTER) {
-      data->enter_count++;
-      data->appended_enter_count++;
-
-      if (data->do_external_correlation_test) {
-        PushOrPopExternalCorrelation(true, data, gpu_op_data->_correlation_id);
-      }
-    } else if (gpu_op_data->_phase == PTI_CB_PHASE_API_EXIT) {
-      data->exit_count++;
-      data->appended_exit_count++;
-
-      if (data->do_external_correlation_test) {
-        PushOrPopExternalCorrelation(false, data, gpu_op_data->_correlation_id);
-
-        // PTI-457: having popped, push a different id from inside the same
-        // callback. The popped id must not be reported alongside this one.
-        if (data->do_pop_then_push_in_callback) {
-          const uint64_t repushed = data->ext_correlation_data.next_external_id.fetch_add(1);
-          if (ptiViewPushExternalCorrelationId(
-                  pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, repushed) ==
-              PTI_SUCCESS) {
-            data->ext_correlation_data.repushed_in_callback[gpu_op_data->_correlation_id] =
-                repushed;
-          } else {
-            data->ext_correlation_data.repush_errors++;
-          }
-        }
-      }
-    }
-  }
-
-  // Processes a single operation in APPENDED domain
-  static void ProcessSingleOperationAppended(CallbackData* data, const pti_gpu_op_details& op,
-                                             pti_callback_gpu_op_data* gpu_op_data,
-                                             uint32_t driver_api_id, pti_backend_ctx_t context) {
-    // Mark operation type as seen
-    if (op._operation_kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      data->kernel_seen = true;
-    } else if (op._operation_kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      data->memory_op_seen = true;
-    }
-
-    // Verify operation ID uniqueness and consistency
-    VerifyOperationIdUniqueness(op._operation_id, op._operation_kind, gpu_op_data->_correlation_id,
-                                data);
-    VerifyOperationIdConsistency(op._operation_id, op._operation_kind, driver_api_id, data);
-
-    // Track operation ID mapping
-    TrackOperationIdMapping(op._operation_id, op._operation_kind, gpu_op_data->_correlation_id,
-                            true, data);
-
-    // Check consistency if enabled
-    if (data->append_complete_all_phases && gpu_op_data->_operation_count == 1) {
-      CheckConsistencyAppendedEnterToExit(context, gpu_op_data, op, data);
-    }
-  }
-
-  // Processes a single operation in COMPLETED domain
-  static void ProcessSingleOperationCompleted(CallbackData* data, const pti_gpu_op_details& op,
-                                              pti_callback_gpu_op_data* gpu_op_data,
-                                              uint32_t index) {
-    std::cout << "\t ops: i: " << index << ", name: " << op._name
-              << " (kind: " << op._operation_kind << ", op id: " << op._operation_id << ")"
-              << std::endl;
-
-    // Verify this operation was previously appended
-    VerifyCompletedWasAppended(op._operation_id, op._operation_kind, data);
-
-    // Track operation ID mapping
-    TrackOperationIdMapping(op._operation_id, op._operation_kind, gpu_op_data->_correlation_id,
-                            false, data);
-
-    // Count by operation type
-    if (op._operation_kind == PTI_GPU_OPERATION_KIND_KERNEL) {
-      data->completed_kernel_count++;
-      data->RecordThreadKernel();
-    } else if (op._operation_kind == PTI_GPU_OPERATION_KIND_MEMORY) {
-      data->completed_memcopy_count++;
-    }
-  }
-
-  // Processes all operation details for APPENDED domain
-  static void ProcessOperationDetailsAppended(CallbackData* data,
-                                              pti_callback_gpu_op_data* gpu_op_data,
-                                              uint32_t driver_api_id, pti_backend_ctx_t context) {
-    if (gpu_op_data->_operation_count == 0 || !gpu_op_data->_operation_details) {
-      return;
-    }
-
-    for (uint32_t i = 0; i < gpu_op_data->_operation_count; ++i) {
-      ProcessSingleOperationAppended(data, gpu_op_data->_operation_details[i], gpu_op_data,
-                                     driver_api_id, context);
-    }
-  }
-
-  // Processes all operation details for COMPLETED domain
-  static void ProcessOperationDetailsCompleted(CallbackData* data,
-                                               pti_callback_gpu_op_data* gpu_op_data,
-                                               pti_backend_ctx_t context) {
-    if (gpu_op_data->_operation_count == 0 || !gpu_op_data->_operation_details) {
-      return;
-    }
-
-    for (uint32_t i = 0; i < gpu_op_data->_operation_count; ++i) {
-      ProcessSingleOperationCompleted(data, gpu_op_data->_operation_details[i], gpu_op_data, i);
-    }
-
-    if (data->append_complete_all_phases) {
-      CheckConsistencyCompletedToAppended(context, gpu_op_data, data);
-    }
-  }
-
-  // Handles APPENDED domain callback
-  static void HandleAppendedCallback(CallbackData* data, pti_callback_gpu_op_data* gpu_op_data,
-                                     uint32_t driver_api_id, pti_api_group_id api_group_id,
-                                     pti_backend_ctx_t context) {
-    data->appended_count++;
-    data->last_phase = gpu_op_data->_phase;
-
-    ValidateGpuOpData(data, gpu_op_data, "APPENDED");
-
-    PrintCallBackInfo("APPENDED", gpu_op_data->_phase, context, gpu_op_data->_device_handle,
-                      api_group_id, driver_api_id, gpu_op_data->_correlation_id,
-                      gpu_op_data->_operation_count, gpu_op_data->_operation_details);
-
-    HandlePhaseAppended(data, gpu_op_data);
-    ProcessOperationDetailsAppended(data, gpu_op_data, driver_api_id, context);
-  }
-
-  // Handles COMPLETED domain callback
-  static void HandleCompletedCallback(CallbackData* data, pti_callback_gpu_op_data* gpu_op_data,
-                                      uint32_t driver_api_id, pti_api_group_id api_group_id,
-                                      pti_backend_ctx_t context) {
-    data->completed_count++;
-    data->last_phase = gpu_op_data->_phase;
-
-    ValidateGpuOpData(data, gpu_op_data, "COMPLETED");
-
-    EXPECT_TRUE(gpu_op_data->_phase == PTI_CB_PHASE_API_EXIT)
-        << "COMPLETED domain should only have EXIT phase callbacks";
-
-    data->exit_count++;
-    data->completed_exit_count++;
-
-    PrintCallBackInfo("COMPLETED", gpu_op_data->_phase, context, gpu_op_data->_device_handle,
-                      api_group_id, driver_api_id, gpu_op_data->_correlation_id,
-                      gpu_op_data->_operation_count, gpu_op_data->_operation_details);
-
-    ProcessOperationDetailsCompleted(data, gpu_op_data, context);
-  }
-
-  // ============================================================================
-  // Main callback function - simplified with helper functions above
-  // ============================================================================
-  static void TestCallback(pti_callback_domain domain, pti_api_group_id driver_api_group_id,
-                           uint32_t driver_api_id, pti_backend_ctx_t backend_context, void* cb_data,
-                           void* global_user_data, [[maybe_unused]] void** instance_user_data) {
-    // Basic setup
-    auto* data = static_cast<CallbackData*>(global_user_data);
-    EXPECT_TRUE(data != nullptr) << "Global user data is null";
-
-    // Update global state
-    data->total_count++;
-    data->last_domain = domain;
-    data->last_api_group = driver_api_group_id;
-    data->user_data_received = global_user_data;
-    data->RecordThreadCallback();
-
-    // Validate common parameters
-    ValidateCallbackParams(data, domain, driver_api_group_id, driver_api_id, backend_context);
-
-    // Validate callback data exists
-    EXPECT_TRUE(cb_data != nullptr) << "cb_data is null for domain: " << domain;
-
-    // Dispatch to domain-specific handler
-    auto* gpu_op_data = static_cast<pti_callback_gpu_op_data*>(cb_data);
-
-    switch (domain) {
-      case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED:
-        HandleAppendedCallback(data, gpu_op_data, driver_api_id, driver_api_group_id,
-                               backend_context);
-        break;
-
-      case PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED:
-        HandleCompletedCallback(data, gpu_op_data, driver_api_id, driver_api_group_id,
-                                backend_context);
-        break;
-
-      default:
-        FAIL() << "Unexpected callback domain: " << domain;
-    }
-  }
-
-  void StopCollectionCommon() {
-    // Clean up PTI view and callback subscriptions
-    // Unsubscribe any remaining subscribers
-    for (auto& subscriber : subscribers_) {
-      if (subscriber) {
-        EXPECT_EQ(ptiCallbackUnsubscribe(subscriber), PTI_SUCCESS);
-      }
-    }
-    subscribers_.clear();
-
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  }
-
-  void SetUp() override {
-    // Set global pointer for BufferCompleted to access test data
-    g_callback_data = &callback_data_;
-
-    // For now, at least one PTI_VIEW_DEVICE_GPU needs to be enabled for callback API to work
-    EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  }
-
-  void TearDown() override {
-    StopCollectionCommon();
-    // Clear global pointers
-    g_callback_data = nullptr;
-  }
-
-  CallbackData callback_data_;
-  inline static bool command_list_immediate_{true};
-  std::vector<pti_callback_subscriber_handle> subscribers_;
-};
-
-bool SkipNonImmediateTestIfBMG(sycl::device& dev, bool& test_command_list_immediate) {
-  // Check Device name to know if it is BMG, and if it is - skip Non-immediate test as by
-  // https://intel.github.io/llvm/EnvironmentVariables.html#controlling-dpc-level-zero-adapter
-  // only immediate supported in 2025.3 on BMG
-  // It is expected to change in 2026.0
-  // and by the way: immediate /non-immediate is only a hint - so we can not 100% count on it
-  auto platform = dev.get_platform();
-  std::string device_name = dev.get_info<sycl::info::device::name>();
-  std::cout << "Device name: " << device_name << std::endl;
-  return (device_name.find("B580 Graphics") != std::string::npos ||
-          device_name.find("B570 Graphics") != std::string::npos) &&
-         (!test_command_list_immediate);
-}
-
-// ============================================================================
-//  TESTS START HERE
-// ============================================================================
-
-//
-// Test basic subscription with GPU kernel invocation
-//
-TEST_P(CallbackApiTest, BasicSubscription) {
-  std::cout << "\n=== Test: BasicSubscription ===" << std::endl;
-
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-
-  // Enable cross-checking data consistency between Append phases and Complete phase
-  callback_data_.append_complete_all_phases = true;
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Test successful subscription
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-
-  subscribers_.push_back(subscriber);
-
-  // Enable callbacks for GPU operation appended and completed
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    1,   // enable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-                                    1,   // enable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-
-  // Launch a GPU kernel
-  try {
-    command_list_immediate_ = GetParam();
-
-    sycl::device dev(sycl::gpu_selector_v);
-    if (SkipNonImmediateTestIfBMG(dev, command_list_immediate_)) {
-      GTEST_SKIP() << "Skipping Non-immediate command list test on BMG";
-    }
-    // Important that queue is in order
-    sycl::property_list prop;
-    if (command_list_immediate_) {
-      std::cout << " ** Immediate command list mode" << std::endl;
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::immediate_command_list()};
-    } else {
-      std::cout << " ** Non-immediate command list mode" << std::endl;
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::no_immediate_command_list()};
-    }
-    sycl::queue queue(dev, sycl::async_handler{}, prop);
-
-    unsigned size = kDefaultMatrixSize;
-    std::vector<float> a(size * size, A_VALUE);
-    std::vector<float> b(size * size, B_VALUE);
-    std::vector<float> c(size * size, 0.0f);
-
-    LaunchMultipleGEMMKernels(queue, a, b, c, size, kDefaultKernelCount);
-
-    // Verify last result
-    float expected_result = A_VALUE * B_VALUE * size;
-    float eps = Check(c, expected_result);
-    EXPECT_LE(eps, MAX_EPS);
-
-  } catch (const sycl::exception& e) {
-    FAIL() << "SYCL exception during kernel execution: " << e.what();
-  }
-
-  // Stop collection
-  StopCollectionCommon();
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-
-  // Flush views to ensure callbacks are processed
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // Verify callbacks were invoked
-  EXPECT_GT(callback_data_.total_count.load(), 0);
-  EXPECT_GT(callback_data_.appended_count.load(), 0);
-  EXPECT_TRUE(callback_data_.kernel_seen.load());
-
-  // Verify APPENDED domain ENTER/EXIT counts
-  // We expect both ENTER and EXIT callbacks for APPENDED domain
-  EXPECT_GT(callback_data_.appended_enter_count.load(), 0)
-      << "APPENDED domain ENTER callbacks should be called";
-  EXPECT_GT(callback_data_.appended_exit_count.load(), 0)
-      << "APPENDED domain EXIT callbacks should be called";
-
-  // The number of ENTER and EXIT callbacks should be equal for APPENDED domain
-  EXPECT_EQ(callback_data_.appended_enter_count.load(), callback_data_.appended_exit_count.load())
-      << "APPENDED domain should have equal number of ENTER and EXIT callbacks";
-
-  // Verify COMPLETED domain counts
-  // COMPLETED domain typically only has EXIT phase (as per the comment in the code)
-  EXPECT_EQ(callback_data_.completed_enter_count.load(), 0)
-      << "COMPLETED domain should not have ENTER callbacks";
-  // We may or may not get completed callbacks depending on timing
-  EXPECT_GE(callback_data_.completed_exit_count.load(), 0)
-      << "COMPLETED domain may have EXIT callbacks";
-
-  // Total enter/exit counts
-  EXPECT_GE(callback_data_.enter_count.load(), 0);
-  EXPECT_GE(callback_data_.exit_count.load(), 0);
-
-  // Print counts for debugging
-  std::cout << "\n=== Count Summary ===" << std::endl;
-  std::cout << "View Records:" << std::endl;
-  std::cout << "  Kernels: " << callback_data_.view_kernel_count.load() << std::endl;
-  std::cout << "  MemCopy: " << callback_data_.view_memcopy_count.load() << std::endl;
-  std::cout << "  MemFill: " << callback_data_.view_memfill_count.load() << std::endl;
-  std::cout << "Callback Completed Operations:" << std::endl;
-  std::cout << "  Kernels: " << callback_data_.completed_kernel_count.load() << std::endl;
-  std::cout << "  Memory Ops: " << callback_data_.completed_memcopy_count.load() << std::endl;
-  std::cout << "====================\n" << std::endl;
-
-  // Verify that counts from view records match counts from callback COMPLETED domain
-  // Note: The kernel count should match exactly
-  EXPECT_EQ(callback_data_.view_kernel_count.load(), callback_data_.completed_kernel_count.load())
-      << "Kernel count from ptiView should match count from Callback COMPLETED domain";
-
-  // Memory operations: view records distinguish between copy and fill,
-  // but callback API reports them all as MEMORY kind
-  int total_view_memory_ops =
-      callback_data_.view_memcopy_count.load() + callback_data_.view_memfill_count.load();
-  EXPECT_EQ(total_view_memory_ops, callback_data_.completed_memcopy_count.load())
-      << "Total memory operation count from ptiView should match count from Callback COMPLETED "
-         "domain";
-
-  // Verify that all callbacks had the correct API group (Level Zero)
-  EXPECT_TRUE(callback_data_.all_callbacks_levelzero.load())
-      << "All callbacks should have driver_api_group_id == PTI_API_GROUP_LEVELZERO";
-  EXPECT_EQ(callback_data_.non_levelzero_count.load(), 0)
-      << "No callbacks should have non-Level Zero API group";
-
-  // Verify that no callbacks had reserved API IDs
-  EXPECT_EQ(callback_data_.reserved_api_id_count.load(), 0)
-      << "No callbacks should have reserved driver_api_id";
-
-  // Verify that all callbacks had non-null backend_context
-  EXPECT_EQ(callback_data_.null_context_count.load(), 0)
-      << "All callbacks should have non-null backend_context";
-
-  // Verify that all GPU operation callbacks had non-null device_handle
-  EXPECT_EQ(callback_data_.null_device_handle_count.load(), 0)
-      << "All GPU operation callbacks (APPENDED and COMPLETED) should have non-null _device_handle";
-
-  // Verify the last API group was Level Zero (as a sanity check)
-  EXPECT_EQ(callback_data_.last_api_group, PTI_API_GROUP_LEVELZERO)
-      << "Last callback should have Level Zero API group";
-
-  // ============================================================================
-  // NEW: Verify operation ID tracking
-  // ============================================================================
-  std::cout << "\n=== Operation ID Verification ===" << std::endl;
-
-  EXPECT_EQ(callback_data_.zero_operation_ids.load(), 0) << "No operation IDs should be zero";
-
-  EXPECT_EQ(callback_data_.duplicate_kernel_ids.load(), 0)
-      << "All kernel operation IDs should be unique in View records";
-
-  EXPECT_EQ(callback_data_.duplicate_memory_ids.load(), 0)
-      << "All memory operation IDs should be unique in View records";
-
-  EXPECT_EQ(callback_data_.kernel_api_id_mismatch.load(), 0)
-      << "Kernel driver_api_id should be consistent within APPENDED domain for each kernel "
-         "operation ID";
-
-  EXPECT_EQ(callback_data_.memory_api_id_mismatch.load(), 0)
-      << "Memory driver_api_id should be consistent within APPENDED domain for each memory "
-         "operation ID";
-
-  // Verify operation lifecycle
-  EXPECT_EQ(callback_data_.completed_without_appended.load(), 0)
-      << "All completed operations should have been previously appended";
-
-  // Verify all appended operations were eventually completed
-  VerifyAllAppendedCompleted(&callback_data_);
-  EXPECT_EQ(callback_data_.appended_without_completed.load(), 0)
-      << "All appended operations should eventually be completed";
-
-  // Cross-verify between Callback and View APIs
-  EXPECT_EQ(callback_data_.seen_kernel_operation_ids.size(),
-            callback_data_.view_kernel_id_to_corr_id.size())
-      << "Kernel ID count mismatch between callback and view records";
-
-  for (const auto& kernel_id : callback_data_.seen_kernel_operation_ids) {
-    EXPECT_TRUE(callback_data_.view_kernel_id_to_corr_id.find(kernel_id) !=
-                callback_data_.view_kernel_id_to_corr_id.end())
-        << "Kernel operation_id " << kernel_id << " from callback not found in view records";
-  }
-
-  for (const auto& mem_id : callback_data_.seen_memory_operation_ids) {
-    EXPECT_TRUE(callback_data_.view_memop_id_to_corr_id.find(mem_id) !=
-                callback_data_.view_memop_id_to_corr_id.end())
-        << "Memory operation_id " << mem_id << " from callback not found in view records";
-  }
-
-  std::cout << "  Unique kernel operation IDs: " << callback_data_.seen_kernel_operation_ids.size()
-            << std::endl;
-  std::cout << "  Unique memory operation IDs: " << callback_data_.seen_memory_operation_ids.size()
-            << std::endl;
-  std::cout << "  View kernel records matched: " << callback_data_.view_kernel_id_to_corr_id.size()
-            << std::endl;
-  std::cout << "  View memory records matched: " << callback_data_.view_memop_id_to_corr_id.size()
-            << std::endl;
-
-  std::cout << "====================================\n" << std::endl;
-
-  // Print operation ID statistics
-  PrintOperationIdStats(&callback_data_, "BasicSubscription");
-
-  // Clean up
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-}
-
-//
-// Test subscription with null parameters
-//
-TEST_F(CallbackApiTest, SubscriptionWithNullParams) {
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Test with null subscriber handle pointer
-  EXPECT_NE(ptiCallbackSubscribe(nullptr, TestCallback, &callback_data_), PTI_SUCCESS);
-
-  // Test with null callback function
-  EXPECT_NE(ptiCallbackSubscribe(&subscriber, nullptr, &callback_data_), PTI_SUCCESS);
-
-  // User data can be null, so this should succeed
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, nullptr), PTI_SUCCESS);
-}
-
-//
-// Test domain enable and disable
-//
-TEST_F(CallbackApiTest, DomainEnableDisable) {
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe first
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  ASSERT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  // Enable domain for GPU operation appended
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    1,   // enable enter callback
-                                    1),  // enable exit callback
-            PTI_SUCCESS);
-
-  // Enable domain for GPU operation completed
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-                                    1,   // enable enter callback
-                                    1),  // enable exit callback
-            PTI_SUCCESS);
-
-  // Disable a domain
-  EXPECT_EQ(ptiCallbackDisableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED),
-            PTI_SUCCESS);
-
-  // Disable all domains
-  EXPECT_EQ(ptiCallbackDisableAllDomains(subscriber), PTI_SUCCESS);
-}
-
-//
-// Test enabling not implemented domains
-//
-TEST_F(CallbackApiTest, NotImplementedDomains) {
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe first
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  ASSERT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  // Try to enable not implemented domains
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_CONTEXT_CREATED, 1, 1),
-            PTI_ERROR_NOT_IMPLEMENTED);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_MODULE_LOADED, 1, 1),
-            PTI_ERROR_NOT_IMPLEMENTED);
-
-  EXPECT_EQ(
-      ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_DISPATCHED, 1, 1),
-      PTI_ERROR_NOT_IMPLEMENTED);
-}
-
-//
-// Test multiple subscribers
-//
-TEST_F(CallbackApiTest, MultipleSubscribers) {
-  const int num_subscribers = 3;
-  std::vector<std::unique_ptr<CallbackData>> callback_data_list;
-
-  // Create multiple subscribers
-  for (int i = 0; i < num_subscribers; ++i) {
-    callback_data_list.push_back(std::make_unique<CallbackData>());
-    pti_callback_subscriber_handle subscriber = nullptr;
-
-    EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, callback_data_list.back().get()),
-              PTI_SUCCESS);
-    EXPECT_NE(subscriber, nullptr);
-    subscribers_.push_back(subscriber);
-
-    // Enable different domains for different subscribers
-    if (i == 0) {
-      EXPECT_EQ(
-          ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-          PTI_SUCCESS);
-    } else if (i == 1) {
-      EXPECT_EQ(
-          ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1),
-          PTI_SUCCESS);
-    } else {
-      // Enable both domains for the third subscriber
-      EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1,
-                                        0),  // Only enter callback
-                PTI_SUCCESS);
-      EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 0,
-                                        1),  // Only exit callback
-                PTI_SUCCESS);
-    }
-  }
-
-  // Verify all subscribers are created
-  EXPECT_EQ(subscribers_.size(), num_subscribers);
-}
-
-//
-// Test unsubscribe with invalid handle
-//
-TEST_F(CallbackApiTest, SubscribeWithNullParamsUnsubscribeInvalidHandle) {
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Test with null subscriber handle pointer
-  EXPECT_NE(ptiCallbackSubscribe(nullptr, TestCallback, &callback_data_), PTI_SUCCESS);
-
-  // Test with null callback function
-  EXPECT_NE(ptiCallbackSubscribe(&subscriber, nullptr, &callback_data_), PTI_SUCCESS);
-
-  // User data can be null, so this should succeed
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, nullptr), PTI_SUCCESS);
-
-  EXPECT_NE(ptiCallbackUnsubscribe(nullptr), PTI_SUCCESS);
-
-  // Test with invalid (but non-null) handle
-  pti_callback_subscriber_handle invalid_handle =
-      reinterpret_cast<pti_callback_subscriber_handle>(0xDEADBEEF);
-  EXPECT_NE(ptiCallbackUnsubscribe(invalid_handle), PTI_SUCCESS);
-}
-
-// Test domain operations with invalid subscriber
-TEST_F(CallbackApiTest, DomainOpsInvalidSubscriber) {
-  // Test enable domain with null subscriber
-  EXPECT_EQ(ptiCallbackEnableDomain(nullptr, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  // Test disable domain with null subscriber
-  EXPECT_EQ(ptiCallbackDisableDomain(static_cast<pti_callback_subscriber_handle>(nullptr),
-                                     PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  // Test disable all domains with null subscriber
-  EXPECT_EQ(ptiCallbackDisableAllDomains(static_cast<pti_callback_subscriber_handle>(nullptr)),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-//
-// Test helper functions for string conversion
-//
-TEST_F(CallbackApiTest, StringConversionFunctions) {
-  // Test domain type to string
-  const char* domain_str =
-      ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED);
-  EXPECT_NE(domain_str, nullptr);
-  EXPECT_STRNE(domain_str, "");
-
-  domain_str = ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED);
-  EXPECT_NE(domain_str, nullptr);
-  EXPECT_STRNE(domain_str, "");
-
-  domain_str = ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_INVALID);
-  EXPECT_NE(domain_str, nullptr);
-
-  // Test phase type to string
-  const char* phase_str = ptiCallbackPhaseTypeToString(PTI_CB_PHASE_API_ENTER);
-  EXPECT_NE(phase_str, nullptr);
-  EXPECT_STRNE(phase_str, "");
-
-  phase_str = ptiCallbackPhaseTypeToString(PTI_CB_PHASE_API_EXIT);
-  EXPECT_NE(phase_str, nullptr);
-  EXPECT_STRNE(phase_str, "");
-
-  phase_str = ptiCallbackPhaseTypeToString(PTI_CB_PHASE_INVALID);
-  EXPECT_NE(phase_str, nullptr);
-}
-
-// Test selective phase enabling
-TEST_F(CallbackApiTest, SelectivePhaseEnable) {
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  ASSERT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  // Enable only enter callbacks
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    1,   // enable enter
-                                    0),  // disable exit
-            PTI_SUCCESS);
-
-  // Enable only exit callbacks
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-                                    0,   // disable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-
-  // Disable and re-enable with both phases
-  EXPECT_EQ(ptiCallbackDisableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED),
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    1,   // enable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-}
-
-//
-// Test multi-threaded kernel execution with callback API
-//
-TEST_F(CallbackApiTest, MultiThreadedKernelExecution) {
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-
-  // Enable cross-checking data consistency between Append phases and Complete phase
-  callback_data_.append_complete_all_phases = true;
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe and enable callbacks
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  // Enable callbacks for GPU operation appended and completed
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED,
-                                    1,   // enable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED,
-                                    1,   // enable enter
-                                    1),  // enable exit
-            PTI_SUCCESS);
-
-  // Launch kernels from multiple threads
-  const int num_threads = kDefaultThreadCount;
-  const int kernels_per_thread = kDefaultKernelCount;
-  std::vector<std::thread> threads;
-  std::vector<std::atomic<bool>> thread_success(num_threads);
-  std::vector<std::atomic<int>> thread_kernel_launches(num_threads);
-
-  for (int tid = 0; tid < num_threads; ++tid) {
-    thread_success[tid] = true;
-    thread_kernel_launches[tid] = 0;
-  }
-
-  for (int tid = 0; tid < num_threads; ++tid) {
-    threads.emplace_back([&, tid]() {
-      try {
-        sycl::device dev(sycl::gpu_selector_v);
-        sycl::property_list prop{sycl::property::queue::in_order()};
-        sycl::queue queue(dev, sycl::async_handler{}, prop);
-
-        for (int i = 0; i < kernels_per_thread; ++i) {
-          unsigned size = 32;  // Small matrix for testing
-          std::vector<float> a(size * size, A_VALUE);
-          std::vector<float> b(size * size, B_VALUE);
-          std::vector<float> c(size * size, 0.0f);
-
-          LaunchMultipleGEMMKernels(queue, a, b, c, size, kDefaultKernelCount);
-          thread_kernel_launches[tid]++;
-
-          // Verify result
-          float expected_result = A_VALUE * B_VALUE * size;
-          float eps = Check(c, expected_result);
-          if (eps > MAX_EPS) {
-            thread_success[tid] = false;
-            std::cerr << "Thread " << tid << " kernel " << i << " failed with eps=" << eps
-                      << std::endl;
-          }
-        }
-      } catch (const sycl::exception& e) {
-        std::cerr << "Thread " << tid << " failed: " << e.what() << std::endl;
-        thread_success[tid] = false;
-      }
-    });
-  }
-
-  // Wait for all threads to complete
-  for (auto& t : threads) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-
-  // Verify all threads succeeded
-  for (int tid = 0; tid < num_threads; ++tid) {
-    EXPECT_TRUE(thread_success[tid]) << "Thread " << tid << " failed";
-    EXPECT_EQ(thread_kernel_launches[tid].load(), kernels_per_thread)
-        << "Thread " << tid << " didn't complete all kernel launches";
-  }
-
-  // Stop Collection
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-  StopCollectionCommon();
-
-  // Flush views to ensure callbacks are processed
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // Verify callbacks were invoked for all kernels
-  int expected_min_kernels = num_threads * kernels_per_thread;
-  EXPECT_GE(callback_data_.completed_kernel_count.load(), expected_min_kernels)
-      << "Expected at least " << expected_min_kernels << " kernel completions";
-
-  // Verify we got callbacks from multiple threads
-  {
-    std::lock_guard<std::mutex> lock(callback_data_.thread_map_mutex);
-    size_t num_threads_with_callbacks = callback_data_.thread_callback_counts.size();
-    EXPECT_GT(num_threads_with_callbacks, 1)
-        << "Expected callbacks from multiple threads, but got callbacks from "
-        << num_threads_with_callbacks << " thread(s)";
-
-    // Print thread callback distribution for debugging
-    std::cout << "\n=== Thread Callback Distribution ===" << std::endl;
-    for (const auto& [tid, count] : callback_data_.thread_callback_counts) {
-      std::cout << "Thread ID " << tid << ": " << count << " callbacks" << std::endl;
-    }
-
-    std::cout << "\n=== Thread Kernel Distribution ===" << std::endl;
-    for (const auto& [tid, count] : callback_data_.thread_kernel_counts) {
-      std::cout << "Thread ID " << tid << ": " << count << " kernels" << std::endl;
-    }
-    std::cout << "====================================\n" << std::endl;
-  }
-
-  // Verify thread safety - no corrupted counters
-  EXPECT_TRUE(callback_data_.all_callbacks_levelzero.load())
-      << "All callbacks should have driver_api_group_id == PTI_API_GROUP_LEVELZERO";
-  EXPECT_EQ(callback_data_.null_context_count.load(), 0)
-      << "All callbacks should have non-null backend_context";
-  EXPECT_EQ(callback_data_.null_device_handle_count.load(), 0)
-      << "All GPU operation callbacks should have non-null _device_handle";
-
-  // ============================================================================
-  // NEW: Verify operation ID tracking in multi-threaded context
-  // ============================================================================
-  std::cout << "\n=== Multi-threaded Operation ID Verification ===" << std::endl;
-
-  EXPECT_EQ(callback_data_.duplicate_kernel_ids.load(), 0)
-      << "All kernel operation IDs should be unique in View records (multi-threaded)";
-
-  EXPECT_EQ(callback_data_.duplicate_memory_ids.load(), 0)
-      << "All memory operation IDs should be unique in View records (multi-threaded)";
-
-  EXPECT_EQ(callback_data_.completed_without_appended.load(), 0)
-      << "All completed operations should have been previously appended (multi-threaded)";
-
-  VerifyAllAppendedCompleted(&callback_data_);
-  EXPECT_EQ(callback_data_.appended_without_completed.load(), 0)
-      << "All appended operations should eventually be completed (multi-threaded)";
-
-  std::cout << "  Unique kernel IDs (multi-threaded): "
-            << callback_data_.seen_kernel_operation_ids.size() << std::endl;
-  std::cout << "  Unique memory IDs (multi-threaded): "
-            << callback_data_.seen_memory_operation_ids.size() << std::endl;
-
-  PrintOperationIdStats(&callback_data_, "MultiThreadedKernelExecution");
-}
-
-//
-// Test concurrent queue submissions with synchronization
-//
-TEST_F(CallbackApiTest, ConcurrentQueueSubmissions) {
-  // Enable additional ptiView
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-
-  // Enable cross-checking data consistency between Append phases and Complete phase
-  callback_data_.append_complete_all_phases = true;
-
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe and enable callbacks
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1),
-            PTI_SUCCESS);
-
-  const int num_threads = kConcurrentThreadCount;
-  const int submissions_per_thread = kConcurrentSubmissions;
-
-  // Use a barrier to synchronize thread start (C++20 feature)
-  // If barrier is not available, use condition variable
-  std::mutex start_mutex;
-  std::condition_variable start_cv;
-  std::atomic<int> threads_ready{0};
-  bool start_flag = false;
-
-  std::vector<std::thread> threads;
-  std::vector<std::atomic<bool>> thread_results(num_threads);
-  std::vector<std::atomic<int>> thread_submission_counts(num_threads);
-
-  for (int tid = 0; tid < num_threads; ++tid) {
-    thread_results[tid] = true;
-    thread_submission_counts[tid] = 0;
-  }
-
-  auto worker = [&](int tid) {
-    try {
-      sycl::device dev(sycl::gpu_selector_v);
-      sycl::queue queue(dev);
-
-      // Signal ready and wait for start
-      {
-        std::unique_lock<std::mutex> lock(start_mutex);
-        threads_ready++;
-        start_cv.notify_all();  // Notify main thread that this thread is ready
-        start_cv.wait(lock, [&] { return start_flag; });
-      }
-
-      // Rapid-fire submissions
-      for (int i = 0; i < submissions_per_thread; ++i) {
-        unsigned size = kSmallMatrixSize;
-        std::vector<float> a(size * size, A_VALUE);
-        std::vector<float> b(size * size, B_VALUE);
-        std::vector<float> c(size * size, 0.0f);
-
-        // Mix kernel and memory operations
-        if (i % 3 == 0) {
-          // Memory copy operation
-          sycl::buffer<float, 1> src_buf(a.data(), a.size());
-          sycl::buffer<float, 1> dst_buf(c.data(), c.size());
-
-          queue.submit([&](sycl::handler& cgh) {
-            auto src_acc = src_buf.get_access<sycl::access::mode::read>(cgh);
-            auto dst_acc = dst_buf.get_access<sycl::access::mode::write>(cgh);
-            cgh.copy(std::move(src_acc), std::move(dst_acc));
-          });
-        } else {
-          // Kernel operation
-          LaunchMultipleGEMMKernels(queue, a, b, c, size, kDefaultKernelCount);
-        }
-
-        thread_submission_counts[tid]++;
-      }
-
-      queue.wait_and_throw();
-    } catch (const sycl::exception& e) {
-      std::cerr << "Thread " << tid << " failed: " << e.what() << std::endl;
-      thread_results[tid] = false;
-    }
-  };
-
-  // Create all threads
-  for (int i = 0; i < num_threads; ++i) {
-    threads.emplace_back(worker, i);
-  }
-
-  // Wait for all threads to be ready
-  {
-    std::unique_lock<std::mutex> lock(start_mutex);
-    start_cv.wait(lock, [&] { return threads_ready == num_threads; });
-  }
-
-  // Start all threads simultaneously
-  {
-    std::lock_guard<std::mutex> lock(start_mutex);
-    start_flag = true;
-  }
-  start_cv.notify_all();
-
-  // Wait for all threads to complete
-  for (auto& t : threads) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-
-  // Verify all threads completed successfully
-  for (int tid = 0; tid < num_threads; ++tid) {
-    EXPECT_TRUE(thread_results[tid]) << "Thread " << tid << " failed";
-    EXPECT_EQ(thread_submission_counts[tid].load(), submissions_per_thread)
-        << "Thread " << tid << " didn't complete all submissions";
-  }
-
-  // Stop Collection
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  StopCollectionCommon();
-  // Flush views
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // Verify callbacks were invoked
-  EXPECT_GT(callback_data_.total_count.load(), 0) << "No callbacks were invoked";
-  EXPECT_GT(callback_data_.appended_count.load(), 0) << "No APPENDED callbacks were invoked";
-
-  // Verify both kernel and memory operations were seen
-  EXPECT_TRUE(callback_data_.kernel_seen.load()) << "No kernel operations were detected";
-  EXPECT_TRUE(callback_data_.memory_op_seen.load()) << "No memory operations were detected";
-
-  // Print statistics
-  std::cout << "\n=== Concurrent Submission Statistics ===" << std::endl;
-  std::cout << "Total callbacks: " << callback_data_.total_count.load() << std::endl;
-  std::cout << "Appended callbacks: " << callback_data_.appended_count.load() << std::endl;
-  std::cout << "Completed callbacks: " << callback_data_.completed_count.load() << std::endl;
-  std::cout << "Kernel operations: " << callback_data_.completed_kernel_count.load() << std::endl;
-  std::cout << "Memory operations: " << callback_data_.completed_memcopy_count.load() << std::endl;
-
-  {
-    std::lock_guard<std::mutex> lock(callback_data_.thread_map_mutex);
-    std::cout << "Unique threads with callbacks: " << callback_data_.thread_callback_counts.size()
-              << std::endl;
-  }
-  std::cout << "========================================\n" << std::endl;
-
-  // ============================================================================
-  // NEW: Verify operation ID uniqueness under concurrent submissions
-  // ============================================================================
-  EXPECT_EQ(callback_data_.duplicate_kernel_ids.load(), 0)
-      << "All kernel operation IDs should be unique in View records (concurrent)";
-
-  EXPECT_EQ(callback_data_.duplicate_memory_ids.load(), 0)
-      << "All memory operation IDs should be unique in View records (concurrent)";
-
-  EXPECT_EQ(callback_data_.completed_without_appended.load(), 0)
-      << "All completed operations should have been previously appended (concurrent)";
-
-  VerifyAllAppendedCompleted(&callback_data_);
-  EXPECT_EQ(callback_data_.appended_without_completed.load(), 0)
-      << "All appended operations should eventually be completed (concurrent)";
-
-  std::cout << "Unique kernel operation IDs (concurrent): "
-            << callback_data_.seen_kernel_operation_ids.size() << std::endl;
-  std::cout << "Unique memory operation IDs (concurrent): "
-            << callback_data_.seen_memory_operation_ids.size() << std::endl;
-
-  PrintOperationIdStats(&callback_data_, "ConcurrentQueueSubmissions");
-}
-
-//
-// Test callback thread safety with shared queue
-//
-TEST_F(CallbackApiTest, CallbackThreadSafety) {
-  // Thread-safe callback data structure
-  struct ThreadSafeCallbackData {
-    std::mutex mutex;
-    std::vector<std::pair<std::thread::id, pti_callback_domain>> callback_log;
-    std::atomic<int> total_callbacks{0};
-
-    void LogCallback(pti_callback_domain domain) {
-      std::lock_guard<std::mutex> lock(mutex);
-      callback_log.emplace_back(std::this_thread::get_id(), domain);
-      total_callbacks++;
-    }
-  };
-
-  auto thread_safe_data = std::make_unique<ThreadSafeCallbackData>();
-
-  // Thread-safe callback that logs calls
-  auto ThreadSafeCallback = [](pti_callback_domain domain, pti_api_group_id /*driver_api_group_id*/,
-                               uint32_t /*driver_api_id*/, pti_backend_ctx_t /*backend_context*/,
-                               void* /*cb_data*/, void* global_user_data,
-                               void** /*instance_user_data*/) {
-    auto* data = static_cast<ThreadSafeCallbackData*>(global_user_data);
-    if (data) {
-      // Simulate some processing to increase chance of race conditions
-      std::this_thread::sleep_for(std::chrono::microseconds(10));
-      data->LogCallback(domain);
-    }
-  };
-
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe with thread-safe callback
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, ThreadSafeCallback, thread_safe_data.get()),
-            PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1),
-            PTI_SUCCESS);
-
-  // Create a shared queue for all threads
-  sycl::device dev(sycl::gpu_selector_v);
-  sycl::queue shared_queue(dev);
-
-  const int num_threads = kThreadSafetyThreadCount;
-  const int kernels_per_thread = kThreadSafetyKernelCount;
-  std::vector<std::thread> threads;
-
-  // Launch kernels from multiple threads using shared queue
-  for (int tid = 0; tid < num_threads; ++tid) {
-    threads.emplace_back([&, tid]() {
-      try {
-        for (int i = 0; i < kernels_per_thread; ++i) {
-          unsigned size = kSmallMatrixSize;
-          std::vector<float> a(size * size, A_VALUE);
-          std::vector<float> b(size * size, B_VALUE);
-          std::vector<float> c(size * size, 0.0f);
-
-          // Use the shared queue
-          LaunchMultipleGEMMKernels(shared_queue, a, b, c, size, kDefaultKernelCount);
-
-          // Small delay to interleave operations
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        }
-      } catch (const sycl::exception& e) {
-        std::cerr << "Thread " << tid << " failed: " << e.what() << std::endl;
-      }
-    });
-  }
-
-  // Wait for all threads to complete
-  for (auto& t : threads) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-
-  // Stop Collection
-  StopCollectionCommon();
-
-  // Flush views
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // Verify callback log integrity
-  {
-    std::lock_guard<std::mutex> lock(thread_safe_data->mutex);
-
-    // Check that we got callbacks
-    EXPECT_GT(thread_safe_data->total_callbacks.load(), 0) << "No callbacks were recorded";
-
-    // Count unique thread IDs in callback log
-    std::set<std::thread::id> unique_threads;
-    std::map<pti_callback_domain, int> domain_counts;
-
-    for (const auto& [tid, domain] : thread_safe_data->callback_log) {
-      unique_threads.insert(tid);
-      domain_counts[domain]++;
-    }
-
-    // We expect callbacks from multiple threads
-    EXPECT_GT(unique_threads.size(), 1)
-        << "Expected callbacks from multiple threads, but got callbacks from "
-        << unique_threads.size() << " thread(s)";
-
-    // Print statistics
-    std::cout << "\n=== Thread Safety Test Statistics ===" << std::endl;
-    std::cout << "Total callbacks logged: " << thread_safe_data->total_callbacks.load()
-              << std::endl;
-    std::cout << "Unique threads in log: " << unique_threads.size() << std::endl;
-    std::cout << "Callback log entries: " << thread_safe_data->callback_log.size() << std::endl;
-
-    for (const auto& [domain, count] : domain_counts) {
-      const char* domain_name = ptiCallbackDomainTypeToString(domain);
-      std::cout << "Domain " << (domain_name ? domain_name : "unknown") << ": " << count
-                << " callbacks" << std::endl;
-    }
-    std::cout << "====================================\n" << std::endl;
-
-    // Verify log consistency
-    EXPECT_EQ(thread_safe_data->callback_log.size(),
-              static_cast<size_t>(thread_safe_data->total_callbacks.load()))
-        << "Callback log size doesn't match total callbacks counter";
-  }
-}
-
-//
-// Test external correlation API when called from Append Enter/Exit callbacks
-//
-TEST_P(CallbackApiTest, ExternalCorrelationInAppendCallbacks) {
-  std::cout << "\n=== Test: ExternalCorrelationInAppendCallbacks ===" << std::endl;
-
-  callback_data_.do_external_correlation_test = true;
-  pti_callback_subscriber_handle subscriber = nullptr;
-
-  // Subscribe for Callbacks
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_COMPLETED, 1, 1),
-            PTI_SUCCESS);
-
-  // Set up ptiView callbacks (using existing BufferRequested/BufferCompleted)
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), PTI_SUCCESS);
-
-  // Limit to GPU operation core APIs only (reduces noise)
-  EXPECT_EQ(
-      ptiViewEnableDriverApiClass(1, PTI_API_CLASS_GPU_OPERATION_CORE, PTI_API_GROUP_LEVELZERO),
-      PTI_SUCCESS);
-
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), PTI_SUCCESS);
-
-  // Launch GPU kernels (single-threaded)
-  try {
-    command_list_immediate_ = GetParam();
-    sycl::device dev(sycl::gpu_selector_v);
-    if (SkipNonImmediateTestIfBMG(dev, command_list_immediate_)) {
-      GTEST_SKIP() << "Skipping Non-immediate command list test on BMG";
-    }
-    // Important that queue is in order
-    sycl::property_list prop;
-    if (command_list_immediate_) {
-      std::cout << " ** Immediate command list mode" << std::endl;
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::immediate_command_list()};
-    } else {
-      std::cout << " ** Non-immediate command list mode" << std::endl;
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::no_immediate_command_list()};
-    }
-    sycl::queue queue(dev, sycl::async_handler{}, prop);
-
-    unsigned size = kDefaultMatrixSize;
-    std::vector<float> a(size * size, A_VALUE);
-    std::vector<float> b(size * size, B_VALUE);
-    std::vector<float> c(size * size, 0.0f);
-
-    LaunchMultipleGEMMKernels(queue, a, b, c, size, kDefaultKernelCount);
-
-    // Verify the last result
-    float expected_result = A_VALUE * B_VALUE * size;
-    float eps = Check(c, expected_result);
-    EXPECT_LE(eps, MAX_EPS) << "GEMM kernel " << kDefaultKernelCount - 1 << " verification failed";
-
-  } catch (const sycl::exception& e) {
-    FAIL() << "SYCL exception during kernel execution: " << e.what();
-  }
-
-  // Stop Collection
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), PTI_SUCCESS);
-
-  StopCollectionCommon();
-
-  // Flush views to ensure callbacks are processed
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // VERIFICATION
-
-  std::cout << "\n========== External Correlation Test Verification ==========" << std::endl;
-
-  const auto& external_corr_test_data_ = callback_data_.ext_correlation_data;
-  // 1. Basic balance checks
-  EXPECT_EQ(external_corr_test_data_.push_count.load(), external_corr_test_data_.pop_count.load())
-      << "Push and pop operations should be balanced";
-  EXPECT_EQ(external_corr_test_data_.push_errors.load(), 0) << "No push errors expected";
-  EXPECT_EQ(external_corr_test_data_.pop_errors.load(), 0) << "No pop errors expected";
-
-  std::cout << "Push count: " << external_corr_test_data_.push_count.load() << std::endl;
-  std::cout << "Pop count: " << external_corr_test_data_.pop_count.load() << std::endl;
-
-  // 2. For each external ID pushed in callbacks, verify view records
-  for (const auto& [callback_corr_id, external_id] :
-       external_corr_test_data_.callback_corr_to_external) {
-    // 2a. External correlation record must exist
-    EXPECT_TRUE(external_corr_test_data_.view_external_to_corr.find(external_id) !=
-                external_corr_test_data_.view_external_to_corr.end())
-        << "External correlation record not found for external_id: " << external_id;
-
-    // 2b. Correlation ID from callback must match view record
-    if (external_corr_test_data_.view_external_to_corr.find(external_id) !=
-        external_corr_test_data_.view_external_to_corr.end()) {
-      const auto& view_corr_id = external_corr_test_data_.view_external_to_corr.at(external_id);
-      EXPECT_EQ(callback_corr_id, view_corr_id)
-          << "Correlation ID mismatch: callback=" << callback_corr_id << " vs view=" << view_corr_id
-          << " for external_id=" << external_id;
-    }
-
-    // 2c. This correlation_id should have a DRIVER API record (not runtime)
-    EXPECT_TRUE(external_corr_test_data_.view_driver_api_records.find(callback_corr_id) !=
-                external_corr_test_data_.view_driver_api_records.end())
-        << "Driver API record not found for correlation_id: " << callback_corr_id;
-  }
-
-  // 3. Verify all external correlation records link to DRIVER API (not runtime)
-  for (const auto& [external_id, corr_id] : external_corr_test_data_.view_external_to_corr) {
-    EXPECT_TRUE(external_corr_test_data_.view_driver_api_records.find(corr_id) !=
-                external_corr_test_data_.view_driver_api_records.end())
-        << "External correlation (external_id=" << external_id
-        << ") references non-existent Driver API record (correlation_id=" << corr_id << ")";
-
-    EXPECT_TRUE(external_corr_test_data_.view_runtime_api_records.find(corr_id) !=
-                external_corr_test_data_.view_runtime_api_records.end())
-        << "Have not seen Runtime API record counterpart to Driver API record "
-        << "(correlation_id=" << corr_id << ") which is expected to exist";
-  }
-
-  // 4. Verify proper ordering and API type constraints
-  EXPECT_TRUE(external_corr_test_data_.ordering_violations.empty())
-      << "Found " << external_corr_test_data_.ordering_violations.size() << " ordering violations";
-
-  if (!external_corr_test_data_.ordering_violations.empty()) {
-    std::cerr << "\nOrdering violations detected:" << std::endl;
-    for (const auto& violation : external_corr_test_data_.ordering_violations) {
-      std::cerr << "  Driver API without preceding external correlation: api_id="
-                << violation.api_id << ", correlation_id=" << violation.correlation_id << std::endl;
-    }
-  }
-
-  // 5. Verify expected operation count
-  EXPECT_GE(external_corr_test_data_.push_count.load(), kDefaultKernelCount)
-      << "Expected at least " << kDefaultKernelCount << " kernel operations";
-
-  // 6. Print summary
-  std::cout << "\n=== External Correlation Test Summary ===" << std::endl;
-  std::cout << "External correlations pushed: " << external_corr_test_data_.push_count.load()
-            << std::endl;
-  std::cout << "External correlation records in view: "
-            << external_corr_test_data_.view_external_to_corr.size() << std::endl;
-  std::cout << "Driver API records: " << external_corr_test_data_.view_driver_api_records.size()
-            << std::endl;
-  std::cout << "Runtime API records: " << external_corr_test_data_.view_runtime_api_records.size()
-            << std::endl;
-  std::cout << "========================================\n" << std::endl;
-
-  // ============================================================================
-  // NEW: Verify operation IDs with external correlation enabled
-  // ============================================================================
-  EXPECT_EQ(callback_data_.duplicate_kernel_ids.load(), 0)
-      << "All kernel operation IDs should be unique in View records (external correlation)";
-
-  EXPECT_EQ(callback_data_.duplicate_memory_ids.load(), 0)
-      << "All memory operation IDs should be unique in View records (external correlation)";
-
-  EXPECT_EQ(callback_data_.completed_without_appended.load(), 0)
-      << "All completed operations should have been previously appended (external correlation)";
-
-  VerifyAllAppendedCompleted(&callback_data_);
-  EXPECT_EQ(callback_data_.appended_without_completed.load(), 0)
-      << "All appended operations should eventually be completed (external correlation)";
-
-  std::cout << "  Kernel IDs seen in APPENDED: "
-            << callback_data_.appended_kernel_id_to_corr_id.size() << std::endl;
-  std::cout << "  Kernel IDs seen in COMPLETED: "
-            << callback_data_.completed_kernel_id_to_corr_id.size() << std::endl;
-  std::cout << "  Memory IDs seen in APPENDED: "
-            << callback_data_.appended_memory_id_to_corr_id.size() << std::endl;
-  std::cout << "  Memory IDs seen in COMPLETED: "
-            << callback_data_.completed_memory_id_to_corr_id.size() << std::endl;
-
-  PrintOperationIdStats(&callback_data_, "ExternalCorrelationInAppendCallbacks");
-}
-
-//
-// PTI-457: an id popped from inside a subscriber callback must not be reported
-// alongside an id pushed after it. The invariant is that every external
-// correlation record sharing a (_correlation_id, _external_kind) pair carries
-// the *same* _external_id -- not that exactly one record exists. This test
-// enables both the Runtime and Driver views, and an operation reported by both
-// collector paths legitimately produces more than one record; those records
-// agree. When the stale popped id was emitted too, the records disagreed and a
-// consumer keyed on that pair could report the already-popped id.
-//
-TEST_P(CallbackApiTest, ExternalCorrelationPopThenPushInCallbackKeepsOneExternalIdPerPair) {
-  std::cout << "\n=== Test: ExternalCorrelationPopThenPushInCallbackKeepsOneExternalIdPerPair ==="
-            << std::endl;
-
-  callback_data_.do_external_correlation_test = true;
-  callback_data_.do_pop_then_push_in_callback = true;
-
-  pti_callback_subscriber_handle subscriber = nullptr;
-  EXPECT_EQ(ptiCallbackSubscribe(&subscriber, TestCallback, &callback_data_), PTI_SUCCESS);
-  EXPECT_NE(subscriber, nullptr);
-  subscribers_.push_back(subscriber);
-
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_GPU_OPERATION_APPENDED, 1, 1),
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), PTI_SUCCESS);
-  EXPECT_EQ(
-      ptiViewEnableDriverApiClass(1, PTI_API_CLASS_GPU_OPERATION_CORE, PTI_API_GROUP_LEVELZERO),
-      PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), PTI_SUCCESS);
-
-  try {
-    command_list_immediate_ = GetParam();
-    sycl::device dev(sycl::gpu_selector_v);
-    if (SkipNonImmediateTestIfBMG(dev, command_list_immediate_)) {
-      GTEST_SKIP() << "Skipping Non-immediate command list test on BMG";
-    }
-    sycl::property_list prop;
-    if (command_list_immediate_) {
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::immediate_command_list()};
-    } else {
-      prop = sycl::property_list{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::no_immediate_command_list()};
-    }
-    sycl::queue queue(dev, sycl::async_handler{}, prop);
-
-    unsigned size = kDefaultMatrixSize;
-    std::vector<float> a(size * size, A_VALUE);
-    std::vector<float> b(size * size, B_VALUE);
-    std::vector<float> c(size * size, 0.0f);
-
-    LaunchMultipleGEMMKernels(queue, a, b, c, size, kDefaultKernelCount);
-  } catch (const sycl::exception& e) {
-    FAIL() << "SYCL exception during kernel execution: " << e.what();
-  }
-
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), PTI_SUCCESS);
-
-  StopCollectionCommon();
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  const auto& data = callback_data_.ext_correlation_data;
-
-  ASSERT_EQ(data.repush_errors.load(), 0)
-      << "a re-push from inside the callback failed, so the records below were never exercised";
-  ASSERT_FALSE(data.repushed_in_callback.empty())
-      << "no id was ever re-pushed from inside a callback, nothing was verified";
-  ASSERT_FALSE(data.ext_ids_per_corr_and_kind.empty())
-      << "no external correlation records were produced, nothing was verified";
-
-  // The defect: an id popped inside a subscriber callback was reported again on
-  // a later operation that already had a live id, so one pair carried two
-  // conflicting external ids -- the live one and the stale one.
-  int offending_pairs = 0;
-  for (const auto& [pair, ids] : data.ext_ids_per_corr_and_kind) {
-    if (ids.size() != 1) {
-      offending_pairs++;
-      std::string id_list;
-      for (auto id : ids) {
-        id_list += (id_list.empty() ? "" : ", ") + std::to_string(id);
-      }
-      ADD_FAILURE() << "correlation_id=" << pair.first << " kind=" << pair.second
-                    << " was labelled with " << ids.size() << " conflicting external ids {"
-                    << id_list
-                    << "}; a consumer cannot resolve which one labels this operation (PTI-457)";
-    }
-  }
-
-  std::cout << "Pairs checked: " << data.ext_ids_per_corr_and_kind.size()
-            << ", offending: " << offending_pairs << std::endl;
-
-  // Checking the ids merely agree is not enough on its own: a regression that
-  // dropped the live record and emitted only the stale popped one would still
-  // leave a single id per pair. Pin the id to the one the callback made live.
-  constexpr uint32_t kCustom0 =
-      static_cast<uint32_t>(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0);
-  for (const auto& [corr_id, expected_id] : data.repushed_in_callback) {
-    const auto it = data.ext_ids_per_corr_and_kind.find({corr_id, kCustom0});
-    if (it == data.ext_ids_per_corr_and_kind.end()) {
-      ADD_FAILURE() << "correlation_id=" << corr_id << " pushed external id " << expected_id
-                    << " from inside its callback but produced no external correlation record";
-      continue;
-    }
-    EXPECT_TRUE(it->second.count(expected_id) != 0)
-        << "correlation_id=" << corr_id << " should carry the external id " << expected_id
-        << " made live from inside its callback, but did not";
-  }
-
-  // Each callback pops one id and pushes one, so the stack depth is unchanged
-  // and only the most recently re-pushed id sits on top -- the ids below it
-  // were pushed by the harness, not by the callbacks. So only the first pop has
-  // a value this test can predict; the rest just drain the stack.
-  auto newest = data.repushed_in_callback.rbegin();
-  if (newest != data.repushed_in_callback.rend()) {
-    uint64_t popped = 0;
-    EXPECT_EQ(ptiViewPopExternalCorrelationId(
-                  pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &popped),
-              PTI_SUCCESS);
-    EXPECT_EQ(popped, newest->second)
-        << "the id pushed from inside the last callback did not stay live on the stack";
-    for (auto it = std::next(newest); it != data.repushed_in_callback.rend(); ++it) {
-      EXPECT_EQ(ptiViewPopExternalCorrelationId(
-                    pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &popped),
-                PTI_SUCCESS);
-    }
-  }
-}
-
-INSTANTIATE_TEST_SUITE_P(Parametrized, CallbackApiTest, ::testing::Values(false, true),
-                         [](const testing::TestParamInfo<bool>& info) {
-                           return fmt::format("Queue_Type_{}", info.param
-                                                                   ? "ImmediateCommandList"
-                                                                   : "NonImmediateCommandList");
-                         });
diff --git a/sdk/test/callback_kernel_lifecycle_test.cc b/sdk/test/callback_kernel_lifecycle_test.cc
deleted file mode 100644
index 0a3ce092..00000000
--- a/sdk/test/callback_kernel_lifecycle_test.cc
+++ /dev/null
@@ -1,377 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Tests for the PTI Callback API kernel-lifecycle domains:
-//   - PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED
-//   - PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED
-//
-// Two test surfaces:
-//   1. Direct Level-Zero: explicit zeKernelCreate / zeKernelDestroy
-//      calls and verification that callbacks fire with matching handle/name.
-//   2. SYCL: run a SYCL kernel; the SYCL runtime triggers L0 kernel
-//      create/destroy under the hood and the callbacks should still fire.
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <atomic>
-#include <cstdlib>
-#include <mutex>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <unordered_set>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_view.h"
-#include "utils.h"
-
-namespace {
-
-constexpr size_t kBufferSize = 64 * 1024;
-constexpr int kLifecycleKernelCount = 3;
-constexpr char kLifecycleKernelName[] = "GEMM";
-
-// ----------------------------------------------------------------------------
-// Shared callback observation state
-// ----------------------------------------------------------------------------
-struct LifecycleEvent {
-  pti_callback_domain domain;
-  pti_callback_phase phase;
-  pti_backend_kernel_t kernel_handle;
-  pti_backend_module_t module_handle;
-  std::string name;
-  uint32_t return_code;
-  uint32_t correlation_id;
-  uint32_t api_id;
-};
-
-struct LifecycleObserver {
-  std::mutex mtx;
-  std::vector<LifecycleEvent> events;
-  std::atomic<int> create_enter{0};
-  std::atomic<int> create_exit{0};
-  std::atomic<int> destroy_enter{0};
-  std::atomic<int> destroy_exit{0};
-
-  void Reset() {
-    std::lock_guard<std::mutex> lock(mtx);
-    events.clear();
-    create_enter = 0;
-    create_exit = 0;
-    destroy_enter = 0;
-    destroy_exit = 0;
-  }
-};
-
-void LifecycleCallback(pti_callback_domain domain, pti_api_group_id /*api_group*/, uint32_t api_id,
-                       pti_backend_ctx_t /*ctx*/, void* cb_data, void* user_data,
-                       void** /*instance_user_data*/) {
-  if (domain != PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED &&
-      domain != PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED) {
-    return;
-  }
-  auto* obs = static_cast<LifecycleObserver*>(user_data);
-  auto* data = static_cast<pti_callback_kernel_data*>(cb_data);
-
-  LifecycleEvent ev{};
-  ev.domain = domain;
-  ev.phase = data->_phase;
-  ev.kernel_handle = data->_device_kernel_handle;
-  ev.module_handle = data->_module_handle;
-  ev.name = (data->_name != nullptr) ? data->_name : "";
-  ev.return_code = data->_return_code;
-  ev.correlation_id = data->_correlation_id;
-  ev.api_id = api_id;
-
-  {
-    std::lock_guard<std::mutex> lock(obs->mtx);
-    obs->events.push_back(std::move(ev));
-  }
-  if (domain == PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED) {
-    if (data->_phase == PTI_CB_PHASE_API_ENTER)
-      ++obs->create_enter;
-    else
-      ++obs->create_exit;
-  } else {
-    if (data->_phase == PTI_CB_PHASE_API_ENTER)
-      ++obs->destroy_enter;
-    else
-      ++obs->destroy_exit;
-  }
-}
-
-void BufferRequested(unsigned char** buf, size_t* size) {
-  *buf = static_cast<unsigned char*>(std::malloc(kBufferSize));
-  *size = (*buf == nullptr) ? 0 : kBufferSize;
-}
-
-void BufferCompleted(unsigned char* buf, size_t /*size*/, size_t /*used*/) { std::free(buf); }
-
-// ----------------------------------------------------------------------------
-// Test fixture: enables PTI view + subscribes to lifecycle domain.
-// ----------------------------------------------------------------------------
-class KernelLifecycleCallbackTest : public ::testing::Test {
- protected:
-  struct ZeKernelResources {
-    ze_driver_handle_t driver = nullptr;
-    ze_device_handle_t device = nullptr;
-    ze_context_handle_t context = nullptr;
-    ze_module_handle_t module_handle = nullptr;
-
-    ~ZeKernelResources() {
-      if (module_handle != nullptr) {
-        EXPECT_EQ(zeModuleDestroy(module_handle), ZE_RESULT_SUCCESS);
-      }
-      if (context != nullptr) {
-        EXPECT_EQ(zeContextDestroy(context), ZE_RESULT_SUCCESS);
-      }
-    }
-  };
-
-  void SetUp() override {
-    observer_.Reset();
-    ASSERT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-
-    ASSERT_EQ(ptiCallbackSubscribe(&subscriber_, &LifecycleCallback, &observer_), PTI_SUCCESS);
-    EnableLifecycleDomains();
-  }
-
-  void TearDown() override {
-    if (subscriber_ != nullptr) {
-      EXPECT_EQ(ptiCallbackDisableDomain(subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED),
-                PTI_SUCCESS);
-      EXPECT_EQ(ptiCallbackDisableDomain(subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED),
-                PTI_SUCCESS);
-      EXPECT_EQ(ptiCallbackUnsubscribe(subscriber_), PTI_SUCCESS);
-      subscriber_ = nullptr;
-    }
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-    ptiFlushAllViews();
-  }
-
-  void EnableLifecycleDomains() {
-    ASSERT_EQ(ptiCallbackEnableDomain(subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, 1, 1),
-              PTI_SUCCESS);
-    ASSERT_EQ(ptiCallbackEnableDomain(subscriber_, PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED, 1, 1),
-              PTI_SUCCESS);
-  }
-
-  std::vector<LifecycleEvent> GetEvents(pti_callback_domain domain, pti_callback_phase phase) {
-    std::lock_guard<std::mutex> lock(observer_.mtx);
-    std::vector<LifecycleEvent> matching_events;
-    for (const auto& event : observer_.events) {
-      if (event.domain == domain && event.phase == phase) {
-        matching_events.push_back(event);
-      }
-    }
-    return matching_events;
-  }
-
-  void CreateKernelResources(ZeKernelResources* resources) {
-    ASSERT_NE(resources, nullptr);
-    ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-
-    uint32_t driver_count = 0;
-    ASSERT_EQ(zeDriverGet(&driver_count, nullptr), ZE_RESULT_SUCCESS);
-    if (driver_count == 0) {
-      GTEST_SKIP() << "No L0 driver";
-    }
-
-    std::vector<ze_driver_handle_t> drivers(driver_count);
-    ASSERT_EQ(zeDriverGet(&driver_count, drivers.data()), ZE_RESULT_SUCCESS);
-
-    resources->driver = drivers[0];
-
-    uint32_t device_count = 0;
-    ASSERT_EQ(zeDeviceGet(resources->driver, &device_count, nullptr), ZE_RESULT_SUCCESS);
-    if (device_count == 0) {
-      GTEST_SKIP() << "No L0 device";
-    }
-
-    std::vector<ze_device_handle_t> devices(device_count);
-    ASSERT_EQ(zeDeviceGet(resources->driver, &device_count, devices.data()), ZE_RESULT_SUCCESS);
-    resources->device = devices[0];
-
-    ze_context_desc_t context_desc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-    ASSERT_EQ(zeContextCreate(resources->driver, &context_desc, &resources->context),
-              ZE_RESULT_SUCCESS);
-
-    std::vector<uint8_t> binary = utils::LoadBinaryFile(utils::GetExecutablePath() + "gemm.spv");
-    if (binary.empty()) {
-      GTEST_SKIP() << "gemm.spv not found; cannot create module";
-    }
-
-    ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                    nullptr,
-                                    ZE_MODULE_FORMAT_IL_SPIRV,
-                                    binary.size(),
-                                    binary.data(),
-                                    nullptr,
-                                    nullptr};
-    ze_result_t module_result = zeModuleCreate(resources->context, resources->device, &module_desc,
-                                               &resources->module_handle, nullptr);
-    if (module_result != ZE_RESULT_SUCCESS || resources->module_handle == nullptr) {
-      GTEST_SKIP() << "zeModuleCreate failed";
-    }
-  }
-
-  std::vector<ze_kernel_handle_t> CreateKernels(ze_module_handle_t module_handle, int kernel_count,
-                                                const char* kernel_name) {
-    std::vector<ze_kernel_handle_t> kernels;
-    kernels.reserve(kernel_count);
-    for (int index = 0; index < kernel_count; ++index) {
-      ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, kernel_name};
-      ze_kernel_handle_t kernel = nullptr;
-      ze_result_t result = zeKernelCreate(module_handle, &kernel_desc, &kernel);
-      EXPECT_EQ(result, ZE_RESULT_SUCCESS);
-      EXPECT_NE(kernel, nullptr);
-
-      kernels.push_back(kernel);
-    }
-    return kernels;
-  }
-
-  static std::unordered_set<pti_backend_kernel_t> ToKernelSet(
-      const std::vector<ze_kernel_handle_t>& kernels) {
-    return {kernels.begin(), kernels.end()};
-  }
-
-  std::unordered_set<pti_backend_kernel_t> FindKernelHandles(pti_callback_domain domain,
-                                                             pti_callback_phase phase) {
-    std::unordered_set<pti_backend_kernel_t> kernel_handles;
-    for (const auto& event : GetEvents(domain, phase)) {
-      kernel_handles.insert(event.kernel_handle);
-    }
-    return kernel_handles;
-  }
-
-  void ExpectSuccessfulCreateExitEvents(ze_module_handle_t module_handle,
-                                        const std::unordered_set<pti_backend_kernel_t>& expected,
-                                        const std::string& expected_name) {
-    std::unordered_set<pti_backend_kernel_t> created;
-    for (const auto& event :
-         GetEvents(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, PTI_CB_PHASE_API_EXIT)) {
-      EXPECT_EQ(event.return_code, static_cast<uint32_t>(ZE_RESULT_SUCCESS));
-      EXPECT_NE(event.kernel_handle, nullptr);
-      EXPECT_EQ(event.module_handle, static_cast<pti_backend_module_t>(module_handle));
-      EXPECT_EQ(event.name, expected_name);
-      created.insert(event.kernel_handle);
-    }
-    EXPECT_EQ(created, expected);
-  }
-
-  LifecycleObserver observer_;
-  pti_callback_subscriber_handle subscriber_ = nullptr;
-};
-
-// ----------------------------------------------------------------------------
-// Test 1: direct Level-Zero kernel create / destroy.
-// ----------------------------------------------------------------------------
-TEST_F(KernelLifecycleCallbackTest, L0_KernelCreateDestroyFiresCallback) {
-  ZeKernelResources resources;
-  CreateKernelResources(&resources);
-
-  auto kernels =
-      CreateKernels(resources.module_handle, kLifecycleKernelCount, kLifecycleKernelName);
-  ASSERT_EQ(kernels.size(), static_cast<size_t>(kLifecycleKernelCount));
-
-  EXPECT_EQ(observer_.create_enter.load(), kLifecycleKernelCount);
-  EXPECT_EQ(observer_.create_exit.load(), kLifecycleKernelCount);
-
-  auto expected_kernels = ToKernelSet(kernels);
-  ExpectSuccessfulCreateExitEvents(resources.module_handle, expected_kernels, kLifecycleKernelName);
-
-  for (auto k : kernels) {
-    ASSERT_EQ(zeKernelDestroy(k), ZE_RESULT_SUCCESS);
-  }
-
-  EXPECT_EQ(observer_.destroy_enter.load(), kLifecycleKernelCount);
-  EXPECT_EQ(observer_.destroy_exit.load(), kLifecycleKernelCount);
-
-  auto destroyed_enter =
-      FindKernelHandles(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED, PTI_CB_PHASE_API_ENTER);
-  EXPECT_EQ(destroyed_enter, expected_kernels);
-}
-
-// ----------------------------------------------------------------------------
-// Test 2: SYCL kernel triggers underlying L0 kernel create/destroy callbacks.
-// ----------------------------------------------------------------------------
-TEST_F(KernelLifecycleCallbackTest, SYCL_KernelTriggersLifecycleCallbacks) {
-  try {
-    sycl::queue q{sycl::gpu_selector_v};
-    constexpr size_t kSize = 1024;
-    std::vector<int> a(kSize, 1);
-    {
-      sycl::buffer<int, 1> buf(a.data(), sycl::range<1>(kSize));
-      q.submit([&](sycl::handler& cgh) {
-         auto acc = buf.get_access<sycl::access::mode::read_write>(cgh);
-         cgh.parallel_for<class CbLifecycleSyclKernel>(sycl::range<1>(kSize),
-                                                       [=](sycl::id<1> i) { acc[i] = acc[i] + 2; });
-       }).wait_and_throw();
-    }
-    EXPECT_EQ(a[0], 3);
-  } catch (const sycl::exception& e) {
-    GTEST_SKIP() << "SYCL exception: " << e.what();
-  }
-
-  // Force PTI to flush before assertions (kernels held by SYCL runtime may
-  // be destroyed lazily, so we focus on CREATE here).
-  ptiFlushAllViews();
-
-  EXPECT_GE(observer_.create_enter.load(), 1);
-  EXPECT_GE(observer_.create_exit.load(), 1);
-
-  // ENTER and EXIT counts should match for create.
-  EXPECT_EQ(observer_.create_enter.load(), observer_.create_exit.load());
-
-  // Each EXIT-phase create must report a non-null kernel handle on success.
-  bool saw_success = false;
-  for (const auto& event : GetEvents(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, PTI_CB_PHASE_API_EXIT)) {
-    if (event.return_code != static_cast<uint32_t>(ZE_RESULT_SUCCESS)) {
-      continue;
-    }
-    EXPECT_NE(event.kernel_handle, nullptr);
-    EXPECT_NE(event.module_handle, nullptr);
-    saw_success = true;
-  }
-  EXPECT_TRUE(saw_success);
-}
-
-// ----------------------------------------------------------------------------
-// Test 3: enabling kernel domains is a separate operation per subscriber, and
-// disabling stops invocations.
-// ----------------------------------------------------------------------------
-TEST(KernelLifecycleCallbackEnableDisable, EnableDisableSemantics) {
-  LifecycleObserver obs;
-  ASSERT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-
-  pti_callback_subscriber_handle subscriber = nullptr;
-  ASSERT_EQ(ptiCallbackSubscribe(&subscriber, &LifecycleCallback, &obs), PTI_SUCCESS);
-
-  // Enabling requires a valid (known) domain.
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED, 1, 1),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiCallbackEnableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED, 1, 1),
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiCallbackDisableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED), PTI_SUCCESS);
-  EXPECT_EQ(ptiCallbackDisableDomain(subscriber, PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED),
-            PTI_SUCCESS);
-
-  // Stringification works for the new domains.
-  EXPECT_STREQ(ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED),
-               "PTI_CB_DOMAIN_DRIVER_KERNEL_CREATED");
-  EXPECT_STREQ(ptiCallbackDomainTypeToString(PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED),
-               "PTI_CB_DOMAIN_DRIVER_KERNEL_DESTROYED");
-
-  EXPECT_EQ(ptiCallbackUnsubscribe(subscriber), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-}
-
-}  // namespace
diff --git a/sdk/test/cmake/add_spirv.cmake b/sdk/test/cmake/add_spirv.cmake
deleted file mode 100644
index 4a5db36c..00000000
--- a/sdk/test/cmake/add_spirv.cmake
+++ /dev/null
@@ -1,64 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-option(PTI_RECOMPILE_TEST_KERNELS "Recompile test SPIR-V kernels" OFF)
-
-function(add_spirv TEST_TARGET KERNEL_FILE_BASENAME)
-  find_program(SPV_COMPILER NAMES clang)
-
-  if(NOT SPV_COMPILER)
-    set(SPV_COMPILER ${CMAKE_C_COMPILER})
-  endif()
-
-  get_filename_component(_kernel_file_basename_ext "${KERNEL_FILE_BASENAME}"
-                         LAST_EXT)
-
-  if(_kernel_file_basename_ext STREQUAL ".spv")
-    get_filename_component(_spirv_filename "${KERNEL_FILE_BASENAME}" NAME)
-    if(IS_ABSOLUTE "${KERNEL_FILE_BASENAME}")
-      set(_spirv_file "${KERNEL_FILE_BASENAME}")
-    else()
-      set(_spirv_file "${CMAKE_CURRENT_SOURCE_DIR}/${KERNEL_FILE_BASENAME}")
-    endif()
-    set(_disable_compile ON)
-  elseif(_kernel_file_basename_ext STREQUAL ".cl")
-    message(
-      FATAL_ERROR
-        "Passing .cl files to add_spirv is not supported. It will not be"
-        " compiled. Pass the .spv file instead or add a cl file without the"
-        " extension and compile with PTI_RECOMPILE_TEST_KERNELS=ON.")
-  else()
-    set(_kernel_src_filename "${KERNEL_FILE_BASENAME}.cl")
-    set(_kernel_src_file "${CMAKE_CURRENT_SOURCE_DIR}/${_kernel_src_filename}")
-    set(_spirv_filename "${KERNEL_FILE_BASENAME}.spv")
-    set(_spirv_file "${CMAKE_CURRENT_SOURCE_DIR}/${_spirv_filename}")
-  endif()
-
-  # This should probably output to build directory. However, for now, we will
-  # keep it in the source directory.
-  if(NOT TARGET compile_${KERNEL_FILE_BASENAME} AND NOT _disable_compile)
-    add_custom_target(
-      compile_${KERNEL_FILE_BASENAME}
-      COMMAND ${CMAKE_COMMAND} -E echo
-              "Compiling ${_kernel_src_filename} to ${_spirv_filename}"
-      COMMAND ${SPV_COMPILER} -target spirv64 -Xclang -finclude-default-header
-              "${_kernel_src_file}" -o "${_spirv_file}"
-      DEPENDS "${_kernel_src_file}"
-      VERBATIM)
-  endif()
-
-  if(PTI_RECOMPILE_TEST_KERNELS
-     AND NOT _disable_compile
-     AND TARGET compile_${KERNEL_FILE_BASENAME})
-    add_dependencies(${TEST_TARGET} compile_${KERNEL_FILE_BASENAME})
-  endif()
-
-  add_custom_command(
-    TARGET ${TEST_TARGET}
-    POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_spirv_file}"
-            "$<TARGET_FILE_DIR:${TEST_TARGET}>/${_spirv_filename}"
-    VERBATIM)
-endfunction()
diff --git a/sdk/test/cmake/stage_xpti_runtime_dependencies.cmake b/sdk/test/cmake/stage_xpti_runtime_dependencies.cmake
deleted file mode 100644
index da477e0f..00000000
--- a/sdk/test/cmake/stage_xpti_runtime_dependencies.cmake
+++ /dev/null
@@ -1,60 +0,0 @@
-# file(GET_RUNTIME_DEPENDENCIES) correctly warns when resolving Core's dependency graph
-# requires the explicit compiler runtime directory. Run the scan in a child CMake process
-# so expected diagnostics do not pollute successful builds, but preserve all output on
-# failure.
-if(NOT PTI_XPTI_RUNTIME_DEPENDENCY_SCAN)
-  execute_process(
-    COMMAND "${CMAKE_COMMAND}"
-            "-DPTI_XPTI_RUNTIME_DEPENDENCY_SCAN=ON"
-            "-DPTI_CORE_LIBRARY=${PTI_CORE_LIBRARY}"
-            "-DPTI_XPTI_LIBRARY=${PTI_XPTI_LIBRARY}"
-            "-DPTI_XPTI_RUNTIME_DIRECTORY=${PTI_XPTI_RUNTIME_DIRECTORY}"
-            "-DPTI_PRELOAD_STAGE_DIRECTORY=${PTI_PRELOAD_STAGE_DIRECTORY}"
-            -P "${CMAKE_CURRENT_LIST_FILE}"
-    RESULT_VARIABLE stage_result
-    OUTPUT_VARIABLE stage_stdout
-    ERROR_VARIABLE stage_stderr)
-  if(NOT stage_result EQUAL 0)
-    message(FATAL_ERROR "Failed to stage the XPTI runtime closure:\n${stage_stdout}${stage_stderr}")
-  endif()
-  return()
-endif()
-
-# Copies XPTI and Core's non-system compiler runtime closure into a staged interface directory.
-# The test runs with LD_LIBRARY_PATH empty, so LoadCoreLibrary must recursively pre-load
-# these files through the interface library's RUNPATH.
-
-foreach(required_variable
-        PTI_CORE_LIBRARY
-        PTI_XPTI_LIBRARY
-        PTI_XPTI_RUNTIME_DIRECTORY
-        PTI_PRELOAD_STAGE_DIRECTORY)
-  if(NOT DEFINED ${required_variable} OR "${${required_variable}}" STREQUAL "")
-    message(FATAL_ERROR "${required_variable} must be set")
-  endif()
-endforeach()
-
-file(COPY "${PTI_XPTI_LIBRARY}" DESTINATION "${PTI_PRELOAD_STAGE_DIRECTORY}"
-     FOLLOW_SYMLINK_CHAIN)
-
-get_filename_component(PTI_XPTI_RUNTIME_ROOT "${PTI_XPTI_RUNTIME_DIRECTORY}" REALPATH)
-file(GET_RUNTIME_DEPENDENCIES
-  LIBRARIES "${PTI_CORE_LIBRARY}" "${PTI_XPTI_LIBRARY}"
-  DIRECTORIES "${PTI_XPTI_RUNTIME_ROOT}"
-  RESOLVED_DEPENDENCIES_VAR PTI_XPTI_RESOLVED_DEPENDENCIES
-  UNRESOLVED_DEPENDENCIES_VAR PTI_XPTI_UNRESOLVED_DEPENDENCIES)
-
-if(PTI_XPTI_UNRESOLVED_DEPENDENCIES)
-  list(JOIN PTI_XPTI_UNRESOLVED_DEPENDENCIES ", " unresolved)
-  message(FATAL_ERROR "Unable to resolve the XPTI runtime closure: ${unresolved}")
-endif()
-
-foreach(dependency IN LISTS PTI_XPTI_RESOLVED_DEPENDENCIES)
-  get_filename_component(PTI_XPTI_RESOLVED_DEPENDENCY "${dependency}" REALPATH)
-  file(RELATIVE_PATH PTI_XPTI_RUNTIME_RELATIVE_DEPENDENCY
-       "${PTI_XPTI_RUNTIME_ROOT}" "${PTI_XPTI_RESOLVED_DEPENDENCY}")
-  if(NOT PTI_XPTI_RUNTIME_RELATIVE_DEPENDENCY MATCHES "^\\.\\.(/|$)")
-    file(COPY "${dependency}" DESTINATION "${PTI_PRELOAD_STAGE_DIRECTORY}"
-         FOLLOW_SYMLINK_CHAIN)
-  endif()
-endforeach()
diff --git a/sdk/test/fuzz/CMakeLists.txt b/sdk/test/fuzz/CMakeLists.txt
deleted file mode 100644
index e39e5959..00000000
--- a/sdk/test/fuzz/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-add_executable(pti_view_fuzz test_pti_view.cc)
-
-target_link_libraries(pti_view_fuzz PUBLIC Pti::pti_view)
-
-target_compile_options(pti_view_fuzz PUBLIC -fsanitize=fuzzer,address)
-target_link_options(pti_view_fuzz PUBLIC -fsanitize=fuzzer,address)
-
-target_include_directories(pti_view_fuzz PRIVATE
-  "${PROJECT_SOURCE_DIR}/src/utils")
-
-# Use CTest has a test runner
-add_test(NAME fuzz-pti-view-lib COMMAND pti_view_fuzz)
-
-# https://github.com/intel/compute-runtime/issues/376#issuecomment-786029828
-set_tests_properties(
-  fuzz-pti-view-lib PROPERTIES LABELS "fuzz" ENVIRONMENT
-                                  "NEOReadDebugKeys=1;DisableDeepBind=1")
diff --git a/sdk/test/fuzz/README.md b/sdk/test/fuzz/README.md
deleted file mode 100644
index aa7a72b9..00000000
--- a/sdk/test/fuzz/README.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# PTI fuzz testing
-
-We are using [libFuzzer](https://llvm.org/docs/LibFuzzer.html) for fuzz
-testing.
-
-## Build
-
-Build PTI for fuzzing targets.
-
-(Using CMake [presets](https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html))
-
-```console
->> source <path_to_pti>/setvars.sh
->> cmake --preset fuzz
->> cd build
->> ninja -j $(nproc)
-```
-
---or--
-
-```console
->> source <path_to_pti>/setvars.sh
->> mkdir build
->> cd build
->> cmake -DCMAKE_BUILD_TYPE=Debug \
-    -DCMAKE_TOOLCHAIN_FILE=../cmake/clang_toolchain.cmake \
-    -DPTI_FUZZ=1 ..
->> make -j
-```
-
-## Run
-
-```console
->> cd build
->> ctest --verbose fuzz-pti-view-lib
-```
diff --git a/sdk/test/fuzz/test_pti_view.cc b/sdk/test/fuzz/test_pti_view.cc
deleted file mode 100644
index 5f2b1754..00000000
--- a/sdk/test/fuzz/test_pti_view.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <pti/pti.h>
-#include <pti/pti_view.h>
-#include <stddef.h>
-
-#include <cstddef>
-#include <cstring>
-#include <type_traits>
-
-///////////////////////////////////////////////////////////////////////////////
-/// @ Filters out function from undefined behaviour sanitizer while fuzzing
-#if defined(__clang__) || defined(__GNUC__)
-#define ATTRIBUTE_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined")))
-#else
-#define ATTRIBUTE_NO_SANITIZE_UNDEFINED
-#endif
-
-namespace {
-template <typename T>
-ATTRIBUTE_NO_SANITIZE_UNDEFINED inline T ConvertByteArray(const unsigned char* byte_array) {
-  static_assert(std::is_trivially_copyable<T>::value,
-                "Must convert from byte array to trivially copyable type or "
-                "risk undefined behavior.");
-
-  T converted_value;
-  std::memcpy(&converted_value, &byte_array, sizeof(T));
-  return converted_value;
-}
-}  // namespace
-
-extern "C" {
-ATTRIBUTE_NO_SANITIZE_UNDEFINED
-int LLVMFuzzerTestOneInput(unsigned char* data, size_t size) {
-  // TODO(PTI): Add more fuzzing and figure out how to deal with function output, for now, not
-  // checking the output is valid.
-  [[maybe_unused]] pti_result result = PTI_SUCCESS;
-  if (size >= sizeof(pti_view_kind)) {
-    auto view_type = ConvertByteArray<pti_view_kind>(data);
-    result = ptiViewEnable(view_type);
-  }
-
-  pti_view_record_base* record = nullptr;
-  result = ptiViewGetNextRecord(data, size, &record);
-
-  if (size >= sizeof(pti_view_kind)) {
-    auto view_type = ConvertByteArray<pti_view_kind>(data);
-    result = ptiViewDisable(view_type);
-  }
-  return 0;
-}
-}
diff --git a/sdk/test/fuzz/ubsan-ignore.txt b/sdk/test/fuzz/ubsan-ignore.txt
deleted file mode 100644
index 8b368877..00000000
--- a/sdk/test/fuzz/ubsan-ignore.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-# Functions excluded from Undefined Behavior Sanitizer (UBSan) analysis.
-# Only a few high-level functions should be listed here.
-fun:ptiViewEnable
-fun:ptiViewDisable
diff --git a/sdk/test/gemm.cl b/sdk/test/gemm.cl
deleted file mode 100644
index d74b9110..00000000
--- a/sdk/test/gemm.cl
+++ /dev/null
@@ -1,10 +0,0 @@
-__kernel void GEMM(__global float* a, __global float* b,
-                    __global float* c, int size) {
-  int j = get_global_id(0);
-  int i = get_global_id(1);
-  float sum = 0.0f;
-  for (int k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
\ No newline at end of file
diff --git a/sdk/test/gemm.spv b/sdk/test/gemm.spv
deleted file mode 100644
index b31c2d35..00000000
Binary files a/sdk/test/gemm.spv and /dev/null differ
diff --git a/sdk/test/graph/CMakeLists.txt b/sdk/test/graph/CMakeLists.txt
deleted file mode 100644
index 96bfd663..00000000
--- a/sdk/test/graph/CMakeLists.txt
+++ /dev/null
@@ -1,148 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# List of Environment Variables and their usage in these tests.
-# PTI_CONV_CLOCK_SYNC_TIME_NS:              Time for synchronization between MONOTONIC_RAW (internal) and REALTIME clocks. Needed for timestamp comparison between graph replays.
-# NEOReadDebugKeys:                         Enables driver debug environment variables.
-# ExperimentalFlatCommandListApiRecording:  Enables dynamic tracing of SYCL graph replays (without tracing graph creation).
-
-find_package(Threads REQUIRED)
-
-if(NOT TARGET LevelZero::level-zero)
-  message(STATUS "Level Zero needed to build graph tests.")
-  return()
-endif()
-
-add_executable(ze_graph_suite ze_graph_fixture.cc)
-
-target_link_libraries(
-  ze_graph_suite
-  PUBLIC Pti::pti_view
-         spdlog::spdlog
-         fmt::fmt
-         GTest::gtest_main
-         Threads::Threads
-         LevelZero::level-zero
-         LevelZero::level-zero-ext
-         ${CMAKE_DL_LIBS})
-
-target_include_directories(
-  ze_graph_suite
-  PUBLIC "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/test" "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${PROJECT_SOURCE_DIR}/src/levelzero")
-
-add_spirv(ze_graph_suite ze_graph_test_kernels)
-
-gtest_discover_tests(
-  ze_graph_suite DISCOVERY_TIMEOUT 60
-  PROPERTIES LABELS
-             "functional"
-             LABELS
-             "graph"
-             LABELS
-             "level-zero"
-             ENVIRONMENT
-             "PTI_CONV_CLOCK_SYNC_TIME_NS=1000000000")
-
-add_executable(
-  ze_graph_integration_tests
-  ${PROJECT_SOURCE_DIR}/src/levelzero/ze_driver_init.cc
-  ${PROJECT_SOURCE_DIR}/src/levelzero/ze_command_visitor.cc
-  ze_command_visitor_tests.cc)
-
-target_include_directories(
-  ze_graph_integration_tests
-  PUBLIC "${PROJECT_SOURCE_DIR}/src/levelzero"
-  PRIVATE "${PROJECT_SOURCE_DIR}/test"
-          "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${PROJECT_SOURCE_DIR}/include"
-          "${PROJECT_BINARY_DIR}"
-          "${PROJECT_BINARY_DIR}/include")
-
-target_link_libraries(
-  ze_graph_integration_tests
-  PUBLIC GTest::gmock GTest::gtest_main LevelZero::level-zero
-         LevelZero::level-zero-ext spdlog::spdlog fmt::fmt
-         ${CMAKE_DL_LIBS})
-
-add_spirv(ze_graph_integration_tests ${PROJECT_SOURCE_DIR}/test/gemm.spv)
-
-gtest_discover_tests(
-  ze_graph_integration_tests DISCOVERY_TIMEOUT 60
-  PROPERTIES LABELS
-             "functional"
-             LABELS
-             "internal"
-             LABELS
-             "level-zero"
-             ENVIRONMENT
-             "NEOReadDebugKeys=1"
-             ENVIRONMENT
-             "ExperimentalFlatCommandListApiRecording=1")
-
-if(NOT HAVE_SYCL)
-  message(STATUS "Skipping SYCL graph tests: SYCL not available")
-  return()
-endif()
-
-add_executable(sycl_graph_suite sycl_graph_fixture.cc)
-
-target_compile_options(sycl_graph_suite PUBLIC -fsycl)
-target_link_options(sycl_graph_suite PUBLIC -fsycl)
-
-target_link_libraries(
-  sycl_graph_suite PUBLIC Pti::pti_view GTest::gtest_main fmt::fmt spdlog::spdlog
-                          Threads::Threads LevelZero::level-zero)
-
-target_include_directories(
-  sycl_graph_suite
-  PUBLIC "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/test" "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils")
-
-gtest_discover_tests(
-  sycl_graph_suite DISCOVERY_TIMEOUT 60
-  PROPERTIES LABELS
-             "functional"
-             LABELS
-             "graph"
-             LABELS
-             "sycl"
-             ENVIRONMENT
-             "PTI_CONV_CLOCK_SYNC_TIME_NS=1000000000"
-             ENVIRONMENT
-             "NEOReadDebugKeys=1"
-             ENVIRONMENT
-             "ExperimentalFlatCommandListApiRecording=1")
-
-add_executable(sycl_graph_overhead_test sycl_graph_overhead_test.cc)
-
-target_compile_options(sycl_graph_overhead_test PUBLIC -fsycl)
-target_link_options(sycl_graph_overhead_test PUBLIC -fsycl)
-
-target_link_libraries(
-  sycl_graph_overhead_test PUBLIC Pti::pti_view fmt::fmt Threads::Threads
-  LevelZero::headers)
-
-target_include_directories(
-  sycl_graph_overhead_test
-  PUBLIC "${PROJECT_SOURCE_DIR}/include" "${PROJECT_BINARY_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/test" "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          $<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>)
-
-add_test(NAME sycl_graph_overhead_test
-  COMMAND $<TARGET_FILE:sycl_graph_overhead_test> --iterations 5)
-
-set_tests_properties(
-  sycl_graph_overhead_test
-  PROPERTIES
-    SKIP_RETURN_CODE 77
-    LABELS "functional;graph;sycl"
-    TIMEOUT 360)
diff --git a/sdk/test/graph/graph_dotproduct_scalars.h b/sdk/test/graph/graph_dotproduct_scalars.h
deleted file mode 100644
index 2a19c8fd..00000000
--- a/sdk/test/graph/graph_dotproduct_scalars.h
+++ /dev/null
@@ -1,13 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_GRAPH_DOTPRODUCT_SCALARS_H_
-#define TEST_GRAPH_GRAPH_DOTPRODUCT_SCALARS_H_
-
-#define PTI_TEST_GRAPH_DOTPRODUCT_ALPHA 1.0f
-#define PTI_TEST_GRAPH_DOTPRODUCT_BETA 2.0f
-#define PTI_TEST_GRAPH_DOTPRODUCT_GAMMA 3.0f
-
-#endif  // TEST_GRAPH_GRAPH_DOTPRODUCT_SCALARS_H_
diff --git a/sdk/test/graph/graph_dotproduct_workload_info.h b/sdk/test/graph/graph_dotproduct_workload_info.h
deleted file mode 100644
index 2a83edf1..00000000
--- a/sdk/test/graph/graph_dotproduct_workload_info.h
+++ /dev/null
@@ -1,79 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_DOTPRODUCT_WORKLOAD_INFO_H_
-#define TEST_GRAPH_DOTPRODUCT_WORKLOAD_INFO_H_
-
-#include <cstddef>
-#include <tuple>
-
-#include "graph_dotproduct_scalars.h"
-
-// Shape: Diamond
-//
-//      *
-//    *   *
-//      *
-//
-// This workload is duplicated in two places (SYCL, Level Zero) to test both the L0 graph API and
-// the SYCL graph API. Major changes to this workload might require changes in both places
-// (sycl_graph_workloads.h, sycl_graph_fixture.cc, ze_graph_workloads.h, ze_graph_fixture.cc).
-template <typename T>
-struct DotProductWorkload {
-  using DefaultVectorDataType = T;
-  using DefaultResultDataType = T;
-  static constexpr auto kDefaultAlpha = PTI_TEST_GRAPH_DOTPRODUCT_ALPHA;
-  static constexpr auto kDefaultBeta = PTI_TEST_GRAPH_DOTPRODUCT_BETA;
-  static constexpr auto kDefaultGamma = PTI_TEST_GRAPH_DOTPRODUCT_GAMMA;
-  static constexpr std::size_t kDefaultVectorSize = 10;
-
-  struct InitDotProductCl {
-    static constexpr const char* const kKernelName = "InitDotProductVectors";
-    static constexpr std::size_t kArgN = 3;
-  };
-
-  struct VecAddAlphaCl {
-    static constexpr const char* const kKernelName = "VecAddAlpha";
-    static constexpr std::size_t kArgN = 2;
-  };
-
-  struct VecAddGammaCl {
-    static constexpr const char* const kKernelName = "VecAddGamma";
-    static constexpr std::size_t kArgN = 2;
-  };
-
-  struct CalculateDotProductCl {
-    static constexpr const char* const kKernelName = "CalculateDotProduct";
-    static constexpr std::size_t kArgN = 4;
-  };
-
-  using KernelInfo =
-      std::tuple<InitDotProductCl, VecAddAlphaCl, VecAddGammaCl, CalculateDotProductCl>;
-
-  static constexpr std::size_t kDefaultKernelNumber = std::tuple_size_v<KernelInfo>;
-
-  static constexpr const char* const kSpvKernelFile = "ze_graph_test_kernels.spv";
-
-  static constexpr DefaultResultDataType Result(std::size_t vector_size) {
-    constexpr auto kResultX = (static_cast<DefaultResultDataType>(kDefaultAlpha) *
-                               static_cast<DefaultResultDataType>(kDefaultAlpha)) +
-                              (static_cast<DefaultResultDataType>(kDefaultBeta) *
-                               static_cast<DefaultResultDataType>(kDefaultBeta));
-    constexpr auto kResultZ = (static_cast<DefaultResultDataType>(kDefaultGamma) *
-                               static_cast<DefaultResultDataType>(kDefaultGamma)) +
-                              (static_cast<DefaultResultDataType>(kDefaultBeta) *
-                               static_cast<DefaultResultDataType>(kDefaultBeta));
-
-    DefaultResultDataType result = 0;
-    for (std::size_t i = 0; i < vector_size; ++i) {
-      result += kResultX * kResultZ;
-    }
-    return result;
-  }
-
-  static constexpr DefaultResultDataType Result() { return Result(kDefaultVectorSize); }
-};
-
-#endif  // TEST_GRAPH_DOTPRODUCT_WORKLOAD_INFO_H_
diff --git a/sdk/test/graph/graph_record_format.h b/sdk/test/graph/graph_record_format.h
deleted file mode 100644
index 29bbcf45..00000000
--- a/sdk/test/graph/graph_record_format.h
+++ /dev/null
@@ -1,38 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_GRAPH_RECORD_FORMAT_H_
-#define TEST_GRAPH_GRAPH_RECORD_FORMAT_H_
-
-#include <fmt/core.h>
-#include <fmt/format.h>
-
-#include <string>
-#include <type_traits>
-
-#include "pti/pti_view.h"
-
-template <typename T>
-inline std::string FormatRecord(const T* record) {
-  auto result = fmt::format(
-      "Name: {} \nDuration (ns): {}\nStart Time (ns): {}\nEnd Time (ns): {}\nThread ID: {}\n",
-      record->_name, record->_end_timestamp - record->_start_timestamp, record->_start_timestamp,
-      record->_end_timestamp, record->_thread_id);
-
-  if constexpr (std::is_same_v<T, pti_view_record_kernel> ||
-                std::is_same_v<T, pti_view_record_kernel_v2>) {
-    result += fmt::format("Submit Time: {}\n", record->_submit_timestamp);
-    result += fmt::format("Append Time: {}\n", record->_append_timestamp);
-    result += fmt::format("Correlation ID: {}\n", record->_correlation_id);
-    result += fmt::format("SYCL Enqueue Begin Time (ns): {}\n", record->_sycl_enqk_begin_timestamp);
-    result += fmt::format("SYCL Task Begin ID (ns): {}\n", record->_sycl_task_begin_timestamp);
-    result += fmt::format("SYCL Queue ID: {}\n", record->_sycl_queue_id);
-    result += fmt::format("Kernel ID: {}\n", record->_kernel_id);
-  }
-
-  return result;
-}
-
-#endif  // TEST_GRAPH_GRAPH_RECORD_FORMAT_H_
diff --git a/sdk/test/graph/graph_record_validation.h b/sdk/test/graph/graph_record_validation.h
deleted file mode 100644
index 94900e2e..00000000
--- a/sdk/test/graph/graph_record_validation.h
+++ /dev/null
@@ -1,39 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_GRAPH_RECORD_VALIDATION_H_
-#define TEST_GRAPH_GRAPH_RECORD_VALIDATION_H_
-
-#include <gtest/gtest.h>
-
-#include <limits>
-#include <vector>
-
-#include "graph_record_format.h"
-
-template <typename T>
-inline void ValidateView(const T* record) {
-  EXPECT_NE(record->_start_timestamp,
-            (std::numeric_limits<decltype(record->_start_timestamp)>::min)())
-      << "Failing record: " << FormatRecord(record);
-  EXPECT_NE(record->_start_timestamp,
-            (std::numeric_limits<decltype(record->_start_timestamp)>::max)())
-      << "Failing record: " << FormatRecord(record);
-  EXPECT_NE(record->_end_timestamp, (std::numeric_limits<decltype(record->_end_timestamp)>::min)())
-      << "Failing record: " << FormatRecord(record);
-  EXPECT_NE(record->_end_timestamp, (std::numeric_limits<decltype(record->_end_timestamp)>::max)())
-      << "Failing record: " << FormatRecord(record);
-  EXPECT_LT(record->_start_timestamp, record->_end_timestamp)
-      << "Failing record: " << FormatRecord(record);
-}
-
-template <typename T>
-inline void ValidateViewTimestamps(const std::vector<T*>& records) {
-  for (const auto* record : records) {
-    ValidateView(record);
-  }
-}
-
-#endif  // TEST_GRAPH_GRAPH_RECORD_VALIDATION_H_
diff --git a/sdk/test/graph/sycl_graph_fixture.cc b/sdk/test/graph/sycl_graph_fixture.cc
deleted file mode 100644
index f93d369b..00000000
--- a/sdk/test/graph/sycl_graph_fixture.cc
+++ /dev/null
@@ -1,568 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <fmt/core.h>
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <array>
-#include <chrono>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "graph_dotproduct_workload_info.h"
-#include "graph_record_validation.h"
-#include "pti/pti_view.h"
-#include "sycl_graph_test_kernels.h"
-#include "sycl_graph_workloads.h"
-#include "utils/pti_record_collection_fixture.h"
-#include "utils/sycl_config_info.h"
-#include "utils/sycl_usm_helper.h"
-
-class SyclGraphTestSuite : public pti::test::utils::RecordCollectionFixture {
- protected:
-  void SetUp() override {
-    try {
-      auto graph_selector = [](const sycl::device& dev) {
-        if (dev.has(sycl::aspect::ext_oneapi_graph)) {
-          return 2;
-        }
-        if (dev.has(sycl::aspect::ext_oneapi_limited_graph)) {
-          return 1;
-        }
-
-        return -1;
-      };
-      queue_ = sycl::queue{graph_selector, {sycl::property::queue::in_order()}};
-    } catch (const sycl::exception& e) {
-      GTEST_SKIP() << "SYCL exception during setup: " << e.what();
-    } catch (...) {
-      FAIL() << "Unknown exception during SYCL queue setup.";
-    }
-  }
-
-  using Workload = DotProductWorkload<float>;
-
-  sycl::queue queue_;
-};
-
-class SyclUsmGraphExecutionTestSuite : public SyclGraphTestSuite,
-                                       public testing::WithParamInterface<std::tuple<std::size_t>> {
- protected:
-  using UnderlyingType = Workload::DefaultVectorDataType;
-  using FloatVec = pti::test::utils::SyclUsmVector<UnderlyingType>;
-  using FinalizedGraphType = sycl::ext::oneapi::experimental::command_graph<
-      sycl::ext::oneapi::experimental::graph_state::executable>;
-  static constexpr std::size_t kExpectedKernelsPerExecution = Workload::kDefaultKernelNumber;
-  // Given that a timestamp conversion is being done after record generation and before buffer
-  // insertion, some tolerance is needed due to timestamp drift.
-  // This could be mitigated in the environment with PTI_CONV_CLOCK_SYNC_TIME_NS=1000000000.
-  // However, that is fragile as well.
-  static constexpr auto kTimestampEqualityTolerance = std::chrono::nanoseconds(40);
-
-  SyclUsmGraphExecutionTestSuite() : replays_(std::get<0>(GetParam())) {}
-
-  void InitializeTracing() {
-    ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  }
-
-  void EnableTracing() {
-    for (const auto view : kEnableViews) {
-      ASSERT_EQ(ptiViewEnable(view), pti_result::PTI_SUCCESS);
-    }
-  }
-
-  void FinalizeTracing() {
-    for (const auto view : kEnableViews) {
-      ASSERT_EQ(ptiViewDisable(view), pti_result::PTI_SUCCESS);
-    }
-    ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    ParseAllBuffers();
-  }
-
-  void SetUp() override {
-    SyclGraphTestSuite::SetUp();
-    std::tie(dot_product_, x_vector_, y_vector_, z_vector_) =
-        CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-  }
-
-  void TearDown() override { SyclGraphTestSuite::TearDown(); }
-
-  void ValidateGraphReplayTimestamps() {
-    // clang-format off
-    // First, sort kernels by submission (unless they're the same, then sort by
-    // append time). We replay the graph N + 1 times. We want to validate all
-    // kernels in a given submission and compare to subsequent submissions.
-    //
-    //  Let's say we have three graph submissions. This tests executes them sequentially.
-    //  Append Time:         A_1 <  A_2 < A_3 < A_4   A_1 < A_2 < A_3 < A_4  A_1 < A_2 < A_3 < A_4
-    //                        /     /    /     /      /    /     /    /      /    /    /     /
-    //  Graph Submissions:  (K1 -  K2 - K3 - K4) -> (K1 - K2 - K3 - K4) -> (K1 - K2 - K3 - K4)
-    //                       /                     /                      /
-    //  Submit Time:       S_1       <           S_2        <           S_3
-    //
-    //  A_1(_1) == A_1(_2)
-    //  Ks_4_1 < Ks_4_2 < Ks_4_3 (Ks = Kernel start time)
-    //  Ks_4_1 < Ks_1_2
-    // clang-format on
-    std::sort(record_storage_.kernel_records.begin(), record_storage_.kernel_records.end(),
-              [](const auto* first_record, const auto* second_record) {
-                if (first_record->_submit_timestamp != second_record->_submit_timestamp) {
-                  return first_record->_submit_timestamp < second_record->_submit_timestamp;
-                }
-                return first_record->_append_timestamp < second_record->_append_timestamp;
-              });
-
-    ValidateViewTimestamps(record_storage_.kernel_records);
-    ValidateGraphSubmitTimestamps();
-    ValidateGraphAppendTimestamps();
-  }
-
-  void ValidateGraphSubmitTimestamps() {
-    for (std::size_t i = 0; i < std::size(record_storage_.kernel_records);
-         i += kExpectedKernelsPerExecution) {
-      const auto* prev_kernel_in_submission = record_storage_.kernel_records.at(i);
-      const std::size_t next_submission_idx = i + kExpectedKernelsPerExecution;
-      // Validate that all kernels in the same submission have the same submit timestamp.
-      for (std::size_t j = i + 1; j < next_submission_idx; ++j) {
-        const auto* curr_kernel_record = record_storage_.kernel_records.at(j);
-        const uint64_t submit_diff =
-            curr_kernel_record->_submit_timestamp > prev_kernel_in_submission->_submit_timestamp
-                ? curr_kernel_record->_submit_timestamp -
-                      prev_kernel_in_submission->_submit_timestamp
-                : prev_kernel_in_submission->_submit_timestamp -
-                      curr_kernel_record->_submit_timestamp;
-        EXPECT_LE(submit_diff, kTimestampEqualityTolerance.count())
-            << "Kernels in the same submission have different submit timestamps. Previous kernel:\n"
-            << FormatRecord(prev_kernel_in_submission)
-            << "\nCurrent kernel: " << FormatRecord(curr_kernel_record);
-        EXPECT_LT(curr_kernel_record->_append_timestamp, curr_kernel_record->_submit_timestamp)
-            << "Append timestamp should be before submit timestamp. Current kernel:\n"
-            << FormatRecord(curr_kernel_record);
-        prev_kernel_in_submission = curr_kernel_record;
-      }
-
-      // Validate that each submission happens after the previous one and that the kernel timestamps
-      // reflect that too. Each graph submission is sequential (perhaps not the kernel execution,
-      // given the diamond shape graph). We're comparing _submissions_.
-      if (next_submission_idx < std::size(record_storage_.kernel_records)) {
-        const auto* next_submission_kernel = record_storage_.kernel_records.at(next_submission_idx);
-        EXPECT_LT(prev_kernel_in_submission->_submit_timestamp,
-                  next_submission_kernel->_submit_timestamp)
-            << "Next submission starts before the previous one. Previous kernel: "
-            << FormatRecord(prev_kernel_in_submission)
-            << "\nNext kernel: " << FormatRecord(next_submission_kernel);
-        EXPECT_LT(prev_kernel_in_submission->_start_timestamp,
-                  next_submission_kernel->_start_timestamp);
-        EXPECT_LT(prev_kernel_in_submission->_end_timestamp,
-                  next_submission_kernel->_end_timestamp);
-      }
-    }
-  }
-
-  void ValidateGraphAppendTimestamps() {
-    // Special handling of append timestamps is needed because our graph isn't strictly linear,
-    // we initially submit K1 then K2 and K3 can execute in any order, then K4 executes after K2 and
-    // K3 are done.
-    constexpr std::size_t kLastKernelIndex = kExpectedKernelsPerExecution - 1;
-    for (std::size_t i = 0; i < std::size(record_storage_.kernel_records);
-         i += kExpectedKernelsPerExecution) {
-      const auto* curr_kernel_record = record_storage_.kernel_records.at(i);
-      const auto* last_kernel_record = record_storage_.kernel_records.at(i + kLastKernelIndex);
-      const std::size_t first_kernel_next_submission_idx = i + kExpectedKernelsPerExecution;
-      const std::size_t last_kernel_next_submission_idx =
-          i + kLastKernelIndex + kExpectedKernelsPerExecution;
-      if (last_kernel_next_submission_idx < std::size(record_storage_.kernel_records)) {
-        const auto* first_kernel_next_submission =
-            record_storage_.kernel_records.at(first_kernel_next_submission_idx);
-        const auto* last_kernel_next_submission =
-            record_storage_.kernel_records.at(last_kernel_next_submission_idx);
-        EXPECT_STREQ(curr_kernel_record->_name, first_kernel_next_submission->_name)
-            << "Kernels being compared should be the same across submissions. Previous kernel:\n"
-            << FormatRecord(curr_kernel_record)
-            << "\nNext submission's kernel: " << FormatRecord(first_kernel_next_submission);
-        uint64_t append_diff =
-            first_kernel_next_submission->_append_timestamp > curr_kernel_record->_append_timestamp
-                ? first_kernel_next_submission->_append_timestamp -
-                      curr_kernel_record->_append_timestamp
-                : curr_kernel_record->_append_timestamp -
-                      first_kernel_next_submission->_append_timestamp;
-        EXPECT_LE(append_diff, kTimestampEqualityTolerance.count())
-            << "Kernels in subsequent submissions have different append timestamps. Previous "
-               "kernel:\n"
-            << FormatRecord(curr_kernel_record)
-            << "\nNext submission's same kernel: " << FormatRecord(first_kernel_next_submission);
-        EXPECT_STREQ(last_kernel_record->_name, last_kernel_next_submission->_name)
-            << "Kernels being compared should be the same across submissions. Previous kernel:\n"
-            << FormatRecord(last_kernel_record)
-            << "\nNext submission's kernel: " << FormatRecord(last_kernel_next_submission);
-
-        append_diff =
-            last_kernel_next_submission->_append_timestamp > last_kernel_record->_append_timestamp
-                ? last_kernel_next_submission->_append_timestamp -
-                      last_kernel_record->_append_timestamp
-                : last_kernel_record->_append_timestamp -
-                      last_kernel_next_submission->_append_timestamp;
-
-        EXPECT_LE(append_diff, kTimestampEqualityTolerance.count())
-            << "Kernels in subsequent submissions have different append timestamps. Previous "
-               "kernel:\n"
-            << FormatRecord(last_kernel_record)
-            << "\nNext submission's same kernel: " << FormatRecord(last_kernel_next_submission);
-      }
-    }
-  }
-
-  constexpr static std::array kEnableViews = {PTI_VIEW_DEVICE_GPU_KERNEL, PTI_VIEW_RUNTIME_API};
-  std::size_t replays_ = 0;
-  FloatVec dot_product_ = nullptr;
-  FloatVec x_vector_ = nullptr;
-  FloatVec y_vector_ = nullptr;
-  FloatVec z_vector_ = nullptr;
-  std::optional<FinalizedGraphType> graph_;
-};
-
-class SyclUsmGraphVisitorTestSuite : public SyclUsmGraphExecutionTestSuite {
- protected:
-  void SetUp() override {
-    if (!pti::test::utils::CommandListVisitAvailable()) {
-      GTEST_SKIP() << "Command list visit extension unavailable. It requires a supporting driver "
-                      "and NEOReadDebugKeys=1 ExperimentalFlatCommandListApiRecording=1 to be set "
-                      "in the environment.";
-    }
-    SyclUsmGraphExecutionTestSuite::SetUp();
-  }
-};
-
-class SyclUsmNativeGraphVisitorTestSuite : public SyclUsmGraphExecutionTestSuite {
- protected:
-  void SetUp() override {
-    if (!pti::test::utils::NativeGraphApisAvailable()) {
-      GTEST_SKIP() << "Command list visit extension unavailable. It requires a supporting driver "
-                      "and NEOReadDebugKeys=1 ExperimentalFlatCommandListApiRecording=1 to be set "
-                      "in the environment.";
-    }
-
-    SyclUsmGraphExecutionTestSuite::SetUp();
-  }
-};
-
-TEST_F(SyclGraphTestSuite, TestSyclUsmGraphExecution) {
-  using UnderlyingType = Workload::DefaultVectorDataType;
-  auto [dot_product, x_vector, y_vector, z_vector] =
-      CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  auto graph = CreateUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product.get(),
-                                        x_vector.get(), y_vector.get(), z_vector.get());
-
-  const auto exec = graph.finalize();
-  queue_.ext_oneapi_graph(exec).wait_and_throw();
-  EXPECT_FLOAT_EQ(*dot_product, Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{Workload::kDefaultKernelNumber});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-#if defined(PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE)
-TEST_F(SyclGraphTestSuite, TestSyclUsmGraphExecutionWithRecordingApi) {
-  using UnderlyingType = Workload::DefaultVectorDataType;
-  auto [dot_product, x_vector, y_vector, z_vector] =
-      CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  try {
-    auto graph = CreateUsmDotProductGraphWithRecording(queue_, Workload::kDefaultVectorSize,
-                                                       dot_product.get(), x_vector.get(),
-                                                       y_vector.get(), z_vector.get());
-
-    const auto exec = graph.finalize();
-    queue_.ext_oneapi_graph(exec).wait_and_throw();
-  } catch (const sycl::exception& e) {
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    if (e.code() == sycl::errc::feature_not_supported) {
-      GTEST_SKIP()
-          << "SYCL exception during graph execution, likely due to unsupported recording API: "
-          << e.what();
-    }
-    FAIL() << "SYCL exception during graph execution: " << e.what();
-  } catch (...) {
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    FAIL() << "Unknown exception during SYCL graph execution.";
-  }
-
-  EXPECT_FLOAT_EQ(*dot_product, Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{Workload::kDefaultKernelNumber});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(SyclGraphTestSuite, TestSyclUsmGraphExecutionWithNativeRecordingApi) {
-  if (!pti::test::utils::NativeGraphApisAvailable()) {
-    GTEST_SKIP()
-        << "Native graph recording extension unavailable. It requires a supporting driver.";
-  }
-  using UnderlyingType = Workload::DefaultVectorDataType;
-  auto [dot_product, x_vector, y_vector, z_vector] =
-      CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  try {
-    auto graph =
-        CreateNativeUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product.get(),
-                                       x_vector.get(), y_vector.get(), z_vector.get());
-
-    const auto exec = graph.finalize();
-    queue_.ext_oneapi_graph(exec).wait_and_throw();
-  } catch (const sycl::exception& e) {
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    if (e.code() == sycl::errc::feature_not_supported) {
-      GTEST_SKIP() << "SYCL exception during graph execution, likely due to unsupported native "
-                      "recording API: "
-                   << e.what();
-    }
-    FAIL() << "SYCL exception during graph execution: " << e.what();
-  } catch (...) {
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    FAIL() << "Unknown exception during SYCL graph execution.";
-  }
-  EXPECT_FLOAT_EQ(*dot_product, Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{Workload::kDefaultKernelNumber});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-#endif  // PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE
-
-TEST_F(SyclGraphTestSuite, TestSyclBuffersGraphExecution) {
-  // https://github.com/intel/llvm/blob/sycl/sycl/doc/syclgraph/SYCLGraphUsageGuide.md#code-examples
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  constexpr std::size_t kNumberOfBuffers = 3;
-  constexpr std::size_t kElements = 32;
-  using UnderlyingType = int;
-  std::vector<UnderlyingType> underlying_vec_a(kElements, 1);
-  std::vector<UnderlyingType> underlying_vec_b(kElements, 2);
-  std::vector<UnderlyingType> underlying_vec_c(kElements, 3);
-  auto range = sycl::range<1>{kElements};
-  sycl::buffer<UnderlyingType> sycl_buffer_a{underlying_vec_a.data(), range};
-  sycl_buffer_a.set_write_back(false);
-  sycl::buffer<UnderlyingType> sycl_buffer_b{underlying_vec_b.data(), range};
-  sycl_buffer_b.set_write_back(false);
-  sycl::buffer<UnderlyingType> sycl_buffer_c{underlying_vec_c.data(), range};
-  sycl_buffer_c.set_write_back(false);
-
-  {
-    sycl::ext::oneapi::experimental::command_graph graph{
-        queue_, {sycl::ext::oneapi::experimental::property::graph::assume_buffer_outlives_graph{}}};
-
-    queue_.submit([&](sycl::handler& cgh) {
-      auto data_ptr = sycl_buffer_a.get_access<sycl::access::mode::read_write>(cgh);
-      cgh.parallel_for(range, IncrementBufferKernel{data_ptr});
-    });
-
-    queue_.submit([&](sycl::handler& cgh) {
-      auto data_ptr1 = sycl_buffer_a.get_access<sycl::access::mode::read>(cgh);
-      auto data_ptr2 = sycl_buffer_b.get_access<sycl::access::mode::read_write>(cgh);
-      cgh.parallel_for(range, AddBuffersKernel{data_ptr1, data_ptr2});
-    });
-
-    queue_.submit([&](sycl::handler& cgh) {
-      auto data_ptr1 = sycl_buffer_a.get_access<sycl::access::mode::read>(cgh);
-      auto data_ptr2 = sycl_buffer_c.get_access<sycl::access::mode::read_write>(cgh);
-      cgh.parallel_for(range, SubtractBuffersKernel{data_ptr1, data_ptr2});
-    });
-
-    queue_.submit([&](sycl::handler& cgh) {
-      auto data_ptr1 = sycl_buffer_b.get_access<sycl::access::mode::read_write>(cgh);
-      auto data_ptr2 = sycl_buffer_c.get_access<sycl::access::mode::read_write>(cgh);
-      cgh.parallel_for(range, DecrementBuffersKernel{data_ptr1, data_ptr2});
-    });
-
-    graph.end_recording();
-
-    auto exec_graph = graph.finalize();
-
-    queue_.submit([&](sycl::handler& cgh) { cgh.ext_oneapi_graph(exec_graph); }).wait();
-  }
-
-  sycl::host_accessor data_access_a(sycl_buffer_a);
-  sycl::host_accessor data_access_b(sycl_buffer_b);
-  sycl::host_accessor data_access_c(sycl_buffer_c);
-
-  for (std::size_t i = 0; i < kElements; ++i) {
-    EXPECT_EQ(data_access_a[i], 2);
-    EXPECT_EQ(data_access_b[i], 3);
-    EXPECT_EQ(data_access_c[i], 0);
-  }
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{4});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-  EXPECT_EQ(std::size(record_storage_.memcpy_records), std::size_t{6});
-  ValidateViewTimestamps(record_storage_.memcpy_records);
-  constexpr std::size_t kExpectedMemCopies = kNumberOfBuffers * 2;
-  constexpr std::size_t kExpectedBytesPerCopy = sizeof(UnderlyingType) * kElements;
-  for (std::size_t idx = 0; idx < kExpectedMemCopies; ++idx) {
-    EXPECT_EQ(record_storage_.memcpy_records.at(idx)->_bytes, kExpectedBytesPerCopy);
-  }
-}
-
-TEST_F(SyclGraphTestSuite, TestSyclUsmTwoGraphsReplay) {
-  using UnderlyingType = Workload::DefaultVectorDataType;
-  constexpr auto kNumberOfReplaysPerGraph = 2;
-  constexpr auto kNumberOfGraphs = 2;
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  auto [dot_product_a, x_vector_a, y_vector_a, z_vector_a] =
-      CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-  auto graph_a = CreateUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product_a.get(),
-                                          x_vector_a.get(), y_vector_a.get(), z_vector_a.get());
-  const auto exec_a = graph_a.finalize();
-
-  auto [dot_product_b, x_vector_b, y_vector_b, z_vector_b] =
-      CreateUsmDotProductVectors<UnderlyingType>(queue_, Workload::kDefaultVectorSize);
-  auto graph_b = CreateUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product_b.get(),
-                                          x_vector_b.get(), y_vector_b.get(), z_vector_b.get());
-  const auto exec_b = graph_b.finalize();
-
-  queue_.ext_oneapi_graph(exec_a).wait_and_throw();
-  queue_.ext_oneapi_graph(exec_b).wait_and_throw();
-  queue_.ext_oneapi_graph(exec_a).wait_and_throw();
-  queue_.ext_oneapi_graph(exec_b).wait_and_throw();
-
-  const auto expected_per_graph = Workload::Result() * kNumberOfReplaysPerGraph;
-  EXPECT_FLOAT_EQ(*dot_product_a, expected_per_graph);
-  EXPECT_FLOAT_EQ(*dot_product_b, expected_per_graph);
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-
-  EXPECT_EQ(
-      std::size(record_storage_.kernel_records),
-      std::size_t{Workload::kDefaultKernelNumber * kNumberOfGraphs * kNumberOfReplaysPerGraph});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_P(SyclUsmGraphExecutionTestSuite, TestArbitraryReplays) {
-  InitializeTracing();
-  EnableTracing();
-  auto graph = CreateUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product_.get(),
-                                        x_vector_.get(), y_vector_.get(), z_vector_.get());
-  graph_.emplace(graph.finalize());
-
-  queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  for (std::size_t i = 0; i < replays_; ++i) {
-    queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  }
-  FinalizeTracing();
-  const auto expected_result =
-      (Workload::Result() * static_cast<UnderlyingType>(replays_)) + Workload::Result();
-  EXPECT_FLOAT_EQ(*dot_product_, expected_result);
-  EXPECT_EQ(std::size(record_storage_.kernel_records),
-            (replays_ + 1) * kExpectedKernelsPerExecution);
-  ValidateGraphReplayTimestamps();
-}
-
-// There is not a reliable way to enable this feature on Windows without a special driver build or
-// proper command list descriptor.
-#if defined(_WIN32)
-TEST_P(SyclUsmGraphVisitorTestSuite, DISABLED_TestArbitraryReplaysWithGraphRecreation) {
-#else
-TEST_P(SyclUsmGraphVisitorTestSuite, TestArbitraryReplaysWithGraphRecreation) {
-#endif
-  auto graph = CreateUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product_.get(),
-                                        x_vector_.get(), y_vector_.get(), z_vector_.get());
-  graph_.emplace(graph.finalize());
-
-  InitializeTracing();
-  EnableTracing();
-  queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  for (std::size_t i = 0; i < replays_; ++i) {
-    queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  }
-  FinalizeTracing();
-  const auto expected_result =
-      (Workload::Result() * static_cast<UnderlyingType>(replays_)) + Workload::Result();
-  EXPECT_FLOAT_EQ(*dot_product_, expected_result);
-  EXPECT_EQ(std::size(record_storage_.kernel_records),
-            (replays_ + 1) * kExpectedKernelsPerExecution);
-  ValidateGraphReplayTimestamps();
-}
-
-#if defined(PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE)
-TEST_P(SyclUsmNativeGraphVisitorTestSuite, TestArbitraryReplaysWithGraphRecreation) {
-  try {
-    auto graph =
-        CreateNativeUsmDotProductGraph(queue_, Workload::kDefaultVectorSize, dot_product_.get(),
-                                       x_vector_.get(), y_vector_.get(), z_vector_.get());
-    graph_.emplace(graph.finalize());
-  } catch (const sycl::exception& e) {
-    if (e.code() == sycl::errc::feature_not_supported) {
-      GTEST_SKIP() << "SYCL exception during graph execution, likely due to unsupported native "
-                      "recording API: "
-                   << e.what();
-    }
-    FAIL() << "SYCL exception during graph execution: " << e.what();
-  } catch (...) {
-    FAIL() << "Unknown exception during SYCL graph execution.";
-  }
-
-  InitializeTracing();
-  EnableTracing();
-  queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  for (std::size_t i = 0; i < replays_; ++i) {
-    queue_.ext_oneapi_graph(*graph_).wait_and_throw();
-  }
-  FinalizeTracing();
-  const auto expected_result =
-      (Workload::Result() * static_cast<UnderlyingType>(replays_)) + Workload::Result();
-  EXPECT_FLOAT_EQ(*dot_product_, expected_result);
-  EXPECT_EQ(std::size(record_storage_.kernel_records),
-            (replays_ + 1) * kExpectedKernelsPerExecution);
-  ValidateGraphReplayTimestamps();
-}
-
-INSTANTIATE_TEST_SUITE_P(SyclUsmNativeGraphVisitorReplayTests, SyclUsmNativeGraphVisitorTestSuite,
-                         ::testing::Values(0, 1, 5, 10), [](const auto& info) {
-                           return fmt::format("{}_Replays", std::get<0>(info.param));
-                         });
-#endif  // PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE
-
-INSTANTIATE_TEST_SUITE_P(SyclUsmGraphExecutionReplayTests, SyclUsmGraphExecutionTestSuite,
-                         ::testing::Values(0, 1, 5, 10), [](const auto& info) {
-                           return fmt::format("{}_Replays", std::get<0>(info.param));
-                         });
-
-INSTANTIATE_TEST_SUITE_P(SyclUsmGraphVisitorReplayTests, SyclUsmGraphVisitorTestSuite,
-                         ::testing::Values(0, 1, 5, 10), [](const auto& info) {
-                           return fmt::format("{}_Replays", std::get<0>(info.param));
-                         });
diff --git a/sdk/test/graph/sycl_graph_overhead_test.cc b/sdk/test/graph/sycl_graph_overhead_test.cc
deleted file mode 100644
index 92f3d2fd..00000000
--- a/sdk/test/graph/sycl_graph_overhead_test.cc
+++ /dev/null
@@ -1,383 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <fmt/core.h>
-#include <fmt/ostream.h>
-
-#include <algorithm>
-#include <chrono>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <mutex>
-#include <stdexcept>
-#include <string>
-#include <sycl/exception.hpp>
-#include <sycl/sycl.hpp>
-#include <tuple>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#include "graph_dotproduct_workload_info.h"
-#include "graph_record_format.h"
-#include "pti/pti_view.h"
-#include "sycl_graph_workloads.h"
-#include "utils/sycl_config_info.h"
-#include "utils/test_helpers.h"
-
-template <>
-struct fmt::formatter<pti_view_kind> : fmt::ostream_formatter {};
-
-namespace {
-constexpr int kSkipTest = 77;
-constexpr int kPassTest = EXIT_SUCCESS;
-constexpr int kFailTest = EXIT_FAILURE;
-
-using Workload = DotProductWorkload<float>;
-
-template <typename T, typename... U>
-inline bool CheckArgument(const T& arg, const U&... args) {
-  return ((!std::strcmp(arg.c_str(), args)) || ...);
-}
-
-struct ProgramSettings {
-  constexpr static std::size_t kDefaultIterations = 1ULL;
-  std::size_t iterations = kDefaultIterations;
-  bool verbose = false;
-};
-
-ProgramSettings ParseArguments(const std::vector<std::string>& args) {
-  ProgramSettings settings{};
-
-  try {
-    for (std::size_t arg_idx = 0; arg_idx < std::size(args); ++arg_idx) {
-      if (CheckArgument(args[arg_idx], "-i", "--iterations")) {
-        settings.iterations = std::stoull(args.at(++arg_idx));
-      } else if (CheckArgument(args[arg_idx], "-v", "--verbose")) {
-        settings.verbose = true;
-      } else {
-        throw std::invalid_argument(fmt::format("{}", args[arg_idx]));
-      }
-    }
-  } catch (const std::out_of_range&) {
-    throw std::invalid_argument("Missing argument for option and/or invalid argument size");
-  }
-
-  return settings;
-}
-
-class PtiCollector {
- public:
-  using PtiViewBuffer = pti::test::utils::PtiViewBuffer;
-  using CallStats = std::pair<uint64_t, std::size_t>;  // ns, count
-
-  struct Records {
-    void Reset() {
-      kernel_records.clear();
-      overhead_records.clear();
-      const std::lock_guard<std::mutex> lock(buffers_mtx);
-      buffers.clear();
-    }
-
-    mutable std::mutex buffers_mtx;
-    std::unordered_map<unsigned char*, PtiViewBuffer> buffers;
-    std::vector<const pti_view_record_kernel_v2*> kernel_records;
-    std::vector<const pti_view_record_overhead*> overhead_records;
-  };
-
-  PtiCollector() {
-    record_storage_.Reset();
-    if (ptiViewSetCallbacks(ProvideBuffer, MarkBuffer) != PTI_SUCCESS) {
-      throw std::runtime_error("Failed to set PTI view callbacks");
-    }
-  }
-
-  PtiCollector(const PtiCollector&) = delete;
-  PtiCollector& operator=(const PtiCollector&) = delete;
-  PtiCollector(PtiCollector&&) = delete;
-  PtiCollector& operator=(PtiCollector&&) = delete;
-  ~PtiCollector() = default;
-
-  static void ProvideBuffer(unsigned char** buf, size_t* buf_size) {
-    auto buffer = PtiViewBuffer(kRequestedBufferSize);
-    if (!buffer.Valid()) {
-      fmt::print(stderr, "[FATAL] Unable to allocate buffer for PTI tracing\n");
-      std::abort();
-    }
-    *buf = buffer.data();
-    *buf_size = buffer.size();
-
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    record_storage_.buffers[*buf] = std::move(buffer);
-  }
-
-  static void MarkBuffer(unsigned char* buf, size_t /*buf_size*/, size_t used_bytes) {
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    if (auto it = record_storage_.buffers.find(buf); it != record_storage_.buffers.end()) {
-      it->second.SetUsedBytes(used_bytes);
-    }
-  }
-
-  static void HandleView(pti_view_record_base* view) {
-    switch (view->_view_kind) {
-      case PTI_VIEW_DEVICE_GPU_KERNEL:
-        record_storage_.kernel_records.push_back(
-            reinterpret_cast<const pti_view_record_kernel_v2*>(view));
-        break;
-      case PTI_VIEW_COLLECTION_OVERHEAD:
-        record_storage_.overhead_records.push_back(
-            reinterpret_cast<const pti_view_record_overhead*>(view));
-        break;
-      default:
-        break;
-    }
-  }
-
-  static void ParseBuffer(unsigned char* buf, size_t used_bytes) {
-    pti_view_record_base* record = nullptr;
-    while (true) {
-      auto status = ptiViewGetNextRecord(buf, used_bytes, &record);
-      if (status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (status != pti_result::PTI_SUCCESS) {
-        fmt::print(stderr, "[FATAL] Failed to parse PTI view record: {}\n",
-                   static_cast<std::size_t>(status));
-        std::abort();
-        break;
-      }
-      HandleView(record);
-    }
-  }
-
-  static void ParseAllBuffers() {
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    for (auto& [_, buffer] : record_storage_.buffers) {
-      ParseBuffer(buffer.data(), buffer.UsedBytes());
-    }
-  }
-
-  template <typename... E>
-  void EnableViews(E... view_kinds) {
-    (
-        [&] {
-          if (ptiViewEnable(view_kinds) != PTI_SUCCESS) {
-            throw std::runtime_error(fmt::format("Failed to enable PTI view: {}", view_kinds));
-          }
-        }(),
-        ...);
-    (enabled_views_.push_back(view_kinds), ...);
-  }
-
-  void FinalizeCollection() {
-    for (auto view_kind : enabled_views_) {
-      if (ptiViewDisable(view_kind) != PTI_SUCCESS) {
-        throw std::runtime_error(fmt::format("Failed to disable PTI view: {}", view_kind));
-      }
-    }
-    if (ptiFlushAllViews() != PTI_SUCCESS) {
-      throw std::runtime_error("Failed to flush PTI views");
-    }
-    ParseAllBuffers();
-    overhead_kind_map_.reserve(record_storage_.overhead_records.size());
-    for (const auto* record : record_storage_.overhead_records) {
-      overhead_kind_map_[record->_api_id].first += record->_overhead_duration_ns;
-      overhead_kind_map_[record->_api_id].second += 1;
-    }
-  }
-
-  void PrintRecordStats(std::size_t iterations, std::chrono::duration<double> duration) {
-    if (record_storage_.kernel_records.empty() || record_storage_.overhead_records.empty()) {
-      throw std::runtime_error("No kernel or overhead records were collected");
-    }
-    fmt::print("  Graph Executions: {}, Graph Executions Per Second: {}\n", iterations,
-               static_cast<double>(iterations) / duration.count());
-    fmt::print("  Kernel Records: {}, Kernels Per Second: {}\n",
-               record_storage_.kernel_records.size(),
-               static_cast<double>(record_storage_.kernel_records.size()) / duration.count());
-    fmt::print("  Overhead Records: {}\n", record_storage_.overhead_records.size());
-
-    // Print call statistics for each overhead API record collected and sort by duration of the
-    // call.
-    std::vector<std::pair<uint32_t, CallStats>> sorted_overhead_records;
-    sorted_overhead_records.reserve(overhead_kind_map_.size());
-    for (const auto& [api_id, stats] : overhead_kind_map_) {
-      sorted_overhead_records.emplace_back(api_id, stats);
-    }
-
-    std::sort(sorted_overhead_records.begin(), sorted_overhead_records.end(),
-              [](const auto& first_rec_info, const auto& second_rec_info) {
-                return first_rec_info.second.first > second_rec_info.second.first;
-              });
-
-    for (const auto& [api_id, total_overhead] : sorted_overhead_records) {
-      const char* api_name = nullptr;
-      auto res = ptiViewGetApiIdName(PTI_API_GROUP_LEVELZERO, api_id, &api_name);
-      fmt::print(
-          "  API: {}, # of Calls {}, Total Overhead (ns): {}, Percentage of Total workload "
-          "duration: {}%\n",
-          res == PTI_SUCCESS ? api_name : std::to_string(static_cast<std::size_t>(api_id)),
-          total_overhead.second, total_overhead.first,
-          (std::chrono::duration_cast<std::chrono::duration<double>>(
-               std::chrono::nanoseconds(total_overhead.first))
-               .count() /
-           duration.count()) *
-              100.0);
-    }
-  }
-
-  static void PrintKernelRecords() {
-    fmt::print("  Kernel Records:\n");
-    for (const auto* record : record_storage_.kernel_records) {
-      fmt::print("{}", FormatRecord(record));
-    }
-  }
-
-  void ValidateKernelRecords(std::size_t iterations) {
-    const auto expected_kernels = iterations * Workload::kDefaultKernelNumber;
-    const auto found_kernels = std::size(record_storage_.kernel_records);
-    if (found_kernels != expected_kernels) {
-      throw std::runtime_error(fmt::format("Kernel record count mismatch: expected {}, got {}",
-                                           expected_kernels, found_kernels));
-    }
-    // The native graph is done when the event is signaled - no need to check the status of each
-    // event in an N-node graph.
-    if (CallCount(zeEventQueryStatus_id) >= found_kernels) {
-      throw std::runtime_error(
-          "Too many zeEventQueryStatus calls per graph execution, expected less than 1 per kernel");
-    }
-    // Note: PTI should only call zeCommandListAppendQueryKernelTimestamps
-    // and zeCommandListAppendWaitOnEvents during instrumented graph creation,
-    // so no iteration math required.
-    if (CallCount(zeCommandListAppendQueryKernelTimestamps_id) >= Workload::kDefaultKernelNumber) {
-      // zeCommandListAppendQueryKernelTimestamps is very expensive inside graph creation (and
-      // destruction of instrumented graph). This might be an issue with Level Zero driver, this
-      // call might need to be optimized.
-      // However, in a single, batched execution of a graph, we can have a least one call to
-      // zeCommandListAppendQueryKernelTimestamps - a single call probably won't be devastating and
-      // actually might be preferrable compared to many queries on the host.
-      throw std::runtime_error(
-          "Too many zeCommandListAppendQueryKernelTimestamps calls, expected less than 1 per "
-          "kernel in the graph");
-    }
-    if (CallCount(zeCommandListAppendWaitOnEvents_id) != 0) {
-      // We've requested an in-order queue - so there should not be a need to wait on events (this
-      // is only needed for out-of-order queues when a signal is required in the correct order).
-      // This could fail if native graphs come to PVC SYCL V1 backend.
-      throw std::runtime_error("Unexpected zeCommandListAppendWaitOnEvents calls");
-    }
-  }
-
- private:
-  std::size_t CallCount(pti_api_id_driver_levelzero api_id) const {
-    const auto call_count_it = overhead_kind_map_.find(api_id);
-    return call_count_it == overhead_kind_map_.end() ? 0 : call_count_it->second.second;
-  }
-
-  inline static Records record_storage_{};
-  constexpr static std::size_t kRequestedBufferSize = 1024 * 1024;
-  std::vector<pti_view_kind> enabled_views_;
-  std::unordered_map<uint32_t, CallStats> overhead_kind_map_;
-};
-
-[[maybe_unused]] double DotProductRelativeError(Workload::DefaultResultDataType result,
-                                                std::size_t iterations) {
-  const auto expected = static_cast<double>(Workload::Result()) * static_cast<double>(iterations);
-  if (expected == 0.0) {
-    throw std::invalid_argument("Dot product cannot be 0.");
-  }
-
-  return (std::abs(static_cast<double>(result) - expected) / std::abs(expected)) * 100.0;
-}
-}  // namespace
-int main(int argc, char* argv[]) {
-  try {
-    [[maybe_unused]] auto settings =
-        ParseArguments(std::vector<std::string>(argv + 1, argv + argc));  // NOLINT
-
-#if defined(PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE)
-    auto graph_selector = [](const sycl::device& dev) {
-      if (dev.has(sycl::aspect::ext_oneapi_graph)) {
-        return 2;
-      }
-      if (dev.has(sycl::aspect::ext_oneapi_limited_graph)) {
-        return 1;
-      }
-
-      return -1;
-    };
-
-    auto sycl_queue = sycl::queue{graph_selector, {sycl::property::queue::in_order()}};
-
-    auto [dot_product, x_vector, y_vector, z_vector] =
-        CreateUsmDotProductVectors<Workload::DefaultVectorDataType>(sycl_queue,
-                                                                    Workload::kDefaultVectorSize);
-    *dot_product = static_cast<Workload::DefaultResultDataType>(0);
-
-    auto graph =
-        CreateNativeUsmDotProductGraph(sycl_queue, Workload::kDefaultVectorSize, dot_product.get(),
-                                       x_vector.get(), y_vector.get(), z_vector.get());
-
-    const auto exec = graph.finalize();
-
-    PtiCollector collector{};
-    collector.EnableViews(PTI_VIEW_DEVICE_GPU_KERNEL, PTI_VIEW_COLLECTION_OVERHEAD);
-
-    auto start_graph_execs = std::chrono::high_resolution_clock::now();
-    for (std::size_t i = 0; i < settings.iterations; ++i) {
-      sycl_queue.ext_oneapi_graph(exec).wait_and_throw();
-    }
-    auto end_graph_execs = std::chrono::high_resolution_clock::now();
-
-    collector.FinalizeCollection();
-
-    const auto total_duration = std::chrono::duration<double>(end_graph_execs - start_graph_execs);
-
-    fmt::print("Completed {} iterations of graph execution(s) in {} seconds\n", settings.iterations,
-               total_duration.count());
-
-    collector.PrintRecordStats(settings.iterations, total_duration);
-    if (settings.verbose) {
-      PtiCollector::PrintKernelRecords();
-    }
-    collector.ValidateKernelRecords(settings.iterations);
-    constexpr static double kMaxErrorPercentage = 5.0;
-    const auto result_valid = DotProductRelativeError(*dot_product, settings.iterations);
-    if (result_valid > kMaxErrorPercentage) {
-      throw std::runtime_error(fmt::format("Dot product validation failed: {}% > {}%", result_valid,
-                                           kMaxErrorPercentage));
-    }
-#else
-    fmt::print(stdout, "[SKIP] Test skipped due to unsupported native graph recording API\n");
-    return kSkipTest;
-#endif  // PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE
-
-  } catch (const sycl::exception& e) {
-    if (e.code() == sycl::make_error_code(sycl::errc::feature_not_supported) ||
-        e.code() == sycl::make_error_code(sycl::errc::invalid)) {
-      fmt::print(stdout, "[SKIP] Test skipped due to unsupported feature: {}\n", e.what());
-      return kSkipTest;
-    }
-    fmt::print(stderr, "[FATAL] SYCL Exception: {}. Error code {}\n", e.what(),
-               static_cast<std::size_t>(e.code().value()));
-    return kFailTest;
-  } catch (const std::invalid_argument& e) {
-    fmt::print(stderr, "Invalid Argument: {}\n", e.what());
-    return kFailTest;
-  } catch (const std::exception& e) {
-    fmt::print(stderr, "[FATAL] Error: {}\n", e.what());
-    return kFailTest;
-  } catch (...) {
-    fmt::print(stderr, "[FATAL] Unknown Error\n");
-    return kFailTest;
-  }
-  return kPassTest;
-}
diff --git a/sdk/test/graph/sycl_graph_test_kernels.h b/sdk/test/graph/sycl_graph_test_kernels.h
deleted file mode 100644
index 7f86b307..00000000
--- a/sdk/test/graph/sycl_graph_test_kernels.h
+++ /dev/null
@@ -1,121 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_SYCL_GRAPH_TEST_KERNELS_H_
-#define TEST_GRAPH_SYCL_GRAPH_TEST_KERNELS_H_
-
-#include <cstddef>
-#include <sycl/sycl.hpp>
-
-#include "graph_dotproduct_scalars.h"
-
-inline static constexpr auto kDefaultAlpha = PTI_TEST_GRAPH_DOTPRODUCT_ALPHA;
-inline static constexpr auto kDefaultBeta = PTI_TEST_GRAPH_DOTPRODUCT_BETA;
-inline static constexpr auto kDefaultGamma = PTI_TEST_GRAPH_DOTPRODUCT_GAMMA;
-
-template <typename T>
-struct InitDotProductVectors {
-  T* x_vec;
-  T* y_vec;
-  T* z_vec;
-  T alpha = static_cast<T>(kDefaultAlpha);
-  T beta = static_cast<T>(kDefaultBeta);
-  T gamma = static_cast<T>(kDefaultGamma);
-
-  InitDotProductVectors(T* x_vec, T* y_vec, T* z_vec) : x_vec(x_vec), y_vec(y_vec), z_vec(z_vec) {}
-
-  void operator()(sycl::id<1> it) const {  // NOLINT
-    const size_t index = it[0];
-    x_vec[index] = alpha;  // NOLINT
-    y_vec[index] = beta;   // NOLINT
-    z_vec[index] = gamma;  // NOLINT
-  }
-};
-
-template <typename T>
-struct CombineTwoVectors {
-  T* a_vec;
-  T* b_vec;
-  T alpha;
-  T beta;
-
-  CombineTwoVectors(T* a_vec, T* b_vec, T alpha, T beta)
-      : a_vec(a_vec), b_vec(b_vec), alpha(alpha), beta(beta) {}
-
-  void operator()(sycl::id<1> it) const {                           // NOLINT
-    const size_t index = it[0];                                     // NOLINT
-    a_vec[index] = (alpha * a_vec[index]) + (beta * b_vec[index]);  // NOLINT
-  }
-};
-
-template <typename T>
-struct CalculateDotProduct {
-  T* a_vec;
-  T* b_vec;
-  T* result;
-  size_t vector_size;
-
-  CalculateDotProduct(T* a_vec, T* b_vec, T* result, size_t vector_size)
-      : a_vec(a_vec), b_vec(b_vec), result(result), vector_size(vector_size) {}
-
-  void operator()() const {
-    for (size_t index = 0; index < vector_size; ++index) {
-      *result += a_vec[index] * b_vec[index];  // NOLINT
-    }
-  }
-};
-
-template <typename T>
-struct IncrementBufferKernel {
-  T data_ptr;
-
-  explicit IncrementBufferKernel(T data_ptr) : data_ptr(data_ptr) {}
-
-  void operator()(sycl::item<1> id) const {  // NOLINT
-    data_ptr[id]++;                          // NOLINT
-  }
-};
-
-template <typename T, typename U>
-struct AddBuffersKernel {
-  T read_buffer;
-  U read_write_buffer;
-
-  AddBuffersKernel(T read_buffer, U read_write_buffer)
-      : read_buffer(read_buffer), read_write_buffer(read_write_buffer) {}
-
-  void operator()(sycl::item<1> id) const {    // NOLINT
-    read_write_buffer[id] += read_buffer[id];  // NOLINT
-  }
-};
-
-template <typename T, typename U>
-struct SubtractBuffersKernel {
-  T read_buffer;
-  U read_write_buffer;
-
-  SubtractBuffersKernel(T read_buffer, U read_write_buffer)
-      : read_buffer(read_buffer), read_write_buffer(read_write_buffer) {}
-
-  void operator()(sycl::item<1> id) const {    // NOLINT
-    read_write_buffer[id] -= read_buffer[id];  // NOLINT
-  }
-};
-
-template <typename T>
-struct DecrementBuffersKernel {
-  T first_buffer;
-  T second_buffer;
-
-  DecrementBuffersKernel(T first_buffer, T second_buffer)
-      : first_buffer(first_buffer), second_buffer(second_buffer) {}
-
-  void operator()(sycl::item<1> id) const {  // NOLINT
-    first_buffer[id]--;
-    second_buffer[id]--;
-  }
-};
-
-#endif  // TEST_GRAPH_SYCL_GRAPH_TEST_KERNELS_H_
diff --git a/sdk/test/graph/sycl_graph_workloads.h b/sdk/test/graph/sycl_graph_workloads.h
deleted file mode 100644
index fb5b9084..00000000
--- a/sdk/test/graph/sycl_graph_workloads.h
+++ /dev/null
@@ -1,110 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_SYCL_GRAPH_WORKLOADS_H_
-#define TEST_GRAPH_SYCL_GRAPH_WORKLOADS_H_
-
-#include <cstddef>
-#include <sycl/sycl.hpp>
-#include <tuple>
-
-#include "graph_dotproduct_workload_info.h"
-#include "sycl_graph_test_kernels.h"
-#include "utils/sycl_config_info.h"
-#include "utils/sycl_usm_helper.h"
-
-// The first USM vector is the result (shared memory with host), the rest are the input vectors
-// (device).
-template <typename T>
-[[nodiscard]] inline auto CreateUsmDotProductVectors(sycl::queue& queue, size_t n) {
-  return std::make_tuple(pti::test::utils::CreateSharedUsmVector<T>(queue, 1),
-                         pti::test::utils::CreateDeviceUsmVector<T>(queue, n),
-                         pti::test::utils::CreateDeviceUsmVector<T>(queue, n),
-                         pti::test::utils::CreateDeviceUsmVector<T>(queue, n));
-}
-
-template <typename T>
-[[nodiscard]] inline auto CreateUsmDotProductGraph(sycl::queue& queue, std::size_t vector_size,
-                                                   T* dot_product, T* x_vector, T* y_vector,
-                                                   T* z_vector) {
-  sycl::ext::oneapi::experimental::command_graph graph{queue};
-  const sycl::range<1> exec_range{vector_size};
-
-  const auto node_i = graph.add([x_vector, y_vector, z_vector, exec_range](auto& handler) {
-    handler.parallel_for(exec_range, InitDotProductVectors(x_vector, y_vector, z_vector));
-  });
-  const auto node_a = graph.add(
-      [x_vector, y_vector, exec_range](auto& handler) {
-        handler.parallel_for(
-            exec_range, CombineTwoVectors{x_vector, y_vector, DotProductWorkload<T>::kDefaultAlpha,
-                                          DotProductWorkload<T>::kDefaultBeta});
-      },
-      {sycl::ext::oneapi::experimental::property::node::depends_on(node_i)});
-
-  const auto node_b = graph.add(
-      [y_vector, z_vector, exec_range](auto& handler) {
-        handler.parallel_for(
-            exec_range, CombineTwoVectors{z_vector, y_vector, DotProductWorkload<T>::kDefaultGamma,
-                                          DotProductWorkload<T>::kDefaultBeta});
-      },
-      {sycl::ext::oneapi::experimental::property::node::depends_on(node_i)});
-
-  graph.add(
-      [dot_product, x_vector, z_vector, vector_size](auto& handler) {
-        handler.single_task(CalculateDotProduct{x_vector, z_vector, dot_product, vector_size});
-      },
-      {sycl::ext::oneapi::experimental::property::node::depends_on(node_a, node_b)});
-
-  return graph;
-}
-
-template <typename T>
-inline void RecordUsmDotProductGraph(sycl::queue& queue, std::size_t vector_size, T* dot_product,
-                                     T* x_vector, T* y_vector, T* z_vector) {
-  const sycl::range<1> exec_range{vector_size};
-  queue.parallel_for(exec_range, InitDotProductVectors(x_vector, y_vector, z_vector));
-
-  queue.parallel_for(exec_range,
-                     CombineTwoVectors{x_vector, y_vector, DotProductWorkload<T>::kDefaultAlpha,
-                                       DotProductWorkload<T>::kDefaultBeta});
-
-  queue.parallel_for(exec_range,
-                     CombineTwoVectors{z_vector, y_vector, DotProductWorkload<T>::kDefaultGamma,
-                                       DotProductWorkload<T>::kDefaultBeta});
-
-  queue.single_task(CalculateDotProduct{x_vector, z_vector, dot_product, vector_size});
-}
-
-#if defined(PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE)
-template <typename T>
-[[nodiscard]] inline auto CreateNativeUsmDotProductGraph(sycl::queue& queue,
-                                                         std::size_t vector_size, T* dot_product,
-                                                         T* x_vector, T* y_vector, T* z_vector) {
-  sycl::ext::oneapi::experimental::command_graph graph{
-      queue, {sycl::ext::oneapi::experimental::property::graph::enable_native_recording{}}};
-
-  graph.begin_recording(queue);
-  RecordUsmDotProductGraph(queue, vector_size, dot_product, x_vector, y_vector, z_vector);
-  graph.end_recording();
-
-  return graph;
-}
-
-template <typename T>
-[[nodiscard]] inline auto CreateUsmDotProductGraphWithRecording(sycl::queue& queue,
-                                                                std::size_t vector_size,
-                                                                T* dot_product, T* x_vector,
-                                                                T* y_vector, T* z_vector) {
-  sycl::ext::oneapi::experimental::command_graph graph{queue};
-
-  graph.begin_recording(queue);
-  RecordUsmDotProductGraph(queue, vector_size, dot_product, x_vector, y_vector, z_vector);
-  graph.end_recording();
-
-  return graph;
-}
-#endif  // PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE
-
-#endif  // TEST_GRAPH_SYCL_GRAPH_WORKLOADS_H_
diff --git a/sdk/test/graph/ze_command_visitor_tests.cc b/sdk/test/graph/ze_command_visitor_tests.cc
deleted file mode 100644
index c8d7add7..00000000
--- a/sdk/test/graph/ze_command_visitor_tests.cc
+++ /dev/null
@@ -1,348 +0,0 @@
-#include <gtest/gtest.h>
-#include <level_zero/driver_experimental/zex_visit.h>
-#include <level_zero/ze_api.h>
-
-#include <memory>
-#include <stdexcept>
-#include <type_traits>
-
-#include "lz_api_tracing_api_loader.h"
-#include "utils.h"
-#include "utils/gtest_helpers.h"
-#include "ze_command_visitor.h"
-#include "ze_driver_init.h"
-#include "ze_event_managers.h"
-#include "ze_gpu_command.h"
-#include "ze_utils.h"
-
-namespace {
-constexpr uint32_t kDriverVersionWithBrokenVisitorExtension = 17012470;
-}  // namespace
-
-class ZeCommandVisitorTestSuite : public testing::Test {
- protected:
-  static constexpr size_t kPtiDeviceId = 0;
-  static constexpr const char* const kKernelName = "GEMM";
-  static constexpr const char* const kKernelFile = "gemm.spv";
-  static constexpr uint32_t kSize = 1024;
-  static constexpr size_t kAlign = 64;
-  using CommandListUniquePtr = std::unique_ptr<std::remove_pointer_t<ze_command_list_handle_t>,
-                                               void (*)(ze_command_list_handle_t)>;
-
-  ZeCommandVisitorTestSuite()
-      : spv_binary_(utils::LoadBinaryFile(utils::GetExecutablePath() + kKernelFile)) {}
-
-  void SetUp() override {
-    if (!driver_init_.Success()) {
-      GTEST_SKIP() << "Driver initialization failed, skipping test.";
-    }
-    for (auto* driver : driver_init_.Drivers()) {
-      auto extension = driver_init_.GetExtension<ZeExts::Visit>(driver);
-      if (extension) {
-        driver_ = driver;
-        driver_props_ = utils::ze::GetDriverProperties(driver_);
-        visit_extension_ = *extension;
-        break;
-      }
-    }
-    if (!visit_extension_.ze_command_list_visit) {
-      GTEST_SKIP() << "Command list visit extension not supported, skipping test.";
-    }
-    auto drivers = std::vector<ze_driver_handle_t>{driver_};
-    device_ = utils::ze::GetGpuDevice(drivers, kPtiDeviceId);
-    if (!device_) {
-      GTEST_SKIP() << "No GPU device found, skipping test.";
-    }
-    context_ = utils::ze::GetContext(driver_);
-  }
-
-  void CreateKernel() {
-    const ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                          nullptr,
-                                          ZE_MODULE_FORMAT_IL_SPIRV,
-                                          std::size(spv_binary_),
-                                          std::data(spv_binary_),
-                                          nullptr,
-                                          nullptr};
-
-    auto status = zeModuleCreate(context_, device_, &module_desc, &mdl_, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    ASSERT_NE(mdl_, nullptr);
-    const ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, kKernelName};
-    status = zeKernelCreate(mdl_, &kernel_desc, &knl_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void SetKernelGroupSize() {
-    ASSERT_NE(knl_, nullptr);
-    auto status = zeKernelSuggestGroupSize(knl_, kSize, kSize, 1, std::data(group_size_),
-                                           std::data(group_size_) + 1, std::data(group_size_) + 2);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    if ((kSize % group_size_[0]) != 0 || (kSize % group_size_[1]) != 0) {
-      FAIL() << "Non-uniform group size";
-    }
-    status = zeKernelSetGroupSize(knl_, group_size_[0], group_size_[1], group_size_[2]);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void SetKernelGroupCount() {
-    ASSERT_NE(group_size_[0], 0U);
-    ASSERT_NE(group_size_[1], 0U);
-    dim_ = {kSize / group_size_[0], kSize / group_size_[1], 1};
-  }
-
-  void* AllocateDeviceBuffer(size_t size, size_t alignment) {
-    void* storage = nullptr;
-    const ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr,
-                                                   0, 0};
-    if (!context_ || !device_) {
-      return nullptr;
-    }
-    if (zeMemAllocDevice(context_, &alloc_desc, size, alignment, device_, &storage) !=
-        ZE_RESULT_SUCCESS) {
-      return nullptr;
-    }
-    return storage;
-  }
-
-  void AllocateGemmDeviceBuffers() {
-    const size_t buffer_size = static_cast<size_t>(kSize) * kSize * sizeof(float);
-    a_buf_ = AllocateDeviceBuffer(buffer_size, kAlign);
-    ASSERT_NE(a_buf_, nullptr);
-    b_buf_ = AllocateDeviceBuffer(buffer_size, kAlign);
-    ASSERT_NE(b_buf_, nullptr);
-    result_buf_ = AllocateDeviceBuffer(buffer_size, kAlign);
-    ASSERT_NE(result_buf_, nullptr);
-  }
-
-  void TearDown() override {
-    if (result_buf_) {
-      EXPECT_EQ(zeMemFree(context_, result_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (b_buf_) {
-      EXPECT_EQ(zeMemFree(context_, b_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (a_buf_) {
-      EXPECT_EQ(zeMemFree(context_, a_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (knl_) {
-      EXPECT_EQ(zeKernelDestroy(knl_), ZE_RESULT_SUCCESS);
-    }
-
-    if (mdl_) {
-      EXPECT_EQ(zeModuleDestroy(mdl_), ZE_RESULT_SUCCESS);
-    }
-    if (context_) {
-      zeContextDestroy(context_);
-    }
-  }
-
-  CommandListUniquePtr CreateCommandList() {
-    ze_command_list_desc_t desc = {};
-    desc.stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC;
-    desc.flags |= ZE_COMMAND_LIST_FLAG_ENABLE_CMD_VISITING;
-    desc.pNext = nullptr;
-    desc.commandQueueGroupOrdinal = 0;
-    ze_command_list_handle_t command_list = nullptr;
-    ze_result_t result = zeCommandListCreate(context_, device_, &desc, &command_list);
-    if (result != ZE_RESULT_SUCCESS) {
-      throw std::runtime_error("Failed to create command list");
-    }
-    return CommandListUniquePtr(command_list, [](auto cmdlist) {
-      if (cmdlist) {
-        zeCommandListDestroy(cmdlist);
-      }
-    });
-  }
-
-  static void ResetCommandList(CommandListUniquePtr& command_list) {
-    if (command_list) {
-      auto result = zeCommandListReset(command_list.get());
-      if (result != ZE_RESULT_SUCCESS) {
-        throw std::runtime_error("Failed to reset command list");
-      }
-    }
-  }
-
-  std::vector<uint8_t> spv_binary_;
-  ZeDriverInit driver_init_{};
-  ZeEventPoolManager event_pool_manager_{};
-  ze_driver_handle_t driver_ = nullptr;
-  std::optional<ze_driver_properties_t> driver_props_ = std::nullopt;
-  ZeExts::Visit visit_extension_{};
-  ze_device_handle_t device_ = nullptr;
-  ze_context_handle_t context_ = nullptr;
-  ze_module_handle_t mdl_ = nullptr;
-  ze_kernel_handle_t knl_ = nullptr;
-  std::array<uint32_t, 3> group_size_ = {0};
-  ze_group_count_t dim_ = {0, 0, 0};
-  void* a_buf_ = nullptr;
-  void* b_buf_ = nullptr;
-  void* result_buf_ = nullptr;
-};
-
-TEST_F(ZeCommandVisitorTestSuite, ConstructCommandVisitorWithNullEventPool) {
-  // We need an event pool to construct the visitor to ensure proper swap event management.
-  EXPECT_THROW(ZeCommandVisitor visitor(visit_extension_, nullptr);, std::invalid_argument);
-}
-
-TEST_F(ZeCommandVisitorTestSuite, ConstructCommandVisitorWithValidEventPool) {
-  // We need an event pool to construct the visitor to ensure proper swap event management.
-  EXPECT_NO_THROW(ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_););
-}
-
-TEST_F(ZeCommandVisitorTestSuite, VisitEmptyCommandList) {
-  auto command_list = CreateCommandList();
-  auto command_list_instrumented = CreateCommandList();
-  ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_);
-  ZeDeviceDescriptor device_desc{};
-  ZeCommandListInfo command_list_info{};
-  auto [commands, result] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                          command_list_instrumented.get());
-  EXPECT_EQ(result, ZE_RESULT_SUCCESS);
-  EXPECT_TRUE(commands.empty());
-}
-
-TEST_F(ZeCommandVisitorTestSuite, VisitOpenCommandListWithASingleCommand) {
-  auto command_list = CreateCommandList();
-  auto command_list_instrumented = CreateCommandList();
-  ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_);
-  ZeDeviceDescriptor device_desc{};
-  ZeCommandListInfo command_list_info{};
-  command_list_info.closed = false;
-  command_list_info.context = context_;
-  command_list_info.device = device_;
-  auto append_result = zeCommandListAppendBarrier(command_list.get(), nullptr, 0, nullptr);
-  ASSERT_EQ(append_result, ZE_RESULT_SUCCESS);
-  auto [commands, result] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                          command_list_instrumented.get());
-  EXPECT_EQ(result, ZE_RESULT_SUCCESS);
-  EXPECT_EQ(commands.size(), 1);
-  EXPECT_EQ(commands[0].get()->props.type, KernelCommandType::kCommand);
-}
-
-TEST_F(ZeCommandVisitorTestSuite, VisitClosedCommandListWithASingleCommand) {
-  auto command_list = CreateCommandList();
-  auto command_list_instrumented = CreateCommandList();
-  ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_);
-  ZeDeviceDescriptor device_desc{};
-  ZeCommandListInfo command_list_info{};
-  command_list_info.context = context_;
-  command_list_info.device = device_;
-  auto append_result = zeCommandListAppendBarrier(command_list.get(), nullptr, 0, nullptr);
-  ASSERT_EQ(append_result, ZE_RESULT_SUCCESS);
-  auto close_result = zeCommandListClose(command_list.get());
-  ASSERT_EQ(close_result, ZE_RESULT_SUCCESS);
-  command_list_info.closed = true;
-  auto [commands, result] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                          command_list_instrumented.get());
-  EXPECT_EQ(result, ZE_RESULT_SUCCESS);
-  EXPECT_EQ(commands.size(), 1);
-  EXPECT_EQ(commands[0].get()->props.type, KernelCommandType::kCommand);
-}
-
-TEST_F(ZeCommandVisitorTestSuite, VisitSkipsCommandWhenLoaderSymbolMissing) {
-  if (driver_props_) {
-    // zeCommandListAppendLaunchKernelWithArguments callback inside the driver has the wrong
-    // signature. This is fixed in later driver versions.
-    if (driver_props_->driverVersion <= kDriverVersionWithBrokenVisitorExtension) {
-      GTEST_SKIP() << "Driver version " << kDriverVersionWithBrokenVisitorExtension
-                   << " or lower has a broken (or non existent) command list visitor extension, "
-                      "skipping test.";
-    }
-  }
-  auto& loader = pti::PtiLzTracerLoader::Instance();
-  auto saved = loader.zeCommandListAppendLaunchKernelWithArguments_;
-  ASSERT_NE(saved, nullptr) << "Loader barrier symbol should be resolved before corruption";
-  loader.zeCommandListAppendLaunchKernelWithArguments_ = nullptr;
-  // Since the loader is global, ensure its restored after test runs.
-  struct GuardLzLoader {
-    using SavedSymbolType = decltype(saved);
-    pti::PtiLzTracerLoader* lz_loader;
-    SavedSymbolType saved_symbol;
-    GuardLzLoader(pti::PtiLzTracerLoader* loader, SavedSymbolType symbol)
-        : lz_loader(loader), saved_symbol(symbol) {}
-    GuardLzLoader(const GuardLzLoader&) = delete;
-    GuardLzLoader& operator=(const GuardLzLoader&) = delete;
-    GuardLzLoader(GuardLzLoader&&) noexcept = delete;
-    GuardLzLoader& operator=(GuardLzLoader&&) noexcept = delete;
-    ~GuardLzLoader() { lz_loader->zeCommandListAppendLaunchKernelWithArguments_ = saved_symbol; }
-  };
-
-  GuardLzLoader restore_symbol{&loader, saved};
-
-  auto command_list = CreateCommandList();
-  auto command_list_instrumented = CreateCommandList();
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelGroupCount();
-  AllocateGemmDeviceBuffers();
-
-  ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_);
-  ZeDeviceDescriptor device_desc{};
-  ZeCommandListInfo command_list_info{};
-  command_list_info.context = context_;
-  command_list_info.device = device_;
-  const ze_group_size_t group_size{group_size_[0], group_size_[1], group_size_[2]};
-  auto kernel_size = kSize;
-  std::array<void*, 4> kernel_args = {&a_buf_, &b_buf_, &result_buf_, &kernel_size};
-  auto append_result = zeCommandListAppendLaunchKernelWithArguments(
-      command_list.get(), knl_, dim_, group_size, kernel_args.data(), nullptr, nullptr, 0, nullptr);
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(append_result);
-  EXPECT_EQ(append_result, ZE_RESULT_SUCCESS);
-  auto close_result = zeCommandListClose(command_list.get());
-  ASSERT_EQ(close_result, ZE_RESULT_SUCCESS);
-  command_list_info.closed = true;
-
-  auto [commands, result] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                          command_list_instrumented.get());
-
-  // We're missing a symbol from the loader; therefore, we cannot rebuild the user's command list.
-  EXPECT_TRUE(commands.empty());
-  ASSERT_NE(result, ZE_RESULT_SUCCESS);
-}
-
-// This test is actually a regression test for a known issue in the driver where the command list
-// visitor extension does not handle CommandListReset.
-TEST_F(ZeCommandVisitorTestSuite, VisitClosedCommandListWithASingleCommandThenResetAndTryAgain) {
-  if (driver_props_) {
-    // This is fixed in later driver versions.
-    if (driver_props_->driverVersion <= kDriverVersionWithBrokenVisitorExtension) {
-      GTEST_SKIP() << "Driver version " << kDriverVersionWithBrokenVisitorExtension
-                   << " or lower has a broken (or non existent) command list visitor extension, "
-                      "skipping test.";
-    }
-  }
-  auto command_list = CreateCommandList();
-  auto command_list_instrumented = CreateCommandList();
-  ZeCommandVisitor visitor(visit_extension_, &event_pool_manager_);
-  ZeDeviceDescriptor device_desc{};
-  ZeCommandListInfo command_list_info{};
-  command_list_info.context = context_;
-  command_list_info.device = device_;
-  auto append_result = zeCommandListAppendBarrier(command_list.get(), nullptr, 0, nullptr);
-  ASSERT_EQ(append_result, ZE_RESULT_SUCCESS);
-  auto close_result = zeCommandListClose(command_list.get());
-  ASSERT_EQ(close_result, ZE_RESULT_SUCCESS);
-  command_list_info.closed = true;
-  auto [commands, result] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                          command_list_instrumented.get());
-  EXPECT_EQ(result, ZE_RESULT_SUCCESS);
-  EXPECT_EQ(commands.size(), 1);
-  EXPECT_EQ(commands[0].get()->props.type, KernelCommandType::kCommand);
-  ResetCommandList(command_list);
-  append_result = zeCommandListAppendBarrier(command_list.get(), nullptr, 0, nullptr);
-  ASSERT_EQ(append_result, ZE_RESULT_SUCCESS);
-  close_result = zeCommandListClose(command_list.get());
-  ASSERT_EQ(close_result, ZE_RESULT_SUCCESS);
-  auto [commands2, result2] = visitor.Visit(device_desc, command_list_info, command_list.get(),
-                                            command_list_instrumented.get());
-  EXPECT_EQ(result2, ZE_RESULT_SUCCESS);
-  EXPECT_EQ(commands2.size(), 1);
-  EXPECT_EQ(commands2[0].get()->props.type, KernelCommandType::kCommand);
-}
diff --git a/sdk/test/graph/ze_graph_fixture.cc b/sdk/test/graph/ze_graph_fixture.cc
deleted file mode 100644
index 152883d9..00000000
--- a/sdk/test/graph/ze_graph_fixture.cc
+++ /dev/null
@@ -1,753 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "graph_dotproduct_workload_info.h"
-#include "graph_record_validation.h"
-#include "pti/pti_view.h"
-#include "utils/gtest_helpers.h"
-#include "utils/pti_record_collection_fixture.h"
-#include "utils/utils.h"
-#include "utils/ze_symbol_loader.h"
-#include "utils/ze_utils.h"
-#include "ze_graph_workloads.h"
-
-namespace {
-
-template <typename T>
-inline void LeakHandle(T handle) {
-  static std::vector<typename T::pointer> leaked_handles;
-  leaked_handles.push_back(handle.release());
-}
-
-}  // namespace
-
-class ZeGraphTestSuite : public pti::test::utils::RecordCollectionFixture {
- protected:
-  struct ZeGraphDestroy {
-    ZeGraphTestSuite* test_suite = nullptr;
-    void operator()(ze_graph_handle_t graph) const {
-      if (graph) {
-        test_suite->ze_graph_destroy_ext_(graph);
-      }
-    }
-  };
-
-  struct ZeExecutableGraphDestroy {
-    ZeGraphTestSuite* test_suite = nullptr;
-    void operator()(ze_executable_graph_handle_t exec_graph) const {
-      if (exec_graph) {
-        test_suite->ze_executable_graph_destroy_ext_(exec_graph);
-      }
-    }
-  };
-
-  static constexpr std::uint32_t kMaxEventsRequired = 100;
-  static constexpr std::size_t kPtiDeviceId = 0;
-
-  using Workload = DotProductWorkload<float>;
-  using ZeGraph = std::unique_ptr<std::remove_pointer_t<ze_graph_handle_t>, ZeGraphDestroy>;
-  using ZeExecutableGraph = std::unique_ptr<std::remove_pointer_t<ze_executable_graph_handle_t>,
-                                            ZeExecutableGraphDestroy>;
-
-  ZeGraphTestSuite()
-      : spirv_binary_(
-            utils::LoadBinaryFile(utils::GetExecutablePath() + Workload::kSpvKernelFile)) {}
-
-  void SetUp() override {
-    if (!loader_.Loaded()) {
-      GTEST_SKIP() << "Level Zero loader not found. Skipping test.";
-    }
-
-    InitializeDriver();
-    if (drv_ == nullptr || dev_ == nullptr) {
-      GTEST_SKIP() << "No Level Zero GPU device available. Skipping ZeGraph test suite.";
-    }
-
-    ctx_ = utils::ze::GetContext(drv_);
-    ASSERT_NE(ctx_, nullptr);
-
-    auto [success, message] = LoadExtensions();
-    if (!success) {
-      GTEST_SKIP() << message;
-    }
-
-    ASSERT_NO_FATAL_FAILURE(CreateEventPool());
-    lists_ = CreateDotProductLists(ctx_, dev_);
-    ASSERT_NO_FATAL_FAILURE(CreateModule());
-    kernels_ = CreateDotProductKernels(module_);
-  }
-
-  void TearDown() override {
-    DestroyDriverResources();
-    if (ctx_) {
-      EXPECT_EQ(zeContextDestroy(ctx_), ZE_RESULT_SUCCESS);
-    }
-  }
-
-  void DestroyDriverResources() {
-    // TODO(PTI): Finish RAII-ifying all resources and simplify this function.
-    kernels_ = DotProductKernels{};
-    lists_ = DotProductLists{};
-    for (auto* event : events_) {
-      if (event) {
-        zeEventDestroy(event);
-      }
-    }
-    events_.clear();
-    if (event_pool_) {
-      zeEventPoolDestroy(event_pool_);
-      event_pool_ = nullptr;
-    }
-    if (module_) {
-      EXPECT_EQ(zeModuleDestroy(module_), ZE_RESULT_SUCCESS);
-      module_ = nullptr;
-    }
-  }
-
-  void InitializeDriver() {
-    ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-    drv_ = utils::ze::GetGpuDriver(kPtiDeviceId);
-    dev_ = utils::ze::GetGpuDevice(kPtiDeviceId);
-  }
-
-  void CreateModule() {
-    ASSERT_NE(ctx_, nullptr);
-    ASSERT_NE(dev_, nullptr);
-    ASSERT_NE(std::size(spirv_binary_), 0ULL);
-
-    const ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                          nullptr,
-                                          ZE_MODULE_FORMAT_IL_SPIRV,
-                                          std::size(spirv_binary_),
-                                          std::data(spirv_binary_),
-                                          nullptr,
-                                          nullptr};
-    ASSERT_EQ(zeModuleCreate(ctx_, dev_, &module_desc, &module_, nullptr), ZE_RESULT_SUCCESS);
-    ASSERT_NE(module_, nullptr);
-  }
-
-  void CreateEventPool() {
-    ASSERT_NE(ctx_, nullptr);
-    ASSERT_NE(dev_, nullptr);
-
-    const ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                                  ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                                                  kMaxEventsRequired};
-    ASSERT_EQ(zeEventPoolCreate(ctx_, &event_pool_desc, 1, &dev_, &event_pool_), ZE_RESULT_SUCCESS);
-    ASSERT_NE(event_pool_, nullptr);
-  }
-
-  ze_event_handle_t GetEvent(ze_event_scope_flags_t signal_scope) {
-    if (!event_pool_ || next_event_index_ >= kMaxEventsRequired) {
-      return nullptr;
-    }
-    ze_event_handle_t event = nullptr;
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, next_event_index_,
-                                  signal_scope, ZE_EVENT_SCOPE_FLAG_SUBDEVICE};
-    if (zeEventCreate(event_pool_, &event_desc, &event) != ZE_RESULT_SUCCESS || !event) {
-      return nullptr;
-    }
-    ++next_event_index_;
-    events_.push_back(event);
-    return event;
-  }
-
-  ze_event_handle_t GetEvent() { return GetEvent(ZE_EVENT_SCOPE_FLAG_SUBDEVICE); }
-
-  template <typename T>
-  auto CreateDotProductVectors(size_t vector_size) {
-    return ::CreateDotProductVectors<T>(ctx_, dev_, vector_size);
-  }
-
-  ZeGraph CreateGraph(ze_context_handle_t ctx) {
-    ze_graph_handle_t graph = nullptr;
-    if (ze_graph_create_ext_(ctx, nullptr, &graph) != ZE_RESULT_SUCCESS || !graph) {
-      throw std::runtime_error("Failed to create graph");
-    }
-    return ZeGraph{graph, ZeGraphDestroy{this}};
-  }
-
-  template <typename Func, typename... Args>
-  std::pair<ZeGraph, ZeExecutableGraph> CaptureGraph(ze_command_list_handle_t primary_list,
-                                                     Func record_func, Args&&... args) {
-    return CaptureGraphInContext(ctx_, primary_list, record_func, std::forward<Args>(args)...);
-  }
-
-  template <typename Func, typename... Args>
-  std::pair<ZeGraph, ZeExecutableGraph> CaptureGraphInContext(ze_context_handle_t ctx,
-                                                              ze_command_list_handle_t primary_list,
-                                                              Func record_func, Args&&... args) {
-    auto graph = CreateGraph(ctx);
-    if (ze_command_list_begin_capture_into_graph_ext_(primary_list, graph.get(), nullptr) !=
-        ZE_RESULT_SUCCESS) {
-      throw std::runtime_error("Failed to begin graph capture");
-    }
-
-    record_func(std::forward<Args>(args)...);
-
-    auto* graph_ptr = graph.get();
-    if (ze_command_list_end_graph_capture_ext_(primary_list, nullptr, &graph_ptr) !=
-        ZE_RESULT_SUCCESS) {
-      throw std::runtime_error("Failed to end graph capture");
-    }
-
-    ze_executable_graph_handle_t exec_graph = nullptr;
-    if (ze_graph_instantiate_ext_(graph.get(), nullptr, &exec_graph) != ZE_RESULT_SUCCESS) {
-      throw std::runtime_error("Failed to instantiate graph");
-    }
-    return {std::move(graph), ZeExecutableGraph{exec_graph, ZeExecutableGraphDestroy{this}}};
-  }
-
-  void ExecuteGraph(ze_command_list_handle_t command_list, ze_executable_graph_handle_t exec_graph,
-                    ze_event_handle_t signal_event = nullptr, uint32_t num_wait_events = 0,
-                    ze_event_handle_t* wait_events = nullptr) {
-    ASSERT_EQ(ze_command_list_append_graph_ext_(command_list, exec_graph, nullptr, signal_event,
-                                                num_wait_events, wait_events),
-              ZE_RESULT_SUCCESS);
-  }
-
-  static void WaitForGraphExecution(ze_event_handle_t event) {
-    ASSERT_EQ(zeEventHostSynchronize(event, (std::numeric_limits<uint64_t>::max)()),
-              ZE_RESULT_SUCCESS);
-  }
-
-  auto& GetDotProductLists() { return lists_; }
-
-  std::pair<bool, std::string> LoadExtensions() {
-    if (!drv_) {
-      return {false, "Driver handle is null"};
-    }
-
-    if (!utils::ze::IsDriverExtensionSupported(drv_, ZE_RECORD_REPLAY_GRAPH_EXT_NAME)) {
-      return {false, "Level Zero " + std::string(ZE_RECORD_REPLAY_GRAPH_EXT_NAME) +
-                         " extension not supported by the driver"};
-    }
-
-#define PTI_TEST_ZE_GET_SYMBOL(name) loader_.Get<decltype(&name)>(#name)
-    ze_graph_create_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeGraphCreateExt);
-    ze_graph_destroy_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeGraphDestroyExt);
-    ze_graph_instantiate_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeGraphInstantiateExt);
-    ze_graph_is_empty_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeGraphIsEmptyExt);
-    ze_graph_dump_contents_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeGraphDumpContentsExt);
-    ze_graph_set_destruction_callback_ext_ =
-        PTI_TEST_ZE_GET_SYMBOL(zeGraphSetDestructionCallbackExt);
-    ze_command_list_begin_graph_capture_ext_ =
-        PTI_TEST_ZE_GET_SYMBOL(zeCommandListBeginGraphCaptureExt);
-    ze_command_list_begin_capture_into_graph_ext_ =
-        PTI_TEST_ZE_GET_SYMBOL(zeCommandListBeginCaptureIntoGraphExt);
-    ze_command_list_end_graph_capture_ext_ =
-        PTI_TEST_ZE_GET_SYMBOL(zeCommandListEndGraphCaptureExt);
-    ze_command_list_is_graph_capture_enabled_ext_ =
-        PTI_TEST_ZE_GET_SYMBOL(zeCommandListIsGraphCaptureEnabledExt);
-    ze_command_list_append_graph_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeCommandListAppendGraphExt);
-    ze_command_list_get_graph_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeCommandListGetGraphExt);
-    ze_executable_graph_destroy_ext_ = PTI_TEST_ZE_GET_SYMBOL(zeExecutableGraphDestroyExt);
-#undef PTI_TEST_ZE_GET_SYMBOL
-
-    if (!ze_graph_create_ext_ || !ze_graph_destroy_ext_ || !ze_graph_instantiate_ext_ ||
-        !ze_graph_is_empty_ext_ || !ze_graph_dump_contents_ext_ ||
-        !ze_graph_set_destruction_callback_ext_ || !ze_command_list_begin_graph_capture_ext_ ||
-        !ze_command_list_begin_capture_into_graph_ext_ || !ze_command_list_end_graph_capture_ext_ ||
-        !ze_command_list_is_graph_capture_enabled_ext_ || !ze_command_list_append_graph_ext_ ||
-        !ze_command_list_get_graph_ext_ || !ze_executable_graph_destroy_ext_) {
-      return {false,
-              "Level Zero loader does not export the record and replay graph entry points. "
-              "Skipping ZeGraph test suite."};
-    }
-    return {true, ""};
-  }
-
-  pti::test::utils::level_zero::ZeSymbolLoader loader_{};
-
-  std::vector<std::uint8_t> spirv_binary_;
-
-  ze_driver_handle_t drv_ = nullptr;
-  ze_device_handle_t dev_ = nullptr;
-  ze_context_handle_t ctx_ = nullptr;
-  ze_module_handle_t module_ = nullptr;
-  ze_event_pool_handle_t event_pool_ = nullptr;
-  std::uint32_t next_event_index_ = 0;
-  std::vector<ze_event_handle_t> events_;
-
-  DotProductLists lists_;
-  DotProductKernels kernels_;
-
-  decltype(&zeGraphCreateExt) ze_graph_create_ext_ = nullptr;
-  decltype(&zeGraphDestroyExt) ze_graph_destroy_ext_ = nullptr;
-  decltype(&zeGraphInstantiateExt) ze_graph_instantiate_ext_ = nullptr;
-  decltype(&zeGraphIsEmptyExt) ze_graph_is_empty_ext_ = nullptr;
-  decltype(&zeGraphDumpContentsExt) ze_graph_dump_contents_ext_ = nullptr;
-  decltype(&zeGraphSetDestructionCallbackExt) ze_graph_set_destruction_callback_ext_ = nullptr;
-  decltype(&zeCommandListBeginGraphCaptureExt) ze_command_list_begin_graph_capture_ext_ = nullptr;
-  decltype(&zeCommandListBeginCaptureIntoGraphExt) ze_command_list_begin_capture_into_graph_ext_ =
-      nullptr;
-  decltype(&zeCommandListEndGraphCaptureExt) ze_command_list_end_graph_capture_ext_ = nullptr;
-  decltype(&zeCommandListIsGraphCaptureEnabledExt) ze_command_list_is_graph_capture_enabled_ext_ =
-      nullptr;
-  decltype(&zeCommandListAppendGraphExt) ze_command_list_append_graph_ext_ = nullptr;
-  decltype(&zeCommandListGetGraphExt) ze_command_list_get_graph_ext_ = nullptr;
-  decltype(&zeExecutableGraphDestroyExt) ze_executable_graph_destroy_ext_ = nullptr;
-};
-
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTracingGraphCreation) {
-  constexpr std::size_t kExpectedNumberOfDriverCalls =
-      10;  // 1 graph creation + 2 graph recording + 1 graph instantiation + 1 graph execution + 4
-           // kernel launches + 1 synch
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  std::uint32_t vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto* vector_init_event = GetEvent();
-  ASSERT_NE(vector_init_event, nullptr);
-  auto* vec_add1_event = GetEvent();
-  ASSERT_NE(vec_add1_event, nullptr);
-  auto* vec_add2_event = GetEvent();
-  ASSERT_NE(vec_add2_event, nullptr);
-  auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_finish, nullptr);
-
-  // Start tracing before graph is created and captured.
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-
-  auto [graph, exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      vector_init_event, vec_add1_event, vec_add2_event, kernels_, vectors, &vec_size);
-
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), graph_finish));
-  WaitForGraphExecution(graph_finish);
-
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  // Graph creation captured, so records expected for all kernels in the graph.
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{Workload::kDefaultKernelNumber});
-  EXPECT_GE(std::size(record_storage_.api_records), kExpectedNumberOfDriverCalls);
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionWithoutTracingGraphCreation) {
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  std::uint32_t vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto* vector_init_event = GetEvent();
-  ASSERT_NE(vector_init_event, nullptr);
-  auto* vec_add1_event = GetEvent();
-  ASSERT_NE(vec_add1_event, nullptr);
-  auto* vec_add2_event = GetEvent();
-  ASSERT_NE(vec_add2_event, nullptr);
-  auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_finish, nullptr);
-
-  auto [graph, exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      vector_init_event, vec_add1_event, vec_add2_event, kernels_, vectors, &vec_size);
-
-  // Start tracing after graph is captured.
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), graph_finish));
-  WaitForGraphExecution(graph_finish);
-
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{4});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceWithExecutableGraphDestroy) {
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto* vector_init_event = GetEvent();
-  ASSERT_NE(vector_init_event, nullptr);
-  auto* vec_add1_event = GetEvent();
-  ASSERT_NE(vec_add1_event, nullptr);
-  auto* vec_add2_event = GetEvent();
-  ASSERT_NE(vec_add2_event, nullptr);
-  auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_finish, nullptr);
-
-  auto [graph, exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      vector_init_event, vec_add1_event, vec_add2_event, kernels_, vectors, &vec_size);
-
-  // Start tracing after graph is captured.
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), graph_finish));
-  WaitForGraphExecution(graph_finish);
-
-  exec_graph.reset();  // Destroy the executable graph while tracing is enabled.
-
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{4});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceWithContextDestroy) {
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto* vector_init_event = GetEvent();
-  ASSERT_NE(vector_init_event, nullptr);
-  auto* vec_add1_event = GetEvent();
-  ASSERT_NE(vec_add1_event, nullptr);
-  auto* vec_add2_event = GetEvent();
-  ASSERT_NE(vec_add2_event, nullptr);
-  auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_finish, nullptr);
-
-  auto [graph, exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      vector_init_event, vec_add1_event, vec_add2_event, kernels_, vectors, &vec_size);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), graph_finish));
-  WaitForGraphExecution(graph_finish);
-
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-
-  // Before the context is destroyed, the resources derived from that context must be destroyed or
-  // else the test is not valid or the source of the crash will not be from the graph test.
-  // Purposely leak the graph and executable graph to test context destroy behavior.
-  LeakHandle(std::move(exec_graph));
-  LeakHandle(std::move(graph));
-
-  vectors = {};
-  DestroyDriverResources();
-  if (ctx_) {
-    const auto destroy_result = zeContextDestroy(ctx_);
-    ctx_ = nullptr;
-    ASSERT_EQ(destroy_result, ZE_RESULT_SUCCESS);
-  }
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{4});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-// Ensures we're handling state correctly when a graph is destroyed between graph executions within
-// a workload. The graph must have completed: the executable graph must not be executing when
-// destroyed.
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceWithExecutableGraphHandleDestroyMidExecution) {
-  auto first_vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto second_vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  auto [first_graph, first_exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      GetEvent(), GetEvent(), GetEvent(), kernels_, first_vectors, &vec_size);
-  auto* first_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(first_graph_finish, nullptr);
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), first_exec_graph.get(), first_graph_finish));
-  WaitForGraphExecution(first_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(first_vectors), Workload::Result());
-
-  first_exec_graph.reset();
-  first_graph.reset();
-
-  auto [second_graph, second_exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      GetEvent(), GetEvent(), GetEvent(), kernels_, second_vectors, &vec_size);
-
-  *std::get<0>(second_vectors) = 0;
-  auto* second_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(second_graph_finish, nullptr);
-  ASSERT_NO_FATAL_FAILURE(
-      ExecuteGraph(primary.get(), second_exec_graph.get(), second_graph_finish));
-  WaitForGraphExecution(second_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(second_vectors), Workload::Result());
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{8});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-// Ensures destroying an executable graph that was never appended while tracing (so it was never
-// stored or instrumented) does not touch the graph storage.
-TEST_F(ZeGraphTestSuite, TestZeUsmExecutableGraphDestroyWithoutTracedExecution) {
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto [graph, exec_graph] = CaptureGraph(primary.get(), RecordDotProductGraph, primary.get(),
-                                          fork_one.get(), fork_two.get(), GetEvent(), GetEvent(),
-                                          GetEvent(), kernels_, vectors, &vec_size);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  exec_graph.reset();
-  graph.reset();
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{0});
-}
-
-// Ensures destroying a context only releases the graphs created from that context.
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceWithOtherContextDestroy) {
-  // Create a graph as normal
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  auto [graph, exec_graph] = CaptureGraph(primary.get(), RecordDotProductGraph, primary.get(),
-                                          fork_one.get(), fork_two.get(), GetEvent(), GetEvent(),
-                                          GetEvent(), kernels_, vectors, &vec_size);
-  auto* first_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(first_graph_finish, nullptr);
-  // Execute graph once (as normal)
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), first_graph_finish));
-  WaitForGraphExecution(first_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-
-  // Create a new context and graph with that new context (will need to re-create other driver
-  // resources with that new context handle)
-  auto* other_ctx = utils::ze::GetContext(drv_);
-  ASSERT_NE(other_ctx, nullptr);
-
-  const ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                        nullptr,
-                                        ZE_MODULE_FORMAT_IL_SPIRV,
-                                        std::size(spirv_binary_),
-                                        std::data(spirv_binary_),
-                                        nullptr,
-                                        nullptr};
-  ze_module_handle_t other_module = nullptr;
-  ASSERT_EQ(zeModuleCreate(other_ctx, dev_, &module_desc, &other_module, nullptr),
-            ZE_RESULT_SUCCESS);
-
-  std::array<ze_event_handle_t, 4> other_events{};
-  constexpr auto kOtherEventCount = static_cast<std::uint32_t>(other_events.size());
-  constexpr auto kHostFlagEventIndex = kOtherEventCount - 1;
-  const ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                                ZE_EVENT_POOL_FLAG_HOST_VISIBLE, kOtherEventCount};
-  ze_event_pool_handle_t other_event_pool = nullptr;
-  ASSERT_EQ(zeEventPoolCreate(other_ctx, &event_pool_desc, 1, &dev_, &other_event_pool),
-            ZE_RESULT_SUCCESS);
-  for (std::uint32_t i = 0; i < kOtherEventCount; ++i) {
-    const auto signal_scope =
-        (i == kHostFlagEventIndex) ? ZE_EVENT_SCOPE_FLAG_HOST : ZE_EVENT_SCOPE_FLAG_SUBDEVICE;
-    const ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, i, signal_scope,
-                                        ZE_EVENT_SCOPE_FLAG_SUBDEVICE};
-    ASSERT_EQ(zeEventCreate(other_event_pool, &event_desc, &other_events.at(i)), ZE_RESULT_SUCCESS);
-  }
-
-  {
-    // Run the workload with a new context.
-    auto other_lists = CreateDotProductLists(other_ctx, dev_);
-    auto other_kernels = CreateDotProductKernels(other_module);
-    auto other_vectors = ::CreateDotProductVectors<Workload::DefaultVectorDataType>(
-        other_ctx, dev_, Workload::kDefaultVectorSize);
-    auto& [other_primary, other_fork_one, other_fork_two] = other_lists;
-
-    auto [other_graph, other_exec_graph] = CaptureGraphInContext(
-        other_ctx, other_primary.get(), RecordDotProductGraph, other_primary.get(),
-        other_fork_one.get(), other_fork_two.get(), other_events[0], other_events[1],
-        other_events[2], other_kernels, other_vectors, &vec_size);
-    ASSERT_NO_FATAL_FAILURE(
-        ExecuteGraph(other_primary.get(), other_exec_graph.get(), other_events[3]));
-    WaitForGraphExecution(other_events[3]);
-    EXPECT_FLOAT_EQ(*std::get<0>(other_vectors), Workload::Result());
-    LeakHandle(std::move(other_exec_graph));
-    LeakHandle(std::move(other_graph));
-  }
-
-  for (auto* event : other_events) {
-    EXPECT_EQ(zeEventDestroy(event), ZE_RESULT_SUCCESS);
-  }
-  EXPECT_EQ(zeEventPoolDestroy(other_event_pool), ZE_RESULT_SUCCESS);
-  EXPECT_EQ(zeModuleDestroy(other_module), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeContextDestroy(other_ctx), ZE_RESULT_SUCCESS);
-
-  *std::get<0>(vectors) = 0;
-  auto* second_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(second_graph_finish, nullptr);
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), second_graph_finish));
-  WaitForGraphExecution(second_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  // Two executions of the graph in this context and one in the destroyed context.
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{12});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-// Excercise start/stop between replays.
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceAcrossStopAndStartTracing) {
-  constexpr std::size_t kNumberOfStartStopTracingCycles = 2;
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto [graph, exec_graph] = CaptureGraph(primary.get(), RecordDotProductGraph, primary.get(),
-                                          fork_one.get(), fork_two.get(), GetEvent(), GetEvent(),
-                                          GetEvent(), kernels_, vectors, &vec_size);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  for (std::size_t i = 0; i < kNumberOfStartStopTracingCycles; ++i) {
-    *std::get<0>(vectors) = 0;
-    auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-    ASSERT_NE(graph_finish, nullptr);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), graph_finish));
-    WaitForGraphExecution(graph_finish);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-  }
-
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records),
-            std::size_t{4} * kNumberOfStartStopTracingCycles);
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionTraceWithGraphDestroyedWhileTracingStopped) {
-  auto first_vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto second_vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  {
-    auto [first_graph, first_exec_graph] = CaptureGraph(
-        primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-        GetEvent(), GetEvent(), GetEvent(), kernels_, first_vectors, &vec_size);
-    auto* first_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-    ASSERT_NE(first_graph_finish, nullptr);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_NO_FATAL_FAILURE(
-        ExecuteGraph(primary.get(), first_exec_graph.get(), first_graph_finish));
-    WaitForGraphExecution(first_graph_finish);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    EXPECT_FLOAT_EQ(*std::get<0>(first_vectors), Workload::Result());
-    // Tracing is stopped and the graph is destroyed.
-  }
-
-  auto [second_graph, second_exec_graph] = CaptureGraph(
-      primary.get(), RecordDotProductGraph, primary.get(), fork_one.get(), fork_two.get(),
-      GetEvent(), GetEvent(), GetEvent(), kernels_, second_vectors, &vec_size);
-  *std::get<0>(second_vectors) = 0;
-  auto* second_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(second_graph_finish, nullptr);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_NO_FATAL_FAILURE(
-      ExecuteGraph(primary.get(), second_exec_graph.get(), second_graph_finish));
-  WaitForGraphExecution(second_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(second_vectors), Workload::Result());
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{8});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
-
-// Stop tracing after the graph has been executed but before the graph event was synchronized.
-TEST_F(ZeGraphTestSuite, TestZeUsmGraphExecutionStopTracingJustBeforeGraphSynchronization) {
-  auto vectors =
-      CreateDotProductVectors<Workload::DefaultVectorDataType>(Workload::kDefaultVectorSize);
-  auto& [primary, fork_one, fork_two] = GetDotProductLists();
-
-  auto vec_size = static_cast<std::uint32_t>(Workload::kDefaultVectorSize);
-
-  auto [graph, exec_graph] = CaptureGraph(primary.get(), RecordDotProductGraph, primary.get(),
-                                          fork_one.get(), fork_two.get(), GetEvent(), GetEvent(),
-                                          GetEvent(), kernels_, vectors, &vec_size);
-  auto* graph_start = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_start, nullptr);
-  auto* graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(graph_finish, nullptr);
-
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_NO_FATAL_FAILURE(
-      ExecuteGraph(primary.get(), exec_graph.get(), graph_finish, 1, &graph_start));
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSignal(graph_start), ZE_RESULT_SUCCESS);
-  WaitForGraphExecution(graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-
-  *std::get<0>(vectors) = 0;
-  auto* second_graph_finish = GetEvent(ZE_EVENT_SCOPE_FLAG_HOST);
-  ASSERT_NE(second_graph_finish, nullptr);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_NO_FATAL_FAILURE(ExecuteGraph(primary.get(), exec_graph.get(), second_graph_finish));
-  WaitForGraphExecution(second_graph_finish);
-  EXPECT_FLOAT_EQ(*std::get<0>(vectors), Workload::Result());
-
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  ParseAllBuffers();
-  // The pending execution's records are delivered once tracing starts again.
-  EXPECT_EQ(std::size(record_storage_.kernel_records), std::size_t{8});
-  ValidateViewTimestamps(record_storage_.kernel_records);
-}
diff --git a/sdk/test/graph/ze_graph_test_kernels.cl b/sdk/test/graph/ze_graph_test_kernels.cl
deleted file mode 100644
index 3b6a7cc5..00000000
--- a/sdk/test/graph/ze_graph_test_kernels.cl
+++ /dev/null
@@ -1,37 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "graph_dotproduct_scalars.h"
-
-#define ALPHA PTI_TEST_GRAPH_DOTPRODUCT_ALPHA
-#define BETA PTI_TEST_GRAPH_DOTPRODUCT_BETA
-#define GAMMA PTI_TEST_GRAPH_DOTPRODUCT_GAMMA
-
-__kernel void InitDotProductVectors(__global float* x, __global float* y, __global float* z) {
-  const size_t i = get_global_id(0);
-  x[i] = ALPHA;
-  y[i] = BETA;
-  z[i] = GAMMA;
-}
-
-__kernel void VecAddAlpha(__global float* a, __global float* b) {
-  const size_t i = get_global_id(0);
-  a[i] = ALPHA * a[i] + BETA * b[i];
-}
-
-__kernel void VecAddGamma(__global float* a, __global float* b) {
-  const size_t i = get_global_id(0);
-  a[i] = GAMMA * a[i] + BETA * b[i];
-}
-
-__kernel void CalculateDotProduct(__global const float* a, __global const float* b,
-                                  __global float* result, const uint vec_size) {
-  float sum = 0.0f;
-  for (uint j = 0; j < vec_size; j++) {
-    sum += a[j] * b[j];
-  }
-  result[0] = sum;
-}
diff --git a/sdk/test/graph/ze_graph_test_kernels.spv b/sdk/test/graph/ze_graph_test_kernels.spv
deleted file mode 100644
index ad8521f1..00000000
Binary files a/sdk/test/graph/ze_graph_test_kernels.spv and /dev/null differ
diff --git a/sdk/test/graph/ze_graph_workloads.h b/sdk/test/graph/ze_graph_workloads.h
deleted file mode 100644
index c2536bfa..00000000
--- a/sdk/test/graph/ze_graph_workloads.h
+++ /dev/null
@@ -1,219 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_GRAPH_ZE_GRAPH_WORKLOADS_H_
-#define TEST_GRAPH_ZE_GRAPH_WORKLOADS_H_
-
-#include <level_zero/ze_api.h>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <tuple>
-#include <type_traits>
-
-#include "graph/graph_dotproduct_workload_info.h"
-#include "utils/ze_memory_helper.h"
-
-struct ZeKernelDestroy {
-  void operator()(ze_kernel_handle_t kernel) const {
-    if (kernel) {
-      zeKernelDestroy(kernel);
-    }
-  }
-};
-
-using ZeKernel = std::unique_ptr<std::remove_pointer_t<ze_kernel_handle_t>, ZeKernelDestroy>;
-
-struct ZeCommandListDestroy {
-  void operator()(ze_command_list_handle_t clist) const {
-    if (clist) {
-      zeCommandListDestroy(clist);
-    }
-  }
-};
-
-using ZeCommandList =
-    std::unique_ptr<std::remove_pointer_t<ze_command_list_handle_t>, ZeCommandListDestroy>;
-
-template <std::size_t ArgN>
-struct KernelBundle {
-  ZeKernel kernel = nullptr;
-  ze_group_size_t group_size{};
-  ze_group_count_t group_count{};
-  std::array<void*, ArgN> args{};
-
-  template <typename... Args>
-  void SetArgs(Args*... kernel_args) {
-    static_assert(sizeof...(kernel_args) == ArgN, "Number of kernel arguments must match ArgN");
-    static_assert(((std::is_void_v<std::remove_pointer_t<Args>> ||
-                    (std::is_trivial_v<std::remove_pointer_t<Args>> &&
-                     std::is_standard_layout_v<std::remove_pointer_t<Args>>)) &&
-                   ...),
-                  "Kernel arguments must be POD types");
-    args = {static_cast<void*>(kernel_args)...};
-  }
-};
-
-template <typename T>
-[[nodiscard]] inline auto CreateDotProductVectors(ze_context_handle_t ctx, ze_device_handle_t dev,
-                                                  size_t vector_size) {
-  return std::make_tuple(pti::test::utils::CreateSharedMemVector<T>(ctx, dev, 1),
-                         pti::test::utils::CreateDeviceMemVector<T>(ctx, dev, vector_size),
-                         pti::test::utils::CreateDeviceMemVector<T>(ctx, dev, vector_size),
-                         pti::test::utils::CreateDeviceMemVector<T>(ctx, dev, vector_size));
-}
-
-[[nodiscard]] inline auto CreateInorderImmediateCommandList(ze_context_handle_t ctx,
-                                                            ze_device_handle_t dev) {
-  ze_command_queue_desc_t cmd_queue_desc = {ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-                                            nullptr,
-                                            0,
-                                            0,
-                                            ZE_COMMAND_QUEUE_FLAG_IN_ORDER,
-                                            ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-                                            ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-
-  ze_command_list_handle_t clist = nullptr;
-  if (zeCommandListCreateImmediate(ctx, dev, &cmd_queue_desc, &clist) != ZE_RESULT_SUCCESS) {
-    throw std::runtime_error("Failed to create immediate command list");
-  }
-
-  return ZeCommandList{clist};
-}
-
-[[nodiscard]] inline auto CreateDotProductLists(ze_context_handle_t ctx, ze_device_handle_t dev) {
-  return std::make_tuple(CreateInorderImmediateCommandList(ctx, dev),
-                         CreateInorderImmediateCommandList(ctx, dev),
-                         CreateInorderImmediateCommandList(ctx, dev));
-}
-
-[[nodiscard]] inline auto CreateKernel(ze_module_handle_t module, const char* name) {
-  const ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, name};
-  ze_kernel_handle_t kernel = nullptr;
-  if (zeKernelCreate(module, &kernel_desc, &kernel) != ZE_RESULT_SUCCESS) {
-    return ZeKernel{nullptr};
-  }
-
-  return ZeKernel{kernel};
-}
-
-template <std::size_t ArgN>
-[[nodiscard]] inline auto MakeKernelBundle(ze_module_handle_t module, const char* kernel_name,
-                                           ze_group_size_t group_size,
-                                           ze_group_count_t group_count) {
-  ZeKernel kernel = CreateKernel(module, kernel_name);
-  if (!kernel) {
-    throw std::runtime_error("Failed to create kernel: " + std::string(kernel_name));
-  }
-
-  KernelBundle<ArgN> bundle;
-  bundle.kernel = std::move(kernel);
-  bundle.group_size = group_size;
-  bundle.group_count = group_count;
-  return bundle;
-}
-
-template <std::size_t ArgN>
-[[nodiscard]] inline auto MakeVectorKernelBundle(ze_module_handle_t module, const char* kernel_name,
-                                                 std::uint32_t vector_size) {
-  constexpr static auto kVectorYDimension = 1U;
-  constexpr static auto kVectorZDimension = 1U;
-
-  auto bundle = MakeKernelBundle<ArgN>(module, kernel_name, {}, {});
-
-  ze_group_size_t group_size{};
-  ze_group_count_t group_count{};
-  if (zeKernelSuggestGroupSize(bundle.kernel.get(), vector_size, kVectorYDimension,
-                               kVectorZDimension, &group_size.groupSizeX, &group_size.groupSizeY,
-                               &group_size.groupSizeZ) != ZE_RESULT_SUCCESS) {
-    throw std::runtime_error("Failed to suggest group size for kernel");
-  }
-
-  if ((vector_size % group_size.groupSizeX) != 0) {
-    throw std::runtime_error("Non-uniform group size suggested by driver");
-  }
-
-  group_count.groupCountX = vector_size / group_size.groupSizeX;
-  group_count.groupCountY = kVectorYDimension;
-  group_count.groupCountZ = kVectorZDimension;
-
-  bundle.group_size = group_size;
-  bundle.group_count = group_count;
-
-  return bundle;
-}
-
-using DotProductLists = std::tuple<ZeCommandList, ZeCommandList, ZeCommandList>;
-
-using DotProductKernels =
-    std::tuple<KernelBundle<DotProductWorkload<float>::InitDotProductCl::kArgN>,
-               KernelBundle<DotProductWorkload<float>::VecAddAlphaCl::kArgN>,
-               KernelBundle<DotProductWorkload<float>::VecAddGammaCl::kArgN>,
-               KernelBundle<DotProductWorkload<float>::CalculateDotProductCl::kArgN>>;
-
-using DotProductVectors =
-    std::tuple<pti::test::utils::ZeMemVector<float>, pti::test::utils::ZeMemVector<float>,
-               pti::test::utils::ZeMemVector<float>, pti::test::utils::ZeMemVector<float>>;
-
-[[nodiscard]] inline DotProductKernels CreateDotProductKernels(ze_module_handle_t module) {
-  using Workload = DotProductWorkload<float>;
-
-  auto init = MakeVectorKernelBundle<Workload::InitDotProductCl::kArgN>(
-      module, Workload::InitDotProductCl::kKernelName, Workload::kDefaultVectorSize);
-  auto vec_add_alpha = MakeVectorKernelBundle<Workload::VecAddAlphaCl::kArgN>(
-      module, Workload::VecAddAlphaCl::kKernelName, Workload::kDefaultVectorSize);
-  auto vec_add_gamma = MakeVectorKernelBundle<Workload::VecAddGammaCl::kArgN>(
-      module, Workload::VecAddGammaCl::kKernelName, Workload::kDefaultVectorSize);
-  auto calculate_dot_product = MakeVectorKernelBundle<Workload::CalculateDotProductCl::kArgN>(
-      module, Workload::CalculateDotProductCl::kKernelName, 1U);
-
-  return std::make_tuple(std::move(init), std::move(vec_add_alpha), std::move(vec_add_gamma),
-                         std::move(calculate_dot_product));
-}
-
-template <typename T, std::size_t NumberOfWaitEvents = 0>
-inline void AppendKernelBundle(ze_command_list_handle_t clist, T& bundle,
-                               ze_event_handle_t signal_event,
-                               std::array<ze_event_handle_t, NumberOfWaitEvents> wait_events = {}) {
-  if (zeCommandListAppendLaunchKernelWithArguments(clist, bundle.kernel.get(), bundle.group_count,
-                                                   bundle.group_size, bundle.args.data(), nullptr,
-                                                   signal_event, std::size(wait_events),
-                                                   std::data(wait_events)) != ZE_RESULT_SUCCESS) {
-    throw std::runtime_error("Failed to append kernel to command list");
-  }
-}
-
-inline void RecordDotProductGraph(ze_command_list_handle_t primary,
-                                  ze_command_list_handle_t fork_one,
-                                  ze_command_list_handle_t fork_two,
-                                  ze_event_handle_t vector_init_event,
-                                  ze_event_handle_t vec_add_event, ze_event_handle_t vec_add2_event,
-                                  DotProductKernels& kernels, DotProductVectors& vectors,
-                                  std::uint32_t* vector_size) {
-  auto& [init_kernel, vec_add_alpha_kernel, vec_add_gamma_kernel, calculate_dot_product_kernel] =
-      kernels;
-  auto& [dot_product_result, a_vec, b_vec, c_vec] = vectors;
-  auto* dot_product_result_ptr = dot_product_result.get();
-  auto* a_vec_ptr = a_vec.get();
-  auto* b_vec_ptr = b_vec.get();
-  auto* c_vec_ptr = c_vec.get();
-
-  init_kernel.SetArgs(&a_vec_ptr, &b_vec_ptr, &c_vec_ptr);
-  vec_add_alpha_kernel.SetArgs(&a_vec_ptr, &b_vec_ptr);
-  vec_add_gamma_kernel.SetArgs(&c_vec_ptr, &b_vec_ptr);
-  calculate_dot_product_kernel.SetArgs(&a_vec_ptr, &c_vec_ptr, &dot_product_result_ptr,
-                                       vector_size);
-  AppendKernelBundle(primary, init_kernel, vector_init_event);
-  AppendKernelBundle(fork_one, vec_add_alpha_kernel, vec_add_event, std::array{vector_init_event});
-  AppendKernelBundle(fork_two, vec_add_gamma_kernel, vec_add2_event, std::array{vector_init_event});
-  AppendKernelBundle(primary, calculate_dot_product_kernel, nullptr,
-                     std::array{vec_add_event, vec_add2_event});
-}
-
-#endif  // TEST_GRAPH_ZE_GRAPH_WORKLOADS_H_
diff --git a/sdk/test/init_tests.cc b/sdk/test/init_tests.cc
deleted file mode 100644
index acfd5b37..00000000
--- a/sdk/test/init_tests.cc
+++ /dev/null
@@ -1,324 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <pti/pti_view.h>
-
-#include <cstdint>
-#include <iostream>
-#include <stdexcept>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "utils/test_helpers.h"
-#include "utils/ze_config_info.h"
-#include "ze_utils.h"
-
-namespace {
-constexpr size_t kPtiDeviceId = 0;  // run on first device
-
-bool ProperLoaderForZeInitDrivers() {
-  auto loader_version = utils::ze::GetLoaderVersion();
-  if (!loader_version) {
-    return false;
-  }
-  return *loader_version >= pti::test::utils::level_zero::kProperLoaderVersionForZeInitDrivers;
-}
-
-bool ProperLoaderForZesInit() {
-  auto loader_version = utils::ze::GetLoaderVersion();
-  if (!loader_version) {
-    return false;
-  }
-  return *loader_version >= pti::test::utils::level_zero::kProperLoaderVersionForZesInit;
-}
-
-void PtiZeInitDrivers(std::vector<ze_driver_handle_t>& drivers) {
-  ze_init_driver_type_desc_t ze_init_des{};
-  ze_init_des.stype = ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC;
-  ze_init_des.pNext = nullptr;
-  ze_init_des.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU;
-  uint32_t driver_count = 0;
-  if (zeInitDrivers(&driver_count, nullptr, &ze_init_des) != ZE_RESULT_SUCCESS) {
-    std::cerr << "zeInitDrivers failed on first call." << '\n';
-    drivers = std::vector<ze_driver_handle_t>();
-    return;
-  }
-  if (driver_count) {
-    drivers = std::vector<ze_driver_handle_t>(driver_count);
-    if (zeInitDrivers(&driver_count, drivers.data(), &ze_init_des) != ZE_RESULT_SUCCESS) {
-      std::cerr << "zeInitDrivers failed to get drivers." << '\n';
-      drivers = std::vector<ze_driver_handle_t>();
-    }
-  }
-}
-
-void ZeInitOrGetDrivers(std::vector<ze_driver_handle_t>& drivers, bool called_ze_init) {
-  if (ProperLoaderForZeInitDrivers()) {
-    PtiZeInitDrivers(drivers);
-  }
-  // If zeInitDrivers is not supported, we can still use the old APIs to get the drivers.
-  if (called_ze_init && drivers.empty()) {
-    drivers = utils::ze::GetDriverList();
-  }
-}
-
-template <typename T>
-void VecAdd(sycl::queue& q, const std::vector<T>& a_vector, const std::vector<T>& b_vector,
-            std::vector<T>& sum) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-  sycl::buffer sum_buf(sum.data(), num_items);
-
-  q.submit([&](sycl::handler& h) {
-    sycl::accessor a(a_buf, h, sycl::read_only);
-    sycl::accessor b(b_buf, h, sycl::read_only);
-    sycl::accessor sum(sum_buf, h, sycl::write_only, sycl::no_init);
-    h.parallel_for(num_items, [=](auto i) { sum[i] = a[i] + b[i]; });
-  });
-  q.wait_and_throw();
-}
-
-// This workload does not really matter, as long as its SYCL and launching a kernel or memory
-// operation.
-template <typename T>
-std::vector<T> AddTwoVectorsDevice(const std::vector<T>& a_vector, const std::vector<T>& b_vector) {
-  if (a_vector.size() != b_vector.size()) {
-    throw std::invalid_argument("only two vectors of the same size supported");
-  }
-  sycl::property_list prop{sycl::property::queue::in_order()};
-  auto queue = sycl::queue(sycl::gpu_selector_v, prop);
-  std::vector<T> result(a_vector.size(), 0);
-  VecAdd(queue, a_vector, b_vector, result);
-  return result;
-}
-
-// This workload does not really matter, as long as its L0 and launching a kernel or memory
-// operation.
-template <typename T>
-void CopyToAndFromDevice(ze_driver_handle_t driver, T& memory) {
-  auto* dev = utils::ze::GetGpuDevice(kPtiDeviceId);
-  ASSERT_NE(driver, nullptr);
-  auto* ctx = utils::ze::GetContext(driver);
-
-  ze_command_queue_desc_t cmd_queue_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0, ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-      ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-
-  ze_command_queue_handle_t queue = nullptr;
-  ASSERT_EQ(zeCommandQueueCreate(ctx, dev, &cmd_queue_desc, &queue), ZE_RESULT_SUCCESS);
-
-  ze_command_list_desc_t cmd_list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-  cmd_list_desc.flags |= ZE_COMMAND_LIST_FLAG_IN_ORDER;
-
-  ze_command_list_handle_t list = nullptr;
-  ASSERT_EQ(zeCommandListCreate(ctx, dev, &cmd_list_desc, &list), ZE_RESULT_SUCCESS);
-
-  const ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr,
-                                                 0, 0};
-  auto copy_size = std::size(memory) * sizeof(typename T::value_type);
-  constexpr auto kAlign = 64;
-  void* device_storage = nullptr;
-  ASSERT_EQ(zeMemAllocDevice(ctx, &alloc_desc, copy_size, kAlign, dev, &device_storage),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(list, device_storage, std::data(memory), copy_size,
-                                          nullptr, 0, nullptr),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendBarrier(list, nullptr, 0, nullptr), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(list, std::data(memory), device_storage, copy_size,
-                                          nullptr, 0, nullptr),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendBarrier(list, nullptr, 0, nullptr), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListClose(list), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandQueueExecuteCommandLists(queue, 1, &list, nullptr), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandQueueSynchronize(queue, UINT64_MAX), ZE_RESULT_SUCCESS);
-  EXPECT_EQ(zeMemFree(ctx, device_storage), ZE_RESULT_SUCCESS);
-}
-
-}  // namespace
-
-// These tests are better run within the context of CTest (i.e., separate processes) since ze*Init*
-// is a global operation. However, they should pass standalone.
-// They can be greatly simplified with the introduction of PTI_VIEW_DRIVER_API (we can test tracing
-// without having to launch a kernel or memory operation. However, we want to backport this to
-// PTI 0.10.
-// Note about using zesInit, zesInit is only supported platforms later than PVC. Therefore, we
-// cannot call it or there could be crashes in other oneAPI component. However, if the user calls
-// it, it will appear as if tracing is broken because we were not able to call it pre-tracing
-// enable.
-class InitTestsFixture : public ::testing::Test {
- protected:
-  constexpr static auto kDefaultRequestedBufferSize = 1'000;
-
-  struct InitTestsData {
-    static InitTestsData& Get() {
-      static InitTestsData test_data{};
-      return test_data;
-    }
-    void Reset() {
-      kernels = 0;
-      mem_copies = 0;
-    }
-    std::size_t kernels = 0;
-    std::size_t mem_copies = 0;
-  };
-
-  static void ParseBuffer(unsigned char* buf, size_t used_bytes) {
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        FAIL() << "Found Error Parsing Records from PTI";
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          InitTestsData::Get().kernels++;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          InitTestsData::Get().mem_copies++;
-          break;
-        }
-        default: {
-          FAIL() << "Found Invalid PTI View Record: " << ptr->_view_kind;
-          break;
-        }
-      }
-    }
-  }
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      if (used_bytes) {
-        pti::test::utils::AlignedDealloc(buf);
-      }
-      return;
-    }
-    ParseBuffer(buf, used_bytes);
-    pti::test::utils::AlignedDealloc(buf);
-  }
-
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf = pti::test::utils::AlignedAlloc<unsigned char>(kDefaultRequestedBufferSize);
-    if (!*buf) {
-      FAIL() << "Unable to allocate buffer for PTI tracing";
-    }
-    *buf_size = kDefaultRequestedBufferSize;
-  }
-
-  void SetUp() override { InitTestsData::Get().Reset(); }
-};
-
-TEST_F(InitTestsFixture, CallAllTheZeInitFunctionsAndForceZesInitAfterTracingBegins) {
-  utils::SetEnv("PTI_SYSMAN_ZESINIT", "1");  // should just warn if not supported. Needed because
-                                             // DG2 and PVC don't support zesInit.
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-  std::vector<ze_driver_handle_t> drivers;
-  ZeInitOrGetDrivers(drivers, true);
-
-  auto bmg_or_newer = utils::ze::ContainsDeviceWithAtLeastIpVersion(
-      drivers, pti::test::utils::level_zero::kBmgIpVersion);
-  if (ProperLoaderForZesInit()) {
-    if (bmg_or_newer) {
-      ASSERT_EQ(zesInit(0), ZE_RESULT_SUCCESS);
-    } else {
-      zesInit(0);  // NOT VALID
-    }
-  }
-
-  constexpr std::size_t kSizeOfTestVector = 10;
-  constexpr int kDefaultValue = 8;
-  std::vector<int> vector_to_copy(kSizeOfTestVector, kDefaultValue);
-  const auto test_vector_to_copy = vector_to_copy;
-
-  ASSERT_GT(drivers.size(), static_cast<size_t>(0));
-  CopyToAndFromDevice(drivers[kPtiDeviceId], vector_to_copy);
-
-  ASSERT_EQ(vector_to_copy, test_vector_to_copy);
-
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  ASSERT_GT(InitTestsData::Get().mem_copies, static_cast<std::size_t>(0));
-}
-
-TEST_F(InitTestsFixture, CallSyclAfterTracingBegins) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  constexpr std::size_t kSizeOfTestVector = 10;
-  constexpr int kDefaultValue = 1;
-  constexpr int kDefaultResultValue = kDefaultValue + kDefaultValue;
-  const std::vector<int> first_vec(kSizeOfTestVector, kDefaultValue);
-
-  const auto result = AddTwoVectorsDevice(first_vec, first_vec);
-
-  const std::vector<int> expected_result(kSizeOfTestVector, kDefaultResultValue);
-
-  ASSERT_EQ(result, expected_result);
-
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  ASSERT_GT(InitTestsData::Get().kernels, static_cast<std::size_t>(0));
-}
-
-TEST_F(InitTestsFixture, CallTheZeInitFunctionsBesidesZesInitAfterTracingBegins) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-  std::vector<ze_driver_handle_t> drivers;
-  ZeInitOrGetDrivers(drivers, true);
-
-  constexpr std::size_t kSizeOfTestVector = 10;
-  constexpr int kDefaultValue = 8;
-  std::vector<int> vector_to_copy(kSizeOfTestVector, kDefaultValue);
-  const auto test_vector_to_copy = vector_to_copy;
-
-  ASSERT_GT(drivers.size(), static_cast<size_t>(0));
-  CopyToAndFromDevice(drivers[kPtiDeviceId], vector_to_copy);
-
-  ASSERT_EQ(vector_to_copy, test_vector_to_copy);
-
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  ASSERT_GT(InitTestsData::Get().mem_copies, static_cast<std::size_t>(0));
-}
-
-TEST_F(InitTestsFixture, CallOnlyZeInitDriversAfterTracingBegins) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-  if (!ProperLoaderForZeInitDrivers()) {  // this will fail without calling a
-                                          // zeInit* function first. However, we want to test w/only
-                                          // zeInitDrivers.
-    GTEST_SKIP() << "Skipping test because zeInitDrivers is not supported by the loader.";
-  }
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  std::vector<ze_driver_handle_t> drivers;
-  PtiZeInitDrivers(drivers);
-  if (drivers.empty()) {
-    GTEST_SKIP() << "Skipping test because zeInitDrivers is not supported by the driver.";
-  }
-
-  constexpr std::size_t kSizeOfTestVector = 10;
-  constexpr int kDefaultValue = 8;
-  std::vector<int> vector_to_copy(kSizeOfTestVector, kDefaultValue);
-  const auto test_vector_to_copy = vector_to_copy;
-
-  ASSERT_GT(drivers.size(), static_cast<size_t>(0));
-  CopyToAndFromDevice(drivers[kPtiDeviceId], vector_to_copy);
-
-  ASSERT_EQ(vector_to_copy, test_vector_to_copy);
-
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  ASSERT_GT(InitTestsData::Get().mem_copies, static_cast<std::size_t>(0));
-}
diff --git a/sdk/test/itt/CMakeLists.txt b/sdk/test/itt/CMakeLists.txt
deleted file mode 100644
index cf203099..00000000
--- a/sdk/test/itt/CMakeLists.txt
+++ /dev/null
@@ -1,245 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# oneCCL ITT collection and domain-filtering tests.
-if(HAVE_SYCL)
-  get_itt()
-
-  add_executable(itt_test_suite itt_test_suite.cc)
-  target_include_directories(
-    itt_test_suite
-    PUBLIC "${PROJECT_SOURCE_DIR}/include"
-     "${PROJECT_BINARY_DIR}/include"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src"
-      "${PROJECT_SOURCE_DIR}/src/utils"
-      "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-  )
-  target_compile_options(itt_test_suite PUBLIC -fsycl)
-  target_link_options(itt_test_suite PUBLIC -fsycl)
-  target_link_libraries(itt_test_suite PUBLIC GTest::gmock
-               GTest::gtest_main
-               spdlog::spdlog
-               fmt::fmt
-               Pti::pti_view
-               ittapi::ittnotify
-               LevelZero::level-zero
-               ${FS_LIB})
-
-  # Loading the core and registering callbacks persist for the process lifetime.
-  # Keep this startup check in its own executable so every run starts fresh.
-  add_executable(itt_initialization_test itt_initialization_test.cc)
-  target_compile_definitions(itt_initialization_test PRIVATE
-    PTI_TEST_CORE_LIBRARY_PATH="$<TARGET_FILE:pti>")
-  target_link_libraries(itt_initialization_test PRIVATE
-    Pti::pti_view ittapi::ittnotify ${CMAKE_DL_LIBS})
-  add_dependencies(itt_initialization_test pti)
-  add_test(
-    NAME IttTest.IttSetupDoesNotLoadCoreBeforeEnable
-    COMMAND itt_initialization_test)
-  set_tests_properties(IttTest.IttSetupDoesNotLoadCoreBeforeEnable PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-    LABELS "unit;itt")
-
-  # Minimal external ITT collector used by
-  # IttTest.ExternalTrivialCollectorDisablesPtiTracing.
-  add_library(itt_trivial_collector SHARED itt_trivial_collector.cc)
-  target_link_libraries(itt_trivial_collector PRIVATE
-    ittapi::headers
-    spdlog::spdlog)
-  target_compile_definitions(itt_trivial_collector PRIVATE
-    SPDLOG_ACTIVE_LEVEL=SPDLOG_LEVEL_TRACE)
-  add_dependencies(itt_test_suite itt_trivial_collector pti)
-
-  # These cases run through the explicit CTest scenarios below, which supply
-  # their startup environments. Exclude duplicate registrations when discovery
-  # filtering is supported; older CMake versions retain the existing behavior.
-  set(PTI_ITT_DISCOVERY_FILTER_ARGS)
-  if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.22")
-    string(CONCAT PTI_ITT_SCENARIO_FILTER
-      "-IttTest.PreconfiguredPtiCollectorEnablesPtiTracing:"
-      "IttTest.ExternalTrivialCollectorDisablesPtiTracing:"
-      "IttTest.UnavailableCollectorRejectsCommunicationView")
-    set(PTI_ITT_DISCOVERY_FILTER_ARGS TEST_FILTER "${PTI_ITT_SCENARIO_FILTER}")
-  endif()
-
-  # Run each collector test with libpti_view.so preconfigured. Pass labels
-  # separately because gtest_discover_tests does not preserve a semicolon list.
-  gtest_discover_tests(
-     itt_test_suite
-     ${PTI_ITT_DISCOVERY_FILTER_ARGS}
-     DISCOVERY_TIMEOUT 60
-     PROPERTIES
-        ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-        LABELS "unit"
-        LABELS "itt")
-
-  #
-  # Validates the self-registration path (GlobalIttInitializer sets
-  # INTEL_LIBITTNOTIFY64 at load time when it is not already set). Running
-  # only Task_Handlecreate_Begin_End is sufficient: if self-registration works,
-  # the ITT collector is loaded and records flow; the test body confirms that.
-  # INTEL_LIBITTNOTIFY64 is intentionally empty here.
-  #
-  add_test(
-    NAME itt_self_registration
-    COMMAND itt_test_suite --gtest_filter=IttTest.Task_Handlecreate_Begin_End)
-  set_tests_properties(itt_self_registration PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64="
-    FAIL_REGULAR_EXPRESSION "did not match any test"
-    LABELS "unit;itt")
-
-  # PTI is preloaded by a relative path. The child changes directory before
-  # loading PTI again, so the inherited collector path must be absolute.
-  string(CONCAT PTI_ITT_CHILD_COMMAND
-    "test -n \"$INTEL_LIBITTNOTIFY64\" && "
-    "unset LD_PRELOAD && cd /tmp && "
-    "exec \"$1\" --gtest_filter=IttTest.Task_Handlecreate_Begin_End")
-  add_test(
-    NAME itt_child_inherits_self_registration
-    COMMAND ${CMAKE_COMMAND} -E chdir
-            "$<TARGET_FILE_DIR:Pti::pti_view>"
-            ${CMAKE_COMMAND} -E env
-              "INTEL_LIBITTNOTIFY64="
-              "LD_PRELOAD=./$<TARGET_FILE_NAME:Pti::pti_view>"
-              /bin/sh -c "${PTI_ITT_CHILD_COMMAND}"
-              sh $<TARGET_FILE:itt_test_suite>)
-  set_tests_properties(itt_child_inherits_self_registration PROPERTIES
-    TIMEOUT 60
-    FAIL_REGULAR_EXPRESSION "did not match any test"
-    LABELS "unit;itt")
-
-  # Preserve INTEL_LIBITTNOTIFY64 when it already points to libpti_view.so and
-  # verify that PTI tracing remains enabled.
-  add_test(
-    NAME itt_preconfigured_pti_collector_enables_pti_tracing
-    COMMAND itt_test_suite --gtest_filter=IttTest.PreconfiguredPtiCollectorEnablesPtiTracing)
-  set_tests_properties(itt_preconfigured_pti_collector_enables_pti_tracing PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>;PTI_TEST_EXPECT_PRECONFIGURED_PTI_COLLECTOR=1"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  # PTI's SONAME must identify the interface already mapped into this process.
-  add_test(
-    NAME itt_preconfigured_pti_library_name_enables_pti_tracing
-    COMMAND itt_test_suite --gtest_filter=IttTest.PreconfiguredPtiCollectorEnablesPtiTracing)
-  set_tests_properties(itt_preconfigured_pti_library_name_enables_pti_tracing PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_SONAME_FILE_NAME:Pti::pti_view>;PTI_TEST_EXPECT_PRECONFIGURED_PTI_COLLECTOR=1"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  # Preserve an externally configured collector: itt_trivial_collector receives
-  # the ITT calls and PTI tracing remains disabled.
-  add_test(
-    NAME itt_external_trivial_collector_disables_pti_tracing
-    COMMAND itt_test_suite --gtest_filter=IttTest.ExternalTrivialCollectorDisablesPtiTracing)
-  set_tests_properties(itt_external_trivial_collector_disables_pti_tracing PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:itt_trivial_collector>;PTI_TEST_EXPECT_NO_ITT_COLLECTION=1"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  # Match unitrace's preloaded collector selected through a bare library name.
-  add_test(
-    NAME itt_preloaded_external_library_name_disables_pti_tracing
-    COMMAND itt_test_suite --gtest_filter=IttTest.ExternalTrivialCollectorDisablesPtiTracing)
-  set_tests_properties(itt_preloaded_external_library_name_disables_pti_tracing PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE_NAME:itt_trivial_collector>;LD_PRELOAD=$<TARGET_FILE:itt_trivial_collector>;PTI_TEST_EXPECT_NO_ITT_COLLECTION=1"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  add_test(
-    NAME itt_unresolved_library_name_rejects_communication_view
-    COMMAND itt_test_suite --gtest_filter=IttTest.UnavailableCollectorRejectsCommunicationView)
-  set_tests_properties(itt_unresolved_library_name_rejects_communication_view PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=libpti_test_missing_itt_collector.so;PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR=1;PTI_TEST_PTI_VIEW_PATH=$<TARGET_FILE:Pti::pti_view>"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  add_test(
-    NAME itt_missing_collector_rejects_communication_view
-    COMMAND itt_test_suite --gtest_filter=IttTest.UnavailableCollectorRejectsCommunicationView)
-  set_tests_properties(itt_missing_collector_rejects_communication_view PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=${PROJECT_BINARY_DIR}/missing_itt_collector.so;PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR=1;PTI_TEST_PTI_VIEW_PATH=$<TARGET_FILE:Pti::pti_view>"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  # A component longer than Linux's NAME_MAX makes the path lookup fail.
-  string(RANDOM LENGTH 256 ALPHABET "x" PTI_ITT_INVALID_PATH_COMPONENT)
-  add_test(
-    NAME itt_configuration_failure_rejects_communication_view
-    COMMAND itt_test_suite --gtest_filter=IttTest.UnavailableCollectorRejectsCommunicationView)
-  set_tests_properties(itt_configuration_failure_rejects_communication_view PROPERTIES
-    TIMEOUT 60
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=${PROJECT_BINARY_DIR}/${PTI_ITT_INVALID_PATH_COMPONENT};PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR=1;PTI_TEST_PTI_VIEW_PATH=$<TARGET_FILE:Pti::pti_view>"
-    FAIL_REGULAR_EXPRESSION "did not match any test;\\[  SKIPPED \\]"
-    LABELS "unit;itt")
-
-  # Add linked and runtime-loaded variants of the oneCCL domain-filtering tests.
-  add_subdirectory(ccl_shared_libs)
-
-  # Functional smoke test: self-register libpti_view.so and collect three ITT
-  # records from basic and nested oneCCL tasks.
-  add_executable(itt_basic itt_basic.cc)
-  target_link_options(itt_basic PUBLIC -fsycl)
-  target_compile_options(itt_basic PUBLIC -fsycl)
-  target_include_directories(itt_basic PRIVATE "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-                                               "${PROJECT_SOURCE_DIR}/src/utils")
-  target_link_libraries(itt_basic PRIVATE Pti::pti_view ittapi::ittnotify ${FS_LIB})
-  add_test(NAME itt_basic
-    COMMAND ${CMAKE_COMMAND}
-            "-DITT_BASIC_EXECUTABLE=$<TARGET_FILE:itt_basic>"
-            -P "${CMAKE_CURRENT_SOURCE_DIR}/check_itt_basic.cmake")
-  add_test(NAME itt_basic_missing_collector
-    COMMAND ${CMAKE_COMMAND}
-            "-DITT_BASIC_EXECUTABLE=$<TARGET_FILE:itt_basic>"
-            "-DITT_COLLECTOR_PATH=${PROJECT_BINARY_DIR}/kykyky"
-            -P "${CMAKE_CURRENT_SOURCE_DIR}/check_itt_basic.cmake")
-  set_tests_properties(itt_basic itt_basic_missing_collector PROPERTIES
-    TIMEOUT 60
-    LABELS "functional;itt")
-
-  # Exercise self-registration with real oneCCL workloads. Keeping
-  # INTEL_LIBITTNOTIFY64 empty verifies registration before oneCCL's first ITT call.
-  if (TARGET sycl_allreduce_usm_test)
-    find_package(oneCCL 2021.17 QUIET)
-    find_package(MPI QUIET)
-
-    if (TARGET oneCCL AND MPI_FOUND)
-      add_test(NAME sycl_allreduce_usm_test
-              COMMAND ${CMAKE_COMMAND} -E env
-                      "INTEL_LIBITTNOTIFY64="
-                      ${MPIEXEC_EXECUTABLE} -n 2
-                      $<TARGET_FILE:sycl_allreduce_usm_test> gpu device)
-      set_tests_properties(sycl_allreduce_usm_test PROPERTIES
-        LABELS "functional;ccl;itt")
-    endif()
-  endif()
-
-  if (TARGET sycl_allreduce_test)
-    find_package(oneCCL 2021.17 QUIET)
-    find_package(MPI QUIET)
-
-    if (TARGET oneCCL AND MPI_FOUND)
-      add_test(NAME sycl_allreduce_test
-              COMMAND ${CMAKE_COMMAND} -E env
-                      "INTEL_LIBITTNOTIFY64="
-                      ${MPIEXEC_EXECUTABLE} -n 2
-                      $<TARGET_FILE:sycl_allreduce_test> gpu)
-      set_tests_properties(sycl_allreduce_test PROPERTIES
-        LABELS "functional;ccl;itt")
-    endif()
-  endif()
-endif()
-
-# Collector configuration tests also run when SYCL is unavailable.
-add_subdirectory(lib_env)
diff --git a/sdk/test/itt/ccl_shared_libs/CMakeLists.txt b/sdk/test/itt/ccl_shared_libs/CMakeLists.txt
deleted file mode 100644
index ace9dcb0..00000000
--- a/sdk/test/itt/ccl_shared_libs/CMakeLists.txt
+++ /dev/null
@@ -1,90 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Add library subdirectories
-add_subdirectory(ccladd)
-add_subdirectory(foomul)
-
-# Linked-library variant of the oneCCL domain-filtering tests.
-add_executable(ccl_itt_libs_test ccl_itt_libs_test.cc)
-
-target_include_directories(
-  ccl_itt_libs_test
-  PUBLIC "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_BINARY_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-)
-target_compile_options(ccl_itt_libs_test PUBLIC -fsycl)
-target_link_options(ccl_itt_libs_test PUBLIC -fsycl)
-target_link_libraries(ccl_itt_libs_test PUBLIC
-  GTest::gmock
-  GTest::gtest_main
-  spdlog::spdlog
-  fmt::fmt
-  Pti::pti_view
-  ittapi::ittnotify
-  LevelZero::level-zero
-  ccladd
-  foomul
-  ${FS_LIB})
-
-  gtest_discover_tests(
-    ccl_itt_libs_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-        ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-        LABELS "functional"
-        LABELS "itt"
-        LABELS "ccl-filter")
-
-# Runtime-loaded variant of the same domain-filtering tests.
-add_executable(ccl_itt_dlopen_test ccl_itt_dlopen_test.cc)
-target_include_directories(
-  ccl_itt_dlopen_test
-  PUBLIC "${PROJECT_SOURCE_DIR}/include"
-         "${PROJECT_BINARY_DIR}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-          "${PROJECT_SOURCE_DIR}/src/utils"
-          "${PROJECT_SOURCE_DIR}/samples/samples_utilities"
-)
-target_compile_options(ccl_itt_dlopen_test PUBLIC -fsycl)
-target_link_options(ccl_itt_dlopen_test PUBLIC -fsycl)
-target_compile_definitions(ccl_itt_dlopen_test PRIVATE
-  CCLADD_LIB_PATH="$<TARGET_FILE:ccladd>"
-  FOOMUL_LIB_PATH="$<TARGET_FILE:foomul>")
-target_link_libraries(ccl_itt_dlopen_test PUBLIC
-  GTest::gmock
-  GTest::gtest_main
-  spdlog::spdlog
-  fmt::fmt
-  Pti::pti_view
-  LevelZero::level-zero
-  ${CMAKE_DL_LIBS}
-  ${FS_LIB})
-add_dependencies(ccl_itt_dlopen_test ccladd foomul)
-
-# Verify that libpti_view.so self-registers before ccladd.so's first ITT call
-# when INTEL_LIBITTNOTIFY64 is empty. ccladd.so models oneCCL calls originating
-# from a separate shared library, and FiltersCclBasic confirms their collection.
-add_test(
-  NAME ccl_itt_collects_without_env_var
-  COMMAND ccl_itt_libs_test --gtest_filter=CclDomainFilterTest.FiltersCclBasic)
-set_tests_properties(ccl_itt_collects_without_env_var PROPERTIES
-  TIMEOUT 60
-  ENVIRONMENT "INTEL_LIBITTNOTIFY64="
-  FAIL_REGULAR_EXPRESSION "did not match any test"
-  LABELS "functional;itt;ccl-filter")
-
-gtest_discover_tests(
-    ccl_itt_dlopen_test
-    DISCOVERY_TIMEOUT 60
-    PROPERTIES
-        ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-        LABELS "functional"
-        LABELS "itt"
-        LABELS "ccl-filter")
diff --git a/sdk/test/itt/ccl_shared_libs/ccl_itt_dlopen_test.cc b/sdk/test/itt/ccl_shared_libs/ccl_itt_dlopen_test.cc
deleted file mode 100644
index 366e2be6..00000000
--- a/sdk/test/itt/ccl_shared_libs/ccl_itt_dlopen_test.cc
+++ /dev/null
@@ -1,245 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// CCL ITT Domain Filter Tests — explicit dlopen variant
-//
-// Same domain-filter semantics as ccl_itt_libs_test but the two
-// helper libraries (libccladd.so, libfoomul.so) are loaded at
-// runtime via dlopen inside each test. This exercises the code
-// path where a profiled library is loaded after process start,
-// which is the common case in real CCL usage.
-//
-// Tests:
-//   1. FiltersCclBasic   — PTI enabled before any ITT calls.
-//      Expects only CCL domain calls (Add, Sub) to be captured.
-//
-//   2. FiltersCclDeferred — ITT calls made before PTI is enabled.
-//      Only the single Add call inside the enable/disable window
-//      should be captured.
-
-#include <dlfcn.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <cstdlib>
-#include <mutex>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "pti/pti_view.h"
-
-#ifndef CCLADD_LIB_PATH
-#error "CCLADD_LIB_PATH must be defined via target_compile_definitions"
-#endif
-
-#ifndef FOOMUL_LIB_PATH
-#error "FOOMUL_LIB_PATH must be defined via target_compile_definitions"
-#endif
-
-#define ASSERT_PTI_SUCCESS(X)                                                         \
-  do {                                                                                \
-    pti_result result = (X);                                                          \
-    ASSERT_EQ(result, pti_result::PTI_SUCCESS)                                        \
-        << "PTI CALL FAILED: " #X << " WITH ERROR " << ptiResultTypeToString(result); \
-  } while (0)
-
-namespace {
-constexpr std::align_val_t kDefaultPtiBufferAlignment{8};
-
-template <typename T>
-T* AlignedAlloc(std::size_t size) {
-  try {
-    return static_cast<T*>(::operator new(size, kDefaultPtiBufferAlignment));
-  } catch (const std::bad_alloc& e) {
-    return nullptr;
-  }
-}
-
-template <typename T>
-void AlignedDealloc(T* buf_ptr) {
-  ::operator delete(buf_ptr, kDefaultPtiBufferAlignment);
-}
-}  // namespace
-
-using FloatBinaryFn = float (*)(float, float);
-
-class CclDomainFilterDlopenTest : public ::testing::Test {
- protected:
-  static inline std::vector<pti_view_record_comms>* comms_vector_ = nullptr;
-  static inline std::mutex buffer_mutex_;
-
-  static void BufferCompletedMultiThreaded(unsigned char* buf, std::size_t buf_size,
-                                           std::size_t valid_buf_size) {
-    if (!buf || !valid_buf_size || !buf_size) {
-      if (buf) {
-        AlignedDealloc(buf);
-      }
-      return;
-    }
-
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-
-    if (!comms_vector_) {
-      ADD_FAILURE() << __FUNCTION__ << " CommsVector is null";
-      AlignedDealloc(buf);
-      return;
-    }
-
-    pti_view_record_base* ptr = nullptr;
-    pti_result result = pti_result::PTI_SUCCESS;
-    bool has_error = false;
-
-    while (pti_result::PTI_STATUS_END_OF_BUFFER !=
-           (result = ptiViewGetNextRecord(buf, valid_buf_size, &ptr))) {
-      if (result != pti_result::PTI_SUCCESS) {
-        ADD_FAILURE() << "Error retrieving the next record: " << ptiResultTypeToString(result);
-        has_error = true;
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          ADD_FAILURE() << __FUNCTION__ << " Received an invalid record";
-          has_error = true;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_COMMUNICATION: {
-          comms_vector_->push_back(*reinterpret_cast<pti_view_record_comms*>(ptr));
-          break;
-        }
-        default: {
-          ADD_FAILURE() << "Unexpected record type: " << std::hex << ptr->_view_kind;
-          has_error = true;
-          break;
-        }
-      }
-      if (has_error) break;
-    }
-
-    AlignedDealloc(buf);
-  }
-
-  static void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-    *buf = AlignedAlloc<unsigned char>(1000);
-    if (!*buf) {
-      std::abort();
-    }
-    *buf_size = 1000;
-  }
-
-  inline void PtiProlog() {
-    ASSERT_EQ(ptiViewSetCallbacks(CclDomainFilterDlopenTest::ProvideBuffer,
-                                  CclDomainFilterDlopenTest::BufferCompletedMultiThreaded),
-              pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_COMMUNICATION), pti_result::PTI_SUCCESS);
-  }
-
-  inline void PtiEpilog() {
-    ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-    ASSERT_PTI_SUCCESS(ptiFlushAllViews());
-  }
-};
-
-TEST_F(CclDomainFilterDlopenTest, LoadFirstCclSoThenNonCclSo) {
-  //
-  // Load the CCL domain library first, then the non-CCL library.
-  // The static initialization __itt_global of non-CCL is presented
-  // to the itt_adapter.cc code, and ignored. oneCCL should collect
-  // unperturbed.
-  //
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  void* ccladd_handle = dlopen(CCLADD_LIB_PATH, RTLD_NOW | RTLD_LOCAL);
-  ASSERT_NE(ccladd_handle, nullptr) << "dlopen ccladd failed: " << dlerror();
-
-  void* foomul_handle = dlopen(FOOMUL_LIB_PATH, RTLD_NOW | RTLD_LOCAL);
-  ASSERT_NE(foomul_handle, nullptr) << "dlopen foomul failed: " << dlerror();
-
-  auto Add = reinterpret_cast<FloatBinaryFn>(dlsym(ccladd_handle, "Add"));
-  ASSERT_NE(Add, nullptr) << "dlsym Add failed: " << dlerror();
-  auto Sub = reinterpret_cast<FloatBinaryFn>(dlsym(ccladd_handle, "Sub"));
-
-  PtiProlog();
-
-  auto result_add = Add(1.0f, 2.0f);
-  auto result_sub = Sub(5.0f, 3.0f);
-
-  ASSERT_NE(Sub, nullptr) << "dlsym Sub failed: " << dlerror();
-  auto Mul = reinterpret_cast<FloatBinaryFn>(dlsym(foomul_handle, "Mul"));
-  ASSERT_NE(Mul, nullptr) << "dlsym Mul failed: " << dlerror();
-  auto Div = reinterpret_cast<FloatBinaryFn>(dlsym(foomul_handle, "Div"));
-  ASSERT_NE(Div, nullptr) << "dlsym Div failed: " << dlerror();
-
-  result_add = Add(1.0f, 2.0f);
-  result_sub = Sub(5.0f, 3.0f);
-
-  auto result_mul = Mul(4.0f, 5.0f);
-  auto result_div = Div(10.0f, 2.0f);
-
-  PtiEpilog();
-
-  dlclose(foomul_handle);
-  dlclose(ccladd_handle);
-
-  ASSERT_EQ(local_records_vector.size(), 4u)
-      << "Expected 2 records from CCL domain, got " << local_records_vector.size();
-
-  std::set<std::string> captured_names;
-  for (const auto& record : local_records_vector) {
-    ASSERT_NE(record._name, nullptr) << "Record name is null";
-    captured_names.insert(record._name);
-  }
-
-  EXPECT_TRUE(captured_names.count("Add") > 0) << "Missing 'Add' record";
-  EXPECT_TRUE(captured_names.count("Sub") > 0) << "Missing 'Sub' record";
-
-  EXPECT_FLOAT_EQ(result_add, 3.0f);
-  EXPECT_FLOAT_EQ(result_sub, 2.0f);
-  EXPECT_FLOAT_EQ(result_mul, 20.0f);
-  EXPECT_FLOAT_EQ(result_div, 5.0f);
-
-  for (const auto& record : local_records_vector) {
-    EXPECT_GE(record._end_timestamp, record._start_timestamp)
-        << "Invalid timestamps for " << record._name;
-    EXPECT_GT(record._process_id, 0) << "Invalid process ID";
-    EXPECT_GT(record._thread_id, 0) << "Invalid thread ID";
-  }
-}
-
-TEST_F(CclDomainFilterDlopenTest, NonCclSo) {
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  void* foomul_handle = dlopen(FOOMUL_LIB_PATH, RTLD_NOW | RTLD_LOCAL);
-  ASSERT_NE(foomul_handle, nullptr) << "dlopen foomul failed: " << dlerror();
-
-  auto Mul = reinterpret_cast<FloatBinaryFn>(dlsym(foomul_handle, "Mul"));
-  ASSERT_NE(Mul, nullptr) << "dlsym Mul failed: " << dlerror();
-  auto Div = reinterpret_cast<FloatBinaryFn>(dlsym(foomul_handle, "Div"));
-  ASSERT_NE(Div, nullptr) << "dlsym Div failed: " << dlerror();
-
-  auto result_mul = Mul(4.0f, 5.0f);
-  auto result_div = Div(10.0f, 2.0f);
-
-  PtiProlog();
-
-  auto result_mul_seen = Mul(3.0f, 3.0f);
-
-  PtiEpilog();
-  auto result_div_2 = Div(20.0f, 4.0f);
-
-  dlclose(foomul_handle);
-
-  ASSERT_EQ(local_records_vector.size(), 0u)
-      << "Expected 0 records from non-CCL domains, got " << local_records_vector.size();
-
-  EXPECT_FLOAT_EQ(result_mul, 20.0f);
-  EXPECT_FLOAT_EQ(result_mul_seen, 9.0f);
-  EXPECT_FLOAT_EQ(result_div, 5.0f);
-  EXPECT_FLOAT_EQ(result_div_2, 5.0f);
-}
diff --git a/sdk/test/itt/ccl_shared_libs/ccl_itt_libs_test.cc b/sdk/test/itt/ccl_shared_libs/ccl_itt_libs_test.cc
deleted file mode 100644
index aa1ac06c..00000000
--- a/sdk/test/itt/ccl_shared_libs/ccl_itt_libs_test.cc
+++ /dev/null
@@ -1,275 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// CCL ITT Domain Filter Tests
-//
-// This test suite verifies that PTI's ITT collector correctly filters
-// ITT calls by domain, capturing only calls from the "oneCCL::API" domain
-// while ignoring calls from other domains. The test mocks real application
-// behavior where ITT notifications are coming from different libraries, each
-// using different ITT domains.
-//
-// Test Libraries:
-//   - libccladd.so: Implements Add/Sub functions using "oneCCL::API" domain
-//   - libfoomul.so: Implements Mul/Div functions using "FOO1" and "FOO2" domains
-//
-// Tests:
-//   1. FiltersCclBasic: Verifies domain filtering when PTI is enabled
-//      before any ITT calls are made. Expects only CCL domain calls
-//      (Add, Sub) to be captured, while FOO domain calls (Mul, Div)
-//      are filtered out.
-//
-//   2. FiltersCclDeferred: Verifies domain filtering when ITT calls
-//      are made before PTI is enabled. Only ITT calls made between
-//      ptiViewEnable() and ptiViewDisable() should be captured.
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <cstdlib>
-#include <mutex>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "pti/pti_view.h"
-
-#define ASSERT_PTI_SUCCESS(X)                                                         \
-  do {                                                                                \
-    pti_result result = (X);                                                          \
-    ASSERT_EQ(result, pti_result::PTI_SUCCESS)                                        \
-        << "PTI CALL FAILED: " #X << " WITH ERROR " << ptiResultTypeToString(result); \
-  } while (0)
-
-namespace {
-constexpr std::align_val_t kDefaultPtiBufferAlignment{8};
-
-template <typename T>
-T* AlignedAlloc(std::size_t size) {
-  try {
-    return static_cast<T*>(::operator new(size, kDefaultPtiBufferAlignment));
-  } catch (const std::bad_alloc& e) {
-    return nullptr;
-  }
-}
-
-template <typename T>
-void AlignedDealloc(T* buf_ptr) {
-  ::operator delete(buf_ptr, kDefaultPtiBufferAlignment);
-}
-}  // namespace
-
-extern "C" {
-float Add(float x, float y);
-float Sub(float x, float y);
-float Mul(float x, float y);
-float Div(float x, float y);
-}
-
-class CclDomainFilterTest : public ::testing::Test {
- protected:
-  static inline std::vector<pti_view_record_comms>* comms_vector_ = nullptr;
-  static inline std::mutex buffer_mutex_;
-
-  static void BufferCompletedMultiThreaded(unsigned char* buf, std::size_t buf_size,
-                                           std::size_t valid_buf_size) {
-    if (!buf || !valid_buf_size || !buf_size) {
-      if (buf) {
-        AlignedDealloc(buf);
-      }
-      return;
-    }
-
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-
-    if (!comms_vector_) {
-      ADD_FAILURE() << __FUNCTION__ << " CommsVector is null";
-      AlignedDealloc(buf);
-      return;
-    }
-
-    pti_view_record_base* ptr = nullptr;
-    pti_result result = pti_result::PTI_SUCCESS;
-    bool has_error = false;
-
-    while (pti_result::PTI_STATUS_END_OF_BUFFER !=
-           (result = ptiViewGetNextRecord(buf, valid_buf_size, &ptr))) {
-      if (result != pti_result::PTI_SUCCESS) {
-        ADD_FAILURE() << "Error retrieving the next record: " << ptiResultTypeToString(result);
-        has_error = true;
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          ADD_FAILURE() << __FUNCTION__ << " Received an invalid record";
-          has_error = true;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_COMMUNICATION: {
-          comms_vector_->push_back(*reinterpret_cast<pti_view_record_comms*>(ptr));
-          break;
-        }
-        default: {
-          ADD_FAILURE() << "Unexpected record type: " << std::hex << ptr->_view_kind;
-          has_error = true;
-          break;
-        }
-      }
-      if (has_error) break;
-    }
-
-    AlignedDealloc(buf);
-  }
-
-  static void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-    *buf = AlignedAlloc<unsigned char>(1000);
-    if (!*buf) {
-      std::abort();
-    }
-    *buf_size = 1000;
-  }
-
-  inline void PtiProlog() {
-    ASSERT_EQ(ptiViewSetCallbacks(CclDomainFilterTest::ProvideBuffer,
-                                  CclDomainFilterTest::BufferCompletedMultiThreaded),
-              pti_result::PTI_SUCCESS);
-
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_COMMUNICATION), pti_result::PTI_SUCCESS);
-  }
-
-  inline void PtiEpilog() {
-    ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-    ASSERT_PTI_SUCCESS(ptiFlushAllViews());
-  }
-};
-
-TEST_F(CclDomainFilterTest, FiltersCclBasic) {
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-  size_t records_to_see = 2;
-
-  PtiProlog();
-
-  auto result_add = Add(1.0f, 2.0f);
-  auto result_sub = Sub(5.0f, 3.0f);
-  auto result_mul = Mul(4.0f, 5.0f);
-  auto result_div = Div(10.0f, 2.0f);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), records_to_see)
-      << "Expected 2 records from CCL domain, got " << local_records_vector.size();
-
-  std::set<std::string> captured_names;
-  for (const auto& record : local_records_vector) {
-    ASSERT_NE(record._name, nullptr) << "Record name is null";
-    captured_names.insert(record._name);
-  }
-
-  EXPECT_TRUE(captured_names.count("Add") > 0) << "Missing 'Add' record";
-  EXPECT_TRUE(captured_names.count("Sub") > 0) << "Missing 'Sub' record";
-
-  EXPECT_FLOAT_EQ(result_add, 3.0f);
-  EXPECT_FLOAT_EQ(result_sub, 2.0f);
-  EXPECT_FLOAT_EQ(result_mul, 20.0f);
-  EXPECT_FLOAT_EQ(result_div, 5.0f);
-
-  for (const auto& record : local_records_vector) {
-    EXPECT_GE(record._end_timestamp, record._start_timestamp)
-        << "Invalid timestamps for " << record._name;
-    EXPECT_GT(record._process_id, 0) << "Invalid process ID";
-    EXPECT_GT(record._thread_id, 0) << "Invalid thread ID";
-  }
-}
-
-TEST_F(CclDomainFilterTest, FiltersDeferredCclFirst) {
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-  size_t records_to_see = 1;
-
-  auto result_add = Add(1.0f, 2.0f);  // these from CCL domain
-  auto result_sub = Sub(5.0f, 3.0f);
-  auto result_mul = Mul(4.0f, 5.0f);  // these from FOO domain
-  auto result_div = Div(10.0f, 2.0f);
-
-  PtiProlog();
-
-  auto result_add_seen = Add(8.0f, 2.0f);
-
-  PtiEpilog();
-  auto result_sub_2 = Sub(10.0f, 3.0f);
-
-  ASSERT_EQ(local_records_vector.size(), records_to_see)
-      << "Expected " << records_to_see << " records from CCL domain, got "
-      << local_records_vector.size();
-
-  std::set<std::string> captured_names;
-  for (const auto& record : local_records_vector) {
-    ASSERT_NE(record._name, nullptr) << "Record name is null";
-    captured_names.insert(record._name);
-  }
-
-  EXPECT_TRUE(captured_names.count("Add") > 0) << "Missing 'Add' record";
-
-  EXPECT_FLOAT_EQ(result_add, 3.0f);
-  EXPECT_FLOAT_EQ(result_add_seen, 10.0f);
-  EXPECT_FLOAT_EQ(result_sub, 2.0f);
-  EXPECT_FLOAT_EQ(result_sub_2, 7.0f);
-  EXPECT_FLOAT_EQ(result_mul, 20.0f);
-  EXPECT_FLOAT_EQ(result_div, 5.0f);
-
-  for (const auto& record : local_records_vector) {
-    EXPECT_GE(record._end_timestamp, record._start_timestamp)
-        << "Invalid timestamps for " << record._name;
-    EXPECT_GT(record._process_id, 0) << "Invalid process ID";
-    EXPECT_GT(record._thread_id, 0) << "Invalid thread ID";
-  }
-}
-
-TEST_F(CclDomainFilterTest, FiltersDeferredCclSecond) {
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-  size_t records_to_see = 1;
-
-  auto result_mul = Mul(4.0f, 5.0f);  // these from FOO domain
-  auto result_div = Div(10.0f, 2.0f);
-  auto result_add = Add(1.0f, 2.0f);  // these from CCL domain
-  auto result_sub = Sub(5.0f, 3.0f);
-
-  PtiProlog();
-
-  auto result_add_seen = Add(8.0f, 2.0f);
-
-  PtiEpilog();
-  auto result_sub_2 = Sub(10.0f, 3.0f);
-
-  ASSERT_EQ(local_records_vector.size(), records_to_see)
-      << "Expected " << records_to_see << " records from CCL domain, got "
-      << local_records_vector.size();
-
-  std::set<std::string> captured_names;
-  for (const auto& record : local_records_vector) {
-    ASSERT_NE(record._name, nullptr) << "Record name is null";
-    captured_names.insert(record._name);
-  }
-
-  EXPECT_TRUE(captured_names.count("Add") > 0) << "Missing 'Add' record";
-
-  EXPECT_FLOAT_EQ(result_add, 3.0f);
-  EXPECT_FLOAT_EQ(result_add_seen, 10.0f);
-  EXPECT_FLOAT_EQ(result_sub, 2.0f);
-  EXPECT_FLOAT_EQ(result_sub_2, 7.0f);
-  EXPECT_FLOAT_EQ(result_mul, 20.0f);
-  EXPECT_FLOAT_EQ(result_div, 5.0f);
-
-  for (const auto& record : local_records_vector) {
-    EXPECT_GE(record._end_timestamp, record._start_timestamp)
-        << "Invalid timestamps for " << record._name;
-    EXPECT_GT(record._process_id, 0) << "Invalid process ID";
-    EXPECT_GT(record._thread_id, 0) << "Invalid thread ID";
-  }
-}
diff --git a/sdk/test/itt/ccl_shared_libs/ccladd/CMakeLists.txt b/sdk/test/itt/ccl_shared_libs/ccladd/CMakeLists.txt
deleted file mode 100644
index 65c5ea14..00000000
--- a/sdk/test/itt/ccl_shared_libs/ccladd/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-add_library(ccladd SHARED ccladd.cc)
-target_link_libraries(ccladd PRIVATE ittapi::ittnotify)
-set_property(TARGET ccladd PROPERTY POSITION_INDEPENDENT_CODE ON)
diff --git a/sdk/test/itt/ccl_shared_libs/ccladd/ccladd.cc b/sdk/test/itt/ccl_shared_libs/ccladd/ccladd.cc
deleted file mode 100644
index d505c6d0..00000000
--- a/sdk/test/itt/ccl_shared_libs/ccladd/ccladd.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <ittnotify.h>
-
-static __itt_domain* domain_ccl = nullptr;
-
-void create_domain() {
-  if (!domain_ccl) {
-    domain_ccl = __itt_domain_create("oneCCL::API");
-  }
-}
-
-extern "C" {
-
-__attribute__((visibility("default"))) float Add(float x, float y) {
-  create_domain();
-  static __itt_string_handle* task_add = __itt_string_handle_create("Add");
-  __itt_task_begin(domain_ccl, __itt_null, __itt_null, task_add);
-
-  float result = x + y;
-
-  __itt_task_end(domain_ccl);
-  return result;
-}
-
-__attribute__((visibility("default"))) float Sub(float x, float y) {
-  create_domain();
-  static __itt_string_handle* task_sub = __itt_string_handle_create("Sub");
-  __itt_task_begin(domain_ccl, __itt_null, __itt_null, task_sub);
-
-  float result = x - y;
-
-  __itt_task_end(domain_ccl);
-  return result;
-}
-}
diff --git a/sdk/test/itt/ccl_shared_libs/foomul/CMakeLists.txt b/sdk/test/itt/ccl_shared_libs/foomul/CMakeLists.txt
deleted file mode 100644
index c68e2bfd..00000000
--- a/sdk/test/itt/ccl_shared_libs/foomul/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-add_library(foomul SHARED foomul.cc)
-target_link_libraries(foomul PRIVATE ittapi::ittnotify)
-set_property(TARGET foomul PROPERTY POSITION_INDEPENDENT_CODE ON)
diff --git a/sdk/test/itt/ccl_shared_libs/foomul/foomul.cc b/sdk/test/itt/ccl_shared_libs/foomul/foomul.cc
deleted file mode 100644
index d53216e3..00000000
--- a/sdk/test/itt/ccl_shared_libs/foomul/foomul.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <ittnotify.h>
-
-static __itt_domain* domain_foo1 = nullptr;
-static __itt_domain* domain_foo2 = nullptr;
-
-void create_domains() {
-  if (!domain_foo1) {
-    domain_foo1 = __itt_domain_create("FOO1");
-  }
-  if (!domain_foo2) {
-    domain_foo2 = __itt_domain_create("FOO2");
-  }
-}
-extern "C" {
-
-__attribute__((visibility("default"))) float Mul(float x, float y) {
-  create_domains();
-  static __itt_string_handle* task_mul = __itt_string_handle_create("Mul");
-  __itt_task_begin(domain_foo1, __itt_null, __itt_null, task_mul);
-
-  float result = x * y;
-
-  __itt_task_end(domain_foo1);
-  return result;
-}
-
-__attribute__((visibility("default"))) float Div(float x, float y) {
-  create_domains();
-  static __itt_string_handle* task_div = __itt_string_handle_create("Div");
-  __itt_task_begin(domain_foo2, __itt_null, __itt_null, task_div);
-
-  float result = x / y;
-
-  __itt_task_end(domain_foo2);
-  return result;
-}
-}
diff --git a/sdk/test/itt/check_itt_basic.cmake b/sdk/test/itt/check_itt_basic.cmake
deleted file mode 100644
index eef24823..00000000
--- a/sdk/test/itt/check_itt_basic.cmake
+++ /dev/null
@@ -1,55 +0,0 @@
-if("${ITT_BASIC_EXECUTABLE}" STREQUAL "")
-  message(FATAL_ERROR "ITT_BASIC_EXECUTABLE must be set")
-endif()
-
-set(test_environment "PTILOG_LEVEL=warn")
-if(ITT_COLLECTOR_PATH)
-  if(EXISTS "${ITT_COLLECTOR_PATH}")
-    message(FATAL_ERROR "The test requires a nonexistent collector: ${ITT_COLLECTOR_PATH}")
-  endif()
-  list(APPEND test_environment
-    "INTEL_LIBITTNOTIFY64=${ITT_COLLECTOR_PATH}"
-    "PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR=1")
-else()
-  list(APPEND test_environment
-    "--unset=INTEL_LIBITTNOTIFY64"
-    "--unset=PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR")
-endif()
-
-execute_process(
-  COMMAND "${CMAKE_COMMAND}" -E env ${test_environment} "${ITT_BASIC_EXECUTABLE}"
-  RESULT_VARIABLE test_result
-  OUTPUT_VARIABLE test_output
-  ERROR_VARIABLE test_output
-  TIMEOUT 55)
-message("${test_output}")
-if(NOT "${test_result}" STREQUAL "0")
-  message(FATAL_ERROR "itt_basic failed: ${test_result}")
-endif()
-
-string(FIND "${test_output}" "BEFORE_COMMUNICATION_ENABLE" before_enable)
-string(FIND "${test_output}" "AFTER_COMMUNICATION_ENABLE" after_enable)
-if(before_enable LESS 0 OR after_enable LESS_EQUAL before_enable)
-  message(FATAL_ERROR "Missing or out-of-order communication enable markers")
-endif()
-
-set(warning_prefix "Cannot enable communication tracing:")
-string(FIND "${test_output}" "${warning_prefix}" first_warning)
-if(NOT ITT_COLLECTOR_PATH)
-  if(NOT first_warning EQUAL -1)
-    message(FATAL_ERROR "Self-registration unexpectedly emitted a collector-unavailable warning")
-  endif()
-  return()
-endif()
-
-set(expected_warning
-  "${warning_prefix} ITT collector path INTEL_LIBITTNOTIFY64='${ITT_COLLECTOR_PATH}' did not exist;")
-string(FIND "${test_output}" "${expected_warning}" warning_position)
-if(warning_position EQUAL -1)
-  message(FATAL_ERROR "Missing collector warning naming '${ITT_COLLECTOR_PATH}'")
-endif()
-
-string(FIND "${test_output}" "${warning_prefix}" last_warning REVERSE)
-if(first_warning LESS_EQUAL before_enable OR last_warning GREATER_EQUAL after_enable)
-  message(FATAL_ERROR "Collector warning must appear only between the ptiViewEnable markers")
-endif()
diff --git a/sdk/test/itt/itt_basic.cc b/sdk/test/itt/itt_basic.cc
deleted file mode 100644
index 400b9775..00000000
--- a/sdk/test/itt/itt_basic.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <ittnotify.h>
-
-#include <chrono>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <sycl/sycl.hpp>
-#include <thread>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-
-#define StopTracing()                                          \
-  do {                                                         \
-    PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION)); \
-  } while (0)
-
-void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(1000);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = 1000;
-}
-
-static constexpr int kThreeRecordsExpected = 3;
-static int record_count = 0;
-static bool parsing_failed = false;
-
-void ParseBuffer(unsigned char *buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    samples_utils::AlignedDealloc(buf);
-    return;
-  }
-
-  pti_view_record_base *ptr = nullptr;
-
-  for (;;) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      parsing_failed = true;
-      break;
-    }
-    if (ptr->_view_kind == pti_view_kind::PTI_VIEW_COMMUNICATION) {
-      ++record_count;
-      std::cout << "Found ITT Record" << '\n';
-      samples_utils::DumpRecord(reinterpret_cast<pti_view_record_comms *>(ptr));
-    } else {
-      std::cerr << "Unexpected record kind: " << ptr->_view_kind << '\n';
-      parsing_failed = true;
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-// Generates three ITT records from the oneCCL::API domain; other domains are filtered.
-int main() {
-  const auto *unavailable_collector_flag = std::getenv("PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR");
-  const bool expect_unavailable_collector =
-      unavailable_collector_flag && std::strcmp(unavailable_collector_flag, "1") == 0;
-  const auto expected_enable_result = expect_unavailable_collector
-                                          ? pti_result::PTI_ERROR_COLLECTOR_UNAVAILABLE
-                                          : pti_result::PTI_SUCCESS;
-  const auto expected_records = expect_unavailable_collector ? 0 : kThreeRecordsExpected;
-
-  PTI_CHECK_SUCCESS(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-
-  std::cout << "BEFORE_COMMUNICATION_ENABLE" << std::endl;
-  const auto enable_result = ptiViewEnable(PTI_VIEW_COMMUNICATION);
-  std::cout << "AFTER_COMMUNICATION_ENABLE" << std::endl;
-  if (enable_result != expected_enable_result) {
-    std::cerr << "FAIL: Expected enable result " << ptiResultTypeToString(expected_enable_result)
-              << ", but received " << ptiResultTypeToString(enable_result) << '\n';
-    return EXIT_FAILURE;
-  }
-
-  //
-  // Essential case
-  // Notice that the itt collector only supports oneCCL::API domain
-  //
-  auto domain = __itt_domain_create("oneCCL::API");
-  auto task = __itt_string_handle_create("main-1sec");
-  __itt_task_begin(domain, __itt_null, __itt_null, task);
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  __itt_task_end(domain);
-
-  //
-  // Nested tasks ended by __itt_task_end
-  //
-  auto task_follow = __itt_string_handle_create("main-2sec-follow");
-  __itt_task_begin(domain, __itt_null, __itt_null, task);
-  __itt_task_begin(domain, __itt_null, __itt_null, task_follow);
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  __itt_task_end(domain);
-  __itt_task_end(domain);
-
-  auto domain1 = __itt_domain_create("Test Domain");
-  auto task1 = __itt_string_handle_create("main-1sec");
-  __itt_task_begin(domain1, __itt_null, __itt_null, task1);
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  __itt_task_end(domain1);
-
-  StopTracing();
-  PTI_CHECK_SUCCESS(ptiFlushAllViews());
-
-  std::cout << "Size of pti_view_record_comms: " << sizeof(pti_view_record_comms) << '\n';
-
-  if (parsing_failed || record_count != expected_records) {
-    std::cerr << "FAIL: Expected " << expected_records << " communication records, but received "
-              << record_count << '\n';
-    return EXIT_FAILURE;
-  }
-  std::cout << "SUCCESS: Collected " << record_count << '/' << expected_records
-            << " communication records" << '\n';
-  return EXIT_SUCCESS;
-}
diff --git a/sdk/test/itt/itt_initialization_test.cc b/sdk/test/itt/itt_initialization_test.cc
deleted file mode 100644
index 608adb10..00000000
--- a/sdk/test/itt/itt_initialization_test.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <dlfcn.h>
-#include <ittnotify.h>
-
-#include <cstdlib>
-#include <iostream>
-
-#include "pti/pti_view.h"
-
-namespace {
-
-bool ExpectCoreUnloaded(const char* phase) {
-  // RTLD_NOLOAD observes the loader state without mapping the core.
-  void* core = dlopen(PTI_TEST_CORE_LIBRARY_PATH, RTLD_NOW | RTLD_NOLOAD);
-  if (core == nullptr) {
-    return true;
-  }
-  std::cerr << "PTI core is already loaded " << phase << '\n';
-  if (dlclose(core) != 0) {
-    std::cerr << "Failed to close the core observation handle\n";
-  }
-  return false;
-}
-
-}  // namespace
-
-int main() {
-  if (!ExpectCoreUnloaded("before ITT setup")) {
-    return EXIT_FAILURE;
-  }
-
-  auto domain = __itt_domain_create("oneCCL::API");
-  auto task = __itt_string_handle_create("BeforeEnable");
-  if (domain == nullptr || task == nullptr) {
-    std::cerr << "Failed to create the ITT domain or task handle\n";
-    return EXIT_FAILURE;
-  }
-  __itt_task_begin(domain, __itt_null, __itt_null, task);
-  __itt_task_end(domain);
-  if (!ExpectCoreUnloaded("after ITT calls")) {
-    return EXIT_FAILURE;
-  }
-
-  // The enable request loads the core before reporting missing callbacks.
-  const auto result = ptiViewEnable(PTI_VIEW_COMMUNICATION);
-  if (result != PTI_ERROR_NO_CALLBACKS_SET) {
-    std::cerr << "Expected PTI_ERROR_NO_CALLBACKS_SET, received " << result << '\n';
-    return EXIT_FAILURE;
-  }
-  void* core = dlopen(PTI_TEST_CORE_LIBRARY_PATH, RTLD_NOW | RTLD_NOLOAD);
-  if (core == nullptr) {
-    std::cerr << "PTI core is not loaded after the enable request\n";
-    return EXIT_FAILURE;
-  }
-  if (dlclose(core) != 0) {
-    std::cerr << "Failed to close the core observation handle\n";
-    return EXIT_FAILURE;
-  }
-  return EXIT_SUCCESS;
-}
diff --git a/sdk/test/itt/itt_test_suite.cc b/sdk/test/itt/itt_test_suite.cc
deleted file mode 100644
index e8438b8e..00000000
--- a/sdk/test/itt/itt_test_suite.cc
+++ /dev/null
@@ -1,923 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Exercises PTI's oneCCL ITT collector: domain filtering, metadata, nested
-// tasks, enable/disable behavior, and multithreaded record consistency.
-
-#include <dlfcn.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <ittnotify.h>
-
-#include <chrono>
-#include <cstdint>
-#include <cstring>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <set>
-#include <string>
-#include <string_view>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-#ifdef __linux__
-#include <unistd.h>
-#endif
-
-#include "pti/pti.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-
-namespace {
-
-struct DlCloser {
-  void operator()(void *handle) const noexcept {
-    if (handle != nullptr) {
-      (void)dlclose(handle);
-    }
-  }
-};
-
-void ExpectTrivialCollectorTaskCounts(const char *ccl_domain, const char *trivial_domain) {
-  const auto collector_path = ::utils::GetEnv("INTEL_LIBITTNOTIFY64");
-  ASSERT_FALSE(collector_path.empty());
-
-  // Clear any existing errors
-  dlerror();
-
-  void *raw_handle = dlopen(collector_path.c_str(), RTLD_NOW | RTLD_NOLOAD);
-  ASSERT_NE(raw_handle, nullptr) << "ittnotify did not load the configured collector: "
-                                 << dlerror();
-  auto handle = std::unique_ptr<void, DlCloser>(raw_handle);
-
-  using Count = std::uint64_t (*)(const char *);
-  constexpr std::uint64_t kExpectedTaskCount = 1;
-  auto task_begin_count =
-      reinterpret_cast<Count>(dlsym(handle.get(), "IttTrivialCollectorGetTaskBeginCount"));
-  ASSERT_NE(task_begin_count, nullptr);
-  auto task_end_count =
-      reinterpret_cast<Count>(dlsym(handle.get(), "IttTrivialCollectorGetTaskEndCount"));
-  ASSERT_NE(task_end_count, nullptr);
-
-  EXPECT_EQ(task_begin_count(ccl_domain), kExpectedTaskCount);
-  EXPECT_EQ(task_end_count(ccl_domain), kExpectedTaskCount);
-  EXPECT_EQ(task_begin_count(trivial_domain), kExpectedTaskCount);
-  EXPECT_EQ(task_end_count(trivial_domain), kExpectedTaskCount);
-}
-
-}  // namespace
-
-// Test-specific assertion macro that uses GoogleTest instead of exit()
-#define ASSERT_PTI_SUCCESS(X)                                                         \
-  do {                                                                                \
-    pti_result result = (X);                                                          \
-    ASSERT_EQ(result, pti_result::PTI_SUCCESS)                                        \
-        << "PTI CALL FAILED: " #X << " WITH ERROR " << ptiResultTypeToString(result); \
-  } while (0)
-
-class IttTest : public ::testing::Test {
- protected:
-  static inline std::vector<pti_view_record_comms> *comms_vector_ = nullptr;
-  static inline std::mutex buffer_mutex_;
-  static inline constexpr std::string_view kCclDomain = "oneCCL::API";
-  static inline constexpr std::string_view kTrivialDomain = "trivial::API";
-  static constexpr uint32_t kSleepTimeMs = 5;
-
-  // Functions for PTI buffer management
-
-  // Buffer completion callback. Also works for multi-threaded tests
-  // Collects records with mutex protection, actual verification done in test body
-  static void BufferCompletedMultiThreaded(unsigned char *buf, std::size_t buf_size,
-                                           std::size_t valid_buf_size) {
-    if (!buf || !valid_buf_size || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      if (buf) {
-        samples_utils::AlignedDealloc(buf);
-      }
-      return;
-    }
-
-    std::lock_guard<std::mutex> lock(buffer_mutex_);
-
-    // Check comms_vector_ validity - use non-fatal ADD_FAILURE to avoid leak
-    if (!comms_vector_) {
-      ADD_FAILURE() << __FUNCTION__ << " CommsVector is null";
-      samples_utils::AlignedDealloc(buf);
-      return;
-    }
-
-    pti_view_record_base *ptr = nullptr;
-    pti_result result = pti_result::PTI_SUCCESS;
-    bool has_error = false;
-
-    // Collect all records in the order they appear in the buffer
-    while (pti_result::PTI_STATUS_END_OF_BUFFER !=
-           (result = ptiViewGetNextRecord(buf, valid_buf_size, &ptr))) {
-      if (result != pti_result::PTI_SUCCESS) {
-        ADD_FAILURE() << "Error retrieving the next record: " << ptiResultTypeToString(result);
-        has_error = true;
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          ADD_FAILURE() << __FUNCTION__ << " Received an invalid record";
-          has_error = true;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_COMMUNICATION: {
-          comms_vector_->push_back(*reinterpret_cast<pti_view_record_comms *>(ptr));
-          break;
-        }
-        default: {
-          ADD_FAILURE() << "Unexpected record type: " << std::hex << ptr->_view_kind;
-          has_error = true;
-          break;
-        }
-      }
-      if (has_error) break;
-    }
-
-    // Always deallocate buffer, even on error
-    samples_utils::AlignedDealloc(buf);
-  }
-
-  static void ProvideBuffer(unsigned char **buf, std::size_t *buf_size) {
-    *buf = samples_utils::AlignedAlloc<unsigned char>(1000);
-    if (!*buf) {
-      std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-      std::abort();
-    }
-    *buf_size = 1000;
-  }
-
-  // Utility function to dump communication records vector
-  [[maybe_unused]] static void DumpRecordsVector(
-      const std::vector<pti_view_record_comms> &records) {
-    std::cout << "\n=== Dumping local_records_vector (" << records.size() << " records) ===\n";
-    for (size_t i = 0; i < records.size(); ++i) {
-      const auto &rec = records[i];
-      std::cout << "Record[" << i << "]:\n";
-      std::cout << "  name: " << (rec._name ? rec._name : "NULL") << "\n";
-      std::cout << "  start_timestamp: " << rec._start_timestamp << "\n";
-      std::cout << "  end_timestamp: " << rec._end_timestamp << "\n";
-      std::cout << "  process_id: " << rec._process_id << "\n";
-      std::cout << "  thread_id: " << rec._thread_id << "\n";
-      std::cout << "  send_size: " << rec._send_size << "\n";
-      std::cout << "  recv_size: " << rec._recv_size << "\n";
-      std::cout << "  communicator_id: " << rec._communicator_id << "\n";
-    }
-    std::cout << "=== End dump ===\n\n";
-  }
-
-  // Collection Start and Stop helpers to avoid repetition in test bodies
-
-  inline void PtiProlog() {
-    ASSERT_EQ(ptiViewSetCallbacks(IttTest::ProvideBuffer, IttTest::BufferCompletedMultiThreaded),
-              pti_result::PTI_SUCCESS);
-
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_COMMUNICATION), pti_result::PTI_SUCCESS);
-  }
-
-  inline void PtiEpilog() {
-    ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-    ASSERT_PTI_SUCCESS(ptiFlushAllViews());
-  }
-
-  void RunPtiCollectorScenario(std::string_view task_name) {
-    constexpr int kExpectedRecords = 1;
-    std::vector<pti_view_record_comms> local_records_vector;
-    comms_vector_ = &local_records_vector;
-
-    PtiProlog();
-
-    auto domain = __itt_domain_create(kCclDomain.data());
-    auto task = __itt_string_handle_create(task_name.data());
-    __itt_task_begin(domain, __itt_null, __itt_null, task);
-    std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-    __itt_task_end(domain);
-
-    PtiEpilog();
-
-    ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-        << "Expected " << kExpectedRecords << " record, collected " << local_records_vector.size();
-    ASSERT_STREQ(local_records_vector[0]._name, task_name.data());
-    ASSERT_GT(local_records_vector[0]._end_timestamp, local_records_vector[0]._start_timestamp);
-    ASSERT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-    ASSERT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-  }
-
-  void RunExternalTrivialCollectorScenario() {
-    constexpr std::string_view task_name = "ExternalIttCollectorTask";
-    constexpr std::string_view trivial_task_name = "TrivialCollectorTask";
-    std::vector<pti_view_record_comms> local_records_vector;
-    comms_vector_ = &local_records_vector;
-
-    ASSERT_PTI_SUCCESS(
-        ptiViewSetCallbacks(IttTest::ProvideBuffer, IttTest::BufferCompletedMultiThreaded));
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_COMMUNICATION), pti_result::PTI_ERROR_COLLECTOR_UNAVAILABLE);
-
-    auto domain = __itt_domain_create(kCclDomain.data());
-    auto task = __itt_string_handle_create(task_name.data());
-    auto trivial_domain = __itt_domain_create(kTrivialDomain.data());
-    auto trivial_task = __itt_string_handle_create(trivial_task_name.data());
-
-    __itt_task_begin(domain, __itt_null, __itt_null, task);
-    std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-    __itt_task_end(domain);
-
-    __itt_task_begin(trivial_domain, __itt_null, __itt_null, trivial_task);
-    std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-    __itt_task_end(trivial_domain);
-
-    ExpectTrivialCollectorTaskCounts(kCclDomain.data(), kTrivialDomain.data());
-
-    PtiEpilog();
-
-    EXPECT_TRUE(local_records_vector.empty())
-        << "collected " << local_records_vector.size()
-        << " oneCCL record(s) although INTEL_LIBITTNOTIFY64 was configured externally";
-  }
-};
-
-TEST_F(IttTest, Task_Handlecreate_Begin_End) {
-  RunPtiCollectorScenario("Task_Handlecreate_Begin_End");
-}
-
-// CTest configures INTEL_LIBITTNOTIFY64 before PTI initialization; otherwise
-// the collector decision has already latched before GoogleTest main().
-TEST_F(IttTest, PreconfiguredPtiCollectorEnablesPtiTracing) {
-  if (::utils::GetEnv("PTI_TEST_EXPECT_PRECONFIGURED_PTI_COLLECTOR").empty()) {
-    GTEST_SKIP() << "requires CTest to preconfigure INTEL_LIBITTNOTIFY64 with PTI";
-  }
-
-  RunPtiCollectorScenario("PreconfiguredPtiCollector");
-}
-
-TEST_F(IttTest, ExternalTrivialCollectorDisablesPtiTracing) {
-  if (::utils::GetEnv("PTI_TEST_EXPECT_NO_ITT_COLLECTION").empty()) {
-    GTEST_SKIP() << "requires ctest to configure INTEL_LIBITTNOTIFY64 externally";
-  }
-
-  RunExternalTrivialCollectorScenario();
-}
-
-TEST_F(IttTest, UnavailableCollectorRejectsCommunicationView) {
-  if (::utils::GetEnv("PTI_TEST_EXPECT_UNAVAILABLE_ITT_COLLECTOR").empty()) {
-    GTEST_SKIP() << "requires CTest to configure an unavailable ITT collector";
-  }
-
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-  // The interface has already saved the load-time decision. Changing the
-  // environment before loading the core must not replace that decision.
-  const auto configured_collector = ::utils::GetEnv("INTEL_LIBITTNOTIFY64");
-  const auto pti_collector = ::utils::GetEnv("PTI_TEST_PTI_VIEW_PATH");
-  ASSERT_FALSE(pti_collector.empty());
-  ::utils::SetEnv("INTEL_LIBITTNOTIFY64", pti_collector.c_str());
-  ASSERT_PTI_SUCCESS(
-      ptiViewSetCallbacks(IttTest::ProvideBuffer, IttTest::BufferCompletedMultiThreaded));
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_COMMUNICATION), pti_result::PTI_ERROR_COLLECTOR_UNAVAILABLE);
-  ::utils::SetEnv("INTEL_LIBITTNOTIFY64", configured_collector.c_str());
-
-  // Failure to enable communication must not prevent other views from working.
-  ASSERT_PTI_SUCCESS(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION));
-  ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION));
-  PtiEpilog();
-  EXPECT_TRUE(local_records_vector.empty());
-}
-
-TEST_F(IttTest, IttCallsBeforeViewInitAndNonStandardDomain) {
-  constexpr std::string_view some_domain1 = "someDomain1";
-  constexpr std::string_view some_domain2 = "someDomain2";
-  constexpr std::string_view task_name1 = "IttCallsBeforeViewInit_Task1";
-  constexpr std::string_view task_name2 = "IttCallsAfterViewInit_Task2";
-  constexpr std::string_view task_name3 = "IttCallsAfterViewInit_Task3";
-
-  constexpr int kExpectedRecords = 2;  // Only two records should be generated for this test
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  auto some_domain_handle1 = __itt_domain_create(some_domain1.data());
-  // Purposely creating CCL domain before ptiViewEnable
-  auto ccl_domain_handle = __itt_domain_create(kCclDomain.data());
-
-  // This task will be handled by default itt implementation
-  auto task2 = __itt_string_handle_create(task_name2.data());
-
-  // Here ITT would call __itt_api_init - on the first task_begin
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  auto task1 = __itt_string_handle_create(task_name1.data());
-
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task1);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  // this domain doesn't satisfy Key invariant (see itt_adapter.cc)
-  // but its tasks should not be captued by PTI anyway
-  auto some_domain_handle2 = __itt_domain_create(some_domain2.data());
-
-  PtiProlog();
-
-  auto task3 = __itt_string_handle_create(task_name3.data());
-
-  // Only these two tasks should be captured by PTI as they are in CCL domain
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task3);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  // This task indeed should not appear in PTI records
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task3);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  __itt_task_begin(some_domain_handle2, __itt_null, __itt_null, task3);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle2);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-  EXPECT_STREQ(local_records_vector[0]._name, task_name2.data());
-  EXPECT_GT(local_records_vector[0]._end_timestamp, local_records_vector[0]._start_timestamp);
-
-  EXPECT_STREQ(local_records_vector[1]._name, task_name3.data());
-  EXPECT_GT(local_records_vector[1]._end_timestamp, local_records_vector[1]._start_timestamp);
-  // Validate PID/TID fields
-  EXPECT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[1]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[1]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, IttCallsBeforeViewInit_CclFirst) {
-  constexpr std::string_view some_domain1 = "someDomain1";
-  constexpr std::string_view task_name1 = "IttCallsBeforeViewInit_CclFirst_Task1";
-  constexpr std::string_view task_name2 = "IttCallsAfterViewInit_Task2";
-  constexpr std::string_view task_name3 = "IttCallsAfterViewInit_Task3";
-
-  constexpr int kExpectedRecords = 1;  // Only one record should be generated for this test
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  // Create CCL domain first, before any other domain
-  auto ccl_domain_handle = __itt_domain_create(kCclDomain.data());
-
-  auto task1 = __itt_string_handle_create(task_name1.data());
-
-  // This task is on CCL domain but before ptiViewEnable, so it should NOT be captured
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task1);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  // Now create a stray domain after CCL domain
-  auto some_domain_handle1 = __itt_domain_create(some_domain1.data());
-
-  auto task2 = __itt_string_handle_create(task_name2.data());
-
-  // This task will be handled by default itt implementation (stray domain, before view init)
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  PtiProlog();
-
-  auto task3 = __itt_string_handle_create(task_name3.data());
-
-  // Only this task should be captured by PTI as it is in CCL domain
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  // This task indeed should not appear in PTI records
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task3);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-  EXPECT_STREQ(local_records_vector[0]._name, task_name2.data());
-  EXPECT_GT(local_records_vector[0]._end_timestamp, local_records_vector[0]._start_timestamp);
-
-  // Validate PID/TID fields
-  EXPECT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, IttCclDomainLateCall) {
-  constexpr std::string_view some_domain1 = "someDomain1";
-  constexpr std::string_view task_name_donotcapture1 = "IttCalls_Wrong_Domain_DoNotCapture1";
-  constexpr std::string_view task_name_donotcapture2 = "IttCalls_Before_ViewInit_DoNotCapture2";
-  constexpr std::string_view task_name_donotcapture3 = "IttCalls_Wrong_Domain_DoNotCapture3";
-  constexpr std::string_view task_name_donotcapture4 = "IttCalls_After_ViewInit_DoNotCapture4";
-  constexpr std::string_view task_name_donotcapture5 =
-      "IttCalls_After_ViewInit_Wrong_Domain_DoNotCapture5";
-  constexpr std::string_view task_name1 = "IttCallsAfterViewInit_Task1";
-  constexpr std::string_view task_name2 = "IttCallsAfterViewInit_Task2";
-
-  constexpr int kExpectedRecords = 2;  // Only two records should be generated for this test
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  auto some_domain_handle1 = __itt_domain_create(some_domain1.data());
-  auto ccl_domain_handle = __itt_domain_create(kCclDomain.data());
-
-  // This task will be handled by default itt implementation
-  auto task_donotcapture1 = __itt_string_handle_create(task_name_donotcapture1.data());
-
-  //
-  // Section 1
-  // No records should be generated because this domain is not CCL domain.
-  // The collector will be loaded by PtiViewEnable.
-  //
-  PtiProlog();
-
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task_donotcapture1);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  PtiEpilog();
-
-  //
-  // Section 2
-  // Purposely calling 1st task of CCL domain outside of PTI COMMUNICATION collection
-  // The collector is loaded but we are outside the capture zone, so this task should not be
-  // captured.
-  //
-  auto task_donotcapture2 = __itt_string_handle_create(task_name_donotcapture2.data());
-
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task_donotcapture2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  //
-  // Section 3
-  // Normal operation, store some records!
-  //
-  auto task1 = __itt_string_handle_create(task_name1.data());
-  auto task2 = __itt_string_handle_create(task_name2.data());
-  auto task_donotcapture3 = __itt_string_handle_create(task_name_donotcapture3.data());
-
-  PtiProlog();
-
-  // Only these two tasks should be captured by PTI as they are in CCL domain
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task1);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  // This task indeed SHOULD NOT appear in PTI records, wrong domain.
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task_donotcapture3);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  PtiEpilog();
-
-  //
-  // Section 4
-  //
-  auto task_donotcapture4 = __itt_string_handle_create(task_name_donotcapture4.data());
-  auto task_donotcapture5 = __itt_string_handle_create(task_name_donotcapture5.data());
-
-  // Wrong domain and outside capture zone. Should not be captured.
-  __itt_task_begin(some_domain_handle1, __itt_null, __itt_null, task_donotcapture4);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(some_domain_handle1);
-
-  // Outside capture zone. Should not be captured.
-  __itt_task_begin(ccl_domain_handle, __itt_null, __itt_null, task_donotcapture5);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain_handle);
-
-  //
-  // Validation
-  //
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-
-  EXPECT_STREQ(local_records_vector[0]._name, task_name1.data());
-  EXPECT_GT(local_records_vector[0]._end_timestamp, local_records_vector[0]._start_timestamp);
-
-  EXPECT_STREQ(local_records_vector[1]._name, task_name2.data());
-  EXPECT_GT(local_records_vector[1]._end_timestamp, local_records_vector[1]._start_timestamp);
-  // Validate PID/TID fields
-  EXPECT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[1]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  EXPECT_EQ(local_records_vector[1]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, StrayDomain_Filtered) {
-  constexpr std::string_view kTaskName = "StrayDomain_Task";
-  constexpr int kExpectedRecords = 0;
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto stray_domain = __itt_domain_create("Stray Domain");
-  auto task = __itt_string_handle_create(kTaskName.data());
-  __itt_task_begin(stray_domain, __itt_null, __itt_null, task);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(stray_domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " record, collected " << local_records_vector.size();
-}
-
-//
-// Interesting fact of this test if you add breakpoints to gdb.
-// The first call to __itt_domain_create will not be hit.
-// The next two will.
-//
-TEST_F(IttTest, ThreeDomainsAdded) {
-  constexpr std::string_view kTaskName = "StrayDomain_Task";
-  constexpr int kExpectedRecords = 1;
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto ccl_domain = __itt_domain_create(kCclDomain.data());
-  auto task_stray = __itt_string_handle_create(kTaskName.data());
-  auto stray_domain1 = __itt_domain_create("Stray Domain1");
-  __itt_task_begin(stray_domain1, __itt_null, __itt_null, task_stray);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(stray_domain1);
-
-  auto stray_domain2 = __itt_domain_create("Stray Domain2");
-  __itt_task_begin(stray_domain2, __itt_null, __itt_null, task_stray);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(stray_domain2);
-
-  constexpr std::string_view task_name = "ThreeDomainsAdded";
-  auto task = __itt_string_handle_create(task_name.data());
-
-  __itt_task_begin(ccl_domain, __itt_null, __itt_null, task);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " record, collected " << local_records_vector.size();
-  ASSERT_STREQ(local_records_vector[0]._name, task_name.data())
-      << "Expected task name to be '" << task_name << "'";
-}
-
-//
-// Test CCL domain when created first because it executes a different
-// code path.
-//
-TEST_F(IttTest, ThreeDomainsAddedCclFirst) {
-  constexpr std::string_view kTaskName = "CclFirst_Task";
-  constexpr int kExpectedRecords = 1;
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  // Create CCL domain first
-  auto ccl_domain = __itt_domain_create(kCclDomain.data());
-  constexpr std::string_view ccl_task_name = "ThreeDomainsAddedCclFirst";
-  auto ccl_task = __itt_string_handle_create(ccl_task_name.data());
-
-  __itt_task_begin(ccl_domain, __itt_null, __itt_null, ccl_task);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(ccl_domain);
-
-  // Then create stray domains
-  auto task_stray = __itt_string_handle_create(kTaskName.data());
-  auto stray_domain1 = __itt_domain_create("Stray Domain1");
-  __itt_task_begin(stray_domain1, __itt_null, __itt_null, task_stray);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(stray_domain1);
-
-  auto stray_domain2 = __itt_domain_create("Stray Domain2");
-  __itt_task_begin(stray_domain2, __itt_null, __itt_null, task_stray);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(stray_domain2);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " record, collected " << local_records_vector.size();
-  ASSERT_STREQ(local_records_vector[0]._name, ccl_task_name.data())
-      << "Expected task name to be '" << ccl_task_name << "'";
-}
-
-TEST_F(IttTest, StackedTasks) {
-  constexpr std::string_view kTask1Name = "task1_should_finish_last";
-  constexpr std::string_view kTask2Name = "task2_should_finish_first";
-  constexpr int kExpectedRecords = 2;
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  auto task1 = __itt_string_handle_create(kTask1Name.data());
-  auto task2 = __itt_string_handle_create(kTask2Name.data());
-
-  __itt_task_begin(domain, __itt_null, __itt_null, task1);
-  __itt_task_begin(domain, __itt_null, __itt_null, task2);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(domain);
-  __itt_task_end(domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-  ASSERT_STREQ(local_records_vector[1]._name, kTask1Name.data());
-  ASSERT_GT(local_records_vector[1]._end_timestamp, local_records_vector[0]._start_timestamp);
-  ASSERT_STREQ(local_records_vector[0]._name, kTask2Name.data());
-  ASSERT_GT(local_records_vector[0]._end_timestamp, local_records_vector[1]._start_timestamp);
-
-  // Validate PID/TID fields - both records should have same PID/TID (same thread)
-  uint32_t expected_pid = utils::GetPid();
-  uint32_t expected_tid = utils::GetTid();
-  for (const auto &rec : local_records_vector) {
-    ASSERT_EQ(rec._process_id, expected_pid) << "PID mismatch in ITT record";
-    ASSERT_EQ(rec._thread_id, expected_tid) << "TID mismatch in ITT record";
-  }
-}
-
-TEST_F(IttTest, Task_Begin_Handlecreate_Addmetadata_End) {
-  constexpr std::string_view kTaskName = "Task_Begin_Handlecreate_Addmetadata_End";
-  uint64_t validate_metadata_expected_size = 0xdeadbeef;
-  constexpr int kExpectedRecords = 1;
-  std::vector<pti_view_record_comms> local_records_vector;
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  auto task = __itt_string_handle_create(kTaskName.data());
-  auto handle = __itt_string_handle_create("send_size");
-
-  __itt_task_begin(domain, __itt_null, __itt_null, task);
-  __itt_metadata_add(domain, __itt_null, handle, __itt_metadata_u64, 1,
-                     &validate_metadata_expected_size);
-  std::this_thread::sleep_for(std::chrono::milliseconds(kSleepTimeMs));
-  __itt_task_end(domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " record, collected " << local_records_vector.size();
-  ASSERT_STREQ(local_records_vector[0]._name, kTaskName.data());
-  ASSERT_GT(local_records_vector[0]._end_timestamp, local_records_vector[0]._start_timestamp);
-  ASSERT_EQ(local_records_vector[0]._send_size, validate_metadata_expected_size);
-
-  // Validate PID/TID fields
-  ASSERT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  ASSERT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, EnableDisableTrace) {
-  constexpr std::string_view kTaskName = "EnableDisableTrace";
-  constexpr int kExpectedRecords = 1;  // Only the first task should be recorded
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  auto task = __itt_string_handle_create(kTaskName.data());
-  __itt_task_begin(domain, __itt_null, __itt_null, task);
-  __itt_task_end(domain);
-
-  // Split Epilog into 2 parts: 1st - disabling
-  ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-
-  // Generate ITT traffic that SHOULD NOT BE RECORDED, but
-  // for the __itt_string_handle that was created.
-  auto no_more_itt_ops = __itt_string_handle_create("there_should_be_no_further_itt_ops");
-  __itt_task_begin(domain, __itt_null, __itt_null, no_more_itt_ops);
-  __itt_task_end(domain);
-
-  // Split Epilog into 2 parts: 2nd - flushing records
-  ASSERT_PTI_SUCCESS(ptiFlushAllViews());
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-  ASSERT_STREQ(local_records_vector[0]._name, kTaskName.data())
-      << "Expected task name to be '" << kTaskName << "'";
-
-  // Validate PID/TID fields for the one recorded task
-  ASSERT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  ASSERT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, EnableDisableEnable) {
-  constexpr std::string_view kFirstTaskName = "Task_First_Record";
-  constexpr std::string_view kSecondTaskName = "Task_Second_Drop";
-  constexpr std::string_view kThirdTaskName = "Task_Third_Record";
-  constexpr int kExpectedRecords = 2;
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-
-  // First task to be recorded
-  auto task1 = __itt_string_handle_create(kFirstTaskName.data());
-  __itt_task_begin(domain, __itt_null, __itt_null, task1);
-  __itt_task_end(domain);
-
-  ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-
-  // Second task to be dropped
-  auto task2 = __itt_string_handle_create(kSecondTaskName.data());
-  __itt_task_begin(domain, __itt_null, __itt_null, task2);
-  __itt_task_end(domain);
-
-  ASSERT_PTI_SUCCESS(ptiViewEnable(PTI_VIEW_COMMUNICATION));
-
-  // Third task to be recorded
-  auto task3 = __itt_string_handle_create(kThirdTaskName.data());
-  __itt_task_begin(domain, __itt_null, __itt_null, task3);
-  __itt_task_end(domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-
-  // Verify specific task names are recorded in correct order
-  ASSERT_STREQ(local_records_vector[0]._name, kFirstTaskName.data())
-      << "First record should be " << kFirstTaskName.data();
-  ASSERT_STREQ(local_records_vector[1]._name, kThirdTaskName.data())
-      << "Second record should be " << kThirdTaskName.data();
-}
-
-TEST_F(IttTest, StackPurgeOnDisable) {
-  constexpr std::string_view kTask1Name = "IncompleteTask1";
-  constexpr std::string_view kTask2Name = "IncompleteTask2";
-  std::vector<pti_view_record_comms> local_records_vector;
-
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  auto task1 = __itt_string_handle_create(kTask1Name.data());
-  auto task2 = __itt_string_handle_create(kTask2Name.data());
-
-  __itt_task_begin(domain, __itt_null, __itt_null, task1);
-  __itt_task_begin(domain, __itt_null, __itt_null, task2);
-
-  ASSERT_PTI_SUCCESS(ptiViewDisable(PTI_VIEW_COMMUNICATION));
-
-  __itt_task_end(domain);
-  __itt_task_end(domain);
-
-  ASSERT_PTI_SUCCESS(ptiViewEnable(PTI_VIEW_COMMUNICATION));
-
-  constexpr std::string_view kValidTaskName = "ValidTaskAfterPurge";
-  auto valid_task = __itt_string_handle_create(kValidTaskName.data());
-  __itt_task_begin(domain, __itt_null, __itt_null, valid_task);
-  __itt_task_end(domain);
-
-  PtiEpilog();
-
-  ASSERT_EQ(local_records_vector.size(), 1)
-      << "Expected 1 record after stack purge, collected " << local_records_vector.size();
-
-  ASSERT_STREQ(local_records_vector[0]._name, kValidTaskName.data())
-      << "Should only record the task created after stack purge";
-
-  ASSERT_EQ(local_records_vector[0]._process_id, utils::GetPid()) << "PID mismatch in ITT record";
-  ASSERT_EQ(local_records_vector[0]._thread_id, utils::GetTid()) << "TID mismatch in ITT record";
-}
-
-TEST_F(IttTest, MultiThreaded_PidTid_Validation) {
-  constexpr int kNumThreads = 4;
-  constexpr int kTasksPerThread = 2;
-  constexpr int kExpectedRecords = kNumThreads * kTasksPerThread;
-
-  std::vector<pti_view_record_comms> local_records_vector;
-  local_records_vector.reserve(kExpectedRecords);
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  std::vector<std::thread> threads;
-  std::vector<uint32_t> thread_ids(kNumThreads);
-
-  // Launch multiple threads
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i]() {
-      thread_ids[i] = utils::GetTid();  // Capture actual TID
-
-      for (int j = 0; j < kTasksPerThread; ++j) {
-        std::string task_name = "thread_" + std::to_string(i) + "_task_" + std::to_string(j);
-        auto task = __itt_string_handle_create(task_name.c_str());
-        __itt_task_begin(domain, __itt_null, __itt_null, task);
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        __itt_task_end(domain);
-      }
-    });
-  }
-
-  // Join all threads with joinability check
-  for (auto &t : threads) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-
-  PtiEpilog();
-
-  // Verify we collected the expected number of records
-  ASSERT_EQ(local_records_vector.size(), kExpectedRecords)
-      << "Expected " << kExpectedRecords << " records, collected " << local_records_vector.size();
-
-  // Validate: All records should have same PID but different TIDs
-  uint32_t expected_pid = utils::GetPid();
-  std::set<uint32_t> observed_tids;
-
-  for (const auto &rec : local_records_vector) {
-    ASSERT_EQ(rec._process_id, expected_pid) << "All records should have same PID";
-    ASSERT_GT(rec._thread_id, 0) << "TID should be non-zero";
-    observed_tids.insert(rec._thread_id);
-  }
-
-  // Should observe multiple different thread IDs
-  ASSERT_GE(observed_tids.size(), kNumThreads)
-      << "Should observe at least " << kNumThreads << " different TIDs, observed "
-      << observed_tids.size();
-
-  // Verify captured TIDs match recorded TIDs
-  for (uint32_t tid : thread_ids) {
-    ASSERT_TRUE(observed_tids.find(tid) != observed_tids.end())
-        << "Expected TID " << tid << " not found in records";
-  }
-}
-
-TEST_F(IttTest, PidTid_Consistency_ThreadLocal) {
-  constexpr std::string_view kTaskName = "consistency_check";
-  constexpr int kIterations = 100;
-  std::vector<pti_view_record_comms> local_records_vector;
-  local_records_vector.reserve(kIterations);
-  comms_vector_ = &local_records_vector;
-
-  PtiProlog();
-
-  auto domain = __itt_domain_create(kCclDomain.data());
-  auto task = __itt_string_handle_create(kTaskName.data());
-
-  // Generate many ITT tasks in same thread
-  for (int i = 0; i < kIterations; ++i) {
-    __itt_task_begin(domain, __itt_null, __itt_null, task);
-    __itt_task_end(domain);
-  }
-
-  PtiEpilog();
-
-  // Verify we collected all expected records
-  ASSERT_EQ(local_records_vector.size(), kIterations)
-      << "Expected " << kIterations << " records, collected " << local_records_vector.size();
-
-  // All records from same thread should have identical PID/TID
-  uint32_t expected_pid = local_records_vector[0]._process_id;
-  uint32_t expected_tid = local_records_vector[0]._thread_id;
-
-  for (int i = 1; i < kIterations; ++i) {
-    ASSERT_EQ(local_records_vector[i]._process_id, expected_pid)
-        << "PID changed unexpectedly at iteration " << i;
-    ASSERT_EQ(local_records_vector[i]._thread_id, expected_tid)
-        << "TID changed unexpectedly at iteration " << i;
-  }
-
-  // Validate against system calls
-  ASSERT_EQ(expected_pid, utils::GetPid()) << "Cached PID doesn't match current PID";
-  ASSERT_EQ(expected_tid, utils::GetTid()) << "Cached TID doesn't match current TID";
-}
diff --git a/sdk/test/itt/itt_trivial_collector.cc b/sdk/test/itt/itt_trivial_collector.cc
deleted file mode 100644
index 82baacd7..00000000
--- a/sdk/test/itt/itt_trivial_collector.cc
+++ /dev/null
@@ -1,95 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-#define ITTAPI_CDECL __attribute__((visibility("default")))
-#include <ittnotify.h>
-#include <ittnotify_config.h>
-#include <spdlog/cfg/helpers.h>
-#include <spdlog/spdlog.h>
-
-#include <atomic>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-
-namespace {
-
-struct TaskCounts {
-  std::atomic<std::uint64_t> begin{0};
-  std::atomic<std::uint64_t> end{0};
-};
-
-TaskCounts ccl_domain_counts;
-TaskCounts trivial_domain_counts;
-
-TaskCounts* GetTaskCounts(const char* domain_name) {
-  if (domain_name == nullptr) {
-    return nullptr;
-  }
-  if (std::strcmp(domain_name, "oneCCL::API") == 0) {
-    return &ccl_domain_counts;
-  }
-  if (std::strcmp(domain_name, "trivial::API") == 0) {
-    return &trivial_domain_counts;
-  }
-  return nullptr;
-}
-
-void ITTAPI TrivialCollectorTaskBegin([[maybe_unused]] const __itt_domain* domain,
-                                      [[maybe_unused]] __itt_id task_id,
-                                      [[maybe_unused]] __itt_id parent_id,
-                                      [[maybe_unused]] __itt_string_handle* name) {
-  if (auto* counts = GetTaskCounts(domain != nullptr ? domain->nameA : nullptr);
-      counts != nullptr) {
-    counts->begin.fetch_add(1, std::memory_order_relaxed);
-  }
-  SPDLOG_DEBUG("{}() domain: {}, task: {}", __FUNCTION__,
-               domain != nullptr ? domain->nameA : "NULL", name != nullptr ? name->strA : "NULL");
-}
-
-void ITTAPI TrivialCollectorTaskEnd([[maybe_unused]] const __itt_domain* domain) {
-  if (auto* counts = GetTaskCounts(domain != nullptr ? domain->nameA : nullptr);
-      counts != nullptr) {
-    counts->end.fetch_add(1, std::memory_order_relaxed);
-  }
-  SPDLOG_DEBUG("{}() domain: {}", __FUNCTION__, domain != nullptr ? domain->nameA : "NULL");
-}
-
-}  // namespace
-
-ITT_EXTERN_C std::uint64_t ITTAPI IttTrivialCollectorGetTaskBeginCount(const char* domain_name) {
-  auto* counts = GetTaskCounts(domain_name);
-  return counts != nullptr ? counts->begin.load(std::memory_order_relaxed) : 0;
-}
-
-ITT_EXTERN_C std::uint64_t ITTAPI IttTrivialCollectorGetTaskEndCount(const char* domain_name) {
-  auto* counts = GetTaskCounts(domain_name);
-  return counts != nullptr ? counts->end.load(std::memory_order_relaxed) : 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_api_init(__itt_global* global,
-                                        [[maybe_unused]] __itt_group_id init_groups) {
-  if (global == nullptr) {
-    return;
-  }
-
-  if (const char* log_level = std::getenv("PTILOG_LEVEL"); log_level != nullptr) {
-    spdlog::cfg::helpers::load_levels(log_level);
-  }
-
-  auto* api_list = global->api_list_ptr;
-  for (int i = 0; api_list[i].name != nullptr; ++i) {
-    void* callback = api_list[i].null_func;
-    if (std::strcmp(api_list[i].name, "__itt_task_begin") == 0) {
-      callback = reinterpret_cast<void*>(&TrivialCollectorTaskBegin);
-    } else if (std::strcmp(api_list[i].name, "__itt_task_end") == 0) {
-      callback = reinterpret_cast<void*>(&TrivialCollectorTaskEnd);
-    }
-    *(api_list[i].func_ptr) = callback;
-  }
-}
diff --git a/sdk/test/itt/lib_env/CMakeLists.txt b/sdk/test/itt/lib_env/CMakeLists.txt
deleted file mode 100644
index f315a0d6..00000000
--- a/sdk/test/itt/lib_env/CMakeLists.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-add_library(itt_lib_env_external SHARED itt_lib_env_fixture.cc)
-
-# Compile the decision helper without the interface's startup registration.
-add_executable(itt_lib_env_test itt_lib_env_test.cc
-  "${PROJECT_SOURCE_DIR}/src/itt/itt_lib_env.cc")
-
-target_compile_definitions(itt_lib_env_test PRIVATE
-  PTI_TEST_LOADER_EXTERNAL_LIBRARY="$<TARGET_FILE:itt_lib_env_external>")
-# Let the bare fixture name resolve through the loader even before it is loaded.
-set_property(TARGET itt_lib_env_test APPEND PROPERTY BUILD_RPATH
-  "$<TARGET_FILE_DIR:itt_lib_env_external>")
-
-target_include_directories(itt_lib_env_test PUBLIC
-  "${PROJECT_SOURCE_DIR}/src"
-  "${PROJECT_SOURCE_DIR}/src/utils"
-  "${PROJECT_BINARY_DIR}")
-
-target_link_libraries(itt_lib_env_test PUBLIC GTest::gtest_main
-                                              spdlog::spdlog
-                                              fmt::fmt
-                                              ittapi::headers
-                                              ${CMAKE_DL_LIBS}
-                                              ${FS_LIB})
-
-add_dependencies(itt_lib_env_test pti_view itt_lib_env_external)
-
-# Register each case separately for precise CTest failure reporting.
-gtest_discover_tests(
-  itt_lib_env_test
-  DISCOVERY_TIMEOUT 60
-  PROPERTIES
-    ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-    LABELS "unit"
-    LABELS "itt")
-
-# Also run the complete suite in one process to verify that no helper state
-# leaks between cases.
-add_test(NAME itt_lib_env_standalone COMMAND itt_lib_env_test)
-set_tests_properties(itt_lib_env_standalone PROPERTIES
-  ENVIRONMENT "INTEL_LIBITTNOTIFY64=$<TARGET_FILE:Pti::pti_view>"
-  LABELS "unit;itt")
diff --git a/sdk/test/itt/lib_env/itt_lib_env_fixture.cc b/sdk/test/itt/lib_env/itt_lib_env_fixture.cc
deleted file mode 100644
index c01063fc..00000000
--- a/sdk/test/itt/lib_env/itt_lib_env_fixture.cc
+++ /dev/null
@@ -1,8 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Real shared module used to test lookup without loading the library.
-extern "C" void IttLibEnvFixtureMarker() {}
diff --git a/sdk/test/itt/lib_env/itt_lib_env_test.cc b/sdk/test/itt/lib_env/itt_lib_env_test.cc
deleted file mode 100644
index 38005575..00000000
--- a/sdk/test/itt/lib_env/itt_lib_env_test.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-//
-// Tests for the INTEL_LIBITTNOTIFY64 diagnostics in src/itt/itt_lib_env.h.
-//
-// These exercise the decision logic only. Path tests use the test binary as a
-// substitute for libpti_view.so; loader-name tests use real shared modules.
-// No test invokes the ITT runtime.
-//
-// Deliberately a separate binary from itt_test_suite: nothing here needs SYCL,
-// pti_view or Level Zero, and no ITT call is ever made. The decision helper
-// retains no process-local state, so these cases work both as individually
-// discovered CTests and as one standalone GoogleTest process.
-// Keeping these tests in their own binary also keeps them independent of
-// ittnotify's collector-present latch in itt_test_suite.
-//
-
-#include "itt/itt_lib_env.h"
-
-#include <dlfcn.h>
-#include <gtest/gtest.h>
-#include <unistd.h>
-
-#include <cstdlib>
-#include <memory>
-#include <string>
-#include <system_error>
-
-#include "library_loader.h"
-#include "pti_filesystem.h"
-#include "utils.h"
-
-namespace {
-
-class IttLibEnvTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    const char *current = std::getenv(itt_lib_env::kIttLibEnvVarName);
-    had_env_var_ = (current != nullptr);
-    if (had_env_var_) {
-      saved_env_var_ = current;
-    }
-    self_path_ = utils::GetPathToSharedObject(&IttLibEnvTest::SelfMarker);
-    if (!self_path_.empty()) {
-      std::error_code err;
-      auto abs = pti::utils::AbsolutePath(self_path_, err);
-      if (!err) self_path_ = abs.string();
-    }
-  }
-
-  void TearDown() override {
-    // Best effort: leave no trace even if a test body bailed out on an
-    // assertion before reaching its own cleanup.
-    std::error_code err;
-    pti::utils::filesystem::remove(SelfLinkPath(), err);
-
-    if (had_env_var_) {
-      utils::SetEnv(itt_lib_env::kIttLibEnvVarName, saved_env_var_.c_str());
-    } else {
-      ASSERT_EQ(::unsetenv(itt_lib_env::kIttLibEnvVarName), 0);
-    }
-  }
-
-  static pti::utils::filesystem::path SelfLinkPath() {
-    std::error_code err;
-    const auto temp_dir = pti::utils::filesystem::temp_directory_path(err);
-    if (err) {
-      return {};
-    }
-    return temp_dir / ("itt_lib_env_self_link_" + std::to_string(::getpid()) + ".so");
-  }
-
-  // Address inside this test binary used to resolve self_path_.
-  static void SelfMarker() {}
-
-  std::string self_path_;
-  std::string saved_env_var_;
-  bool had_env_var_ = false;
-};
-
-TEST_F(IttLibEnvTest, SelfRegistersWhenVariableUnset) {
-  ASSERT_EQ(::unsetenv(itt_lib_env::kIttLibEnvVarName), 0);
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kSetByPti);
-  EXPECT_FALSE(::utils::GetEnv(itt_lib_env::kIttLibEnvVarName).empty());
-}
-
-TEST_F(IttLibEnvTest, EmptyModulePathReportsConfigurationFailure) {
-  ASSERT_EQ(::unsetenv(itt_lib_env::kIttLibEnvVarName), 0);
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector({}),
-            itt_lib_env::IttCollectorConfig::kConfigurationFailed);
-  EXPECT_TRUE(::utils::GetEnv(itt_lib_env::kIttLibEnvVarName).empty());
-}
-
-TEST_F(IttLibEnvTest, DoesNotOverwriteWhenVariableAlreadySet) {
-  ASSERT_FALSE(self_path_.empty()) << "could not resolve this binary's own path";
-  utils::SetEnv(itt_lib_env::kIttLibEnvVarName, self_path_.c_str());
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kAlreadyPti);
-  EXPECT_EQ(::utils::GetEnv(itt_lib_env::kIttLibEnvVarName), self_path_);
-}
-
-TEST_F(IttLibEnvTest, NonExistentPathReportsNotFound) {
-  utils::SetEnv(itt_lib_env::kIttLibEnvVarName, "/nonexistent/libpti_view.so");
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kExternalNotFound);
-}
-
-TEST_F(IttLibEnvTest, ForeignLibraryReportsNotThisModule) {
-  // The stale/foreign-collector case: an existing library that is not us.
-  // ctest points the variable at libpti_view.so, which serves here as a real
-  // shared object that differs from this test binary.
-  if (!had_env_var_ || saved_env_var_.empty()) {
-    GTEST_SKIP() << itt_lib_env::kIttLibEnvVarName
-                 << " is not set; no foreign ITT library available to test with";
-  }
-  ASSERT_NE(saved_env_var_, self_path_);
-  utils::SetEnv(itt_lib_env::kIttLibEnvVarName, saved_env_var_.c_str());
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kExternalLibrary);
-}
-
-TEST_F(IttLibEnvTest, SymlinkToThisModuleComparesEqual) {
-  // The property that motivates filesystem::equivalent over string comparison:
-  // vars.sh resolves through readlink, users type whatever they like, and the
-  // loader reports its own spelling (libpti_view.so vs .so.1 vs .so.1.0.1).
-  ASSERT_FALSE(self_path_.empty());
-  const auto link_path = SelfLinkPath();
-  ASSERT_FALSE(link_path.empty()) << "no usable temporary directory";
-
-  std::error_code err;
-  // dladdr reports the path as spelled on the command line, often relative. The
-  // link lives elsewhere, so its target has to be absolute or it would dangle.
-  const auto self_absolute = pti::utils::AbsolutePath(self_path_, err);
-  ASSERT_FALSE(err) << "could not absolutize " << self_path_ << ": " << err.message();
-  pti::utils::filesystem::remove(link_path, err);
-  pti::utils::filesystem::create_symlink(self_absolute, link_path, err);
-  ASSERT_FALSE(err) << "could not create symlink: " << err.message();
-
-  utils::SetEnv(itt_lib_env::kIttLibEnvVarName, link_path.c_str());
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kAlreadyPti)
-      << "a symlink to this module must not be reported as a different module";
-}
-
-TEST_F(IttLibEnvTest, UnloadedLibraryNameRemainsUnloaded) {
-  ASSERT_TRUE(pti::utils::filesystem::exists(PTI_TEST_LOADER_EXTERNAL_LIBRARY));
-  const auto name =
-      pti::utils::filesystem::path(PTI_TEST_LOADER_EXTERNAL_LIBRARY).filename().string();
-  auto before = LibraryLoader::Probe(name);
-  ASSERT_EQ(before, nullptr);
-  ::utils::SetEnv(itt_lib_env::kIttLibEnvVarName, name.c_str());
-
-  EXPECT_EQ(itt_lib_env::ConfigureIttCollector(self_path_),
-            itt_lib_env::IttCollectorConfig::kUnresolvedLibraryName);
-  EXPECT_EQ(::utils::GetEnv(itt_lib_env::kIttLibEnvVarName), name);
-  auto after = LibraryLoader::Probe(name);
-  EXPECT_EQ(after, nullptr);
-}
-
-}  // namespace
diff --git a/sdk/test/lib_load_suite.cc b/sdk/test/lib_load_suite.cc
deleted file mode 100644
index d4ead3b2..00000000
--- a/sdk/test/lib_load_suite.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Real-library preload integration regression test. The executable deliberately does
-// not link against either PTI library, so loading begins through the staged interface.
-
-#include <dlfcn.h>
-#include <gtest/gtest.h>
-
-#include <memory>
-
-#include "pti/pti_view.h"
-
-// The staged interface and XPTI runtime closure share a directory, but Core resides in
-// its pti/ child. Core's $ORIGIN cannot reach XPTI, so LoadCoreLibrary must recursively
-// pre-load XPTI and its missing runtime dependencies through the interface RUNPATH.
-TEST(LibLoadTest, InterfacePreloadsCoreDependenciesWithoutLdLibraryPath) {
-  // The staged Core has no route to the interface-directory runtime closure on its own.
-  dlerror();
-  void *direct_core_handle = dlopen(PTI_PRELOAD_CORE_LIBRARY_PATH, RTLD_NOW | RTLD_LOCAL);
-  ASSERT_EQ(direct_core_handle, nullptr)
-      << "staged Core unexpectedly loaded without interface-side pre-loading: " << dlerror();
-  void *raw_handle = dlopen(PTI_PRELOAD_VIEW_LIBRARY_PATH, RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
-  ASSERT_NE(raw_handle, nullptr) << "Failed to dlopen staged libpti_view.so: " << dlerror();
-  auto handle = std::unique_ptr<void, decltype(&dlclose)>(raw_handle, dlclose);
-
-  using ptiViewOverheadKindToString_t = const char *(*)(pti_view_overhead_kind);
-  dlerror();
-  auto overhead_kind_to_string = reinterpret_cast<ptiViewOverheadKindToString_t>(
-      dlsym(handle.get(), "ptiViewOverheadKindToString"));
-  ASSERT_NE(overhead_kind_to_string, nullptr)
-      << "Failed to find ptiViewOverheadKindToString: " << dlerror();
-  // The interface fallback is "INVALID"; use a distinct value to prove Core dispatch.
-  EXPECT_STREQ(overhead_kind_to_string(PTI_VIEW_OVERHEAD_KIND_RESOURCE), "RESOURCE");
-
-  // RTLD_NOLOAD verifies that the preceding API call mapped staged Core; it cannot load it.
-  dlerror();
-  void *core_handle = dlopen(PTI_PRELOAD_CORE_LIBRARY_PATH, RTLD_NOW | RTLD_NOLOAD);
-  ASSERT_NE(core_handle, nullptr) << "ptiViewOverheadKindToString did not load staged libpti.so: "
-                                  << dlerror();
-  EXPECT_EQ(dlclose(core_handle), 0);
-}
diff --git a/sdk/test/libld_dependency_preload_test.cc b/sdk/test/libld_dependency_preload_test.cc
deleted file mode 100644
index ef8cf610..00000000
--- a/sdk/test/libld_dependency_preload_test.cc
+++ /dev/null
@@ -1,210 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Test the dependency pre-load path in pti_lib_handler.h, which exists because the
-// loader's search order does not always reach the directories where the PTI Core
-// library's dependencies are deployed - in a Python wheel they sit next to the interface
-// library, one directory up from the Core library's $ORIGIN.
-//
-// The layout below reproduces that without needing a wheel: this executable stands in
-// for the interface library, and the synthetic libraries built by AddPreloadStub() in
-// CMakeLists.txt stand in for the Core library and its dependencies.
-//
-// Each dependency's directory is its test case, one per way it can relate to the two
-// searches in play: the loader's own (which follows this executable's RUNPATH) and the
-// full path fallback over DependencySearchDirs(). One core library per dependency, so
-// no test can leave a dependency loaded that satisfies another one.
-//
-//   <build>/test/
-//     preload_stage/                            (2nd fallback search directory)
-//       libld_dependency_preload_test          (executable, sets RUNPATH to $ORIGIN)
-//       libpti_preload_dep_bysoname.so         (dependency: found by loader's search)
-//       libpti_preload_dep_chain_head.so       (dependency: found by loader's search)
-//       libpti_preload_dep_chain_tail.so       (dependency: also here, but chain_head
-//                                               has no RUNPATH to reach it - found only
-//                                               when pre-loaded from this executable)
-//       pti/                                   (1st fallback search directory)
-//         libpti_preload_core_bysoname.so      (core test: depends on dep_bysoname)
-//         libpti_preload_core_byfullpath.so    (core test: depends on dep_byfullpath)
-//         libpti_preload_core_chain.so         (core test: depends on chain_head ->
-//                                               chain_tail)
-//         libpti_preload_core_unreachable.so   (core test: depends on dep_unreachable)
-//         libpti_preload_core_undefined.so     (core test: has unresolved symbol)
-//         libpti_preload_dep_byfullpath.so     (dependency: only in fallback search)
-//     preload_unreachable/
-//       libpti_preload_dep_unreachable.so      (dependency: unreachable by both searches)
-
-#include <dlfcn.h>
-#include <gtest/gtest.h>
-
-#include <string>
-
-#include "pti_lib_handler.h"
-
-namespace {
-
-constexpr const char* kCoreBySoname = "libpti_preload_core_bysoname.so";
-constexpr const char* kCoreByFullPath = "libpti_preload_core_byfullpath.so";
-constexpr const char* kCoreChain = "libpti_preload_core_chain.so";
-constexpr const char* kCoreUnreachable = "libpti_preload_core_unreachable.so";
-constexpr const char* kCoreUndefinedSymbol = "libpti_preload_core_undefined.so";
-constexpr const char* kCoreCleanupFailure = "libpti_preload_core_cleanup_failure.so";
-
-std::string CoreLibPath(const char* file_name) { return pti::GetPathToPtiModule() + file_name; }
-
-// LoadCoreLibrary reports failure by throwing. Returns the message it reported,
-// or an empty string if the load succeeded.
-std::string LoadFailure(const std::string& core_lib_path) {
-  try {
-    pti::LoadCoreLibrary(core_lib_path);
-  } catch (const std::exception& error) {
-    return error.what();
-  }
-  return std::string{};
-}
-
-// The code under test logs which dependency it could not resolve, but the setup that
-// sets a level lives in the PtiLibHandler constructor these tests bypass. Verbose by
-// default, since ctest shows output only for a failing test. PTILOG_LEVEL overrides.
-class LogLevelFromEnvironment : public ::testing::Environment {
- public:
-  void SetUp() override {
-    spdlog::set_level(spdlog::level::trace);
-
-    const auto env_string = ::utils::GetEnv("PTILOG_LEVEL");
-    if (!env_string.empty()) {
-      spdlog::cfg::helpers::load_levels(env_string);
-    }
-    ::utils::SetGlobalSpdLogPattern();
-  }
-};
-
-// GoogleTest takes ownership of the environment and deletes it after the run.
-[[maybe_unused]] const auto* const kLogLevelFromEnvironment = ::testing::AddGlobalTestEnvironment(
-    new LogLevelFromEnvironment);  // NOLINT(cppcoreguidelines-owning-memory)
-
-// Every core library has its own dependency shape, keeping these tests independent of
-// the order they run in.
-class DependencyPreloadTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    // GetPathToPtiModule() derives everything from dladdr, which for an executable
-    // reports argv[0]. Invoked by a bare or relative name, the paths below come out
-    // relative to the current directory; say so rather than fail with a dlopen error
-    // that looks like the code under test misbehaving.
-    ASSERT_TRUE(pti::utils::filesystem::exists(CoreLibPath(kCoreBySoname)))
-        << "the synthetic core libraries are not where this test expects them ("
-        << pti::GetPathToPtiModule() << "); run the executable by its full path";
-  }
-};
-
-TEST_F(DependencyPreloadTest, ResolvesADependencyReachableBySoname) {
-  // The wheel case: the loader cannot resolve the dependency on behalf of the core
-  // library, but this executable's RUNPATH covers it.
-  auto core_lib = pti::LoadCoreLibrary(CoreLibPath(kCoreBySoname));
-  ASSERT_NE(core_lib, nullptr);
-  EXPECT_NE(core_lib->GetSymbol<int (*)()>("PtiPreloadStub_core_bysoname"), nullptr);
-}
-
-TEST_F(DependencyPreloadTest, ResolvesADependencyReachableOnlyByFullPath) {
-  // Shipped alongside the core library instead: no RUNPATH in the process covers the
-  // module subdirectory, so the fallback has to name the file outright.
-  auto core_lib = pti::LoadCoreLibrary(CoreLibPath(kCoreByFullPath));
-  ASSERT_NE(core_lib, nullptr);
-  EXPECT_NE(core_lib->GetSymbol<int (*)()>("PtiPreloadStub_core_byfullpath"), nullptr);
-}
-
-TEST_F(DependencyPreloadTest, ResolvesADependencyOfADependency) {
-  // Pre-loading the core library's dependency fails too, because it needs something the
-  // loader cannot find either: the deeper one has to be satisfied first.
-  auto core_lib = pti::LoadCoreLibrary(CoreLibPath(kCoreChain));
-  ASSERT_NE(core_lib, nullptr);
-  EXPECT_NE(core_lib->GetSymbol<int (*)()>("PtiPreloadStub_core_chain"), nullptr);
-
-  auto head_dependency = core_lib->GetSymbol<int (*)()>("PtiPreloadStub_dep_chain_head_Dependency");
-  ASSERT_NE(head_dependency, nullptr);
-  EXPECT_EQ(head_dependency(), 0);
-}
-
-TEST_F(DependencyPreloadTest, ReportsADependencyItCannotFindAnywhere) {
-  const auto error = LoadFailure(CoreLibPath(kCoreUnreachable));
-  ASSERT_FALSE(error.empty()) << "expected the load to fail: the dependency is reachable "
-                                 "neither by soname nor from a fallback directory";
-  // The reported message is the loader's, so it names what is actually missing.
-  EXPECT_NE(error.find("libpti_preload_dep_unreachable.so"), std::string::npos) << error;
-}
-
-TEST_F(DependencyPreloadTest, ReleasesAllPreloadedDependenciesWhenRecoveryFails) {
-  const auto error = LoadFailure(CoreLibPath(kCoreCleanupFailure));
-  ASSERT_FALSE(error.empty()) << "expected the load to fail after pre-loading head and tail";
-  EXPECT_NE(error.find("libpti_preload_dep_cleanup_missing.so"), std::string::npos) << error;
-
-  for (const char* dependency : {
-           "libpti_preload_dep_cleanup_head.so",
-           "libpti_preload_dep_cleanup_tail.so",
-       }) {
-    dlerror();
-    void* handle = dlopen(dependency, RTLD_NOW | RTLD_NOLOAD);
-    if (handle != nullptr) {
-      EXPECT_EQ(dlclose(handle), 0);
-    }
-    EXPECT_EQ(handle, nullptr) << dependency << " remained mapped after a failed recovery attempt";
-  }
-}
-
-TEST_F(DependencyPreloadTest, ReportsAFailureThatIsNotAMissingDependency) {
-  const auto error = LoadFailure(CoreLibPath(kCoreUndefinedSymbol));
-  ASSERT_FALSE(error.empty()) << "expected the load to fail: the library has an undefined symbol";
-  EXPECT_NE(error.find("undefined symbol"), std::string::npos) << error;
-}
-
-TEST_F(DependencyPreloadTest, ReportsAMissingCoreLibrary) {
-  // The loader names the file we asked for by path, and a path is not a soname,
-  // so there is nothing to pre-load and no point retrying.
-  const auto missing = CoreLibPath("libpti_preload_core_not_installed.so");
-  const auto error = LoadFailure(missing);
-  ASSERT_FALSE(error.empty()) << "expected the load to fail: " << missing << " does not exist";
-  EXPECT_NE(error.find("libpti_preload_core_not_installed.so"), std::string::npos) << error;
-}
-
-TEST(DependencySearchDirs, AreTheModuleDirectoryAndItsParent) {
-  const auto dirs = pti::DependencySearchDirs();
-  ASSERT_EQ(dirs.size(), 2U);
-  // Where the Core library is deployed, then one level up. Neither carries a trailing
-  // separator, or the parent of the first would be the first itself.
-  EXPECT_EQ(dirs[0].filename().string(), std::string{pti::strings::kModuleSubdir});
-  EXPECT_EQ(dirs[1], dirs[0].parent_path());
-  EXPECT_NE(dirs[1], dirs[0]);
-}
-
-TEST(MissingSonameFromLoaderError, ExtractsTheSonameTheLoaderCouldNotFind) {
-  EXPECT_EQ(pti::MissingSonameFromLoaderError(
-                "libxptifw.so: cannot open shared object file: No such file or directory"),
-            "libxptifw.so");
-}
-
-TEST(MissingSonameFromLoaderError, IgnoresAFailureThatIsNotAMissingDependency) {
-  EXPECT_TRUE(
-      pti::MissingSonameFromLoaderError("/opt/pti/lib/pti/libpti.so: undefined symbol: ptiFake")
-          .empty());
-  EXPECT_TRUE(
-      pti::MissingSonameFromLoaderError("/opt/pti/lib/pti/libpti.so: wrong ELF class: ELFCLASS32")
-          .empty());
-  EXPECT_TRUE(pti::MissingSonameFromLoaderError("").empty());
-}
-
-TEST(MissingSonameFromLoaderError, IgnoresAPathBecauseThereIsNoSonameToPreload) {
-  // What the loader reports when the file we named is the one it could not open.
-  // Pre-loading a path satisfies no NEEDED entry, and retrying it would only loop.
-  EXPECT_TRUE(pti::MissingSonameFromLoaderError("/opt/pti/lib/pti/libpti.so: cannot open shared "
-                                                "object file: No such file or directory")
-                  .empty());
-  EXPECT_TRUE(pti::MissingSonameFromLoaderError(
-                  ": cannot open shared object file: No such file or directory")
-                  .empty());
-}
-
-}  // namespace
diff --git a/sdk/test/libld_origin_test.cc b/sdk/test/libld_origin_test.cc
deleted file mode 100644
index 6c49eb47..00000000
--- a/sdk/test/libld_origin_test.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <dlfcn.h>
-#include <gtest/gtest.h>
-
-#include <iostream>
-#include <memory>
-
-namespace {
-
-struct DlCloser {
-  void operator()(void* handle) const noexcept {
-    if (handle != nullptr) {
-      (void)dlclose(handle);
-    }
-  }
-};
-
-const char* LibraryPathForSymbol(const void* symbol) {
-  Dl_info info{};
-  if (dladdr(symbol, &info) == 0 || info.dli_fname == nullptr) {
-    return "<unknown>";
-  }
-  return info.dli_fname;
-}
-
-}  // namespace
-
-// This synthetic Core-like library has RUNPATH $ORIGIN and a colocated dependency.
-// Loading it directly proves normal ELF $ORIGIN resolution without PTI's preloader.
-TEST(OriginResolution, CoreResolvesColocatedDependency) {
-  dlerror();
-  void* raw_handle = dlopen(PTI_ORIGIN_CORE_LIBRARY_PATH, RTLD_NOW | RTLD_LOCAL);
-  ASSERT_NE(raw_handle, nullptr) << "Failed to dlopen synthetic Core library: " << dlerror();
-  auto handle = std::unique_ptr<void, DlCloser>(raw_handle);
-
-  using CoreSymbol = int (*)();
-  dlerror();
-  auto core_symbol =
-      reinterpret_cast<CoreSymbol>(dlsym(handle.get(), "PtiPreloadStub_core_origin"));
-  ASSERT_NE(core_symbol, nullptr) << "Failed to find synthetic Core symbol: " << dlerror();
-
-  dlerror();
-  auto dependency_symbol =
-      reinterpret_cast<CoreSymbol>(dlsym(handle.get(), "PtiPreloadStub_dep_origin"));
-  ASSERT_NE(dependency_symbol, nullptr)
-      << "Failed to find colocated dependency symbol: " << dlerror();
-
-  std::cout << "Requested Core library: " << PTI_ORIGIN_CORE_LIBRARY_PATH << '\n'
-            << "Core symbol resolved from: "
-            << LibraryPathForSymbol(reinterpret_cast<const void*>(core_symbol)) << '\n'
-            << "Dependency symbol resolved from: "
-            << LibraryPathForSymbol(reinterpret_cast<const void*>(dependency_symbol)) << std::endl;
-
-  EXPECT_EQ(core_symbol(), 0);
-  EXPECT_EQ(dependency_symbol(), 0);
-}
diff --git a/sdk/test/libld_preload_stub.c b/sdk/test/libld_preload_stub.c
deleted file mode 100644
index 9595e6dc..00000000
--- a/sdk/test/libld_preload_stub.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*==============================================================
- * Copyright (C) Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- * =============================================================
- *
- * One source for every synthetic shared library that libld_dependency_preload_test
- * builds; see AddPreloadStub() in CMakeLists.txt for the definitions it is compiled
- * with.
- *
- * Plain C on purpose: the fewer DT_NEEDED entries these libraries carry of their
- * own, the fewer ways they can fail for a reason the test did not set up.
- */
-
-#if !defined(PRELOAD_STUB_NAME)
-#error "PRELOAD_STUB_NAME must name this stub; use AddPreloadStub() to build it"
-#endif
-
-/* The project compiles with hidden visibility, and a hidden symbol is neither
- * linkable from another stub nor findable with dlsym. */
-#define PRELOAD_EXPORT __attribute__((visibility("default")))
-
-#define PRELOAD_CONCAT_(a, b) a##b
-#define PRELOAD_CONCAT(a, b) PRELOAD_CONCAT_(a, b)
-#define PRELOAD_SYMBOL(name) PRELOAD_CONCAT(PtiPreloadStub_, name)
-
-PRELOAD_EXPORT int PRELOAD_SYMBOL(PRELOAD_STUB_NAME)(void) { return 0; }
-
-#if defined(PRELOAD_STUB_NEEDS)
-/* Calling into the other stub is what makes the linker record it as a DT_NEEDED
- * entry, the dependency the loader then has to resolve. */
-PRELOAD_EXPORT int PRELOAD_SYMBOL(PRELOAD_STUB_NEEDS)(void);
-
-PRELOAD_EXPORT int PRELOAD_CONCAT(PRELOAD_SYMBOL(PRELOAD_STUB_NAME), _Dependency)(void) {
-  return PRELOAD_SYMBOL(PRELOAD_STUB_NEEDS)();
-}
-#endif
-
-#if defined(PRELOAD_STUB_ALSO_NEEDS)
-/* A second direct dependency lets a test prove that a successful first pre-load is
- * released when the Core library still cannot load its next dependency. */
-PRELOAD_EXPORT int PRELOAD_SYMBOL(PRELOAD_STUB_ALSO_NEEDS)(void);
-
-PRELOAD_EXPORT int PRELOAD_CONCAT(PRELOAD_SYMBOL(PRELOAD_STUB_NAME), _AlsoDependency)(void) {
-  return PRELOAD_SYMBOL(PRELOAD_STUB_ALSO_NEEDS)();
-}
-#endif
-
-#if defined(PRELOAD_STUB_UNDEFINED_SYMBOL)
-/* Referenced here, defined nowhere: dlopen with RTLD_NOW fails on this with an
- * "undefined symbol" error rather than a missing-dependency one, which is a
- * failure no amount of pre-loading can fix. */
-PRELOAD_EXPORT int PtiPreloadStubSymbolThatDoesNotExist(void);
-
-PRELOAD_EXPORT int PRELOAD_CONCAT(PRELOAD_SYMBOL(PRELOAD_STUB_NAME), _Undefined)(void) {
-  return PtiPreloadStubSymbolThatDoesNotExist();
-}
-#endif
diff --git a/sdk/test/local_ze_collection_fixture.cc b/sdk/test/local_ze_collection_fixture.cc
deleted file mode 100644
index a664c84e..00000000
--- a/sdk/test/local_ze_collection_fixture.cc
+++ /dev/null
@@ -1,1008 +0,0 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <level_zero/driver_experimental/zex_visit.h>
-#include <level_zero/ze_api.h>
-
-#include <chrono>
-#include <stdexcept>
-#include <thread>
-
-#include "pti/pti_view.h"
-#include "utils.h"
-#include "utils/gtest_helpers.h"
-#include "utils/test_helpers.h"
-#include "utils/ze_config_info.h"
-#include "ze_utils.h"
-
-namespace {
-constexpr size_t kPtiDeviceId = 0;  // run on first device
-constexpr auto kAlign = 64;
-constexpr auto kAValue = 0.128f;
-constexpr auto kBValue = 0.256f;
-constexpr auto kMaxEps = 1.0e-4f;
-constexpr uint32_t kDefaultEventWaitTimeMs = 5000;
-constexpr uint32_t kDriverVersionWithBrokenVisitorExtension = 17012470;
-
-// Prevent Test from hanging indefinitely
-ze_result_t SpinBlockEvent(ze_event_handle_t event, uint32_t milliseconds) {
-  ze_result_t result = ZE_RESULT_NOT_READY;
-  auto start = std::chrono::high_resolution_clock::now();
-  while ((result = zeEventQueryStatus(event)) == ZE_RESULT_NOT_READY) {
-    auto now = std::chrono::high_resolution_clock::now();
-    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();
-    if (elapsed > milliseconds) {
-      return ZE_RESULT_NOT_READY;
-    }
-    std::this_thread::yield();
-  }
-  return result;
-}
-
-ze_result_t SpinBlockEvent(ze_event_handle_t event) {
-  return SpinBlockEvent(event, kDefaultEventWaitTimeMs);
-}
-
-float Check(const std::vector<float>& result, float value) {
-  if (value <= kMaxEps) {
-    throw std::invalid_argument("Value must be greater than max epsilon");
-  }
-
-  float eps = 0.0f;
-  for (auto result_val : result) {
-    eps += std::fabs((result_val - value) / value);
-  }
-  return eps / static_cast<float>(std::size(result));
-}
-}  // namespace
-
-class LocalModeZeGemmTest : public testing::Test {
- protected:
-  LocalModeZeGemmTest()
-      : spv_binary_(utils::LoadBinaryFile(utils::GetExecutablePath() + kKernelFile)) {
-    a_vector_ = std::vector<float>(size_ * size_, kAValue);
-    b_vector_ = std::vector<float>(size_ * size_, kBValue);
-    result_vector_ = std::vector<float>(size_ * size_, 0);
-  }
-
-  void EnableView(pti_view_kind view) {
-    EXPECT_EQ(ptiViewEnable(view), PTI_SUCCESS);
-    enabled_views_.push_back(view);
-  }
-
-  void DisableAndFlushAllViews() {
-    for (auto view : enabled_views_) {
-      EXPECT_EQ(ptiViewDisable(view), PTI_SUCCESS);
-    }
-    enabled_views_.clear();
-    EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  }
-
-  void InitializeDrivers() {
-    auto status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    drv_ = utils::ze::GetGpuDriver(kPtiDeviceId);
-    ASSERT_NE(drv_, nullptr);
-    auto props = utils::ze::GetDriverProperties(drv_);
-    command_list_visit_supported_ =
-        ::utils::ze::IsDriverExtensionSupported(drv_, ZE_COMMAND_VISIT_EXT_NAME);
-    if (props) {
-      if (props->driverVersion <= kDriverVersionWithBrokenVisitorExtension) {
-        command_list_visit_supported_ = false;
-      }
-    }
-    dev_ = utils::ze::GetGpuDevice(kPtiDeviceId);
-    ctx_ = utils::ze::GetContext(drv_);
-  }
-
-  void InitializeEvents(uint32_t event_count) {
-    ze_event_pool_desc_t event_pool_desc = {
-        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-        ZE_EVENT_POOL_FLAG_HOST_VISIBLE,  // all events in pool are visible to Host
-        event_count                       // count
-    };
-
-    if (event_timestamps_enabled_) {
-      event_pool_desc.flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
-    }
-
-    ASSERT_NE(ctx_, nullptr);
-    ASSERT_NE(dev_, nullptr);
-    auto status = zeEventPoolCreate(ctx_, &event_pool_desc, 1, &dev_, &evt_pl_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0,
-                                  ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-
-    ASSERT_NE(evt_pl_, nullptr);
-    evts_.resize(event_count);
-    for (uint32_t i = 0; i < event_count; ++i) {
-      event_desc.index = i;
-      ASSERT_EQ(zeEventCreate(evt_pl_, &event_desc, &evts_[i]), ZE_RESULT_SUCCESS);
-    }
-  }
-
-  void InitializeQueue() {
-    ze_command_queue_desc_t cmd_queue_desc = {
-        ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0, ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-        ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-
-    auto status = zeCommandQueueCreate(ctx_, dev_, &cmd_queue_desc, &cmd_q_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    ze_command_list_desc_t cmd_list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-
-    if (kInorderQueue) {
-      cmd_list_desc.flags |= ZE_COMMAND_LIST_FLAG_IN_ORDER;
-    }
-
-    if (command_list_visit_supported_) {
-      cmd_list_desc.flags |= ZE_COMMAND_LIST_FLAG_ENABLE_CMD_VISITING;
-    }
-
-    status = zeCommandListCreate(ctx_, dev_, &cmd_list_desc, &cmd_list_);
-
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void InitializeLists(bool synchronous) {
-    ze_command_queue_desc_t cmd_queue_desc = {ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-                                              nullptr,
-                                              0,
-                                              0,
-                                              ZE_COMMAND_QUEUE_FLAG_IN_ORDER,
-                                              ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-                                              ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-    if (synchronous) {
-      cmd_queue_desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
-    }
-    uint32_t compute_queue_ordinal = 0;
-    uint32_t copy_queue_ordinal = 0;
-    ASSERT_EQ(pti::test::utils::level_zero::GetGroupOrdinals(dev_, compute_queue_ordinal,
-                                                             copy_queue_ordinal),
-              0);
-    cmd_queue_desc.ordinal = compute_queue_ordinal;
-    ASSERT_EQ(zeCommandListCreateImmediate(ctx_, dev_, &cmd_queue_desc, &compute_cmd_list_),
-              ZE_RESULT_SUCCESS);
-    cmd_queue_desc.ordinal = copy_queue_ordinal;
-    ASSERT_EQ(zeCommandListCreateImmediate(ctx_, dev_, &cmd_queue_desc, &copy_cmd_list_),
-              ZE_RESULT_SUCCESS);
-  }
-
-  void SetKernelGroupSize() {
-    ASSERT_NE(knl_, nullptr);
-    auto status = zeKernelSuggestGroupSize(knl_, size_, size_, 1, std::data(group_size_),
-                                           std::data(group_size_) + 1, std::data(group_size_) + 2);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    if ((size_ % group_size_[0]) != 0 || (size_ % group_size_[1]) != 0) {
-      FAIL() << "Non-uniform group size";
-    }
-    status = zeKernelSetGroupSize(knl_, group_size_[0], group_size_[1], group_size_[2]);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void* AllocateDeviceBuffer(size_t size, size_t alignment) {
-    void* storage = nullptr;
-    const ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr,
-                                                   0, 0};
-    if (!ctx_) {
-      return nullptr;
-    }
-    if (!dev_) {
-      return nullptr;
-    }
-
-    auto status = zeMemAllocDevice(ctx_, &alloc_desc, size, alignment, dev_, &storage);
-
-    if (status != ZE_RESULT_SUCCESS) {
-      return nullptr;
-    }
-
-    return storage;
-  }
-
-  template <typename T>
-  void AppendCopyToDevice(void* dev, const T& host_container) {
-    ASSERT_NE(cmd_list_, nullptr);
-    ASSERT_NE(dev, nullptr);
-    auto status = zeCommandListAppendMemoryCopy(
-        cmd_list_, dev, std::data(host_container),
-        std::size(host_container) * sizeof(typename T::value_type), nullptr, 0, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  template <typename T>
-  void AppendCopyFromDevice(T& host_container, const void* dev) {
-    ASSERT_NE(cmd_list_, nullptr);
-    ASSERT_NE(dev, nullptr);
-    auto status = zeCommandListAppendMemoryCopy(
-        cmd_list_, std::data(host_container), dev,
-        std::size(host_container) * sizeof(typename T::value_type), nullptr, 0, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void AppendBarrier() {
-    ASSERT_NE(cmd_list_, nullptr);
-    auto status = zeCommandListAppendBarrier(cmd_list_, nullptr, 0, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void SetKernelGroupCount() {
-    ASSERT_NE(group_size_[0], 0U);
-    ASSERT_NE(group_size_[1], 0U);
-    dim_ = {size_ / group_size_[0], size_ / group_size_[1], 1};
-  }
-
-  void AppendGemmKernel() {
-    SetKernelGroupCount();
-    ASSERT_NE(cmd_list_, nullptr);
-    auto status = zeCommandListAppendLaunchKernel(cmd_list_, knl_, &dim_, evts_[0], 0, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void ValidateGemmKernel() const {
-    float expected_result = kAValue * kBValue * static_cast<float>(size_);
-    auto eps = Check(result_vector_, expected_result);
-    ASSERT_LE(eps, kMaxEps);
-  }
-
-  void PrepareCommandList() {
-    AppendCopyToDevice(a_buf_, a_vector_);
-    AppendCopyToDevice(b_buf_, b_vector_);
-    AppendBarrier();
-    AppendGemmKernel();
-    AppendBarrier();
-    AppendCopyFromDevice(result_vector_, result_buf_);
-    AppendBarrier();
-    ASSERT_NE(cmd_list_, nullptr);
-    auto status = zeCommandListClose(cmd_list_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void AllocateGemmDeviceBuffers() {
-    a_buf_ = AllocateDeviceBuffer(size_ * size_ * sizeof(typename decltype(a_vector_)::value_type),
-                                  kAlign);
-    ASSERT_NE(a_buf_, nullptr);
-
-    b_buf_ = AllocateDeviceBuffer(size_ * size_ * sizeof(typename decltype(b_vector_)::value_type),
-                                  kAlign);
-    ASSERT_NE(b_buf_, nullptr);
-
-    result_buf_ = AllocateDeviceBuffer(
-        size_ * size_ * sizeof(typename decltype(result_vector_)::value_type), kAlign);
-    ASSERT_NE(result_buf_, nullptr);
-  }
-
-  void SetKernelArguments() {
-    AllocateGemmDeviceBuffers();
-    ASSERT_NE(knl_, nullptr);
-    auto status = zeKernelSetArgumentValue(knl_, 0, sizeof(a_buf_), &a_buf_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    status = zeKernelSetArgumentValue(knl_, 1, sizeof(b_buf_), &b_buf_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    status = zeKernelSetArgumentValue(knl_, 2, sizeof(result_buf_), &result_buf_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    status = zeKernelSetArgumentValue(knl_, 3, sizeof(size_), &size_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void CreateKernel() {
-    const ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                          nullptr,
-                                          ZE_MODULE_FORMAT_IL_SPIRV,
-                                          std::size(spv_binary_),
-                                          std::data(spv_binary_),
-                                          nullptr,
-                                          nullptr};
-
-    auto status = zeModuleCreate(ctx_, dev_, &module_desc, &mdl_, nullptr);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    ASSERT_NE(mdl_, nullptr);
-    const ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, kKernelName};
-    status = zeKernelCreate(mdl_, &kernel_desc, &knl_);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  }
-
-  void SetUp() override {
-    if (ptiViewGPULocalAvailable() != pti_result::PTI_SUCCESS) {
-      GTEST_SKIP() << "GPULocal is not available. Skipping Test Suite";
-    }
-    ASSERT_NE(std::size(spv_binary_), 0ULL);
-
-    ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer), pti_result::PTI_SUCCESS);
-
-    LocalModeZeGemmTestData::Instance().Reset();
-  }
-
-  void TearDown() override {
-    // Workaround for driver reusing handles:
-    // The collector's internal state does not reset between tests. Also, unless tracing is enabled,
-    // we do not properly track command list destruction.
-    // Therefore, this is a workaround to enable tracing and ensure any internal state tracking the
-    // queues is properly reset. For example, a handle being tracked as an "immediate" command list
-    // could become a regular command list in the next test, and if we do not reset the state.
-    // TODO: fix in the collector.
-
-    EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-    // TODO: RAII-ify this
-    if (result_buf_) {
-      EXPECT_EQ(zeMemFree(ctx_, result_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (b_buf_) {
-      EXPECT_EQ(zeMemFree(ctx_, b_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (a_buf_) {
-      EXPECT_EQ(zeMemFree(ctx_, a_buf_), ZE_RESULT_SUCCESS);
-    }
-
-    if (cmd_list_) {
-      EXPECT_EQ(zeCommandListDestroy(cmd_list_), ZE_RESULT_SUCCESS);
-    }
-
-    if (compute_cmd_list_) {
-      EXPECT_EQ(zeCommandListDestroy(compute_cmd_list_), ZE_RESULT_SUCCESS);
-    }
-
-    if (copy_cmd_list_) {
-      EXPECT_EQ(zeCommandListDestroy(copy_cmd_list_), ZE_RESULT_SUCCESS);
-    }
-
-    if (cmd_q_) {
-      EXPECT_EQ(zeCommandQueueDestroy(cmd_q_), ZE_RESULT_SUCCESS);
-    }
-
-    for (auto* evt : evts_) {
-      if (evt) {
-        EXPECT_EQ(zeEventDestroy(evt), ZE_RESULT_SUCCESS);
-      }
-    }
-
-    if (evt_pl_) {
-      EXPECT_EQ(zeEventPoolDestroy(evt_pl_), ZE_RESULT_SUCCESS);
-    }
-
-    if (knl_) {
-      EXPECT_EQ(zeKernelDestroy(knl_), ZE_RESULT_SUCCESS);
-    }
-
-    if (mdl_) {
-      EXPECT_EQ(zeModuleDestroy(mdl_), ZE_RESULT_SUCCESS);
-    }
-
-    if (ctx_) {
-      EXPECT_EQ(zeContextDestroy(ctx_), ZE_RESULT_SUCCESS);
-    }
-    DisableAndFlushAllViews();
-  }
-
-  static void ProvideBuffer(unsigned char** buf, size_t* buf_size) {
-    *buf = pti::test::utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-    if (!*buf) {
-      FAIL() << "Unable to allocate buffer for PTI tracing";
-    }
-    *buf_size = kRequestedBufferSize;
-  }
-
-  static void ParseBuffer(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      if (used_bytes) {
-        pti::test::utils::AlignedDealloc(buf);
-      }
-      return;
-    }
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        FAIL() << "Found Error Parsing Records from PTI";
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          FAIL() << "Found Invalid PTI View Record";
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DRIVER_API: {
-          LocalModeZeGemmTestData::Instance().num_ze_records++;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          LocalModeZeGemmTestData::Instance().num_mem_copies++;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION: {
-          LocalModeZeGemmTestData::Instance().num_syncs++;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          LocalModeZeGemmTestData::Instance().num_kernels++;
-          auto* kernel_record = reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-          EXPECT_THAT(kernel_record->_name, ::testing::StrEq(kKernelName));
-          break;
-        }
-        default: {
-          break;
-        }
-      }
-    }
-    pti::test::utils::AlignedDealloc(buf);
-  }
-  static constexpr auto kRequestedBufferSize = 1'000;
-  static constexpr auto kInorderQueue = true;
-  static constexpr const char* const kKernelName = "GEMM";
-  static constexpr const char* const kKernelFile = "gemm.spv";
-
-  struct LocalModeZeGemmTestData {
-    static LocalModeZeGemmTestData& Instance() {
-      static LocalModeZeGemmTestData test_data{};
-      return test_data;
-    }
-
-    void Reset() {
-      num_ze_records = 0;
-      num_kernels = 0;
-      num_mem_copies = 0;
-      num_syncs = 0;
-    }
-
-    size_t num_ze_records = 0;
-    size_t num_kernels = 0;
-    size_t num_mem_copies = 0;
-    size_t num_syncs = 0;
-  };
-
-  std::vector<pti_view_kind> enabled_views_;
-  bool event_timestamps_enabled_ = false;
-  std::vector<uint8_t> spv_binary_;
-  unsigned int size_ = 1024;
-  std::vector<float> a_vector_;
-  std::vector<float> b_vector_;
-  std::vector<float> result_vector_;
-  bool command_list_visit_supported_ = false;
-  ze_driver_handle_t drv_ = nullptr;
-  ze_device_handle_t dev_ = nullptr;
-  ze_context_handle_t ctx_ = nullptr;
-  ze_module_handle_t mdl_ = nullptr;
-  std::array<uint32_t, 3> group_size_ = {0};
-  ze_kernel_handle_t knl_ = nullptr;
-  ze_event_pool_handle_t evt_pl_ = nullptr;
-  std::vector<ze_event_handle_t> evts_;
-  ze_command_queue_handle_t cmd_q_ = nullptr;
-  ze_command_list_handle_t cmd_list_ = nullptr;
-  ze_command_list_handle_t copy_cmd_list_ = nullptr;
-  ze_command_list_handle_t compute_cmd_list_ = nullptr;
-  void* a_buf_ = nullptr;
-  void* b_buf_ = nullptr;
-  void* result_buf_ = nullptr;
-  ze_group_count_t dim_ = {0, 0, 0};
-};
-
-TEST_F(LocalModeZeGemmTest, TestStartTracingExecuteCommandQueue) {
-  // Leaving out of Constructor / SetUp for now to allow extending to more test
-  // cases.
-  InitializeDrivers();
-  InitializeEvents(1);
-  InitializeQueue();
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  PrepareCommandList();
-
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DRIVER_API);
-
-  auto status = zeCommandQueueExecuteCommandLists(cmd_q_, 1, &cmd_list_, nullptr);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  status = zeCommandQueueSynchronize(cmd_q_, UINT64_MAX);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_ze_records, static_cast<size_t>(2));
-
-  if (command_list_visit_supported_) {
-    EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-    SUCCEED()
-        << "Command List Visiting is supported, expected 2 driver API records and 1 kernel record.";
-  } else {
-    EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(0));
-  }
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest, TestStartTracingExecuteCommandQueueWithoutVisitorExtensionEnabled) {
-  // Leaving out of Constructor / SetUp for now to allow extending to more test
-  // cases.
-  InitializeDrivers();
-  command_list_visit_supported_ = false;
-  InitializeEvents(1);
-  InitializeQueue();
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  PrepareCommandList();
-
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DRIVER_API);
-
-  auto status = zeCommandQueueExecuteCommandLists(cmd_q_, 1, &cmd_list_, nullptr);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  status = zeCommandQueueSynchronize(cmd_q_, UINT64_MAX);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_ze_records, static_cast<size_t>(2));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(0));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest, TestExecuteCommandListResetWhileTracingStopped) {
-  InitializeDrivers();
-  if (!command_list_visit_supported_) {
-    GTEST_SKIP() << "Command list visiting is not supported. Skipping test.";
-  }
-  InitializeEvents(1);
-  InitializeQueue();
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  PrepareCommandList();
-
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  ASSERT_EQ(zeCommandQueueExecuteCommandLists(cmd_q_, 1, &cmd_list_, nullptr), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandQueueSynchronize(cmd_q_, UINT64_MAX), ZE_RESULT_SUCCESS);
-  DisableAndFlushAllViews();
-  ValidateGemmKernel();
-
-  // Keep the first result buffer alive so the new recording copies to a different address.
-  std::vector<float> first_result(size_ * size_, 0);
-  result_vector_.swap(first_result);
-  ASSERT_EQ(zeCommandListReset(cmd_list_), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeEventHostReset(evts_[0]), ZE_RESULT_SUCCESS);
-  PrepareCommandList();
-
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  ASSERT_EQ(zeCommandQueueExecuteCommandLists(cmd_q_, 1, &cmd_list_, nullptr), ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandQueueSynchronize(cmd_q_, UINT64_MAX), ZE_RESULT_SUCCESS);
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(2));
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest, TestStartTracingPrepareCommandList) {
-  // Leaving out of Constructor / SetUp for now to allow extending to more test
-  // cases.
-  InitializeDrivers();
-  InitializeEvents(1);
-  InitializeQueue();
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  PrepareCommandList();
-
-  auto status = zeCommandQueueExecuteCommandLists(cmd_q_, 1, &cmd_list_, nullptr);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-  status = zeCommandQueueSynchronize(cmd_q_, UINT64_MAX);
-  ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest, TestAsynchInorderQueueImplementationWithImmediateCommandLists) {
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(false);
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 1,
-                                          &memcpy_signal_1),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendLaunchKernel(compute_cmd_list_, knl_, &dim_, kernel_signal, 2,
-                                            evts_.data()),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSynchronize(memcpy_signal_3, ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(
-    LocalModeZeGemmTest,
-    TestAsynchInorderQueueImplementationWithImmediateCommandListsAndZeCommandListAppendLaunchKernelWithParameters) {
-#if !defined(_WIN32)
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(false);
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 1,
-                                          &memcpy_signal_1),
-            ZE_RESULT_SUCCESS);
-
-  ze_command_list_append_launch_kernel_param_cooperative_desc_t launch_params = {
-      ZE_STRUCTURE_TYPE_COMMAND_LIST_APPEND_PARAM_COOPERATIVE_DESC,
-      nullptr,
-      static_cast<ze_bool_t>(0),
-  };
-
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeCommandListAppendLaunchKernelWithParameters(
-      compute_cmd_list_, knl_, &dim_, static_cast<const void*>(&launch_params), kernel_signal, 2,
-      evts_.data()));
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSynchronize(memcpy_signal_3, ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-#else
-  GTEST_SKIP() << "zeCommandListAppendLaunchKernelWithParameters is not supported";
-#endif
-}
-
-TEST_F(
-    LocalModeZeGemmTest,
-    TestAsynchInorderQueueImplementationWithImmediateCommandListsAndZeCommandListAppendLaunchKernelWithArguments) {
-#if !defined(_WIN32)
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(false);
-  AllocateGemmDeviceBuffers();
-  CreateKernel();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 1,
-                                          &memcpy_signal_1),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeKernelSuggestGroupSize(knl_, size_, size_, 1, std::data(group_size_),
-                                     std::data(group_size_) + 1, std::data(group_size_) + 2),
-            ZE_RESULT_SUCCESS);
-
-  std::array<void*, 4> kernel_args = {&a_buf_, &b_buf_, &result_buf_, &size_};
-  ze_group_size_t suggested_group_size = {group_size_[0], group_size_[1], group_size_[2]};
-  SetKernelGroupCount();
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeCommandListAppendLaunchKernelWithArguments(
-      compute_cmd_list_, knl_, dim_, suggested_group_size, kernel_args.data(), nullptr,
-      kernel_signal, 2, evts_.data()));
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSynchronize(memcpy_signal_3, ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-#else
-  GTEST_SKIP() << "zeCommandListAppendLaunchKernelWithArguments is not supported";
-#endif
-}
-
-TEST_F(LocalModeZeGemmTest, TestAsynchInorderQueueImplementationWithImmediateCommandListsAndReset) {
-  constexpr auto kNumberOfEventsRequired = 3;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(true);  // ensure we're OK regarding synchronization.
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 1,
-                                          &memcpy_signal_1),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendLaunchKernel(compute_cmd_list_, knl_, &dim_, kernel_signal, 2,
-                                            evts_.data()),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostReset(memcpy_signal_1), ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_1, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSynchronize(memcpy_signal_1, ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest,
-       TestInorderQueueImplementationWithCommandListImmediateAppendCommandListsExp) {
-  InitializeDrivers();
-  InitializeEvents(4);
-  InitializeQueue();
-  InitializeLists(false);
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-  PrepareCommandList();
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeCommandListImmediateAppendCommandListsExp(
-      compute_cmd_list_, 1, &cmd_list_, evts_[1], 0, nullptr));
-
-  ASSERT_EQ(zeEventHostSynchronize(evts_[1], ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest,
-       TestAsynchInorderQueueImplementationWithImmediateCommandListsAndEventDestroy) {
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(true);  // ensure we're OK regarding synchronization.
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 1,
-                                          &memcpy_signal_1),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendLaunchKernel(compute_cmd_list_, knl_, &dim_, kernel_signal, 1,
-                                            &memcpy_signal_2),
-            ZE_RESULT_SUCCESS);
-
-  // 2 waits for 1, so no need to wait for 1.
-  ASSERT_EQ(SpinBlockEvent(memcpy_signal_2), ZE_RESULT_SUCCESS)
-      << "Timeout waiting for event to be signaled";
-
-  ASSERT_EQ(zeEventDestroy(memcpy_signal_1), ZE_RESULT_SUCCESS);
-  evts_[0] = nullptr;  // prevent clean up segv
-
-  ASSERT_EQ(zeCommandListReset(copy_cmd_list_), ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeEventHostSynchronize(memcpy_signal_3, ((std::numeric_limits<uint64_t>::max)() - 1)),
-            ZE_RESULT_SUCCESS);
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest,
-       TestAsynchInorderQueueImplementationWithImmediateCommandListsSpinBlock) {
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(false);
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(SpinBlockEvent(memcpy_signal_1), ZE_RESULT_SUCCESS)
-      << "Timeout waiting for event to be signaled";
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(SpinBlockEvent(memcpy_signal_2), ZE_RESULT_SUCCESS)
-      << "Timeout waiting for event to be signaled";
-
-  ASSERT_EQ(
-      zeCommandListAppendLaunchKernel(compute_cmd_list_, knl_, &dim_, kernel_signal, 0, nullptr),
-      ZE_RESULT_SUCCESS);
-
-  // TODO(PTI): Investigate why this doesn't work in FULL mode (i.e., PTI_COLLECTION_MODE=0)
-  // ASSERT_EQ(SpinBlockEvent(kernel_signal), ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ASSERT_EQ(SpinBlockEvent(memcpy_signal_3), ZE_RESULT_SUCCESS)
-      << "Timeout waiting for event to be signaled";
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-
-  ValidateGemmKernel();
-}
-
-TEST_F(LocalModeZeGemmTest,
-       TestAsynchInorderQueueImplementationWithImmediateCommandListsDeviceSynch) {
-  constexpr auto kNumberOfEventsRequired = 4;
-  InitializeDrivers();
-  InitializeEvents(kNumberOfEventsRequired);
-  InitializeLists(false);
-  CreateKernel();
-  SetKernelGroupSize();
-  SetKernelArguments();
-  SetKernelGroupCount();
-  EnableView(PTI_VIEW_DEVICE_GPU_KERNEL);
-  EnableView(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-  EnableView(PTI_VIEW_DEVICE_SYNCHRONIZATION);
-
-  auto* memcpy_signal_1 = evts_[0];
-  auto* memcpy_signal_2 = evts_[1];
-  auto* kernel_signal = evts_[2];
-  auto* memcpy_signal_3 = evts_[3];
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, a_buf_, std::data(a_vector_),
-                                          std::size(a_vector_) * sizeof(float), memcpy_signal_1, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeDeviceSynchronize(dev_));
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, b_buf_, std::data(b_vector_),
-                                          std::size(b_vector_) * sizeof(float), memcpy_signal_2, 0,
-                                          nullptr),
-            ZE_RESULT_SUCCESS);
-
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeDeviceSynchronize(dev_));
-
-  ASSERT_EQ(
-      zeCommandListAppendLaunchKernel(compute_cmd_list_, knl_, &dim_, kernel_signal, 0, nullptr),
-      ZE_RESULT_SUCCESS);
-
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeDeviceSynchronize(dev_));
-
-  ASSERT_EQ(zeCommandListAppendMemoryCopy(copy_cmd_list_, std::data(result_vector_), result_buf_,
-                                          std::size(result_vector_) * sizeof(float),
-                                          memcpy_signal_3, 1, &kernel_signal),
-            ZE_RESULT_SUCCESS);
-
-  ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(zeDeviceSynchronize(dev_));
-
-  DisableAndFlushAllViews();
-
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_kernels, static_cast<size_t>(1));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_mem_copies, static_cast<size_t>(3));
-  EXPECT_EQ(LocalModeZeGemmTestData::Instance().num_syncs, static_cast<size_t>(4));
-
-  ValidateGemmKernel();
-}
diff --git a/sdk/test/main_classapi_fixture.cc b/sdk/test/main_classapi_fixture.cc
deleted file mode 100644
index 3d832a6d..00000000
--- a/sdk/test/main_classapi_fixture.cc
+++ /dev/null
@@ -1,1672 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Based on Vector Add example from OneAPI samples
-//==============================================================
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <cmath>
-#include <iostream>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/sycl_config_info.h"
-#include "utils/test_helpers.h"
-#include "utils/ze_utils.h"
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-namespace {
-
-struct ClassTestData {
-  bool event_host_synch_rec_present = false;
-  bool ze_kernel_rec_present = false;
-  bool ur_event_wait_rec_present = false;
-  bool ur_mem_write_rec_present = false;
-  bool ur_mem_read_rec_present = false;
-  bool ur_kernel_rec_present = false;
-  bool zecall_present = false;
-  bool zecall_command_list_append_memory_copy_present = false;
-  bool zecall_command_list_append_memory_fill_present = false;
-  bool zecall_command_list_append_launch_kernel_present = false;
-  bool zecall_command_queue_execute_command_lists_present = false;
-  bool zecall_host_synch_class_rec_present = false;
-  uint64_t zecall_count = 0;
-  bool urcall_present = false;
-  uint64_t urcall_count = 0;
-  std::array<uint8_t, PTI_MAX_DEVICE_UUID_SIZE> device_uuid_test = {};
-  pti_backend_queue_t queue_test = nullptr;
-
-  static ClassTestData& Get() {
-    static ClassTestData instance{};
-    return instance;
-  }
-
-  void Reset() {
-    event_host_synch_rec_present = false;
-    ze_kernel_rec_present = false;
-    ur_event_wait_rec_present = false;
-    ur_mem_write_rec_present = false;
-    ur_mem_read_rec_present = false;
-    ur_kernel_rec_present = false;
-    zecall_present = false;
-    zecall_count = 0;
-    urcall_present = false;
-    urcall_count = 0;
-    zecall_command_list_append_memory_copy_present = false;
-    zecall_command_list_append_memory_fill_present = false;
-    zecall_command_list_append_launch_kernel_present = false;
-    zecall_command_queue_execute_command_lists_present = false;
-    zecall_host_synch_class_rec_present = false;
-    std::fill_n(device_uuid_test.begin(), device_uuid_test.size(), 0);
-    queue_test = nullptr;
-  }
-
- private:
-  ClassTestData() = default;
-  ~ClassTestData() = default;
-};
-
-float Check(const std::vector<float>& a, float value) {
-  PTI_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-float RunAndCheck(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-                  std::vector<float>& c, unsigned size, float expected_result) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  PTI_ASSERT(b.size() == size * size);
-  PTI_ASSERT(c.size() == size * size);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    std::cerr << "[ERROR] " << e.what() << std::endl;
-  }
-
-  return Check(c, expected_result);
-}
-
-void Compute(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-             std::vector<float>& c, unsigned size, unsigned repeat_count, float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    [[maybe_unused]] volatile float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-  }
-}
-}  // namespace
-
-class ClassApiFixtureTest : public ::testing::TestWithParam<std::tuple<bool, bool, bool>> {
- protected:
-  void SetUp() override {  // Called right after constructor before each test
-    ClassTestData::Get().Reset();
-    try {
-      dev_ = sycl::device(sycl::gpu_selector_v);
-      auto* device_l0_test = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(dev_);
-      if (device_l0_test) {
-        ASSERT_TRUE(
-            utils::ze::GetDeviceUuid(device_l0_test, ClassTestData::Get().device_uuid_test.data()));
-        samples_utils::PrintUuid(ClassTestData::Get().device_uuid_test.data(),
-                                 "Test Device UUID: ");
-      } else {
-        FAIL() << "PTI doesn't support this backend yet. Backend is not Level Zero";
-      }
-
-    } catch (const sycl::exception& e) {
-      FAIL() << "Unable to select valid device to run tests on. Check your hardware, driver "
-                "install, or system configuration.";
-    }
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-    void* ptr = ::operator new(*buf_size);
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-  }
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      ::operator delete(buf);
-      return;
-    }
-
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        std::cerr << "Found Error Parsing Records from PTI" << '\n';
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          std::cout << "Found Invalid Record" << '\n';
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DRIVER_API: {
-          auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          if (rec->_api_group != pti_api_group_id::PTI_API_GROUP_LEVELZERO) {
-            std::cerr << "Unexpected API group in PTI_VIEW_DRIVER_API: "
-                         "expected PTI_API_GROUP_LEVELZERO, got "
-                      << rec->_api_group << '\n';
-          }
-          ClassTestData::Get().zecall_present = true;
-          ClassTestData::Get().zecall_count++;
-          const char* api_name = nullptr;
-          auto status = ptiViewGetApiIdName(rec->_api_group, rec->_api_id, &api_name);
-          PTI_ASSERT(status == PTI_SUCCESS);
-          std::string function_name(api_name);
-          if ((function_name.find("zeEventHostSynchronize") != std::string::npos)) {
-            ClassTestData::Get().event_host_synch_rec_present = true;
-          }
-          if ((function_name.find("zeCommandListAppendMemoryCopy") != std::string::npos)) {
-            ClassTestData::Get().zecall_command_list_append_memory_copy_present = true;
-          }
-          if ((function_name.find("zeCommandListAppendMemoryFill") != std::string::npos)) {
-            ClassTestData::Get().zecall_command_list_append_memory_fill_present = true;
-          }
-          if ((function_name.find("zeCommandListAppendLaunchKernel") != std::string::npos)) {
-            ClassTestData::Get().zecall_command_list_append_launch_kernel_present = true;
-          }
-          if ((function_name.find("zeCommandQueueExecuteCommandLists") != std::string::npos)) {
-            ClassTestData::Get().zecall_command_queue_execute_command_lists_present = true;
-          }
-          // Any member of kPtiClassLzHostSynchOpApis. Which one an in-order queue waits on varies
-          // by runtime, so all of them count.
-          if ((function_name.find("zeEventHostSynchronize") != std::string::npos) ||
-              (function_name.find("zeFenceHostSynchronize") != std::string::npos) ||
-              (function_name.find("zeCommandQueueSynchronize") != std::string::npos) ||
-              (function_name.find("zeCommandListHostSynchronize") != std::string::npos) ||
-              (function_name.find("zeDeviceSynchronize") != std::string::npos)) {
-            ClassTestData::Get().zecall_host_synch_class_rec_present = true;
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-          auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          if (rec->_api_group != pti_api_group_id::PTI_API_GROUP_SYCL) {
-            std::cerr << "Unexpected API group in PTI_VIEW_RUNTIME_API: "
-                      << "expected PTI_API_GROUP_SYCL, got " << rec->_api_group << '\n';
-          }
-          ClassTestData::Get().urcall_present = true;
-          ClassTestData::Get().urcall_count++;
-          const char* api_name = nullptr;
-          auto status = ptiViewGetApiIdName(rec->_api_group, rec->_api_id, &api_name);
-          PTI_ASSERT(status == PTI_SUCCESS);
-          std::string function_name(api_name);
-          if ((function_name.find("urEventWait") != std::string::npos)) {
-            ClassTestData::Get().ur_event_wait_rec_present = true;
-          }
-          if ((function_name.find("urEnqueueMemBufferWrite") != std::string::npos)) {
-            ClassTestData::Get().ur_mem_write_rec_present = true;
-          }
-          if ((function_name.find("urEnqueueKernelLaunch") != std::string::npos)) {
-            ClassTestData::Get().ur_kernel_rec_present = true;
-          }
-          if ((function_name.find("urEnqueueMemBufferRead") != std::string::npos)) {
-            ClassTestData::Get().ur_mem_read_rec_present = true;
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          ClassTestData::Get().ze_kernel_rec_present = true;
-          break;
-        }
-        default: {
-          std::cerr << "This shouldn't happen" << '\n';
-          break;
-        }
-      }
-    }
-    ::operator delete(buf);
-  }
-
-  // Non-immediate is a hint only: the adapter may ignore it, so callers must confirm what they got.
-  void RunGemmNoTrace(bool use_immediate_command_list = true) {
-    sycl::property_list prop =
-        use_immediate_command_list
-            ? sycl::property_list{sycl::property::queue::in_order(),
-                                  sycl::property::queue::enable_profiling(),
-                                  sycl::ext::intel::property::queue::immediate_command_list()}
-            : sycl::property_list{sycl::property::queue::in_order(),
-                                  sycl::property::queue::enable_profiling(),
-                                  sycl::ext::intel::property::queue::no_immediate_command_list()};
-
-    sycl::queue queue(dev_, sycl::async_handler{}, prop);
-
-    auto sycl_context = queue.get_context();
-
-    std::cout << "DPC++ Matrix Multiplication (matrix size: " << size_ << " x " << size_
-              << ", repeats " << repeat_count_ << " times)" << std::endl;
-    std::cout << "Target device: "
-              << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-              << std::endl;
-
-    ClassTestData::Get().queue_test = pti::test::utils::GetLevelZeroBackendQueue(queue);
-    if (ClassTestData::Get().queue_test == nullptr) {
-      FAIL() << "Underlying level zero queue handle could not be obtained.";
-    }
-    std::cout << " == Native Queue reported by Sycl: " << ClassTestData::Get().queue_test
-              << std::endl;
-
-    std::vector<float> a(size_ * size_, A_VALUE);
-    std::vector<float> b(size_ * size_, B_VALUE);
-    std::vector<float> c(size_ * size_, 0.0f);
-
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size_;
-    Compute(std::move(queue), a, b, c, size_, repeat_count_, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  }
-
-  // Class members commonly used by all tests in the test suite for ClassApiFixtureTest
-  sycl::device dev_;
-  unsigned size_ = 1024;
-  unsigned repeat_count_ = 1;
-};
-
-void EnableIndividualApis(bool is_for_driver, pti_api_group_id pti_group) {
-  // Depending on GPU device/UR/L0 - one or more of these APIs will be present
-  if (is_for_driver) {
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group, pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernel_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group,
-        pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithParameters_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group,
-        pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithArguments_id));
-  } else {
-    PTI_CHECK_SUCCESS(
-        ptiViewEnableRuntimeApi(1, pti_group, pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(
-        1, pti_group, pti_api_id_runtime_sycl::urEnqueueKernelLaunchWithArgsExp_id));
-  }
-}
-
-void DisableSyclOpsClassApis(bool useAllGroups = true) {
-  if (useAllGroups) {
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApiClass(
-        0, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE, pti_api_group_id::PTI_API_GROUP_ALL));
-  } else {
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApiClass(
-        0, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE, pti_api_group_id::PTI_API_GROUP_SYCL));
-  }
-}
-
-void EnableClassApis(bool is_for_driver, pti_api_class pti_class, pti_api_group_id pti_group) {
-  if (is_for_driver) {
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApiClass(1, pti_class, pti_group));
-  } else {
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApiClass(1, pti_class, pti_group));
-  }
-}
-
-TEST_F(ClassApiFixtureTest, EnableGPUCoreApisViaClassForLevelZero) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  EnableClassApis(true, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                  pti_api_group_id::PTI_API_GROUP_LEVELZERO);
-  RunGemmNoTrace();
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ClassTestData::Get().urcall_present, false);
-  EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-  EXPECT_GE(ClassTestData::Get().zecall_count, 1ULL);
-  EXPECT_EQ(ClassTestData::Get().zecall_command_list_append_memory_copy_present, true);
-  EXPECT_EQ(ClassTestData::Get().zecall_command_list_append_launch_kernel_present, true);
-}
-
-// PTI_API_CLASS_GPU_OPERATION_CORE has to cover the command queue submission API, not just the
-// append APIs: with a non-immediate command list the appends only build the list, and the work
-// does not reach the GPU until zeCommandQueueExecuteCommandLists.
-TEST_F(ClassApiFixtureTest, GPUCoreApiClassForLevelZeroReportsCommandQueueExecute) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-
-  // Pass 1, control: every Level Zero API traced. Confirms this device really does submit through
-  // a command queue. Without this pass, pass 2 would pass vacuously instead of failing.
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnableDriverApiClass(1, pti_api_class::PTI_API_CLASS_ALL,
-                                        pti_api_group_id::PTI_API_GROUP_LEVELZERO),
-            pti_result::PTI_SUCCESS);
-  RunGemmNoTrace(false);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-
-  // Without this, a regression that emitted no driver records at all would take the skip below and
-  // report green, blaming the device.
-  ASSERT_EQ(ClassTestData::Get().zecall_present, true) << "pass 1 produced no driver API records";
-
-  if (!ClassTestData::Get().zecall_command_queue_execute_command_lists_present) {
-    GTEST_SKIP() << "Non-immediate command list hint not honored on this device";
-  }
-
-  // The host synchronization APIs are a different class, so their disappearance in pass 2 is the
-  // witness that tracing was narrowed rather than inherited from pass 1. Captured before the reset
-  // below clears it, and only usable if pass 1 saw one.
-  const bool host_synch_reported_with_all_apis =
-      ClassTestData::Get().zecall_host_synch_class_rec_present;
-
-  // Pass 2, subject: only the GPU operation core class. ptiViewEnable(PTI_VIEW_DRIVER_API) below
-  // unsets granularity, so EnableClassApis resets every Level Zero API to disabled before enabling
-  // the class, which also keeps the result independent of the order tests run in.
-  ClassTestData::Get().Reset();
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  EnableClassApis(true, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                  pti_api_group_id::PTI_API_GROUP_LEVELZERO);
-  RunGemmNoTrace(false);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-
-  // Sanity: the class enable took effect.
-  EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-  EXPECT_EQ(ClassTestData::Get().zecall_command_list_append_launch_kernel_present, true);
-  // Confirms the subject assertion is about the core class, not tracing left over from pass 1.
-  if (host_synch_reported_with_all_apis) {
-    EXPECT_EQ(ClassTestData::Get().zecall_host_synch_class_rec_present, false)
-        << "host synchronization APIs still reported under PTI_API_CLASS_GPU_OPERATION_CORE -- "
-           "tracing was not narrowed, so the zeCommandQueueExecuteCommandLists check is vacuous";
-  }
-  EXPECT_EQ(ClassTestData::Get().zecall_command_queue_execute_command_lists_present, true)
-      << "expected a zeCommandQueueExecuteCommandLists record under "
-         "PTI_API_CLASS_GPU_OPERATION_CORE";
-}
-
-TEST_F(ClassApiFixtureTest, EnableRuntimeApisViaClassSpecificGroup) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  EnableClassApis(false, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                  pti_api_group_id::PTI_API_GROUP_SYCL);
-  RunGemmNoTrace();
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ClassTestData::Get().urcall_present, true);
-}
-
-TEST_F(ClassApiFixtureTest, EnableThenDisableRuntimeApisViaClass) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  EnableClassApis(false, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                  pti_api_group_id::PTI_API_GROUP_SYCL);
-  DisableSyclOpsClassApis();
-  RunGemmNoTrace();
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ClassTestData::Get().urcall_present, false);
-}
-
-// GetParam() - Tuple values correspond to (from left to right) whether we enable the
-// use_class_api, use_all_classes, use_all_groups
-TEST_P(ClassApiFixtureTest, ClassApiCallsCoarseGranularity) {
-  auto [use_class_api, use_all_classes, use_all_groups] = GetParam();
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  if (!use_class_api) {
-    if (use_all_groups) {
-      // Test individual granular case -- no class but all groups.
-      EnableIndividualApis(false, pti_api_group_id::PTI_API_GROUP_ALL);
-      ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-      EnableIndividualApis(true, pti_api_group_id::PTI_API_GROUP_ALL);
-      RunGemmNoTrace();
-      ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-      EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-      EXPECT_EQ(ClassTestData::Get().urcall_present, true);
-    } else {
-      // Test individual granular case -- no class and specific group.
-      EnableIndividualApis(false, pti_api_group_id::PTI_API_GROUP_SYCL);
-      ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-      EnableIndividualApis(true, pti_api_group_id::PTI_API_GROUP_LEVELZERO);
-      RunGemmNoTrace();
-      ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-      ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-      EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-      EXPECT_EQ(ClassTestData::Get().zecall_count, 1ULL);
-      EXPECT_EQ(ClassTestData::Get().urcall_present, true);
-      EXPECT_GT(ClassTestData::Get().urcall_count, 2ULL);
-    }
-  } else if (use_all_classes && use_all_groups) {
-    // Test with use_all_classes and use_all_groups --- class level apis
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-    EnableClassApis(true, pti_api_class::PTI_API_CLASS_ALL, pti_api_group_id::PTI_API_GROUP_ALL);
-    RunGemmNoTrace();
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-    EXPECT_EQ(ClassTestData::Get().urcall_present, false);
-    EXPECT_GT(ClassTestData::Get().zecall_count, 1ULL);
-    EXPECT_EQ(ClassTestData::Get().urcall_count, 0ULL);
-    EXPECT_EQ(ClassTestData::Get().event_host_synch_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().ze_kernel_rec_present, false);
-  } else if (!use_all_classes && use_all_groups) {  // any valid class and use_all_groups
-    // Test with specific class but use_all_groups --- class level apis
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    EnableClassApis(false, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                    pti_api_group_id::PTI_API_GROUP_ALL);
-    RunGemmNoTrace();
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ClassTestData::Get().urcall_present, true);
-    if (!pti::test::utils::IsIntegratedGraphics(dev_)) {
-      EXPECT_GT(ClassTestData::Get().urcall_count, 2ULL);
-      EXPECT_EQ(ClassTestData::Get().ur_mem_write_rec_present, true);
-    }
-
-    EXPECT_EQ(ClassTestData::Get().ur_event_wait_rec_present, false);
-    EXPECT_EQ(ClassTestData::Get().ur_mem_read_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().ur_kernel_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().event_host_synch_rec_present, false);
-  } else if (use_all_classes && !use_all_groups) {  // use_all_classes and any valid group
-    // Test with all classes but use specific groups --- class level apis
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-    EnableClassApis(true, pti_api_class::PTI_API_CLASS_ALL,
-                    pti_api_group_id::PTI_API_GROUP_LEVELZERO);
-    RunGemmNoTrace();
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ClassTestData::Get().zecall_present, true);
-    EXPECT_GT(ClassTestData::Get().zecall_count, 1ULL);
-    EXPECT_EQ(ClassTestData::Get().event_host_synch_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().ze_kernel_rec_present, false);
-  } else {
-    // any specific class with any specific group
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    EnableClassApis(false, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                    pti_api_group_id::PTI_API_GROUP_SYCL);
-    RunGemmNoTrace();
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    EXPECT_EQ(ClassTestData::Get().urcall_present, true);
-    EXPECT_EQ(ClassTestData::Get().zecall_present, false);
-    if (!pti::test::utils::IsIntegratedGraphics(dev_)) {
-      EXPECT_GT(ClassTestData::Get().urcall_count, 2ULL);
-      EXPECT_EQ(ClassTestData::Get().ur_mem_write_rec_present, true);
-    }
-    EXPECT_EQ(ClassTestData::Get().zecall_count, 0ULL);
-    EXPECT_EQ(ClassTestData::Get().ur_event_wait_rec_present, false);
-    EXPECT_EQ(ClassTestData::Get().ur_mem_read_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().ur_kernel_rec_present, true);
-    EXPECT_EQ(ClassTestData::Get().event_host_synch_rec_present, false);
-  }
-}
-
-TEST_F(ClassApiFixtureTest, ValidateClassApiSyclOpsEnableSuccessful) {
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApiClass(1, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE,
-                                                 pti_api_group_id::PTI_API_GROUP_SYCL));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApiClass(1, pti_api_class::PTI_API_CLASS_ALL,
-                                                 pti_api_group_id::PTI_API_GROUP_SYCL));
-}
-
-// Validate that after regeneration ApiIds have not changed.
-TEST_F(ClassApiFixtureTest, ValidateApiIdsNotChanged) {
-  const char* api_name = nullptr;
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 1, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 2, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 3, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 4, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 5, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 6, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 7, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urContextSetExtendedDeleter") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 8, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceGet") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 9, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 10, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 11, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 12, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDevicePartition") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 13, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceSelectBinary") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 14, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 15, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 16, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceGetGlobalTimestamps") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 17, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueKernelLaunch") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 18, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueEventsWait") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 19, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueEventsWaitWithBarrier") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 20, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferRead") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 21, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferWrite") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 22, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferReadRect") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 23, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferWriteRect") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 24, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferCopy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 25, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferCopyRect") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 26, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferFill") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 27, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemImageRead") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 28, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemImageWrite") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 29, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemImageCopy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 30, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemBufferMap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 31, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueMemUnmap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 32, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMFill") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 33, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMMemcpy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 34, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMPrefetch") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 35, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMAdvise") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 38, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueDeviceGlobalVariableWrite") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 39, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueDeviceGlobalVariableRead") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 40, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 41, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventGetProfilingInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 42, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventWait") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 43, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 44, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 45, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 46, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 47, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEventSetCallback") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 48, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 49, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetArgValue") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 50, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetArgLocal") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 51, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 52, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelGetGroupInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 53, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelGetSubGroupInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 54, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 55, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 56, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetArgPointer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 57, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetExecInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 58, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetArgSampler") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 59, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetArgMemObj") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 60, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSetSpecializationConstants") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 61, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 62, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 63, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemImageCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 64, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemBufferCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 65, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 66, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 67, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemBufferPartition") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 68, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 69, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueReadHostPipe") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 70, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 71, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemImageGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 72, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformGet") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 73, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 74, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformGetApiVersion") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 75, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 76, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 78, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramCreateWithIL") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 79, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramCreateWithBinary") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 80, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramBuild") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 81, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramCompile") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 82, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramLink") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 83, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 84, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 85, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramGetFunctionPointer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 86, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 87, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramGetBuildInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 88, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramSetSpecializationConstants") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 89, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 90, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 91, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 92, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 93, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 94, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 95, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 96, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 97, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueFinish") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 98, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urQueueFlush") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 101, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 102, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 103, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 104, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 105, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerGetNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 106, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urSamplerCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 107, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMHostAlloc") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 108, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMDeviceAlloc") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 109, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMSharedAlloc") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 110, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMFree") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 111, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMGetMemAllocInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 112, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMPoolCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 113, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 114, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPlatformGetBackendOption") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 115, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemBufferCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 116, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urMemImageCreateWithNativeHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 117, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueWriteHostPipe") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 118, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMPoolRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 119, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMPoolRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 120, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMPoolGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 121, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferRetainExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 122, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferReleaseExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 123, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferFinalizeExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 125, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendKernelLaunchExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 128, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferEnqueueExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 132, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMPitchedAllocExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 133, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesUnsampledImageHandleDestroyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 134, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesSampledImageHandleDestroyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 135, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImageAllocateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 136, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImageFreeExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 137, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesUnsampledImageCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 138, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesSampledImageCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 139, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImageCopyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 140, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImageGetInfoExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 141, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesMipmapGetLevelExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 142, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesMipmapFreeExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 144, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesMapExternalArrayExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 147, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesReleaseExternalSemaphoreExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 148, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesWaitExternalSemaphoreExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 149, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesSignalExternalSemaphoreExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 151, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMFill2D") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 152, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueUSMMemcpy2D") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 153, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemGranularityGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 154, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemReserve") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 155, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemFree") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 156, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemMap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 157, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemUnmap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 158, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemSetAccess") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 159, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urVirtualMemGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 160, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPhysicalMemCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 161, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPhysicalMemRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 162, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urPhysicalMemRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 163, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMImportExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 164, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUSMReleaseExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 165, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUsmP2PEnablePeerAccessExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 166, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUsmP2PDisablePeerAccessExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 167, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urUsmP2PPeerAccessGetInfoExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 172, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 173, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 174, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 175, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 176, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigEnableLayer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 177, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urAdapterRelease") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 178, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urAdapterGet") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 179, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urAdapterRetain") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 180, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urAdapterGetLastError") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 181, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urAdapterGetInfo") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 197, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramBuildExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 198, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramCompileExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 199, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramLinkExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 200, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigSetCodeLocationCallback") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 201, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderInit") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 202, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderTearDown") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 203, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendUSMMemcpyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 204, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendUSMFillExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 205, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferCopyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 206, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferWriteExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 207, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferReadExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 208, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferCopyRectExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 209, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferWriteRectExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 210, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferReadRectExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 211, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendMemBufferFillExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 212, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendUSMPrefetchExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 213, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferAppendUSMAdviseExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 214, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueCooperativeKernelLaunchExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 215, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelSuggestMaxCooperativeGroupCountExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 216, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urProgramGetGlobalVariablePointer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 217, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urDeviceGetSelected") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 218, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferRetainCommandExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 219, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferReleaseCommandExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 220, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferUpdateKernelLaunchExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 221, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferGetInfoExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 222, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urCommandBufferCommandGetInfoExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 223, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueTimestampRecordingExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 224, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueKernelLaunchCustomExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 225, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urKernelGetSuggestedLocalWorkSize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 226, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImportExternalMemoryExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 227, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesImportExternalSemaphoreExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 228, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urEnqueueNativeCommandExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 229, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urLoaderConfigSetMockingEnabled") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 230, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "urBindlessImagesReleaseExternalMemoryExp") == 0), true);
-
-  // Start using EXPECT_STREQ for string comparison TODO: Change above but for now keep to minimize
-  // changes to existing tests (Perhaps even consider using an array).
-
-  // Warning: API name for ID 231 changed in oneAPI 2025.1.
-  // This is not supposed to happen (URT-967)
-  // urBindlessImagesMapExternalLinearMemoryExp -> urCommandBufferAppendUSMMemcpyExp
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 231, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendUSMMemcpyExp");
-  /////////////////////////////////////////////////////////////////////////////////////////////
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 232, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendUSMFillExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 233, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferCopyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 234, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferWriteExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 235, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferReadExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 236, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferCopyRectExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 237, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferWriteRectExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 238, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferReadRectExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 239, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendMemBufferFillExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 240, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendUSMPrefetchExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 241, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendUSMAdviseExp");
-  // Warning: API name for ID 242 changed in oneAPI 2025.2.
-  // This is not supposed to happen (URT-967)
-  // urCommandBufferEnqueueExp -> urEnqueueCommandBufferExp
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 242, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueCommandBufferExp");
-  /////////////////////////////////////////////////////////////////////////////////////////////
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 243, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferUpdateSignalEventExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 244, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferUpdateWaitEventsExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 245, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesMapExternalLinearMemoryExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 246, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueEventsWaitWithBarrierExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 247, &api_name));
-  EXPECT_STREQ(api_name, "urTensorMapEncodeIm2ColExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 248, &api_name));
-  EXPECT_STREQ(api_name, "urTensorMapEncodeTiledExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 249, &api_name));
-  EXPECT_STREQ(api_name, "urPhysicalMemGetInfo");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 250, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueUSMDeviceAllocExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 251, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueUSMSharedAllocExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 252, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueUSMHostAllocExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 253, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueUSMFreeExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 254, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolCreateExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 255, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolDestroyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 256, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolSetThresholdExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 257, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolGetDefaultDevicePoolExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 259, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolSetDevicePoolExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 260, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolGetDevicePoolExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 261, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolTrimToExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 262, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolGetInfoExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 263, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendNativeCommandExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 264, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferGetNativeHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 265, &api_name));
-  EXPECT_STREQ(api_name, "urUSMPoolSetInfoExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 266, &api_name));
-  EXPECT_STREQ(api_name, "urAdapterSetLoggerCallback");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 267, &api_name));
-  EXPECT_STREQ(api_name, "urAdapterSetLoggerCallbackLevel");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 268, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesGetImageUnsampledHandleSupportExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 269, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesGetImageSampledHandleSupportExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 270, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesGetImageMemoryHandleTypeSupportExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 271, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesFreeMappedLinearMemoryExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 272, &api_name));
-  EXPECT_STREQ(api_name, "urKernelSuggestMaxCooperativeGroupCount");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 273, &api_name));
-  EXPECT_STREQ(api_name, "urUSMContextMemcpyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 285, &api_name));
-  EXPECT_STREQ(api_name, "urMemoryExportAllocExportableMemoryExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 286, &api_name));
-  EXPECT_STREQ(api_name, "urMemoryExportFreeExportableMemoryExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 287, &api_name));
-  EXPECT_STREQ(api_name, "urMemoryExportExportMemoryHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 288, &api_name));
-  EXPECT_STREQ(api_name, "urBindlessImagesSupportsImportingHandleTypeExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 289, &api_name));
-  EXPECT_STREQ(api_name, "urIPCGetMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 290, &api_name));
-  EXPECT_STREQ(api_name, "urIPCPutMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 291, &api_name));
-  EXPECT_STREQ(api_name, "urIPCOpenMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 292, &api_name));
-  EXPECT_STREQ(api_name, "urIPCCloseMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 293, &api_name));
-  EXPECT_STREQ(api_name, "urDeviceWaitExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 294, &api_name));
-  EXPECT_STREQ(api_name, "urProgramDynamicLinkExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 295, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueKernelLaunchWithArgsExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 296, &api_name));
-  EXPECT_STREQ(api_name, "urGraphCreateExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 297, &api_name));
-  EXPECT_STREQ(api_name, "urQueueBeginGraphCaptureExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 298, &api_name));
-  EXPECT_STREQ(api_name, "urQueueBeginCaptureIntoGraphExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 299, &api_name));
-  EXPECT_STREQ(api_name, "urQueueEndGraphCaptureExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 302, &api_name));
-  EXPECT_STREQ(api_name, "urGraphDestroyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 303, &api_name));
-  EXPECT_STREQ(api_name, "urGraphExecutableGraphDestroyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 304, &api_name));
-  EXPECT_STREQ(api_name, "urQueueIsGraphCaptureEnabledExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 305, &api_name));
-  EXPECT_STREQ(api_name, "urGraphIsEmptyExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 306, &api_name));
-  EXPECT_STREQ(api_name, "urGraphDumpContentsExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 307, &api_name));
-  EXPECT_STREQ(api_name, "urGraphInstantiateGraphExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 308, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueGraphExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 309, &api_name));
-  EXPECT_STREQ(api_name, "urEnqueueHostTaskExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 310, &api_name));
-  EXPECT_STREQ(api_name, "urCommandBufferAppendKernelLaunchWithArgsExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 311, &api_name));
-  EXPECT_STREQ(api_name, "urKernelGetSuggestedLocalWorkSizeWithArgs");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 312, &api_name));
-  EXPECT_STREQ(api_name, "urUSMHostAllocRegisterExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 313, &api_name));
-  EXPECT_STREQ(api_name, "urUSMHostAllocUnregisterExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 314, &api_name));
-  EXPECT_STREQ(api_name, "urQueueGetGraphExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 315, &api_name));
-  EXPECT_STREQ(api_name, "urGraphSetDestructionCallbackExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 316, &api_name));
-  EXPECT_STREQ(api_name, "urIPCGetPhysMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 317, &api_name));
-  EXPECT_STREQ(api_name, "urIPCPutPhysMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 318, &api_name));
-  EXPECT_STREQ(api_name, "urIPCOpenPhysMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 319, &api_name));
-  EXPECT_STREQ(api_name, "urIPCClosePhysMemHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 320, &api_name));
-  EXPECT_STREQ(api_name, "urGraphGetNativeHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 321, &api_name));
-  EXPECT_STREQ(api_name, "urGraphExecutableGraphGetNativeHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 322, &api_name));
-  EXPECT_STREQ(api_name, "urEventCreateExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 323, &api_name));
-  EXPECT_STREQ(api_name, "urIPCGetEventHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 324, &api_name));
-  EXPECT_STREQ(api_name, "urIPCPutEventHandleExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, 325, &api_name));
-  EXPECT_STREQ(api_name, "urIPCOpenEventHandleExp");
-
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 1, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeInit") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 2, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGet") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 3, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetApiVersion") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 4, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 5, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetIpcProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 6, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetExtensionProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 7, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGet") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 8, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetSubDevices") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 9, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 10, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetComputeProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 11, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetModuleProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 12, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetCommandQueueGroupProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 13, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetMemoryProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 14, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetMemoryAccessProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 15, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetCacheProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 16, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetImageProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 17, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetExternalMemoryProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 18, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetP2PProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 19, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceCanAccessPeer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 20, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetStatus") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 21, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 22, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 23, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextGetStatus") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 24, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextSystemBarrier") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 25, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextMakeMemoryResident") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 26, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextEvictMemory") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 27, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextMakeImageResident") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 28, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextEvictImage") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 29, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 30, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 31, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueExecuteCommandLists") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 32, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueSynchronize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 33, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 34, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListCreateImmediate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 35, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 36, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListClose") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 37, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListReset") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 38, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendWriteGlobalTimestamp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 39, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendBarrier") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 40, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryRangesBarrier") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 41, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryCopy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 42, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryFill") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 43, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryCopyRegion") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 44, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryCopyFromContext") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 45, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 46, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopyRegion") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 47, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopyToMemory") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 48, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopyFromMemory") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 49, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemoryPrefetch") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 50, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendMemAdvise") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 51, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendSignalEvent") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 52, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendWaitOnEvents") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 53, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendEventReset") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 54, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendQueryKernelTimestamps") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 55, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchKernel") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 56, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchCooperativeKernel") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 57, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchKernelIndirect") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 58, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchMultipleKernelsIndirect") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 59, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageGetProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 60, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 61, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 62, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemAllocShared") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 63, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemAllocDevice") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 64, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemAllocHost") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 65, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemFree") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 66, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetAllocProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 67, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetAddressRange") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 68, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 69, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemOpenIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 70, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemCloseIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 71, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFenceCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 72, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFenceDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 73, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFenceHostSynchronize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 74, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFenceQueryStatus") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 75, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFenceReset") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 76, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 77, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 78, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolGetIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 79, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolOpenIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 80, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolCloseIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 81, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 82, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 83, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventHostSignal") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 84, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventHostSynchronize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 85, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventQueryStatus") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 86, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventHostReset") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 87, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventQueryKernelTimestamp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 88, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 89, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 90, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleDynamicLink") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 91, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleGetNativeBinary") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 92, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleGetGlobalPointer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 93, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleGetKernelNames") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 94, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleGetProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 95, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleGetFunctionPointer") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 96, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleBuildLogDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 97, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleBuildLogGetString") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 98, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 99, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 100, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSetCacheConfig") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 101, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSetGroupSize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 102, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSuggestGroupSize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 103, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSuggestMaxCooperativeGroupCount") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 104, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSetArgumentValue") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 105, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSetIndirectAccess") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 106, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetIndirectAccess") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 107, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetSourceAttributes") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 108, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetProperties") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 109, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetName") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 110, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeSamplerCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 111, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeSamplerDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 112, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zePhysicalMemCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 113, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zePhysicalMemDestroy") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 114, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemReserve") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 115, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemFree") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 116, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemQueryPageSize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 117, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemMap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 118, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemUnmap") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 119, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemSetAccessAttribute") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 120, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeVirtualMemGetAccessAttribute") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 121, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeInitDrivers") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 122, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 123, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderGetBuildPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 124, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderBuildExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 125, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderDestroyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 126, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 127, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationGetPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 128, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationJoinExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 129, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationDestroyExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 130, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetExtensionFunctionAddress") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 131, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetLastErrorDescription") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 132, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverRTASFormatCompatibilityCheckExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 133, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetGlobalTimestamps") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 134, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceImportExternalSemaphoreExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 135, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceReleaseExternalSemaphoreExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 136, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceReserveCacheExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 137, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceSetCacheAdviceExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 138, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDevicePciGetPropertiesExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 139, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetFabricVertexExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 140, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetRootDevice") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 141, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeContextCreateEx") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 142, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueGetOrdinal") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 143, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandQueueGetIndex") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 144, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListGetNextCommandIdWithKernelsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 145, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListUpdateMutableCommandKernelsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 146, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendSignalExternalSemaphoreExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 147, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendWaitExternalSemaphoreExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 148, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopyToMemoryExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 149, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendImageCopyFromMemoryExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 150, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListHostSynchronize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 151, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListCreateCloneExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 152, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListGetDeviceHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 153, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListGetContextHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 154, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListGetOrdinal") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 155, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListImmediateGetIndex") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 156, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListIsImmediate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 157, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListImmediateAppendCommandListsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 158, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListGetNextCommandIdExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 159, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListUpdateMutableCommandsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 160, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListUpdateMutableCommandSignalEventExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 161, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListUpdateMutableCommandWaitEventsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 162, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventQueryTimestampsExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 163, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventQueryKernelTimestampsExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 164, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventGetEventPool") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 165, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventGetSignalScope") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 166, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventGetWaitScope") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 167, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolPutIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 168, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolGetContextHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 169, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeEventPoolGetFlags") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 170, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageGetMemoryPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 171, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageViewCreateExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 172, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageGetAllocPropertiesExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 173, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageViewCreateExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 174, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeImageGetDeviceOffsetExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 175, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSetGlobalOffsetExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 176, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetBinaryExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 177, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelSchedulingHintExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 178, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemFreeExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 179, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetIpcHandleFromFileDescriptorExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 180, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetFileDescriptorFromIpcHandleExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 181, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemPutIpcHandle") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 182, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemSetAtomicAccessAttributeExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 183, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetAtomicAccessAttributeExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 184, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeMemGetPitchFor2dImage") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 185, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeModuleInspectLinkageExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 186, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricEdgeGetExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 187, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricEdgeGetVerticesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 188, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricEdgeGetPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 189, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricVertexGetExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 190, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricVertexGetSubVerticesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 191, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricVertexGetPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 192, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeFabricVertexGetDeviceExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 193, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zelTracerSetEnabled") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 194, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zelTracerCreate") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 195, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderCreateExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 196, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderGetBuildPropertiesExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 197, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderBuildExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 198, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderCommandListAppendCopyExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 199, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASBuilderDestroyExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 200, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationCreateExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 201, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationGetPropertiesExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 202, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationJoinExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 203, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeRTASParallelOperationDestroyExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 204, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverRTASFormatCompatibilityCheckExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 205, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceGetVectorWidthPropertiesExt") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 206, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDeviceSynchronize") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 207, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeDriverGetDefaultContext") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 208, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchKernelWithParameters") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 209, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeCommandListAppendLaunchKernelWithArguments") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 210, &api_name));
-  EXPECT_EQ((std::strcmp(api_name, "zeKernelGetAllocationPropertiesExp") == 0), true);
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 211, &api_name));
-  EXPECT_STREQ(api_name, "zeDeviceGetAggregatedCopyOffloadIncrementValue");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 212, &api_name));
-  EXPECT_STREQ(api_name, "zeEventCounterBasedCreate");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 213, &api_name));
-  EXPECT_STREQ(api_name, "zeEventCounterBasedGetIpcHandle");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 214, &api_name));
-  EXPECT_STREQ(api_name, "zeEventCounterBasedOpenIpcHandle");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 215, &api_name));
-  EXPECT_STREQ(api_name, "zeEventCounterBasedCloseIpcHandle");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 216, &api_name));
-  EXPECT_STREQ(api_name, "zeEventCounterBasedGetDeviceAddress");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 217, &api_name));
-  EXPECT_STREQ(api_name, "zeMemGetIpcHandleWithProperties");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 218, &api_name));
-  EXPECT_STREQ(api_name, "zePhysicalMemGetProperties");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 219, &api_name));
-  EXPECT_STREQ(api_name, "zeDeviceGetRuntimeRequirements");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 220, &api_name));
-  EXPECT_STREQ(api_name, "zeDeviceGetRuntimeRequirementsKey");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 221, &api_name));
-  EXPECT_STREQ(api_name, "zeDeviceValidateRuntimeRequirements");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 222, &api_name));
-  EXPECT_STREQ(api_name, "zeDeviceGetCounterBasedEventMaxValue");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 223, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandQueueGetFlags");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 224, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandQueueGetMode");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 225, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandQueueGetPriority");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 226, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListAppendMemoryCopyWithParameters");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 227, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListAppendMemoryFillWithParameters");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 228, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListImmediateAppendCommandListsWithParameters");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 229, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListGetFlags");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 230, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListImmediateGetFlags");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 231, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListImmediateGetMode");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 232, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListImmediateGetPriority");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 233, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListIsMutableExp");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 234, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListBeginGraphCaptureExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 235, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListBeginCaptureIntoGraphExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 236, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListIsGraphCaptureEnabledExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 237, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListEndGraphCaptureExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 238, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListGetGraphExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 239, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListAppendGraphExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 240, &api_name));
-  EXPECT_STREQ(api_name, "zeCommandListAppendHostFunction");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 241, &api_name));
-  EXPECT_STREQ(api_name, "zeEventGetCounterBasedFlags");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 242, &api_name));
-  EXPECT_STREQ(api_name, "zeExecutableGraphGetSourceGraphExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 243, &api_name));
-  EXPECT_STREQ(api_name, "zeExecutableGraphDestroyExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 244, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphCreateExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 245, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphGetPrimaryCommandListExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 246, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphSetDestructionCallbackExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 247, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphInstantiateExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 248, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphIsEmptyExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 249, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphDumpContentsExt");
-  PTI_CHECK_SUCCESS(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, 250, &api_name));
-  EXPECT_STREQ(api_name, "zeGraphDestroyExt");
-}
-
-// Force failure of granular api with incorrect api_ids and ensure error code returned.
-TEST_F(ClassApiFixtureTest, ValidateSetApiTracingFailure) {
-  constexpr auto kInvalidApiId = 3'000;
-  pti_result status = ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              static_cast<pti_api_id_runtime_sycl>(kInvalidApiId));
-  EXPECT_EQ(status, pti_result::PTI_ERROR_BAD_API_ID);
-  status = ptiViewEnableDriverApi(1, pti_api_group_id::PTI_API_GROUP_LEVELZERO,
-                                  static_cast<pti_api_id_driver_levelzero>(kInvalidApiId));
-  EXPECT_EQ(status, pti_result::PTI_ERROR_BAD_API_ID);
-  status = ptiViewEnableDriverApi(1, pti_api_group_id::PTI_API_GROUP_OPENCL,
-                                  static_cast<pti_api_id_driver_levelzero>(kInvalidApiId));
-  EXPECT_EQ(status, pti_result::PTI_ERROR_NOT_IMPLEMENTED);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    ClassTests, ClassApiFixtureTest,
-    ::testing::Values(std::make_tuple(true, true, true), std::make_tuple(true, true, false),
-                      std::make_tuple(false, true, true), std::make_tuple(false, true, false),
-                      std::make_tuple(true, false, true), std::make_tuple(true, false, false),
-                      std::make_tuple(false, false, true), std::make_tuple(false, false, false)),
-
-    [](const testing::TestParamInfo<ClassApiFixtureTest::ParamType>& info) {
-      return fmt::format("Use_ClassAPI_{}_Use_All_Classes_{}_Use_All_Groups_{}",
-                         std::get<0>(info.param) ? "On" : "Off",
-                         std::get<1>(info.param) ? "On" : "Off",
-                         std::get<2>(info.param) ? "On" : "Off");
-    });
diff --git a/sdk/test/main_dpcgemm_fixture.cc b/sdk/test/main_dpcgemm_fixture.cc
deleted file mode 100644
index 890a95b4..00000000
--- a/sdk/test/main_dpcgemm_fixture.cc
+++ /dev/null
@@ -1,1326 +0,0 @@
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <mutex>
-#include <ostream>
-#include <sycl/sycl.hpp>
-#include <tuple>
-
-#include "pti/pti.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/sycl_config_info.h"
-#include "utils/test_helpers.h"
-#include "utils/ze_utils.h"
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-namespace {
-constexpr uint32_t kUrSuccessReturnValue = 0;
-constexpr uint32_t kUrUnsupportedFeatureReturnValue = 44;
-
-size_t requested_buffer_calls = 0;
-size_t rejected_buffer_calls = 0;  // Buffer requests that are called and rejected by the API
-size_t completed_buffer_calls = 0;
-size_t completed_buffer_used_bytes = 0;
-uint64_t eid_ = 11;
-const uint64_t kEnqueueKernelLaunchId = 17;  // apiid of urEnqueueKernelLaunch
-const uint64_t kEnqueueKernelLaunchWithArgsExpId =
-    295;  // apiid of urEnqueueKernelLaunchWithArgsExp
-pti_result pop_null_ptr_result = pti_result::PTI_SUCCESS;
-bool special_sycl_rec_present = false;
-bool memory_view_record_created = false;
-bool kernel_view_record_created = false;
-bool kernel_has_sycl_file_info = false;
-bool kernel_has_sycl_enqk_info = false;
-bool kernel_timestamps_monotonic = false;
-bool kernel_has_task_begin0_record = false;
-bool kernel_has_enqk_begin0_record = false;
-bool demangled_kernel_name = false;
-bool kernel_launch_func_name = false;
-uint64_t kernel_launch_func_id = 0;
-bool zecall_corrids_unique = true;
-bool zecall_at_gpu_op_corrids_unique = true;
-bool zecall_good_id_name = false;
-bool zecall_bad_id_name = false;
-bool zecall_present = false;
-uint64_t zecall_count = 0;
-std::set<uint32_t> zecall_corrids_already_seen;
-std::set<uint32_t> zecall_at_gpu_op_corrids_already_seen;
-bool urcall_present = false;
-uint64_t urcall_count = 0;
-size_t urcall_failure_count = 0;
-bool sycl_has_all_records = false;
-uint64_t memory_bytes_copied = 0;
-uint64_t memory_view_record_count = 0;
-uint64_t kernel_view_record_count = 0;
-bool kernel_uuid_zero = true;
-[[maybe_unused]] uint64_t kernel_has_sycl_file_count = 0;
-uint64_t masked_by_last_id_records = 0;
-uint64_t last_pop_eid = 0;
-uint64_t last_id_records = 0;
-[[maybe_unused]] double perf_time_with_tracing = 0;
-[[maybe_unused]] double perf_time_without_tracing = 0;
-[[maybe_unused]] double perf_time = 0;
-uint64_t num_of_overhead_recs = 0;
-bool overhead_kind_stringified = false;
-uint64_t num_of_overhead_counts = 0;
-bool buffer_size_atleast_largest_record = false;
-uint64_t last_kernel_timestamp = 0;
-uint64_t user_real_timestamp = 0;
-
-uint8_t device_uuid_test[PTI_MAX_DEVICE_UUID_SIZE] = {};
-pti_backend_ctx_t context_test = nullptr;
-pti_backend_queue_t queue_test = nullptr;
-
-// TODO - make the enable type param more generic (maybe a bitmap of somesort) so that we can enable
-// a mishmash of types
-void StartTracing(bool enable_only_zecalls = false) {
-  if (!enable_only_zecalls) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_SYNCHRONIZATION), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  } else {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-}
-
-void StopTracing(bool enable_only_zecalls = false) {
-  if (!enable_only_zecalls) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_SYNCHRONIZATION), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  } else {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-}
-
-float Check(const std::vector<float>& a, float value) {
-  PTI_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-void LaunchGemm(sycl::queue& queue, const std::vector<float>& a_vector,
-                const std::vector<float>& b_vector, std::vector<float>& result, unsigned size) {
-  ASSERT_GT(size, 0U);
-  ASSERT_EQ(a_vector.size(), size * size);
-  ASSERT_EQ(b_vector.size(), size * size);
-  ASSERT_EQ(result.size(), size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a_vector.data(), a_vector.size());
-    sycl::buffer<float, 1> b_buf(b_vector.data(), b_vector.size());
-    sycl::buffer<float, 1> c_buf(result.data(), result.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    FAIL() << "[ERROR] Launching GEMM Kernel" << e.what();
-  }
-}
-
-void ValidateGemm(const std::vector<float>& result, float a_value, float b_value, unsigned size) {
-  auto expected_result = a_value * b_value * static_cast<float>(size);
-  auto eps = Check(result, expected_result);
-  ASSERT_LE(eps, MAX_EPS);
-}
-
-float RunAndCheck(sycl::queue& queue, const std::vector<float>& a, const std::vector<float>& b,
-                  std::vector<float>& c, unsigned size, float expected_result) {
-  LaunchGemm(queue, a, b, c, size);
-  return Check(c, expected_result);
-}
-
-void Compute(sycl::queue& queue, const std::vector<float>& a, const std::vector<float>& b,
-             std::vector<float>& c, unsigned size, unsigned repeat_count, float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    [[maybe_unused]] volatile float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-  }
-}
-}  // namespace
-
-class MainFixtureTest : public ::testing::TestWithParam<std::tuple<bool, bool, bool>> {
- protected:
-  void SetUp() override {  // Called right after constructor before each test
-    try {
-      dev_ = sycl::device(sycl::gpu_selector_v);
-      if (pti::test::utils::IsIntegratedGraphics(dev_)) {
-        expected_mem_transfers_per_mult_ = 1;
-      }
-      auto device_l0_test = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(dev_);
-      if (device_l0_test) {
-        ASSERT_TRUE(utils::ze::GetDeviceUuid(device_l0_test, device_uuid_test));
-        samples_utils::PrintUuid(device_uuid_test, "Test Device UUID: ");
-      } else {
-        FAIL() << "PTI doesn't support this backend yet. Backend is not Level Zero";
-      }
-
-    } catch (const sycl::exception& e) {
-      FAIL() << "Unable to select valid device to run tests on. Check your hardware, driver "
-                "install, or system configuration.";
-    }
-    buffer_cb_registered_ = true;
-    requested_buffer_calls = 0;
-    rejected_buffer_calls = 0;
-    completed_buffer_calls = 0;
-    completed_buffer_used_bytes = 0;
-    eid_ = 11;
-    pop_null_ptr_result = pti_result::PTI_SUCCESS;
-    special_sycl_rec_present = false;
-    memory_view_record_created = false;
-    kernel_view_record_created = false;
-    kernel_has_sycl_file_info = false;
-    kernel_has_sycl_enqk_info = false;
-    kernel_timestamps_monotonic = false;
-    kernel_has_task_begin0_record = false;
-    kernel_has_enqk_begin0_record = false;
-    zecall_corrids_unique = true;
-    zecall_at_gpu_op_corrids_unique = true;
-    zecall_good_id_name = false;
-    zecall_bad_id_name = false;
-    zecall_present = false;
-    zecall_count = 0;
-    zecall_corrids_already_seen.clear();
-    zecall_at_gpu_op_corrids_already_seen.clear();
-    urcall_present = false;
-    urcall_count = 0;
-    urcall_failure_count = 0;
-    memory_bytes_copied = 0;
-    memory_view_record_count = 0;
-    kernel_view_record_count = 0;
-    kernel_has_sycl_file_count = 0;
-    masked_by_last_id_records = 0;
-    num_of_overhead_recs = 0;
-    overhead_kind_stringified = false;
-    num_of_overhead_counts = 0;
-    last_pop_eid = 0;
-    last_id_records = 0;
-    perf_time_with_tracing = 0;
-    perf_time_without_tracing = 0;
-    perf_time = 0;
-    last_kernel_timestamp = 0;
-    user_real_timestamp = 0;
-    sycl_has_all_records = false;
-    context_test = nullptr;
-    queue_test = nullptr;
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-
-  static void InadequateBufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = 1;
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    rejected_buffer_calls += 1;
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_kernel_type);
-  }
-
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_kernel_type);
-  }
-
-  static void NullBufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = sizeof(pti_view_record_memory_copy_type) - sizeof(pti_view_record_memory_copy_type);
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    rejected_buffer_calls += 1;
-    *buf = static_cast<unsigned char*>(ptr);
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_memory_copy_type);
-  }
-
-  static void CheckIfIdUniqueAndSaveIt(bool& is_unique, uint32_t id, std::set<uint32_t>& id_set,
-                                       const char* message_when_not_unique) {
-    if (is_unique && id_set.find(id) != id_set.end()) {
-      is_unique = false;
-      std::cout << "corr_id: " << id << message_when_not_unique << "\n";
-    }
-    id_set.insert(id);
-  }
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      ::operator delete(buf);
-      return;
-    }
-
-    completed_buffer_calls += 1;
-    completed_buffer_used_bytes = used_bytes;
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        std::cerr << "Found Error Parsing Records from PTI" << '\n';
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          std::cout << "Found Invalid Record" << '\n';
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-          pti_view_record_external_correlation* aExtRec =
-              reinterpret_cast<pti_view_record_external_correlation*>(ptr);
-          switch (aExtRec->_external_kind) {
-            case pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3: {
-              if (aExtRec->_external_id == eid_) {
-                masked_by_last_id_records += 1;
-              }
-              if (aExtRec->_external_id == eid_ + 50) {
-                last_id_records += 1;
-              }
-              break;
-            }
-            default:
-              break;
-          }
-          // PTI_VIEW_EXTERNAL_KIND_CUSTOM_0 = 4,
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-          pti_view_record_overhead* record = reinterpret_cast<pti_view_record_overhead*>(ptr);
-          num_of_overhead_counts += record->_overhead_count;
-          num_of_overhead_recs++;
-          overhead_kind_stringified =
-              (std::strcmp(ptiViewOverheadKindToString(record->_overhead_kind),
-                           "Instrumentation") == 0);
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL:
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          memory_view_record_created = true;
-          memory_view_record_count += 1;
-          uint32_t this_corrid = 0;
-          if (ptr->_view_kind == PTI_VIEW_DEVICE_GPU_MEM_COPY) {
-            memory_bytes_copied = reinterpret_cast<pti_view_record_memory_copy_type*>(ptr)->_bytes;
-            this_corrid = reinterpret_cast<pti_view_record_memory_copy_type*>(ptr)->_correlation_id;
-          } else {
-            this_corrid = reinterpret_cast<pti_view_record_memory_fill_type*>(ptr)->_correlation_id;
-          }
-
-          CheckIfIdUniqueAndSaveIt(zecall_at_gpu_op_corrids_unique, this_corrid,
-                                   zecall_at_gpu_op_corrids_already_seen,
-                                   " ,found in GPU memory op , is not unique across GPU ops and "
-                                   "seen before");
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DRIVER_API: {
-          pti_view_record_api* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          uint32_t this_corrid = rec->_correlation_id;
-          if (rec->_api_group == pti_api_group_id::PTI_API_GROUP_LEVELZERO) {
-            zecall_present = true;
-            zecall_count++;
-          }
-          CheckIfIdUniqueAndSaveIt(zecall_corrids_unique, this_corrid, zecall_corrids_already_seen,
-                                   " ,found in Driver API (ZECALL) record , "
-                                   "is not unique across ZECALLs records and seen before");
-          const char* api_name = nullptr;
-          pti_result status = ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO,
-                                                  rec->_api_id, &api_name);
-          if (pti_result::PTI_SUCCESS == status) zecall_good_id_name = true;
-          std::cout << "ZECALL: " << api_name << "\n";
-          status = ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, -1, &api_name);
-          if (status != pti_result::PTI_SUCCESS) zecall_bad_id_name = true;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-          const auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          urcall_present = true;
-          urcall_count++;
-          if (rec->_return_code != kUrSuccessReturnValue &&
-              rec->_return_code != kUrUnsupportedFeatureReturnValue) {
-            urcall_failure_count++;
-          }
-          const char* api_name = nullptr;
-          pti_result status =
-              ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id, &api_name);
-          PTI_ASSERT(status == PTI_SUCCESS);
-          std::string function_name(api_name);
-          if ((function_name.find("zeCommandListAppendLaunchKernel") != std::string::npos)) {
-            special_sycl_rec_present = true;
-          }
-          if ((function_name.find("EnqueueKernelLaunch") != std::string::npos)) {
-            kernel_launch_func_name = true;
-            kernel_launch_func_id = rec->_api_id;
-          } else if ((function_name.find("piEventsWait") != std::string::npos) ||
-                     (function_name.find("urEventWait") != std::string::npos)) {
-            sycl_has_all_records = true;
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          pti_view_record_kernel_type* rec = reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-          std::string kernel_name = reinterpret_cast<pti_view_record_kernel_type*>(ptr)->_name;
-          if (kernel_name.find("LaunchGemm(") != std::string::npos) {
-            demangled_kernel_name = true;
-          }
-          std::string kernel_source_filename =
-              reinterpret_cast<pti_view_record_kernel_type*>(ptr)->_source_file_name;
-          uint64_t kernel_enqueue_ts =
-              reinterpret_cast<pti_view_record_kernel_type*>(ptr)->_sycl_enqk_begin_timestamp;
-          if (kernel_source_filename != "") {
-            kernel_has_sycl_file_count += 1;
-            kernel_has_sycl_file_info = true;
-          }
-          if (kernel_enqueue_ts > 0) {
-            kernel_has_sycl_enqk_info = true;
-          }
-          kernel_view_record_created = true;
-          kernel_view_record_count += 1;
-          kernel_timestamps_monotonic = samples_utils::IsMonotonic(
-              {rec->_sycl_task_begin_timestamp, rec->_sycl_enqk_begin_timestamp,
-               rec->_append_timestamp, rec->_submit_timestamp, rec->_start_timestamp,
-               rec->_end_timestamp});
-          if (rec->_sycl_task_begin_timestamp == 0) {
-            kernel_has_task_begin0_record = true;
-          }
-          if (rec->_sycl_enqk_begin_timestamp == 0) {
-            kernel_has_enqk_begin0_record = true;
-          }
-          last_kernel_timestamp = rec->_end_timestamp;
-          ASSERT_EQ(rec->_context_handle, context_test);
-          ASSERT_EQ(rec->_queue_handle, queue_test);
-          std::cout << " == Queue reported by PTI: " << rec->_queue_handle << std::endl;
-
-          uint32_t this_corrid = rec->_correlation_id;
-          CheckIfIdUniqueAndSaveIt(zecall_at_gpu_op_corrids_unique, this_corrid,
-                                   zecall_at_gpu_op_corrids_already_seen,
-                                   " ,found at GPU Kernel record , is not unique across GPU ops "
-                                   "and seen before");
-
-          if (samples_utils::StringifyUuid(rec->_device_uuid, "") !=
-              "00000000-0000-0000-0000-000000000000") {
-            kernel_uuid_zero = false;
-            samples_utils::PrintUuid(rec->_device_uuid, "Kernel Device UUID: ");
-            ASSERT_EQ(std::memcmp(rec->_device_uuid, device_uuid_test, PTI_MAX_DEVICE_UUID_SIZE),
-                      0);
-          }
-          break;
-        }
-        default: {
-          std::cerr << "This shouldn't happen" << '\n';
-          break;
-        }
-      }
-    }
-    ::operator delete(buf);
-  }
-
-  void RunGemm(bool do_immediate = true) {
-    StartTracing();
-    RunGemmNoTrace(do_immediate);
-    StopTracing();
-    ptiFlushAllViews();
-  }
-
-  void RunGemmNoTrace(bool do_immediate = true) {
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid_);
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0,
-                                     eid_ + 10);
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1,
-                                     eid_ + 20);
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                     eid_ + 50);
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0,
-                                     eid_ + 30);
-    ptiViewPushExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_2,
-                                     eid_ + 40);
-
-    sycl::property_list prop_list;
-
-    if (do_immediate) {
-      sycl::property_list prop{sycl::property::queue::in_order(),
-                               sycl::property::queue::enable_profiling(),
-                               sycl::ext::intel::property::queue::immediate_command_list()};
-      prop_list = std::move(prop);
-    } else {
-      sycl::property_list prop{sycl::property::queue::in_order(),
-                               sycl::property::queue::enable_profiling(),
-                               sycl::ext::intel::property::queue::no_immediate_command_list()};
-      prop_list = std::move(prop);
-    }
-
-    sycl::queue queue(dev_, sycl::async_handler{}, prop_list);
-
-    auto sycl_context = queue.get_context();
-    context_test = static_cast<pti_backend_ctx_t>(
-        sycl::get_native<sycl::backend::ext_oneapi_level_zero>(sycl_context));
-
-    std::cout << "DPC++ Matrix Multiplication (matrix size: " << size_ << " x " << size_
-              << ", repeats " << repeat_count_ << " times)" << std::endl;
-    std::cout << "Target device: "
-              << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-              << std::endl;
-
-    queue_test = pti::test::utils::GetLevelZeroBackendQueue(queue);
-    if (queue_test == nullptr) {
-      FAIL() << "Underlying level zero queue handle could not be obtained.";
-    }
-    std::cout << " == Native Queue reported by Sycl: " << queue_test << std::endl;
-
-    std::vector<float> a(size_ * size_, A_VALUE);
-    std::vector<float> b(size_ * size_, B_VALUE);
-    std::vector<float> c(size_ * size_, 0.0f);
-
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, &eid_);
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &eid_);
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_1, &eid_);
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, &eid_);
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_0, &eid_);
-    ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_2, &eid_);
-    pop_null_ptr_result = ptiViewPopExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_2, nullptr);
-    last_pop_eid = eid_;
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size_;
-    Compute(queue, a, b, c, size_, repeat_count_, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    perf_time = time.count();
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  }
-
-  // Class members commonly used by all tests in the test suite for MainFixture
-  sycl::device dev_;
-  int expected_mem_transfers_per_mult_ = 4;
-  unsigned size_ = 1024;
-  unsigned repeat_count_ = 1;
-  bool buffer_cb_registered_ = false;
-};
-
-TEST_F(MainFixtureTest, ErrorCodeReturnedOnCallbacksNotSet) {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_ERROR_NO_CALLBACKS_SET);
-}
-
-TEST_F(MainFixtureTest, BufferFirstArgumentNull) {
-  EXPECT_EQ(ptiViewSetCallbacks(nullptr, BufferCompleted), pti_result::PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(MainFixtureTest, BufferSecondArgumentNull) {
-  EXPECT_EQ(ptiViewSetCallbacks(InadequateBufferRequested, nullptr),
-            pti_result::PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(MainFixtureTest, NegTestBufferSizeAtleastLargestRecord) {
-  EXPECT_EQ(ptiViewSetCallbacks(InadequateBufferRequested, BufferCompleted),
-            pti_result::PTI_ERROR_BAD_ARGUMENT);
-  RunGemm();
-  ASSERT_EQ(rejected_buffer_calls, 1 * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, BufferSizeAtleastLargestRecord) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_EQ(buffer_size_atleast_largest_record, true);
-}
-
-TEST_F(MainFixtureTest, BufferCallBacksRegistered) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(buffer_cb_registered_, true);
-}
-
-TEST_F(MainFixtureTest, SecondCallbackCalled) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_GT(completed_buffer_used_bytes, static_cast<std::size_t>(0));
-}
-
-TEST_F(MainFixtureTest, MemoryViewRecordCreated) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(memory_view_record_created, true);
-  EXPECT_EQ(memory_bytes_copied, 4194304ULL);
-}
-
-TEST_F(MainFixtureTest, KernelViewRecordCreated) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_view_record_created, true);
-}
-
-// TODO(PTI-359): kernel_has_sycl_file_info is not provided if NDEBUG is set.
-#if !defined(NDEBUG)
-TEST_F(MainFixtureTest, KernelViewRecordHasSyclFileName) {
-#else
-TEST_F(MainFixtureTest, DISABLED_KernelViewRecordHasSyclFileName) {
-#endif
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_has_sycl_file_info, true);
-}
-
-TEST_F(MainFixtureTest, KernelViewRecordHasSyclPiEnqLaunchKernel) {
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_has_sycl_enqk_info, true);
-}
-
-TEST_F(MainFixtureTest, KernelViewRecordHasMonotonicRecords) {
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_timestamps_monotonic, true);
-}
-
-TEST_F(MainFixtureTest, KernelViewRecordHasNonZeroTaskBeginRecords) {
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_has_task_begin0_record, false);
-}
-
-TEST_F(MainFixtureTest, KernelViewRecordHasNonZeroEnqkBeginRecords) {
-  ptiViewSetCallbacks(BufferRequested, BufferCompleted);
-  RunGemm();
-  EXPECT_EQ(kernel_has_enqk_begin0_record, false);
-}
-
-TEST_F(MainFixtureTest, NumberOfExpectedMemoryRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(memory_view_record_count, expected_mem_transfers_per_mult_ * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, NumberOfExpectedMemoryRecordsAfterStopTracing) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemmNoTrace();
-  RunGemmNoTrace();
-  StartTracing();
-  RunGemmNoTrace();
-  StopTracing();
-  RunGemmNoTrace();
-  EXPECT_EQ(memory_view_record_count, expected_mem_transfers_per_mult_ * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, NumberOfExpectedKernelRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(kernel_view_record_count, 1 * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, NumberOfExpectedKernelRecordsAfterStopTracing) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemmNoTrace();
-  StartTracing();
-  RunGemmNoTrace();
-  StopTracing();
-  RunGemmNoTrace();
-  RunGemmNoTrace();
-  EXPECT_EQ(kernel_view_record_count, 1 * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, RequestedAndCompletedBuffers) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(requested_buffer_calls, completed_buffer_calls);
-}
-
-TEST_F(MainFixtureTest, SyclRunTimeFunctionCheck) {
-  int32_t env_value = utils::IsSetEnv("PTI_VIEW_RUNTIME_API");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  if (env_value == 0) {
-    EXPECT_EQ(kernel_launch_func_name, false);
-    EXPECT_EQ(sycl_has_all_records, false);  // user has requested no records in buffer via env var.
-  } else {
-    EXPECT_EQ(kernel_launch_func_name, true);
-    // EnqueueKernelLaunch or EnqueueKernelLaunchWithArgsExp
-    EXPECT_TRUE(kernel_launch_func_id == kEnqueueKernelLaunchId ||
-                kernel_launch_func_id == kEnqueueKernelLaunchWithArgsExpId);
-    EXPECT_EQ(sycl_has_all_records, true);
-  }
-}
-
-// Test if sycl records seen or not based on env value
-TEST_F(MainFixtureTest, SyclRunTimeTraceEnv) {
-  int32_t env_value = utils::IsSetEnv("PTI_VIEW_RUNTIME_API");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  if ((env_value < 0) || (env_value > 0)) {
-    EXPECT_EQ(sycl_has_all_records, true);
-  } else {
-    EXPECT_EQ(sycl_has_all_records, false);
-  }
-}
-
-// TODO(PTI-358): Figure out if demangling can be supported on Windows or should we outright remove
-// this test on Windows.
-#if !defined(_WIN32)
-TEST_F(MainFixtureTest, DeMangledKernelNameCheck) {
-#else
-TEST_F(MainFixtureTest, DISABLED_DeMangledKernelNameCheck) {
-#endif
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(demangled_kernel_name, true);
-}
-
-TEST_F(MainFixtureTest, NoMaskedByLastIdExternalViewRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_EQ(masked_by_last_id_records, 0ULL);
-}
-
-// Tests for external_corr_id parameter properly populated on a pop.
-TEST_F(MainFixtureTest, LastEidReturnedParameter) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_EQ(last_pop_eid, 51ULL);
-}
-
-// Ensures that ImmediateCommandList on or off by default does not result in
-// number of kernel/memory records in buffer.
-TEST_F(MainFixtureTest, ZeroDiffICLonOroff) {
-  uint64_t memory_view_record_count_on = 0;
-  uint64_t memory_view_record_count_off = 0;
-  uint64_t kernel_view_record_count_on = 0;
-  uint64_t kernel_view_record_count_off = 0;
-
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm(true);
-  kernel_view_record_count_on = kernel_view_record_count;
-  memory_view_record_count_on = memory_view_record_count;
-  kernel_view_record_count = 0;
-  memory_view_record_count = 0;
-  queue_test = nullptr;
-  RunGemm(false);
-  kernel_view_record_count_off = kernel_view_record_count;
-  memory_view_record_count_off = memory_view_record_count;
-  ASSERT_EQ(kernel_view_record_count_on - kernel_view_record_count_off, 0ULL);
-  ASSERT_EQ(memory_view_record_count_on - memory_view_record_count_off, 0ULL);
-}
-
-// Tests for external_corr_id usage of kind stack --- use only the top/last for
-// the kind.
-TEST_F(MainFixtureTest, OnlyLastIdExternalViewRecords) {
-  if (utils::IsSetEnv("PTI_VIEW_RUNTIME_API") != 1) GTEST_SKIP();
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_GT(last_id_records, 0ULL);
-}
-
-// Tests for overhead records present in stream.
-TEST_F(MainFixtureTest, OverheadRecordsPresentViewRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_GT(num_of_overhead_recs, 0ULL);
-}
-
-// Tests for overhead records have stringified enum types in stream.
-TEST_F(MainFixtureTest, OverheadRecordsKindTypeStringified) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(overhead_kind_stringified, true);
-}
-
-// Tests for overhead records present in stream.
-TEST_F(MainFixtureTest, OverheadRecordsCountsAllOnesViewRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(num_of_overhead_counts, num_of_overhead_recs);
-}
-
-// TEST_F(MainFixtureTest, PerfDeltaForTracingUnder3For1100Repeats) {
-//   EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted),
-//             pti_result::PTI_SUCCESS);
-//   repeat_count_ = 1100;
-//   RunGemm();
-//   perf_time_with_tracing = perf_time;
-//   RunGemmNoTrace();
-//   perf_time_without_tracing = perf_time;
-//   repeat_count_ = 1;
-//   EXPECT_LT((perf_time_with_tracing / perf_time_without_tracing) * 100 - 100,
-//             3);
-// }
-
-TEST_F(MainFixtureTest, NegTestNullBufferSize) {
-  EXPECT_EQ(ptiViewSetCallbacks(NullBufferRequested, BufferCompleted),
-            pti_result::PTI_ERROR_BAD_ARGUMENT);
-  RunGemm();
-  ASSERT_EQ(rejected_buffer_calls, 1 * repeat_count_);
-}
-
-TEST_F(MainFixtureTest, ValidateNotImplementedViewReturn) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_CPU_KERNEL), pti_result::PTI_ERROR_NOT_IMPLEMENTED);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-}
-
-TEST_F(MainFixtureTest, ValidateNullPtrPopExternalId) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_EQ(pop_null_ptr_result, PTI_ERROR_EXTERNAL_ID_QUEUE_EMPTY);
-}
-
-TEST_F(MainFixtureTest, KerneluuidDeviceNonZero) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_EQ(kernel_uuid_zero, false);
-}
-
-// ptisdk default is real clock api_group -- this tests that ptiViewGetTimestamp returns a
-// monotonically increasing ts in same api_group.
-TEST_F(MainFixtureTest, ValidateRealTimestampToUser) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  ASSERT_GT(last_kernel_timestamp, 0ULL);
-  user_real_timestamp = ptiViewGetTimestamp();
-  ASSERT_GT(user_real_timestamp, last_kernel_timestamp);
-}
-
-// set user ts function in clockmonotonic raw api_group -- test output is in increasing
-// timestamps in same api_group.
-TEST_F(MainFixtureTest, ValidateRealTimestampFromUser) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewSetTimestampCallback(utils::GetTime), pti_result::PTI_SUCCESS);
-  uint64_t before_run = utils::GetTime();
-  RunGemm();
-  ASSERT_GT(last_kernel_timestamp, 0ULL);
-  uint64_t after_run = utils::GetTime();
-  ASSERT_LT(before_run, last_kernel_timestamp);
-  ASSERT_GT(after_run, last_kernel_timestamp);
-}
-
-// set user ts function in real clock api_group and capture last timestamp before switch
-// switch to monotonic raw api_group and capture last timestamp
-// -- test output is in increasing timestamps in same api_group.
-TEST_F(MainFixtureTest, ValidateSwitchedTSCallbackFromUser) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewSetTimestampCallback(utils::GetRealTime),
-            pti_result::PTI_SUCCESS);  // kernels will have real api_group
-  RunGemm();
-  ASSERT_GT(last_kernel_timestamp, 0ULL);
-  user_real_timestamp = ptiViewGetTimestamp();  // Real Domain
-  uint64_t after_run = utils::GetTime();        // Monotonic raw Domain
-  ASSERT_LT(after_run, last_kernel_timestamp);
-  ASSERT_LT(after_run, user_real_timestamp);
-  ASSERT_LT(last_kernel_timestamp, user_real_timestamp);
-
-  uint64_t before_switch_last_kernel_ts = last_kernel_timestamp;  // real clock
-  ASSERT_EQ(ptiViewSetTimestampCallback(utils::GetTime),
-            pti_result::PTI_SUCCESS);           // Switch -- kernels will have monotonic raw
-  user_real_timestamp = ptiViewGetTimestamp();  // Monotonic raw also
-  RunGemm();
-  ASSERT_GT(last_kernel_timestamp, 0ULL);
-  ASSERT_GT(last_kernel_timestamp, user_real_timestamp);
-  after_run = utils::GetTime();
-
-  ASSERT_GT(before_switch_last_kernel_ts,
-            last_kernel_timestamp);  // real clock raw value > than monotonic raw
-  ASSERT_GT(after_run,
-            last_kernel_timestamp);  // in same api_group so monotonically increasing
-}
-
-TEST_F(MainFixtureTest, ValidateNullptrTSCallbackFromUser) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_NE(ptiViewSetTimestampCallback(nullptr), pti_result::PTI_SUCCESS);
-  EXPECT_GT(ptiViewGetTimestamp(), 0ULL);
-  RunGemm();
-  EXPECT_GT(ptiViewGetTimestamp(), 0ULL);
-}
-
-TEST_F(MainFixtureTest, UniqueCorrIdsAllZeCalls) {
-  bool env_off = (utils::IsSetEnv("PTI_VIEW_DRIVER_API") == 0);
-  if (env_off) GTEST_SKIP();
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(zecall_corrids_unique, true);
-  EXPECT_EQ(zecall_good_id_name, true);
-  EXPECT_EQ(zecall_bad_id_name, true);
-}
-
-TEST_F(MainFixtureTest, OnlyZeCallsTraced) {
-  bool env_off = (utils::IsSetEnv("PTI_VIEW_DRIVER_API") == 0);
-  if (env_off) GTEST_SKIP();
-  bool enable_only_zecalls = true;
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  StartTracing(enable_only_zecalls);
-  RunGemmNoTrace();
-  StopTracing(enable_only_zecalls);
-  ptiFlushAllViews();
-  EXPECT_EQ(zecall_good_id_name, true);
-  EXPECT_EQ(zecall_bad_id_name, true);
-}
-
-// GetParam() - Tuple values correspond to (from left to right) whether we enable the viewkinds for
-// --- sycl, zecalls, kernel.
-TEST_P(MainFixtureTest, ZeCallsGeneration) {
-  bool env_off = (utils::IsSetEnv("PTI_VIEW_DRIVER_API") == 0);
-  if (env_off) GTEST_SKIP();
-  auto [sycl, zecall, gpu_ops] = GetParam();
-
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-
-  if (gpu_ops) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  }
-
-  if (sycl) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  }
-
-  if (zecall) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-
-  RunGemmNoTrace();
-
-  if (gpu_ops) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  }
-  if (sycl) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  }
-  if (zecall) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-
-  if (zecall) {
-    EXPECT_EQ(zecall_present, true);
-    EXPECT_EQ(special_sycl_rec_present, false);
-
-    // When both zecall and gpu_ops are enabled, verify that all GPU operation
-    // correlation IDs are found in DRIVER_API records
-    if (gpu_ops) {
-      std::cout << "Validating correlation ID correspondence between GPU ops and DRIVER_API "
-                   "records\n";
-      std::cout << "GPU ops correlation IDs seen: " << zecall_at_gpu_op_corrids_already_seen.size()
-                << "\n";
-      std::cout << "DRIVER_API correlation IDs seen: " << zecall_corrids_already_seen.size()
-                << "\n";
-
-      // Check that all GPU operation correlation IDs exist in DRIVER_API correlation IDs
-      for (const auto& gpu_corrid : zecall_at_gpu_op_corrids_already_seen) {
-        EXPECT_TRUE(zecall_corrids_already_seen.find(gpu_corrid) !=
-                    zecall_corrids_already_seen.end())
-            << "GPU operation correlation ID " << gpu_corrid << " not found in DRIVER_API records";
-      }
-    }
-  } else {
-    // special rec requires (no sycl rec+sycl+kernel enabled+zecalls disabled) -- hence false
-    // expected.
-    EXPECT_EQ(special_sycl_rec_present, false);
-    EXPECT_EQ(zecall_present, false);
-    EXPECT_EQ(zecall_at_gpu_op_corrids_unique, true);
-  }
-}
-
-void EnableIndividualApis(bool is_for_driver, pti_api_group_id pti_group) {
-  // Depending on GPU device/UR/L0 - one or more of these APIs will be present
-  if (is_for_driver) {
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group, pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernel_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group,
-        pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithParameters_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableDriverApi(
-        1, pti_group,
-        pti_api_id_driver_levelzero::zeCommandListAppendLaunchKernelWithArguments_id));
-  } else {
-    // Either of these two APIs should be present
-    PTI_CHECK_SUCCESS(
-        ptiViewEnableRuntimeApi(1, pti_group, pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(
-        1, pti_group, pti_api_id_runtime_sycl::urEnqueueKernelLaunchWithArgsExp_id));
-  }
-}
-
-// apicalls have the following behaviour depending on env variable:
-//     0/off --- no calls should be present
-//     1/on  --- all calls should be present irrespective of individual level apis set.
-//    unset  --- calls should be present either granularly OR fully depending on how apis used.
-TEST_P(MainFixtureTest, ApiCallsGenerationDriver) {
-  auto [driver_view_kind, env_off, granular_on] = GetParam();  // Note:  env_off is overridden below
-  env_off = (utils::IsSetEnv("PTI_VIEW_DRIVER_API") == 0);
-  bool env_on = (utils::IsSetEnv("PTI_VIEW_DRIVER_API") == 1);
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  if (driver_view_kind) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-  if (granular_on) {
-    EnableIndividualApis(true, pti_api_group_id::PTI_API_GROUP_ALL);
-  }
-  RunGemmNoTrace();
-  if (driver_view_kind) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  }
-  EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  if (driver_view_kind && !env_off) {
-    // We get here if env variable for DRIVER API is on or unset  ---  L0 calls should be found.
-    EXPECT_EQ(zecall_present, true);
-    if (env_on) {
-      std::cout << "Env set 1 case: " << zecall_count << "\n";
-      // If env var is explicitly 1 -- then L0 call count should be more than 1
-      //                            -- since the granular apis have no effect
-      EXPECT_GE(zecall_count, 2ULL);
-    } else {
-      std::cout << "Env Unset case-Granular(" << granular_on << "): " << zecall_count << "\n";
-      // If env is unset
-      if (granular_on) {                // and granular api is individually on.
-        EXPECT_EQ(zecall_count, 1ULL);  // call count should be exactly 1
-      } else {
-        EXPECT_GE(zecall_count, 2ULL);  // no granular hence call count should be all calls (> 1)
-      }
-    }
-  } else {
-    std::cout << "Env set 0 case: " << zecall_count << "\n";
-    // We get here if env variable for DRIVER API is off --- so no l0 calls should be found.
-    EXPECT_EQ(zecall_present, false);
-  }
-}
-
-// GetParam() - Tuple values correspond to (from left to right) whether we enable the apicalls for
-// --- runtime, set runtime env to off, set runtime granular api
-// apicalls have the following behaviour depending on env variable:
-//     0/off --- no calls should be present
-//     1/on  --- all calls should be present irrespective of individual level apis set.
-//    unset  --- calls should be present either granularly OR fully depending on how apis used.
-TEST_P(MainFixtureTest, ApiCallsGenerationRuntime) {
-  auto [runtime_view_kind, env_off, granular_on] = GetParam();  // Note: env_off is overridden below
-  // RUNTIME_API env is triggered via the CMakeLists.txt by the test type being run -- check there.
-  env_off = (utils::IsSetEnv("PTI_VIEW_RUNTIME_API") == 0);
-  bool env_on = (utils::IsSetEnv("PTI_VIEW_RUNTIME_API") == 1);
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  if (runtime_view_kind) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  }
-  if (granular_on) {
-    EnableIndividualApis(false, pti_api_group_id::PTI_API_GROUP_ALL);
-  }
-  RunGemmNoTrace();
-  if (runtime_view_kind) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  }
-  if (runtime_view_kind && !env_off) {
-    // We get here if env variable for RUNTIME API is on or unset  ---  ur calls should be found.
-    EXPECT_EQ(urcall_present, true);
-    if (env_on) {
-      std::cout << "Env set 1 case: " << urcall_count << "\n";
-      // If env var is explicitly 1 -- then ur call count should be more than 1
-      //                            -- since the granular apis have no effect
-      EXPECT_GE(urcall_count, 2ULL);
-      EXPECT_EQ(urcall_failure_count, 0ULL);
-    } else {
-      // If env is unset
-      std::cout << "Env Unset case-Granular(" << granular_on << "): " << urcall_count << "\n";
-      if (granular_on) {                // and granular api is individually on.
-        EXPECT_EQ(urcall_count, 1ULL);  // call count should be exactly 1
-        EXPECT_EQ(urcall_failure_count, 0ULL);
-      } else {
-        EXPECT_GE(urcall_count, 2ULL);  // no granular hence call count should be all calls (> 1)
-        EXPECT_EQ(urcall_failure_count, 0ULL);
-      }
-    }
-  } else {
-    // We get here if env variable for RUNTIME API is off --- so no ur calls should be found.
-    std::cout << "Env set 0 case: " << urcall_count << "\n";
-    EXPECT_EQ(urcall_present, false);
-  }
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    MainTests, MainFixtureTest,
-    ::testing::Values(std::make_tuple(true, true, true), std::make_tuple(true, true, false),
-                      std::make_tuple(false, true, true), std::make_tuple(false, true, false),
-                      std::make_tuple(true, false, true), std::make_tuple(true, false, false),
-                      std::make_tuple(false, false, true), std::make_tuple(false, false, false)));
-
-namespace {
-constexpr std::size_t kTestParam1 = 0;
-constexpr std::size_t kTestParam2 = 1;
-
-constexpr std::size_t kNumOverflowInts = 11;
-
-template <typename T>
-constexpr auto OverflowIntValues() {
-  return std::array<T, kNumOverflowInts>{static_cast<T>(-1), 0,          0x100,      0x3fffffff,
-                                         0x7ffffffe,         0x7fffffff, 0x80000000, 0xfffffffe,
-                                         0xffffffff,         0x10000,    0x100000};
-}
-
-constexpr std::array<pti_view_external_kind, 1> kExternalKinds = {
-    pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3};
-
-constexpr auto kExternalIds = OverflowIntValues<uint64_t>();
-}  // namespace
-
-class ExternalCorrelationOverFlowSuite
-    : public testing::TestWithParam<std::tuple<pti_view_external_kind, uint64_t>> {};
-
-TEST_P(ExternalCorrelationOverFlowSuite, ValidatePushExternalOverflowValues) {
-  const auto result = ptiViewPushExternalCorrelationId(std::get<kTestParam1>(GetParam()),
-                                                       std::get<kTestParam2>(GetParam()));
-  ASSERT_EQ(result, PTI_SUCCESS);
-}
-
-TEST_P(ExternalCorrelationOverFlowSuite, ValidatePopExternalOverflowValues) {
-  auto result_id = static_cast<uint64_t>(-1);
-  auto result = ptiViewPushExternalCorrelationId(std::get<kTestParam1>(GetParam()),
-                                                 std::get<kTestParam2>(GetParam()));
-  result = ptiViewPopExternalCorrelationId(std::get<kTestParam1>(GetParam()), &result_id);
-  ASSERT_EQ(result, PTI_SUCCESS);
-  ASSERT_EQ(result_id, std::get<kTestParam2>(GetParam()));
-}
-
-INSTANTIATE_TEST_SUITE_P(OverflowGroup, ExternalCorrelationOverFlowSuite,
-                         testing::Combine(testing::ValuesIn(kExternalKinds),
-                                          testing::ValuesIn(kExternalIds)));
-
-// Can be a tad easier to read than boolean.
-enum class QueueType { kImmediate, kNonImmediate };
-
-class GemmLaunchTest
-    : public ::testing::TestWithParam<std::tuple<std::size_t, unsigned int, QueueType>> {
- protected:
-  static constexpr unsigned int kDefaultMatrixSize = 8;
-  // This is a reasonable default. We are storing the buffers during the tests, so not super
-  // important.
-  static constexpr auto kRequestedBufferSize = 1'000 * sizeof(pti_view_record_kernel_type);
-
-  struct TimestampRange {
-    uint64_t start = 0;
-    uint64_t end = 0;
-  };
-
-  struct GemmLaunchTestData {
-    static GemmLaunchTestData& Instance() {
-      static GemmLaunchTestData data{};
-      return data;
-    }
-
-    void Reset() {
-      range = std::nullopt;
-      kernels = 0;
-      buffers.clear();
-    }
-
-    std::optional<TimestampRange> range = std::nullopt;  // If set, only consider values in range
-    std::size_t kernels = 0;
-    mutable std::mutex buffers_mtx;  // buffers requested and stored in different threads.
-    std::unordered_map<unsigned char*, pti::test::utils::PtiViewBuffer> buffers;
-  };
-
-  GemmLaunchTest() {
-    GemmLaunchTestData::Instance().Reset();
-    const auto [iterations, mat_size, queue_type] = GetParam();
-    const std::size_t vec_size = mat_size * mat_size;
-
-    a_vector_ = std::vector<float>(vec_size, A_VALUE);
-    b_vector_ = std::vector<float>(vec_size, B_VALUE);
-    result_vector_ = std::vector<float>(vec_size, 0.0f);
-  }
-
-  static bool WithinRange(TimestampRange range, uint64_t timestamp) {
-    return timestamp >= range.start && timestamp <= range.end;
-  }
-
-  static void HandleView(pti_view_record_base* view) {
-    switch (view->_view_kind) {
-      case PTI_VIEW_DEVICE_GPU_KERNEL: {
-        const auto* const kernel = reinterpret_cast<const pti_view_record_kernel_type*>(view);
-        auto range = GemmLaunchTestData::Instance().range;
-        if (range.has_value()) {
-          auto within_range = WithinRange(*range, kernel->_start_timestamp);
-          EXPECT_TRUE(within_range)
-              << "Range Start: " << range->start << " Range End: " << range->end
-              << " Kernel Start Timestamp: " << kernel->_start_timestamp
-              << " Kernel End Timestamp: " << kernel->_end_timestamp
-              << "Kernel Duration: " << kernel->_end_timestamp - kernel->_start_timestamp << '\n';
-          if (within_range) {
-            ++GemmLaunchTestData::Instance().kernels;
-          }
-        }
-        break;
-      }
-      default: {
-        FAIL() << "View found but not handled: " << view->_view_kind;
-        break;
-      }
-    }
-  }
-
-  static void ProvideBuffer(unsigned char** buf, size_t* buf_size) {
-    auto buffer = pti::test::utils::PtiViewBuffer(kRequestedBufferSize);
-    if (!buffer.Valid()) {
-      FAIL() << "Unable to allocate buffer for PTI tracing";
-    }
-    *buf = buffer.data();
-    *buf_size = buffer.size();
-
-    const std::lock_guard<std::mutex> lock(GemmLaunchTestData::Instance().buffers_mtx);
-    GemmLaunchTestData::Instance().buffers[*buf] = std::move(buffer);
-  }
-
-  static void ParseBuffer(unsigned char* buf, size_t used_bytes) {
-    pti_view_record_base* record = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &record);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        FAIL() << "Found Error Parsing Records from PTI";
-        break;
-      }
-      HandleView(record);
-    }
-  }
-
-  static void MarkBuffer(unsigned char* buf, size_t /*buf_size*/, size_t used_bytes) {
-    const std::lock_guard<std::mutex> lock(GemmLaunchTestData::Instance().buffers_mtx);
-    if (auto buffer = GemmLaunchTestData::Instance().buffers.find(buf);
-        buffer != GemmLaunchTestData::Instance().buffers.end()) {
-      buffer->second.SetUsedBytes(used_bytes);
-    }
-  }
-
-  void SetUp() override {
-    try {
-      dev_ = sycl::device(sycl::gpu_selector_v);
-
-      const auto [iterations, mat_size, queue_type] = GetParam();
-
-      sycl::property_list prop_list;
-
-      if (queue_type == QueueType::kImmediate) {
-        sycl::property_list prop{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::immediate_command_list()};
-        prop_list = std::move(prop);
-      } else {
-        sycl::property_list prop{sycl::property::queue::in_order(),
-                                 sycl::ext::intel::property::queue::no_immediate_command_list()};
-        prop_list = std::move(prop);
-      }
-
-      queue_ = sycl::queue(dev_, prop_list);
-
-    } catch (const std::exception& e) {
-      FAIL() << "Unable to select valid device to run tests on. Check your hardware, driver "
-                "install, or system configuration.";
-    }
-  }
-
-  unsigned int mat_size_ = kDefaultMatrixSize;
-  std::vector<float> a_vector_;
-  std::vector<float> b_vector_;
-  std::vector<float> result_vector_;
-  sycl::device dev_;
-  sycl::queue queue_;
-};
-
-auto format_as(QueueType queue_enum) {
-  switch (queue_enum) {
-    case QueueType::kImmediate:
-      return "ImmediateQueue";
-    case QueueType::kNonImmediate:
-      return "NonImmediateQueue";
-    default:
-      return "UnknownQueue";
-  }
-}
-
-std::ostream& operator<<(std::ostream& out, QueueType queue_enum) {
-  out << format_as(queue_enum);
-  return out;
-}
-
-TEST_P(GemmLaunchTest, CheckWhetherAllLaunchedKernelDeviceTimestampsFitWithinAGivenTimeRange) {
-  const auto [iterations, mat_size, queue_type] = GetParam();
-  TimestampRange range;
-  ASSERT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  range.start = ptiViewGetTimestamp();
-  for (std::size_t run_idx = 0; run_idx < iterations; ++run_idx) {
-    LaunchGemm(queue_, a_vector_, b_vector_, result_vector_, mat_size);
-    ValidateGemm(result_vector_, A_VALUE, B_VALUE, mat_size);
-  }
-  range.end = ptiViewGetTimestamp();
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  GemmLaunchTestData::Instance().range = range;
-  ASSERT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  for (auto& [buf, buffer] : GemmLaunchTestData::Instance().buffers) {
-    ParseBuffer(buffer.data(), buffer.UsedBytes());
-  }
-
-  ASSERT_EQ(GemmLaunchTestData::Instance().kernels, iterations);
-}
-
-INSTANTIATE_TEST_SUITE_P(GranularGemmLaunchTest, GemmLaunchTest,
-                         testing::Values(std::make_tuple(100, 8, QueueType::kImmediate),
-                                         std::make_tuple(100, 8, QueueType::kNonImmediate)),
-
-                         [](const testing::TestParamInfo<GemmLaunchTest::ParamType>& info) {
-                           return fmt::format("Kernel_Launches_{}_GEMM_SIZE_{}_Queue_Type_{}",
-                                              std::get<0>(info.param), std::get<1>(info.param),
-                                              std::get<2>(info.param));
-                         });
diff --git a/sdk/test/main_startstop_fixture.cc b/sdk/test/main_startstop_fixture.cc
deleted file mode 100644
index bfa5b324..00000000
--- a/sdk/test/main_startstop_fixture.cc
+++ /dev/null
@@ -1,626 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Based on Vector Add example from OneAPI samples
-//==============================================================
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <cmath>
-#include <condition_variable>
-#include <cstdlib>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-
-namespace {
-
-enum class TestType {
-  kArbStartStop = 1,
-  kArbStartStopDupEnables = 2,
-  kArbStartStopDupDisables = 3,
-  kArbStartStopNoKernelStart = 4,
-  kArbStartStopNoKernelStop = 5,
-  kArbStartStopSycl = 6,
-  kArbStartStopMt = 7,
-  kArbStartStopMtDupEnables = 8,
-  kArbStartStopMtDupDisables = 9,
-  kArbStartStopMtNoKernelStart = 10,
-  kArbStartStopMtNoKernelStop = 11,
-  kArbStartStopMtSycl = 12,
-};
-
-constexpr uint32_t kArbStartStopCounter =
-    4;  // keep this an even number if changed -- test requires it.
-constexpr size_t kVectorSize = 5000;
-constexpr size_t kThreadCount = 3;
-constexpr size_t kNumElementsForCorrIds = 3;
-constexpr uint64_t kMinKernelDurationNs = 100;
-constexpr uint64_t kExternalCorrelationIdBase = 11;
-
-[[maybe_unused]] bool matched_sq_corr_ids = false;
-[[maybe_unused]] bool matched_add_corr_ids = false;
-bool timestamps_nonzero_duration = true;
-bool kernel_timestamps_monotonic = false;
-uint64_t sycl_kernel_corr_id[kNumElementsForCorrIds];
-uint64_t sycl_kernel_start_time[kNumElementsForCorrIds];
-uint64_t kernel_corr_id[kNumElementsForCorrIds];
-uint64_t kernel_append_time[kNumElementsForCorrIds];
-uint64_t sycl_idx = 0;
-uint64_t kernel_idx = 0;
-[[maybe_unused]] uint64_t kernel_start_ts = 0;
-[[maybe_unused]] uint64_t kernel_stop_ts = 0;
-uint64_t number_of_kernel_recs = 0;
-uint64_t number_of_sycl_recs = 0;
-[[maybe_unused]] uint64_t expected_sycl_recs = 0;
-uint64_t eid = kExternalCorrelationIdBase;
-
-// sync variables
-std::mutex common_m;
-std::condition_variable main_cv;
-std::atomic<size_t> shared_thread_count[kArbStartStopCounter] = {0};
-
-std::mutex g_test_result_mutex;
-
-//************************************
-// Vector square in SYCL on device: modifies each input vector
-//************************************
-template <typename T>
-void VecSq(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector) {
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(
-                pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid + 20),
-            pti_result::PTI_SUCCESS);
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                            &eid),
-            pti_result::PTI_SUCCESS);
-}
-
-//************************************
-// Vector add in SYCL on device: returns sum in 4th parameter "sq_add".
-//************************************
-template <typename T>
-[[maybe_unused]] void VecAdd(sycl::queue &q, const std::vector<T> &a_vector,
-                             const std::vector<T> &b_vector, std::vector<T> &sq_add) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-  sycl::buffer sum_buf(sq_add.data(), num_items);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_only);
-    sycl::accessor b(b_buf, h, sycl::read_only);
-    sycl::accessor sum(sum_buf, h, sycl::write_only, sycl::no_init);
-    h.parallel_for(num_items, [=](auto i) { sum[i] = a[i] + b[i]; });
-  });
-  q.wait();
-}
-
-[[maybe_unused]] void StartTracingNonL0() {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-[[maybe_unused]] void StopTracingNonL0() {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-[[maybe_unused]] void StartTracingMTL0([[maybe_unused]] TestType type) {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-}
-
-void StartTracingL0([[maybe_unused]] TestType type) {
-  if (type != TestType::kArbStartStopNoKernelStart)
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  if (type == TestType::kArbStartStopDupEnables) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-}
-
-[[maybe_unused]] void StopTracingMTL0([[maybe_unused]] TestType type) {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-}
-
-void StopTracingL0([[maybe_unused]] TestType type, bool force = false) {
-  if (type != TestType::kArbStartStopNoKernelStop) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-  if (type == TestType::kArbStartStopDupDisables) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-  if (force) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-}
-
-// This function is needed to:
-// - avoid tests affecting each other when running in the same process
-// - enforce that in Local mode (which is default)
-//    - all profiling is disabled prior to process completion
-void GlobalPTIDisable() {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-static void BufferRequested(unsigned char **buf, size_t *buf_size) {
-  *buf_size = 10000 * sizeof(pti_view_record_kernel);
-  void *ptr = ::operator new(*buf_size);
-  ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-  *buf = reinterpret_cast<unsigned char *>(ptr);
-  if (!*buf) {
-    std::abort();
-  }
-  return;
-}
-
-static void BufferCompleted(unsigned char *buf, size_t buf_size, size_t valid_buf_size) {
-  if (!buf_size || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (valid_buf_size) {
-      ::operator delete(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    const std::lock_guard<std::mutex> lock(g_test_result_mutex);
-
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        [[maybe_unused]] pti_view_record_external_correlation *a_ext_rec =
-            reinterpret_cast<pti_view_record_external_correlation *>(ptr);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        [[maybe_unused]] pti_view_record_overhead *record =
-            reinterpret_cast<pti_view_record_overhead *>(ptr);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        number_of_sycl_recs++;
-        pti_view_record_api *rec = reinterpret_cast<pti_view_record_api *>(ptr);
-        const char *pName = nullptr;
-        pti_result status =
-            ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id, &pName);
-        PTI_ASSERT(status == PTI_SUCCESS);
-        std::string function_name(pName);
-        if ((sycl_idx < 2) && (function_name.find("EnqueueKernelLaunch") != std::string::npos)) {
-          sycl_kernel_corr_id[sycl_idx] = rec->_correlation_id;
-          sycl_kernel_start_time[sycl_idx] = rec->_start_timestamp;
-          sycl_idx++;
-        };
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        pti_view_record_kernel *a_kernel_rec = reinterpret_cast<pti_view_record_kernel *>(ptr);
-        std::string kernel_name = a_kernel_rec->_name;
-        number_of_kernel_recs++;
-        if ((kernel_idx < 2) && (kernel_name.find("VecSq<") != std::string::npos)) {
-          kernel_corr_id[kernel_idx] = a_kernel_rec->_correlation_id;
-          kernel_append_time[kernel_idx] = a_kernel_rec->_append_timestamp;
-          kernel_idx++;
-        }
-        if ((kernel_idx < 2) && (kernel_name.find("VecAdd<") != std::string::npos)) {
-          kernel_corr_id[kernel_idx] = a_kernel_rec->_correlation_id;
-          kernel_append_time[kernel_idx] = a_kernel_rec->_append_timestamp;
-          kernel_idx++;
-        }
-        // std::cout << "KernelTimestamp for VecAdd: " << a_kernel_rec->_append_timestamp << ":"
-        //           << a_kernel_rec->_thread_id << "\n";
-        timestamps_nonzero_duration = timestamps_nonzero_duration &&
-                                      ((a_kernel_rec->_end_timestamp -
-                                        a_kernel_rec->_start_timestamp) > kMinKernelDurationNs);
-
-        kernel_timestamps_monotonic = samples_utils::IsMonotonic(
-            {a_kernel_rec->_sycl_task_begin_timestamp, a_kernel_rec->_sycl_enqk_begin_timestamp,
-             a_kernel_rec->_append_timestamp, a_kernel_rec->_submit_timestamp,
-             a_kernel_rec->_start_timestamp, a_kernel_rec->_end_timestamp});
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  ::operator delete(buf);
-}
-
-template <typename T>
-[[maybe_unused]] void InitVectors(std::vector<T> &a, std::vector<T> &b, std::vector<T> &c,
-                                  std::vector<T> &d) {
-  a.resize(kVectorSize);
-  b.resize(kVectorSize);
-  c.resize(2 * kVectorSize);
-  d.resize(2 * kVectorSize);
-
-  for (size_t i = 0; i < kVectorSize; i++) {
-    a[i] = std::sin(i);
-    b[i] = std::cos(i);
-    c[2 * i] = std::sin(i) * std::sin(i);
-    c[2 * i + 1] = std::sin(i);
-    d[2 * i] = std::cos(i) * std::cos(i);
-    d[2 * i + 1] = std::cos(i);
-  }
-}
-
-[[maybe_unused]] void ArriveAndWait(unsigned int index) {
-  std::unique_lock<std::mutex> lk(common_m);
-  shared_thread_count[index]++;
-  main_cv.wait(lk, [&] { return (shared_thread_count[index] == kThreadCount); });
-  main_cv.notify_all();
-}
-
-template <typename T>
-void RunArbStartStopTestMultiThreaded(sycl::queue &q, const std::vector<T> &a,
-                                      const std::vector<T> &b, TestType a_test_type) {
-  auto thread_function = [&q](const auto &a, const auto &b, TestType a_test_type) {
-    for (unsigned int i = 0; i < kArbStartStopCounter; i++) {
-      if (i % 2) {
-        if (a_test_type != TestType::kArbStartStopMtSycl)
-          StartTracingL0(a_test_type);
-        else
-          StartTracingNonL0();
-      }
-      VecSq(q, a, b);
-      ArriveAndWait(i);
-      if (i % 2) {
-        if (a_test_type != TestType::kArbStartStopMtSycl) {
-          StopTracingL0(a_test_type);
-        } else {
-          StopTracingNonL0();
-        }
-        ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-      }
-    }
-
-    // Ensure L0 tracing is stopped at the end of each thread
-    // TODO: ptiViewEnable/Disable should make effects process-wide not per-thread
-    StopTracingL0(a_test_type, true);
-  };
-
-  std::vector<std::thread> the_threads;
-  for (unsigned i = 0; i < kThreadCount; i++) {
-    std::thread t = std::thread(thread_function, a, b, a_test_type);
-    the_threads.push_back(std::move(t));
-  }
-
-  for (auto &th : the_threads) {
-    if (th.joinable()) {
-      th.join();
-    }
-  }
-}
-
-template <typename T>
-void RunArbStartStopTest(sycl::queue &q, [[maybe_unused]] const std::vector<T> &a,
-                         [[maybe_unused]] const std::vector<T> &b, TestType a_test_type) {
-  for (unsigned int i = 1; i <= kArbStartStopCounter; i++) {
-    if (i % 2) {
-      if (a_test_type != TestType::kArbStartStopSycl)
-        StartTracingL0(a_test_type);
-      else
-        StartTracingNonL0();
-    }
-
-    VecSq(q, a, b);
-
-    if (i % 2) {
-      if (a_test_type != TestType::kArbStartStopSycl) {
-        StopTracingL0(a_test_type);
-      } else {
-        StopTracingNonL0();
-      }
-      ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    }
-  }
-}
-
-template <typename T>
-void VecSqAddRouter(sycl::queue &sycl_queue, TestType a_test_type) {
-  std::vector<T> a(kVectorSize);
-  std::vector<T> b(kVectorSize);
-  std::vector<T> c(2 * kVectorSize);
-  std::vector<T> d(2 * kVectorSize);
-  std::vector<T> sq_add(kVectorSize);
-  std::vector<T> sq_add2(2 * kVectorSize);
-
-  for (size_t i = 0; i < kVectorSize; i++) {
-    a[i] = std::sin(i);
-    b[i] = std::cos(i);
-    c[2 * i] = std::sin(i) * std::sin(i);
-    c[2 * i + 1] = std::sin(i);
-    d[2 * i] = std::cos(i) * std::cos(i);
-    d[2 * i + 1] = std::cos(i);
-  }
-
-  // Start Tests by Type
-  if (a_test_type == TestType::kArbStartStop) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopDupEnables) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopDupDisables) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopNoKernelStart) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopNoKernelStop) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopSycl) {
-    RunArbStartStopTest(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMt) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, a_test_type);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMtDupEnables) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, TestType::kArbStartStopDupEnables);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMtDupDisables) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, TestType::kArbStartStopDupDisables);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMtNoKernelStart) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, TestType::kArbStartStopNoKernelStart);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMtNoKernelStop) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, TestType::kArbStartStopNoKernelStop);
-  }
-
-  if (a_test_type == TestType::kArbStartStopMtSycl) {
-    RunArbStartStopTestMultiThreaded(sycl_queue, a, b, TestType::kArbStartStopMtSycl);
-  }
-}
-
-void RunVecsqadd(TestType a_test_type) {
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(
-                pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid),
-            pti_result::PTI_SUCCESS);
-
-  auto d_selector{sycl::gpu_selector_v};
-  sycl::property_list prop_list{sycl::property::queue::in_order()};
-  sycl::queue q(d_selector, sycl::async_handler{}, prop_list);
-
-  if (q.get_device().has(sycl::aspect::fp64)) {
-    VecSqAddRouter<double>(q, a_test_type);
-  } else {
-    VecSqAddRouter<float>(q, a_test_type);
-  }
-
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                            &eid),
-            pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-}
-
-}  // namespace
-
-class StartStopFixtureTest : public ::testing::TestWithParam<bool> {
- protected:
-  void SetUp() override {
-    const std::lock_guard<std::mutex> lock(g_test_result_mutex);
-    matched_sq_corr_ids = false;
-    matched_add_corr_ids = false;
-    timestamps_nonzero_duration = true;
-    kernel_timestamps_monotonic = false;
-    sycl_idx = 0;
-    kernel_idx = 0;
-    kernel_start_ts = 0;
-    kernel_stop_ts = 0;
-    number_of_kernel_recs = 0;
-    number_of_sycl_recs = 0;
-    expected_sycl_recs = 0;
-    eid = kExternalCorrelationIdBase;
-    for (unsigned int i = 0; i < kArbStartStopCounter; i++) {
-      shared_thread_count[i] = 0;
-    }
-    for (size_t i = 0; i < kNumElementsForCorrIds; i++) {
-      sycl_kernel_corr_id[i] = 0;
-      sycl_kernel_start_time[i] = 0;
-      kernel_corr_id[i] = 0;
-      kernel_append_time[i] = 0;
-    }
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-    GlobalPTIDisable();
-  }
-};
-
-// MT - StartTracing / StopTracing have matching enable/disable of gpu_kernels every other
-// iteration.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedBalanced) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMt);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter * kThreadCount / 2);
-  EXPECT_EQ(timestamps_nonzero_duration, true);
-  EXPECT_EQ(kernel_timestamps_monotonic, true);
-}
-
-// MT - Enable gpu_kernels multiple times when we start / stop disables it once.   Should have no
-// effect on expected kernels.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedKernelsDuplicatedEnables) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMtDupEnables);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter * kThreadCount / 2);
-}
-
-// MT - Enable gpu_kernels once when we start / stop disables it multiple times.   Should have no
-// effect on expected kernels.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedKernelsDuplicatedDisables) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMtDupDisables);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter * kThreadCount / 2);
-}
-
-// MT - sycl only tracing -- no l0.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedSycls) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMtSycl);
-  EXPECT_GT(number_of_sycl_recs, 0ULL);
-  EXPECT_EQ(number_of_kernel_recs, 0ULL);
-}
-
-// MT - StartTracing does *not* enable gpu_kernel view kind,  StopTracing has disable for it -- so
-// expect 0 kernel recs.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedNoStartKernelWithStopKernel) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMtNoKernelStart);
-  EXPECT_EQ(number_of_kernel_recs, 0ULL);
-}
-
-// MT - StartTracing enable gpu_kernel view kind,  StopTracing does not disable it -- so span of
-// tracing is 1st start to end of prog.
-TEST_P(StartStopFixtureTest, ArbStartStopCountMultiThreadedNoStopKernelWithStartKernel) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopMtNoKernelStop);
-  EXPECT_EQ(number_of_kernel_recs, (kArbStartStopCounter - 1) * kThreadCount);
-}
-
-// Enable gpu_kernels once when we start / stop disables it multiple times.   Should have no effect
-// on expected kernels.
-TEST_P(StartStopFixtureTest, ArbStartStopCountKernelsDuplicatedDisables) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopDupDisables);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter / 2);
-}
-
-// Enable gpu_kernels multiple times when we start / stop disables it once.   Should have no effect
-// on expected kernels.
-TEST_P(StartStopFixtureTest, ArbStartStopCountKernelsDuplicatedEnables) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopDupEnables);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter / 2);
-}
-
-// StartTracing / StopTracing have matching enable/disable of gpu_kernels every other iteration.
-TEST_P(StartStopFixtureTest, ArbStartStopCountKernelsBalanced) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStop);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter / 2);
-  EXPECT_EQ(timestamps_nonzero_duration, true);
-  EXPECT_EQ(kernel_timestamps_monotonic, true);
-}
-
-// sycl only tracing -- no l0.
-TEST_P(StartStopFixtureTest, ArbStartStopCountSycls) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopSycl);
-  EXPECT_GT(number_of_sycl_recs, 0ULL);
-  EXPECT_EQ(number_of_kernel_recs, 0ULL);
-}
-
-// StartTracing does *not* enable gpu_kernel view kind,  StopTracing has disable it -- so expect 0
-// kernel recs.
-TEST_P(StartStopFixtureTest, ArbStartStopCountNoStartKernelWithStopKernel) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopNoKernelStart);
-  EXPECT_EQ(number_of_kernel_recs, 0ULL);
-}
-
-// StartTracing enable gpu_kernel view kind,  StopTracing does not disable it -- so span of tracing
-// is 1st start to end of prog.
-TEST_P(StartStopFixtureTest, ArbStartStopCountNoStopKernelWithStartKernel) {
-  bool do_immediate = GetParam();
-  // use SetEnv until
-  utils::SetEnv("SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS", do_immediate ? "1" : "0");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kArbStartStopNoKernelStop);
-  EXPECT_EQ(number_of_kernel_recs, kArbStartStopCounter);
-}
-
-INSTANTIATE_TEST_SUITE_P(StartStopTests, StartStopFixtureTest, ::testing::Values(false, true),
-                         [](const testing::TestParamInfo<StartStopFixtureTest::ParamType> &info) {
-                           return fmt::format("Queue_Type_{}",
-                                              info.param ? "ImmediateQueue" : "NonImmediateQueue");
-                         });
diff --git a/sdk/test/main_urgemm_fixture.cc b/sdk/test/main_urgemm_fixture.cc
deleted file mode 100644
index f77d580d..00000000
--- a/sdk/test/main_urgemm_fixture.cc
+++ /dev/null
@@ -1,651 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <gtest/gtest.h>
-#include <string.h>
-
-// Unified Runtime header(s) can be found in either directory.
-#if __has_include(<sycl/ur_api.h>)
-#include <sycl/ur_api.h>
-#else
-#include <ur_api.h>
-#endif
-
-#include <chrono>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <fstream>
-#include <iostream>
-#include <sycl/kernel_bundle.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_runtime_sycl_api_ids.h"
-#include "pti/pti_version.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/sycl_config_info.h"
-#include "utils/test_helpers.h"
-
-#define ALIGN 64
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-#define UR_CHECK_SUCCESS(X)                                                                   \
-  do {                                                                                        \
-    if (X != ur_result_t::UR_RESULT_SUCCESS) {                                                \
-      std::cerr << "UR CALL FAILED: " #X << " WITH ERROR " << std::to_string(X) << std::endl; \
-      std::exit(EXIT_FAILURE);                                                                \
-    }                                                                                         \
-  } while (0)
-
-// Removed check of __SYCL_COMPILER_VERSION number as it refers to the build date,
-// instead rely on  __INTEL_LLVM_COMPILER that provided by oneAPI compiler
-// (can be seen: icpx -dM -E -x c /dev/null),
-// but not defined in any of header files.
-//
-// However, for Open Source compiler there is still no reliable solution -
-// as we found no macro definition from which compiler version could be derived and
-// so UR API signatures derived.
-// The solution in such case - disable building this test at configuring build
-// - providing to cmake "-DPTI_BUILD_URGEMM=OFF"
-// or providing one of defines PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3 /
-// PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0
-
-#if !defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3)
-#if (defined(__INTEL_LLVM_COMPILER) && (__INTEL_LLVM_COMPILER >= 20250300))
-
-#define PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3 1
-
-#endif
-#endif
-
-#if !defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0)
-#if (defined(__INTEL_LLVM_COMPILER) && (__INTEL_LLVM_COMPILER >= 20260000))
-
-#define PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0 1
-#undef PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3
-
-#endif
-#endif
-
-// This corrects for future patch releases prior to 2025.3. We will assume a patch won't be issued
-// for the open-source version of the compiler (which has only __SYCL_COMPILER_VERSION).
-// For oneAPI compiler we rely on  __INTEL_LLVM_COMPILER check.
-#if defined(__INTEL_LLVM_COMPILER) && (__INTEL_LLVM_COMPILER < 20250300)
-#undef PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3
-#undef PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0
-#endif
-
-// Static asserts to ensure PTI and UR API ids match.
-// These are critical for PyTorch framework. We have to tolerate some breakages between oneAPI
-// versions due to a bug but not these.
-static_assert(static_cast<uint32_t>(urEnqueueUSMFill_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_USM_FILL),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueUSMFill2D_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_USM_FILL_2D),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueUSMMemcpy2D_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_USM_MEMCPY_2D),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueUSMMemcpy_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_USM_MEMCPY),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueKernelLaunch_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-#if !defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3) && !defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0)
-// These were removed in 2025.3. They should not be reassigned though.
-static_assert(static_cast<uint32_t>(urEnqueueKernelLaunchCustomExp_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_KERNEL_LAUNCH_CUSTOM_EXP),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueCooperativeKernelLaunchExp_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_COOPERATIVE_KERNEL_LAUNCH_EXP),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-#endif
-static_assert(static_cast<uint32_t>(urEnqueueMemBufferFill_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_MEM_BUFFER_FILL),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueMemBufferRead_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_MEM_BUFFER_READ),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueMemBufferWrite_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_MEM_BUFFER_WRITE),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urEnqueueMemBufferCopy_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_ENQUEUE_MEM_BUFFER_COPY),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urUSMHostAlloc_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_USM_HOST_ALLOC),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urUSMSharedAlloc_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_USM_SHARED_ALLOC),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-static_assert(static_cast<uint32_t>(urUSMDeviceAlloc_id) ==
-                  static_cast<uint32_t>(UR_FUNCTION_USM_DEVICE_ALLOC),
-              "Critical PTI - Unified Runtime API ID Mismatch");
-
-namespace syclex = sycl::ext::oneapi::experimental;
-
-namespace {
-
-// Use V2 record types when PTI version > 0.17
-#if (PTI_VERSION_MAJOR > 0) || (PTI_VERSION_MAJOR == 0 && PTI_VERSION_MINOR > 17)
-using pti_view_record_kernel_type = pti_view_record_kernel_v2;
-using pti_view_record_memory_copy_type = pti_view_record_memory_copy_v2;
-using pti_view_record_memory_fill_type = pti_view_record_memory_fill_v2;
-using pti_view_record_memory_copy_p2p_type = pti_view_record_memory_copy_p2p_v2;
-#else
-using pti_view_record_kernel_type = pti_view_record_kernel;
-using pti_view_record_memory_copy_type = pti_view_record_memory_copy;
-using pti_view_record_memory_fill_type = pti_view_record_memory_fill;
-using pti_view_record_memory_copy_p2p_type = pti_view_record_memory_copy_p2p;
-#endif
-
-bool is_integrated_graphics = false;
-bool memory_view_record_created = false;
-bool kernel_view_record_created = false;
-bool sycl_runtime_record_created = false;
-bool sycl_spv_special_rec_seen = false;
-bool sycl_spv_kernel_seen = false;
-bool sycl_spv_mem_buffer_fill_seen = false;
-bool sycl_spv_mem_buffer_read_seen = false;
-bool sycl_spv_mem_buffer_write_seen = false;
-bool sycl_spv_mem_buffer_copy_seen = false;
-uint64_t memory_view_record_count = 0;
-bool memory_view_record_with_zero_uuid = false;
-uint64_t kernel_view_record_count = 0;
-uint64_t sycl_runtime_record_count = 0;
-
-size_t requested_buffer_calls = 0;
-size_t rejected_buffer_calls = 0;  // Buffer requests that are called and rejected by the API
-size_t completed_buffer_calls = 0;
-size_t completed_buffer_used_bytes = 0;
-bool buffer_size_atleast_largest_record = false;
-bool capture_records = false;
-std::vector<pti_view_record_memory_copy_type> copy_records;
-std::vector<pti_view_record_kernel_type> kernel_records;
-
-float Check(const std::vector<float>& a, float value) {
-  PTI_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-float RunAndCheckSycl(sycl::kernel& k, sycl::queue& q, std::vector<float>& a, std::vector<float>& b,
-                      std::vector<float>& c, unsigned size, float expected_result) {
-  PTI_ASSERT(size > 0);
-  sycl::buffer<float, 1> a_buf(a.data(), a.size());
-  sycl::buffer<float, 1> b_buf(b.data(), b.size());
-  sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-  sycl::event event = q.submit([&](sycl::handler& cgh) {
-    auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-    auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-    auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-    cgh.set_args(a_acc, b_acc, c_acc, size);
-    cgh.parallel_for(sycl::range<2>(size, size), k);
-  });
-  q.wait_and_throw();
-
-  // Test mem_buffer_copy
-  sycl::event event_cp = q.submit([&](sycl::handler& cgh) {
-    auto a_acc = a_buf.get_access<sycl::access::mode::read_write>(cgh);
-    auto b_acc = b_buf.get_access<sycl::access::mode::read_write>(cgh);
-    cgh.copy(a_acc, b_acc);
-  });
-  q.wait_and_throw();
-
-  return Check(c, expected_result);
-}
-
-float RunAndCheck(ur_kernel_handle_t kernel, ur_device_handle_t device, ur_context_handle_t context,
-                  std::vector<float>& a, std::vector<float>& b, std::vector<float>& c,
-                  unsigned size, float expected_result) {
-  PTI_ASSERT(kernel != nullptr);
-  PTI_ASSERT(device != nullptr);
-  PTI_ASSERT(context != nullptr);
-
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  PTI_ASSERT(b.size() == size * size);
-  PTI_ASSERT(c.size() == size * size);
-
-  ur_mem_handle_t dA, dB, dC;
-  UR_CHECK_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, size * size * sizeof(float),
-                                     nullptr, &dA));
-  UR_CHECK_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, size * size * sizeof(float),
-                                     nullptr, &dB));
-  UR_CHECK_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, size * size * sizeof(float),
-                                     nullptr, &dC));
-
-  UR_CHECK_SUCCESS(urKernelSetArgMemObj(kernel, 0, nullptr, dA));
-  UR_CHECK_SUCCESS(urKernelSetArgMemObj(kernel, 1, nullptr, dB));
-  UR_CHECK_SUCCESS(urKernelSetArgMemObj(kernel, 2, nullptr, dC));
-  UR_CHECK_SUCCESS(urKernelSetArgValue(kernel, 3, sizeof(size), nullptr, &size));
-
-  ur_queue_handle_t queue;
-  UR_CHECK_SUCCESS(urQueueCreate(context, device, nullptr, &queue));
-
-  float zero = 0;
-  UR_CHECK_SUCCESS(urEnqueueMemBufferFill(queue, dC, &zero, sizeof(zero), 0,
-                                          size * size * sizeof(float), 0, nullptr, nullptr));
-  UR_CHECK_SUCCESS(urEnqueueMemBufferWrite(queue, dA, true, 0, size * size * sizeof(float),
-                                           a.data(), 0, nullptr, nullptr));
-  UR_CHECK_SUCCESS(urEnqueueMemBufferWrite(queue, dB, true, 0, size * size * sizeof(float),
-                                           b.data(), 0, nullptr, nullptr));
-
-  const size_t gWorkOffset[] = {0, 0, 0};
-  const size_t gWorkSize[] = {size, size, size};
-  const size_t lWorkSize[] = {1, 1, 1};
-
-  ur_event_handle_t event;
-
-  // UR API Compatibility Matrix for urEnqueueKernelLaunch:
-  //
-  // Compiler Version | Signature
-  // -----------------|------------------------------------------------------------------
-  // < 2025.3         | (queue, kernel, dim, offset, global, local,
-  //                  |  num_events_in_wait_list, event_wait_list, event)
-  //                  |
-  // 2025.3           | (queue, kernel, dim, offset, global, local,
-  //                  |  num_events_in_wait_list, event_wait_list,
-  //                  |  num_sync_points_in_wait_list, sync_point_wait_list, event)
-  //                  | Added: sync point parameters after event_wait_list
-  //                  |
-  // 2026.0+          | (queue, kernel, dim, offset, global, local,
-  //                  |  kernel_launch_ext_properties,
-  //                  |  num_events_in_wait_list, event_wait_list, event)
-  //                  | Added: kernel_launch_ext_properties after lWorkSize
-  //                  | Removed: sync_point parameters (replaced by ext_properties)
-  //
-  // Note: event_wait_list parameter specifies events that must complete before
-  //       this kernel launch begins execution (for dependency ordering)
-  //
-  // Deprecated APIs removed in 2025.3+:
-  //   - urEnqueueKernelLaunchCustomExp
-  //   - urEnqueueCooperativeKernelLaunchExp
-  // But we still keep their ids - e.g. in sycl_collector.h kCoreApis
-  // as someone might run with previous compiler runtime
-
-#if defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0)
-  UR_CHECK_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 2, gWorkOffset, gWorkSize, lWorkSize,
-                                         /* kernel_launch_ext_properties */ nullptr,
-                                         /* num_events_in_wait_list */ 0,
-                                         /* event_wait_list */ nullptr, &event));
-#elif defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3)
-  UR_CHECK_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 2, gWorkOffset, gWorkSize, lWorkSize,
-                                         /* num_events_in_wait_list */ 0,
-                                         /* event_wait_list */ nullptr,
-                                         /* num_sync_points_in_wait_list */ 0,
-                                         /* sync_point_wait_list */ nullptr, &event));
-#else
-  UR_CHECK_SUCCESS(urEnqueueKernelLaunch(queue, kernel, 2, gWorkOffset, gWorkSize, lWorkSize,
-                                         /* num_events_in_wait_list */ 0,
-                                         /* event_wait_list */ nullptr, &event));
-#endif
-
-  UR_CHECK_SUCCESS(urEnqueueMemBufferRead(queue, dC, true, 0, size * size * sizeof(float), c.data(),
-                                          1, &event, nullptr));
-
-  UR_CHECK_SUCCESS(urQueueFinish(queue));
-
-  return Check(c, expected_result);
-}
-
-ur_result_t GetL0Adapter(std::vector<ur_adapter_handle_t>& adapters, unsigned int& idx) {
-  unsigned int index = 0;
-  for (auto adapter : adapters) {
-#if defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3) || defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0)
-    ur_backend_t backend;
-    UR_CHECK_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, sizeof(ur_backend_t),
-                                      &backend, nullptr));
-
-    if (backend == UR_BACKEND_LEVEL_ZERO) {
-#else
-    ur_adapter_backend_t backend;
-    UR_CHECK_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
-                                      sizeof(ur_adapter_backend_t), &backend, nullptr));
-    if (backend == UR_ADAPTER_BACKEND_LEVEL_ZERO) {
-#endif
-      idx = index;
-      return UR_RESULT_SUCCESS;
-    }
-    index++;
-  }
-  return UR_RESULT_ERROR_ADAPTER_SPECIFIC;
-}
-
-void ComputeUsingUr(std::vector<float>& a, std::vector<float>& b, std::vector<float>& c,
-                    unsigned size, unsigned repeat_count, float expected_result) {
-  PTI_ASSERT(size > 0 && repeat_count > 0);
-
-  ur_loader_config_handle_t loader_config = nullptr;
-  urLoaderInit(UR_DEVICE_INIT_FLAG_GPU, loader_config);
-
-  uint32_t count = 0;
-  uint32_t dcount = 0;
-
-  UR_CHECK_SUCCESS(urAdapterGet(0, nullptr, &count));
-  std::vector<ur_adapter_handle_t> adapters(count);
-  UR_CHECK_SUCCESS(urAdapterGet(count, adapters.data(), nullptr));
-
-  unsigned int idx;
-  UR_CHECK_SUCCESS(GetL0Adapter(adapters, idx));
-
-  std::vector<ur_platform_handle_t> platforms(count);
-#if defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2025_3) || defined(PTI_TESTS_INTEL_ONEAPI_CMPLR_2026_0)
-  UR_CHECK_SUCCESS(urPlatformGet(adapters[idx], 1, platforms.data(), nullptr));
-#else
-  UR_CHECK_SUCCESS(urPlatformGet(&adapters[idx], 1, 1, platforms.data(), nullptr));
-#endif
-
-  UR_CHECK_SUCCESS(urDeviceGet(platforms[0], UR_DEVICE_TYPE_GPU, 0, nullptr, &dcount));
-  std::vector<ur_device_handle_t> devices(dcount);
-  UR_CHECK_SUCCESS(
-      urDeviceGet(platforms.front(), UR_DEVICE_TYPE_GPU, dcount, devices.data(), nullptr));
-
-  ur_context_handle_t hContext;
-  UR_CHECK_SUCCESS(urContextCreate(1, &devices[0], nullptr, &hContext));
-
-  std::string module_name = "gemm.spv";
-  std::vector<uint8_t> spv = utils::LoadBinaryFile(utils::GetExecutablePath() + module_name);
-  if (spv.size() == 0) {
-    std::cout << "Unable to find module " << module_name << std::endl;
-    return;
-  }
-
-  ur_program_handle_t hProgram;
-  UR_CHECK_SUCCESS(urProgramCreateWithIL(hContext, spv.data(), spv.size(), nullptr, &hProgram));
-  UR_CHECK_SUCCESS(urProgramBuild(hContext, hProgram, nullptr));
-
-  ur_kernel_handle_t hKernel;
-  UR_CHECK_SUCCESS(urKernelCreate(hProgram, "GEMM", &hKernel));
-
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(hKernel, devices[0], hContext, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-}
-
-}  // namespace
-
-class MainUrFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override {  // Called right after constructor before each test
-    try {
-      dev_ = sycl::device(sycl::gpu_selector_v);
-      if (pti::test::utils::IsIntegratedGraphics(dev_)) {
-        is_integrated_graphics = true;
-      }
-    } catch (const sycl::exception& e) {
-      FAIL() << "Unable to select valid device to run tests on. Check your hardware, driver "
-                "install, or system configuration.";
-    }
-    buffer_cb_registered = true;
-    requested_buffer_calls = 0;
-    rejected_buffer_calls = 0;
-    completed_buffer_calls = 0;
-    completed_buffer_used_bytes = 0;
-    memory_view_record_created = false;
-    kernel_view_record_created = false;
-    sycl_runtime_record_created = false;
-    sycl_spv_special_rec_seen = false;
-    sycl_spv_kernel_seen = false;
-    sycl_spv_mem_buffer_fill_seen = false;
-    sycl_spv_mem_buffer_read_seen = false;
-    sycl_spv_mem_buffer_write_seen = false;
-    sycl_spv_mem_buffer_copy_seen = false;
-    memory_view_record_count = 0;
-    memory_view_record_with_zero_uuid = false;
-    kernel_view_record_count = 0;
-    sycl_runtime_record_count = 0;
-    capture_records = false;
-    copy_records.clear();
-    kernel_records.clear();
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-
-  // Class members commonly used by all tests in the test suite for MainFixture
-  unsigned size = 1024;
-
-  unsigned repeat_count = 1;
-
-  bool buffer_cb_registered = false;
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      ::operator delete(buf);
-      return;
-    }
-
-    completed_buffer_calls += 1;
-    completed_buffer_used_bytes = used_bytes;
-    uint8_t zero_uuid[PTI_MAX_DEVICE_UUID_SIZE];
-    memset(zero_uuid, 0, PTI_MAX_DEVICE_UUID_SIZE);
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        std::cerr << "Found Error Parsing Records from PTI" << '\n';
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          std::cout << "Found Invalid Record" << '\n';
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          memory_view_record_created = true;
-          memory_view_record_count += 1;
-          pti_view_record_memory_copy_type* rec =
-              reinterpret_cast<pti_view_record_memory_copy_type*>(ptr);
-          std::cout << " --- Found Memory Copy Record" << '\n';
-          samples_utils::DumpRecord(rec);
-
-          if (memcmp(rec->_device_uuid, zero_uuid, PTI_MAX_DEVICE_UUID_SIZE) == 0) {
-            if (!is_integrated_graphics) {
-              EXPECT_TRUE(false) << "Device UUID is zero, which is not expected";
-            }
-            memory_view_record_with_zero_uuid = true;
-          }
-          if (capture_records) {
-            copy_records.push_back(*rec);
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-          memory_view_record_created = true;
-          pti_view_record_memory_fill_type* rec =
-              reinterpret_cast<pti_view_record_memory_fill_type*>(ptr);
-          samples_utils::DumpRecord(rec);
-
-          if (memcmp(rec->_device_uuid, zero_uuid, PTI_MAX_DEVICE_UUID_SIZE) == 0) {
-            if (!is_integrated_graphics) {
-              EXPECT_TRUE(false) << "Device UUID is zero, which is not expected";
-            }
-            memory_view_record_with_zero_uuid = true;
-          }
-
-          memory_view_record_count += 1;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-          sycl_runtime_record_created = true;
-          sycl_runtime_record_count += 1;
-          if (capture_records) {
-            pti_view_record_api* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-            const char* pName = nullptr;
-            pti_result status =
-                ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id, &pName);
-            PTI_ASSERT(status == PTI_SUCCESS);
-            std::string function_name(pName);
-            if ((function_name.find("EnqueueKernelLaunch") != std::string::npos)) {
-              sycl_spv_kernel_seen = true;
-            } else if ((function_name.find("EnqueueMemBufferFill") != std::string::npos)) {
-              sycl_spv_mem_buffer_fill_seen = true;
-            } else if ((function_name.find("EnqueueMemBufferRead") != std::string::npos)) {
-              sycl_spv_mem_buffer_read_seen = true;
-            } else if ((function_name.find("EnqueueMemBufferWrite") != std::string::npos)) {
-              sycl_spv_mem_buffer_write_seen = true;
-            } else if ((function_name.find("EnqueueMemBufferCopy") != std::string::npos)) {
-              sycl_spv_mem_buffer_copy_seen = true;
-            } else if ((function_name.find("zeCommandListAppendLaunchKernel") !=
-                        std::string::npos)) {
-              sycl_spv_special_rec_seen = true;
-            }
-            break;
-          }
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          kernel_view_record_created = true;
-          kernel_view_record_count += 1;
-          if (capture_records) {
-            pti_view_record_kernel_type* rec = reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-            kernel_records.push_back(*rec);
-          }
-          break;
-        }
-        default: {
-          std::cerr << "This shouldn't happen" << '\n';
-          break;
-        }
-      }
-    }
-    ::operator delete(buf);
-  }
-
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_memory_copy_type);
-  }
-
-  void ComputeUsingSycl(std::vector<float>& a, std::vector<float>& b, std::vector<float>& c,
-                        unsigned size, unsigned repeat_count, float expected_result) {
-    sycl::queue q;
-    bool l0_backend_found = false;
-    for (auto platform : sycl::platform::get_platforms()) {
-      std::vector<sycl::device> gpu_devices = platform.get_devices();
-      if (platform.get_backend() == sycl::backend::ext_oneapi_level_zero) {
-        q = sycl::queue(gpu_devices[0]);
-        l0_backend_found = true;
-      }
-    }
-
-    PTI_ASSERT(l0_backend_found);
-    std::string module_name = "gemm.spv";
-    std::cout << utils::GetExecutablePath() + module_name << std::endl;
-    std::ifstream spv_stream(utils::GetExecutablePath() + module_name, std::ios::binary);
-    spv_stream.seekg(0, std::ios::end);
-    size_t sz = spv_stream.tellg();
-    spv_stream.seekg(0);
-    std::vector<std::byte> spv(sz);
-    spv_stream.read((char*)spv.data(), sz);
-
-    // Create a kernel bundle from the binary SPIR-V.
-    sycl::kernel_bundle<sycl::bundle_state::ext_oneapi_source> kb_src =
-        syclex::create_kernel_bundle_from_source(q.get_context(), syclex::source_language::spirv,
-                                                 spv);
-
-    // Build the SPIR-V module for our device.
-    sycl::kernel_bundle<sycl::bundle_state::executable> kb_exe = syclex::build(kb_src);
-
-    // Get a "kernel" object representing the kernel from the SPIR-V module.
-    sycl::kernel k = kb_exe.ext_oneapi_get_kernel("GEMM");
-
-    for (unsigned i = 0; i < repeat_count; ++i) {
-      float eps = RunAndCheckSycl(k, q, a, b, c, size, expected_result);
-      std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN")
-                << "CORRECT with accuracy: " << eps << std::endl;
-    }
-  }
-
-  int RunGemm(bool use_ur = false) {
-    PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-    PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-    PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-    PTI_CHECK_SUCCESS(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-
-    std::cout << "Level Zero Matrix Multiplication (matrix size: " << size << " x " << size
-              << ", repeats " << repeat_count << " times)" << std::endl;
-
-    std::vector<float> a(size * size, A_VALUE);
-    std::vector<float> b(size * size, B_VALUE);
-    std::vector<float> c(size * size, 0.0f);
-
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    if (use_ur) {
-      ComputeUsingUr(a, b, c, size, repeat_count, expected_result);
-    } else {
-      ComputeUsingSycl(a, b, c, size, repeat_count, expected_result);
-    }
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-    PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-    PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-    PTI_CHECK_SUCCESS(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-    auto flush_results = ptiFlushAllViews();
-    return flush_results;
-  }
-  sycl::device dev_;
-};
-
-TEST_F(MainUrFixtureTest, urGemmSpvKernelDetected) {
-  capture_records = true;
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm(true);
-  EXPECT_EQ(sycl_spv_kernel_seen, true);
-  EXPECT_EQ(sycl_spv_special_rec_seen, false);
-  EXPECT_EQ(sycl_spv_mem_buffer_fill_seen, true);
-  if (!is_integrated_graphics) {
-    EXPECT_EQ(memory_view_record_with_zero_uuid, false);
-  }
-}
-
-// TODO -- add tests for USMFill2D and USMMemcpy2D
-TEST_F(MainUrFixtureTest, syclGemmSpvRuntimeRecordsDetected) {
-  capture_records = true;
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunGemm();
-  EXPECT_EQ(sycl_spv_kernel_seen, true);
-  EXPECT_EQ(sycl_spv_special_rec_seen, false);
-  EXPECT_EQ(sycl_spv_mem_buffer_read_seen, true);
-  EXPECT_EQ(sycl_spv_mem_buffer_copy_seen, true);
-  if (!is_integrated_graphics) {
-    EXPECT_EQ(memory_view_record_with_zero_uuid, false);
-    EXPECT_EQ(sycl_spv_mem_buffer_write_seen, true);
-  }
-}
diff --git a/sdk/test/main_vecsqadd_fixture.cc b/sdk/test/main_vecsqadd_fixture.cc
deleted file mode 100644
index 7754b34d..00000000
--- a/sdk/test/main_vecsqadd_fixture.cc
+++ /dev/null
@@ -1,523 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Based on Vector Add example from OneAPI samples
-//==============================================================
-
-#include <gtest/gtest.h>
-
-#include <chrono>
-#include <cmath>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-
-namespace {
-
-enum class TestType {
-  kRunAll = 0,
-  kOverflowStress = 1,
-  kExternalCorrId = 2,
-};
-
-constexpr uint32_t kStressLoopCounter = 5;
-constexpr size_t kVectorSize = 5000;
-constexpr auto kStressWaitTime = std::chrono::seconds{5};
-
-bool timestamps_monotonic = true;
-uint64_t sycl_kernel_corr_id[3];
-uint64_t sycl_kernel_start_time[3];
-uint64_t kernel_corr_id[3];
-uint64_t kernel_append_time[3];
-uint64_t sycl_idx = 0;
-uint64_t kernel_idx = 0;
-uint64_t a_append_timestamp = 0;
-const uint64_t eid = 11;  // external correlation id base.
-const uint64_t eid_offset_vecSq = 20;
-
-// These structures are to store the correlation between the external annotations and
-// the runtime APIs calls and GPU kernel/mem ops
-std::map<uint32_t, std::pair<pti_view_external_kind, uint64_t> > external_corr_map;
-std::map<uint32_t, std::string> runtime_enq_2_gpu_kernel_name_map;
-std::map<uint32_t, std::string> runtime_enq_2_gpu_mem_op_name_map;
-
-//************************************
-// Vector square in SYCL on device: modifies each input vector
-//************************************
-template <typename T>
-void VecSq(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector) {
-  uint64_t ret_eid = 0;
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(
-                pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid + eid_offset_vecSq),
-            pti_result::PTI_SUCCESS);
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                            &ret_eid),
-            pti_result::PTI_SUCCESS);
-}
-
-template <typename T>
-void VecPassThroughToVecSq(sycl::queue &q, const std::vector<T> &a_vector,
-                           const std::vector<T> &b_vector) {
-  uint64_t ret_eid = 0;
-  // This external id(21) is ignored due to overriding push in the VecSq call it precedes.
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(
-                pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid + 10),
-            pti_result::PTI_SUCCESS);
-  VecSq(q, a_vector, b_vector);
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                            &ret_eid),
-            pti_result::PTI_SUCCESS);
-}
-
-//************************************
-// Vector add in SYCL on device: returns sum in 4th parameter "sq_add".
-//************************************
-template <typename T>
-void VecAdd(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector,
-            std::vector<T> &sq_add) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-  sycl::buffer sum_buf(sq_add.data(), num_items);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_only);
-    sycl::accessor b(b_buf, h, sycl::read_only);
-    sycl::accessor sum(sum_buf, h, sycl::write_only, sycl::no_init);
-    h.parallel_for(num_items, [=](auto i) { sum[i] = a[i] + b[i]; });
-  });
-  q.wait();
-}
-
-template <typename T>
-void PrintResults(const std::vector<T> &sq_add, int n) {
-  double sum = 0;
-  for (int i = 0; i < n; i++) sum += sq_add[i];
-  printf("final result: %f\n", sum / n);
-}
-
-void StartTracing() {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-}
-
-// Submits one trivial kernel and drains the view buffers, so that the records left in
-// the global maps afterwards belong to this launch only.
-template <typename T>
-void RunSingleKernelAndFlush(sycl::queue &q, std::vector<T> &v) {
-  {
-    sycl::buffer v_buf(v);
-    q.submit([&](sycl::handler &h) {
-      sycl::accessor a(v_buf, h, sycl::read_write);
-      h.parallel_for(sycl::range<1>{v.size()}, [=](auto i) { a[i] = a[i] + static_cast<T>(1); });
-    });
-    q.wait();
-  }
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-}
-
-// Checks every external correlation record collected so far carries `expected_kind` and
-// `expected_id`, and returns how many were inspected so the caller can reject a vacuous
-// pass. PTI never emits external correlation records on its own: every one traces back to
-// a ptiViewPushExternalCorrelationId call, so any other kind here is a real failure.
-size_t CountExternalIdsAndExpectAllAre(pti_view_external_kind expected_kind, uint64_t expected_id) {
-  size_t inspected = 0;
-  for (const auto &entry : external_corr_map) {
-    EXPECT_EQ(entry.second.first, expected_kind)
-        << "correlation id " << entry.first << " carries the wrong external kind";
-    EXPECT_EQ(entry.second.second, expected_id)
-        << "correlation id " << entry.first << " carries the wrong external id";
-    inspected++;
-  }
-  return inspected;
-}
-
-void StopTracing() {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-}
-
-static void BufferRequested(unsigned char **buf, size_t *buf_size) {
-  *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-  void *ptr = ::operator new(*buf_size);
-  ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-  *buf = reinterpret_cast<unsigned char *>(ptr);
-  if (!*buf) {
-    std::abort();
-  }
-  return;
-}
-
-static void BufferCompleted(unsigned char *buf, size_t buf_size, size_t valid_buf_size) {
-  if (!buf_size || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    if (valid_buf_size) {
-      ::operator delete(buf);
-    }
-    return;
-  }
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        pti_view_record_external_correlation *rec =
-            reinterpret_cast<pti_view_record_external_correlation *>(ptr);
-        external_corr_map[rec->_correlation_id] = std::pair{rec->_external_kind, rec->_external_id};
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        [[maybe_unused]] pti_view_record_overhead *record =
-            reinterpret_cast<pti_view_record_overhead *>(ptr);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        pti_view_record_memory_copy_type *rec =
-            reinterpret_cast<pti_view_record_memory_copy_type *>(ptr);
-        runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = rec->_name;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        pti_view_record_memory_fill_type *rec =
-            reinterpret_cast<pti_view_record_memory_fill_type *>(ptr);
-        runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = rec->_name;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        pti_view_record_api *rec = reinterpret_cast<pti_view_record_api *>(ptr);
-        const char *pName = nullptr;
-        pti_result status =
-            ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id, &pName);
-        PTI_ASSERT(status == PTI_SUCCESS);
-        std::string function_name(pName);
-        if ((sycl_idx < 2) && (function_name.find("EnqueueKernelLaunch") != std::string::npos)) {
-          sycl_kernel_corr_id[sycl_idx] = rec->_correlation_id;
-          sycl_kernel_start_time[sycl_idx] = rec->_start_timestamp;
-          sycl_idx++;
-        };
-        if (function_name.find("EnqueueKernel") != std::string::npos) {
-          runtime_enq_2_gpu_kernel_name_map[rec->_correlation_id] = "unknown_at_this_point";
-        }
-        if (function_name.find("EnqueueMem") != std::string::npos) {
-          runtime_enq_2_gpu_mem_op_name_map[rec->_correlation_id] = "unknown_at_this_point";
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        pti_view_record_kernel_type *a_kernel_rec =
-            reinterpret_cast<pti_view_record_kernel_type *>(ptr);
-        std::string kernel_name = a_kernel_rec->_name;
-        runtime_enq_2_gpu_kernel_name_map[a_kernel_rec->_correlation_id] = kernel_name;
-        std::cout << "Found Kernel: " << kernel_name << '\n';
-        if ((kernel_idx < 2) && (kernel_name.find("VecSq") != std::string::npos)) {
-          kernel_corr_id[kernel_idx] = a_kernel_rec->_correlation_id;
-          kernel_append_time[kernel_idx] = a_kernel_rec->_append_timestamp;
-          kernel_idx++;
-        }
-        if ((kernel_idx < 2) && (kernel_name.find("VecAdd") != std::string::npos)) {
-          kernel_corr_id[kernel_idx] = a_kernel_rec->_correlation_id;
-          kernel_append_time[kernel_idx] = a_kernel_rec->_append_timestamp;
-          kernel_idx++;
-        }
-        std::cout << "KernelTimestamp for VecAdd: " << a_kernel_rec->_append_timestamp << "\n";
-        timestamps_monotonic =
-            timestamps_monotonic && (a_append_timestamp < a_kernel_rec->_append_timestamp);
-        a_append_timestamp = a_kernel_rec->_append_timestamp;
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  ::operator delete(buf);
-}
-
-template <typename T>
-void RunExternalCorrIdTest(sycl::queue &q, const std::vector<T> &a, const std::vector<T> &b,
-                           const std::vector<T> &c, const std::vector<T> &d, std::vector<T> &sq_add,
-                           std::vector<T> &sq_add2) {
-  StartTracing();
-  VecPassThroughToVecSq(q, a, b);
-  StopTracing();
-  VecAdd(q, a, b, sq_add);
-  PrintResults(sq_add, kVectorSize);
-
-  VecAdd(q, a, b, sq_add);
-  PrintResults(sq_add, kVectorSize);
-
-  StartTracing();
-  VecAdd(q, c, d, sq_add2);
-  StopTracing();
-  PrintResults(sq_add2, 2 * kVectorSize);
-}
-
-template <typename T>
-void RunOverflowStressTest(sycl::queue &q, [[maybe_unused]] const std::vector<T> &a,
-                           [[maybe_unused]] const std::vector<T> &b, const std::vector<T> &c,
-                           const std::vector<T> &d, [[maybe_unused]] std::vector<T> &sq_add,
-                           std::vector<T> &sq_add2) {
-  StartTracing();
-  // kStressLoopCounter value of 17500 works to drive the collection time to 24hours+.
-  // TODO: Do we really need this? As it stands, this isn't really a stress test.
-  for (uint32_t i = 0; i < kStressLoopCounter; i++) {
-    VecAdd(q, c, d, sq_add2);
-    std::this_thread::sleep_for(kStressWaitTime);
-  }
-  StopTracing();
-}
-
-template <typename T>
-void VecSqAddRouter(sycl::queue &sycl_queue, TestType a_test_type) {
-  uint64_t ret_eid = 0;
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(
-                pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid),
-            pti_result::PTI_SUCCESS);
-  std::vector<T> a(kVectorSize);
-  std::vector<T> b(kVectorSize);
-  std::vector<T> c(2 * kVectorSize);
-  std::vector<T> d(2 * kVectorSize);
-  std::vector<T> sq_add(kVectorSize);
-  std::vector<T> sq_add2(2 * kVectorSize);
-
-  for (size_t i = 0; i < kVectorSize; i++) {
-    a[i] = std::sin(i);
-    b[i] = std::cos(i);
-    c[2 * i] = std::sin(i) * std::sin(i);
-    c[2 * i + 1] = std::sin(i);
-    d[2 * i] = std::cos(i) * std::cos(i);
-    d[2 * i + 1] = std::cos(i);
-  }
-
-  if (a_test_type == TestType::kRunAll) {
-    RunExternalCorrIdTest(sycl_queue, a, b, c, d, sq_add, sq_add2);
-    RunOverflowStressTest(sycl_queue, a, b, c, d, sq_add, sq_add2);
-  }
-
-  if (a_test_type == TestType::kExternalCorrId) {
-    RunExternalCorrIdTest(sycl_queue, a, b, c, d, sq_add, sq_add2);
-  }
-
-  if (a_test_type == TestType::kOverflowStress) {
-    RunOverflowStressTest(sycl_queue, a, b, c, d, sq_add, sq_add2);
-  }
-
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3,
-                                            &ret_eid),
-            pti_result::PTI_SUCCESS);
-}
-
-void RunVecsqadd(TestType a_test_type) {
-  auto d_selector{sycl::gpu_selector_v};
-  sycl::property_list prop{sycl::property::queue::in_order()};
-  sycl::queue q(d_selector, prop);
-
-  if (q.get_device().has(sycl::aspect::fp64)) {
-    VecSqAddRouter<double>(q, a_test_type);
-  } else {
-    VecSqAddRouter<float>(q, a_test_type);
-  }
-
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-}
-
-enum CollectionMode { kModeFull = 0, kModeHybrid = 1, kModeLocal = 2 };
-
-}  // namespace
-
-class VecsqaddFixtureTest : public ::testing::TestWithParam<CollectionMode> {
- protected:
-  void SetUp() override {
-    timestamps_monotonic = true;
-    a_append_timestamp = 0;
-    external_corr_map.clear();
-    runtime_enq_2_gpu_kernel_name_map.clear();
-    runtime_enq_2_gpu_mem_op_name_map.clear();
-    CollectionMode _collection_mode = GetParam();
-    // while passed ModeLocal local it is expected it will be selected automatically of course
-    // in case introspection API is available
-    if (_collection_mode != CollectionMode::kModeLocal) {
-      utils::SetEnv("PTI_COLLECTION_MODE", std::to_string(_collection_mode).c_str());
-    }
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-};
-
-TEST_P(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSq) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kExternalCorrId);
-  uint64_t correlation_id = kernel_corr_id[0];
-  // Check that the correlation id of runtime and kernel matches
-  EXPECT_EQ(sycl_kernel_corr_id[0], correlation_id);
-  // Check time ordering
-  EXPECT_LE(sycl_kernel_start_time[0], kernel_append_time[0]);
-  // Check that correlation id belongs to specific passed external kind and id
-  EXPECT_NE(external_corr_map.find(correlation_id), external_corr_map.end());
-  EXPECT_EQ(external_corr_map[correlation_id].first,
-            pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3);
-  EXPECT_EQ(external_corr_map[correlation_id].second, eid + eid_offset_vecSq);
-  // Check that the kernel name and mem op name are as expected
-  EXPECT_NE(runtime_enq_2_gpu_kernel_name_map[correlation_id].find("VecSq"), std::string::npos);
-  for (auto &elem : runtime_enq_2_gpu_mem_op_name_map) {
-    EXPECT_NE(elem.second.find("Copy"), std::string::npos);
-  }
-}
-
-// Simplest external correlation nesting case, exercised on the plain View API with no
-// Callback API subscriber involved: push(outer) then push(inner) with no pop in between
-// must label subsequent work with the *inner* id, and popping the inner id must restore
-// the outer one rather than leave the stack empty or keep reporting the inner id.
-TEST_P(VecsqaddFixtureTest, ExternalCorrelationIdNestsAndRestoresOuterId) {
-  constexpr auto kKind = pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3;
-  constexpr uint64_t kOuterId = 0x11;
-  constexpr uint64_t kInnerId = 0x12;
-
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-
-  sycl::queue q(sycl::gpu_selector_v, sycl::property_list{sycl::property::queue::in_order()});
-  std::vector<float> v(kVectorSize, 1.0F);
-
-  StartTracing();
-
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(kKind, kOuterId), pti_result::PTI_SUCCESS);
-  external_corr_map.clear();
-  RunSingleKernelAndFlush(q, v);
-  EXPECT_GT(CountExternalIdsAndExpectAllAre(kKind, kOuterId), 0U)
-      << "no external correlation records were collected for the outer id";
-
-  // A second push with no intervening pop: the inner id takes over from here on.
-  ASSERT_EQ(ptiViewPushExternalCorrelationId(kKind, kInnerId), pti_result::PTI_SUCCESS);
-  external_corr_map.clear();
-  RunSingleKernelAndFlush(q, v);
-  EXPECT_GT(CountExternalIdsAndExpectAllAre(kKind, kInnerId), 0U)
-      << "no external correlation records were collected for the inner id";
-
-  uint64_t popped_id = 0;
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(kKind, &popped_id), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(popped_id, kInnerId);
-
-  // Nesting, not reset: the outer id is live again after the inner one is popped.
-  external_corr_map.clear();
-  RunSingleKernelAndFlush(q, v);
-  EXPECT_GT(CountExternalIdsAndExpectAllAre(kKind, kOuterId), 0U)
-      << "no external correlation records were collected after popping the inner id";
-
-  popped_id = 0;
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(kKind, &popped_id), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(popped_id, kOuterId);
-
-  ASSERT_EQ(ptiViewPopExternalCorrelationId(kKind, &popped_id),
-            pti_result::PTI_ERROR_EXTERNAL_ID_QUEUE_EMPTY);
-
-  StopTracing();
-}
-
-void EnableIndividualRuntimeApis() {
-  ASSERT_EQ(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                    pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id),
-            pti_result::PTI_SUCCESS);
-}
-
-TEST_P(VecsqaddFixtureTest, CorrelationIdsAndExternalCorrelationMatchForSqReducedOps) {
-  utils::SetEnv("PTI_VIEW_RUNTIME_API", "1");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EnableIndividualRuntimeApis();
-  RunVecsqadd(TestType::kExternalCorrId);
-  uint64_t correlation_id = kernel_corr_id[0];
-  // Check that the correlation id of runtime and kernel matches
-  EXPECT_EQ(sycl_kernel_corr_id[0], correlation_id);
-  // Check time ordering
-  EXPECT_LE(sycl_kernel_start_time[0], kernel_append_time[0]);
-  // Check that correlation id belongs to specific passed external kind and id
-  EXPECT_NE(external_corr_map.find(correlation_id), external_corr_map.end());
-  EXPECT_EQ(external_corr_map[correlation_id].first,
-            pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3);
-  EXPECT_EQ(external_corr_map[correlation_id].second, eid + eid_offset_vecSq);
-  // Check that the kernel name and mem op name are as expected
-  EXPECT_NE(runtime_enq_2_gpu_kernel_name_map[correlation_id].find("VecSq"), std::string::npos);
-  for (auto &elem : runtime_enq_2_gpu_mem_op_name_map) {
-    EXPECT_NE(elem.second.find("Copy"), std::string::npos);
-  }
-}
-
-TEST_P(VecsqaddFixtureTest, CorrelationIdsMatchForAdd) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kExternalCorrId);
-  // Check that the correlation id of runtime and kernel matches
-  EXPECT_EQ(sycl_kernel_corr_id[1], kernel_corr_id[1]);
-  // Check time ordering
-  EXPECT_LE(sycl_kernel_start_time[1], kernel_append_time[1]);
-}
-
-TEST_P(VecsqaddFixtureTest, CorrelationIdsMatchForAddReducedOps) {
-  utils::SetEnv("PTI_VIEW_RUNTIME_API", "1");
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EnableIndividualRuntimeApis();
-  RunVecsqadd(TestType::kExternalCorrId);
-  // Check that the correlation id of runtime and kernel matches
-  EXPECT_EQ(sycl_kernel_corr_id[1], kernel_corr_id[1]);
-  // Check time ordering
-  EXPECT_LE(sycl_kernel_start_time[1], kernel_append_time[1]);
-}
-
-TEST_P(VecsqaddFixtureTest, TimestampWrapAroundOnOverflow) {
-  // TODO: Move this to the fixture if we get more stress tests. However, for now this is our only
-  // one so we will soft disable it until it is enabled in CI.
-  const auto result = utils::GetEnv("PTI_ENABLE_STRESS_TESTS");
-
-  if (result.empty() || result != "1") {
-    GTEST_SKIP() << "Skipping timestamp wrap around test. set PTI_ENABLE_STRESS_TESTS=1 to enable "
-                    "stress tests.";
-  }
-
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunVecsqadd(TestType::kOverflowStress);
-  EXPECT_EQ(timestamps_monotonic, true);
-}
-
-INSTANTIATE_TEST_SUITE_P(VecSqAddSuite, VecsqaddFixtureTest,
-                         ::testing::Values(CollectionMode::kModeFull, CollectionMode::kModeLocal,
-                                           CollectionMode::kModeHybrid));
diff --git a/sdk/test/main_zegemm_fixture.cc b/sdk/test/main_zegemm_fixture.cc
deleted file mode 100644
index 07b8eda6..00000000
--- a/sdk/test/main_zegemm_fixture.cc
+++ /dev/null
@@ -1,1279 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#include <fmt/format.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-#include <math.h>
-#include <string.h>
-
-#include <array>
-#include <chrono>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <sycl/kernel_bundle.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-#include "utils/ze_config_info.h"
-#include "ze_utils.h"
-
-#define ALIGN 64
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-namespace {
-
-constexpr size_t kPtiDeviceId = 0;  // run on first device
-
-// Value to check if the duration diff between the two similar H2D transfers is within reasonable
-// limits
-constexpr float kExpectedHeuristicMaxRelativeTimeDifference = 2.f;
-
-uint64_t eid_ = 11;
-size_t requested_buffer_calls = 0;
-size_t rejected_buffer_calls = 0;  // Buffer requests that are called and rejected by the API
-size_t completed_buffer_calls = 0;
-size_t completed_buffer_used_bytes = 0;
-bool memory_view_record_created = false;
-bool kernel_view_record_created = false;
-uint64_t memory_view_record_count = 0;
-uint64_t kernel_view_record_count = 0;
-bool buffer_size_atleast_largest_record = false;
-bool ze_initialization_succeeded = false;
-bool capture_records = false;
-bool special_record_seen = false;
-[[maybe_unused]] bool synchronization_record_seen = false;
-bool synchronization_record_barrier_exec_seen = false;
-bool synchronization_record_barrier_mem_seen = false;
-bool synchronization_record_fence_exec_seen = false;
-bool synchronization_record_event_seen = false;
-bool synchronization_record_clist_seen = false;
-bool synchronization_record_cqueue_seen = false;
-uint32_t synchronization_barrier_event_number = 0;
-uint32_t synch_clist_record_api_group = 0;
-void* synch_clist_record_context = nullptr;
-void* synch_cqueue_record_queue = nullptr;
-void* synch_event_record_context = nullptr;
-void* synch_event_record_event = nullptr;
-void* synch_fence_record_context = nullptr;
-void* synch_fence_record_queue = nullptr;
-void* synch_fence_record_event = nullptr;
-void* synch_barrier_record_context = nullptr;
-void* synch_barrier_record_event = nullptr;
-void* synch_barrier_record_queue = nullptr;
-void* synch_input_event = nullptr;
-void* synch_input_context = nullptr;
-void* synch_input_queue = nullptr;
-const char* barrier_exec_api_name = nullptr;
-const char* barrier_mem_ranges_api_name = nullptr;
-const char* fence_api_name = nullptr;
-uint32_t synch_input_event_number = 0;
-[[maybe_unused]] uint32_t synchronization_record_number = 0;
-bool sycl_runtime_launch_seen = false;
-bool zecall_record_seen = false;
-bool external_corrid_record_seen = false;
-uint32_t num_special_records = 0;
-uint32_t num_sycl_runtime_launch_records = 0;
-uint64_t corrid_in_special_record = 0;
-uint64_t external_corrid_in_ext_rec = 0;
-std::vector<pti_view_record_memory_copy_type> copy_records;
-std::vector<pti_view_record_kernel_type> kernel_records;
-ze_device_uuid_t device_uuid = {};
-ze_context_handle_t context_test = nullptr;
-[[maybe_unused]] ze_device_handle_t device_test = nullptr;
-ze_command_queue_handle_t queue_test_kernel = nullptr;
-ze_command_queue_handle_t queue_test_mem_copy = nullptr;
-
-// TODO - make the enable type param more generic (maybe a bitmap of somesort) so that we can enable
-// a mishmash of types
-void StartTracing(bool include_sycl_runtime = false, bool include_zecalls = false,
-                  bool include_gpu_kernels = true, bool include_synch = false) {
-  std::cout << "Starting Tracing with options: " << " include_sycl_runtime="
-            << (include_sycl_runtime ? "true" : "false")
-            << " include_zecalls=" << (include_zecalls ? "true" : "false")
-            << " include_gpu_kernels=" << (include_gpu_kernels ? "true" : "false")
-            << " include_synch=" << (include_synch ? "true" : "false") << std::endl;
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-  if (include_gpu_kernels) {
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-  if (include_sycl_runtime) ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  if (include_zecalls) ASSERT_EQ(ptiViewEnable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-  if (include_synch)
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_SYNCHRONIZATION), pti_result::PTI_SUCCESS);
-}
-
-void StopTracing(bool include_sycl_runtime = false, bool include_zecalls = false,
-                 bool include_gpu_kernels = true, bool include_synch = false) {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_EXTERNAL_CORRELATION), pti_result::PTI_SUCCESS);
-  if (include_gpu_kernels) {
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  }
-  if (include_synch)
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_SYNCHRONIZATION), pti_result::PTI_SUCCESS);
-  if (include_sycl_runtime)
-    ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-  if (include_zecalls) ASSERT_EQ(ptiViewDisable(PTI_VIEW_DRIVER_API), pti_result::PTI_SUCCESS);
-}
-
-float Check(const std::vector<float>& a, float value) {
-  PTI_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-  return eps / a.size();
-}
-
-float RunWithPollingAndCheck(ze_kernel_handle_t kernel, ze_device_handle_t device,
-                             ze_context_handle_t context, const std::vector<float>& a,
-                             const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                             float expected_result) {
-  PTI_ASSERT(kernel != nullptr);
-  PTI_ASSERT(device != nullptr);
-  PTI_ASSERT(context != nullptr);
-
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  PTI_ASSERT(b.size() == size * size);
-  PTI_ASSERT(c.size() == size * size);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t group_size[3] = {0};
-  status = zeKernelSuggestGroupSize(kernel, size, size, 1, &(group_size[0]), &(group_size[1]),
-                                    &(group_size[2]));
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if ((size % group_size[0]) != 0 || (size % group_size[1]) != 0) {
-    std::cout << "Non-uniform workgroups are not supported" << std::endl;
-    return 0.0f;
-  }
-
-  std::cout << "Sizes and return values: " << size << " : " << group_size[0] << " : "
-            << group_size[1] << " : " << group_size[2] << "\n";
-  uint32_t compute_queue_ordinal = 0;
-  uint32_t copy_queue_ordinal = 0;
-  if (0 != pti::test::utils::level_zero::GetGroupOrdinals(device, compute_queue_ordinal,
-                                                          copy_queue_ordinal)) {
-    // no compute or copy queue group found
-    return 0.0f;
-  }
-  std::cout << "Compute Queue Ordinal: " << compute_queue_ordinal << std::endl;
-  std::cout << "Copy Queue Ordinal: " << copy_queue_ordinal << std::endl;
-
-  ze_command_queue_desc_t cmd_queue_desc_copy = {ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-                                                 nullptr,
-                                                 copy_queue_ordinal,
-                                                 0,
-                                                 ZE_COMMAND_QUEUE_FLAG_IN_ORDER,
-                                                 ZE_COMMAND_QUEUE_MODE_DEFAULT,
-                                                 ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-  ze_command_queue_desc_t cmd_queue_desc_kernel = {ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-                                                   nullptr,
-                                                   compute_queue_ordinal,
-                                                   0,
-                                                   ZE_COMMAND_QUEUE_FLAG_IN_ORDER,
-                                                   ZE_COMMAND_QUEUE_MODE_DEFAULT,
-                                                   ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-
-  ze_command_list_handle_t cmd_list_copy = nullptr;
-  ze_command_list_handle_t cmd_list_kernel = nullptr;
-  status = zeCommandListCreateImmediate(context, device, &cmd_queue_desc_copy, &cmd_list_copy);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  queue_test_mem_copy = reinterpret_cast<ze_command_queue_handle_t>(cmd_list_copy);
-
-  status = zeCommandListCreateImmediate(context, device, &cmd_queue_desc_kernel, &cmd_list_kernel);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  synch_input_context = context;
-
-  queue_test_kernel = reinterpret_cast<ze_command_queue_handle_t>(cmd_list_kernel);
-
-  void* dev_a = nullptr;
-  ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr, 0, 0};
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  void* dev_b = nullptr;
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  void* dev_c = nullptr;
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeKernelSetGroupSize(kernel, group_size[0], group_size[1], group_size[2]);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeKernelSetArgumentValue(kernel, 0, sizeof(dev_a), &dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 1, sizeof(dev_a), &dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 2, sizeof(dev_a), &dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 3, sizeof(size), &size);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  // No Timestamp information in the Pool
-  ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                          ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 3};
-  ze_event_pool_handle_t event_pool = nullptr;
-  status = zeEventPoolCreate(context, &event_pool_desc, 0, nullptr, &event_pool);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_event_handle_t event_mem_copy1 = nullptr;
-  ze_event_handle_t event_mem_copy2 = nullptr;
-  ze_event_handle_t event_kernel = nullptr;
-  ze_event_desc_t event_desc_copy1 = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0, 0, 0};
-  ze_event_desc_t event_desc_copy2 = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 1, 0, 0};
-  ze_event_desc_t event_desc_kernel = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 2, 0, 0};
-  zeEventCreate(event_pool, &event_desc_copy1, &event_mem_copy1);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  zeEventCreate(event_pool, &event_desc_copy2, &event_mem_copy2);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  zeEventCreate(event_pool, &event_desc_kernel, &event_kernel);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  std::cout << "Event Mem Copy 1: " << event_mem_copy1 << std::endl;
-  std::cout << "Event Mem Copy 2: " << event_mem_copy2 << std::endl;
-  std::cout << "Event Kernel: " << event_kernel << std::endl;
-
-  status = zeCommandListAppendMemoryCopy(cmd_list_copy, dev_a, a.data(),
-                                         size * size * sizeof(float), event_mem_copy1, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeCommandListAppendMemoryCopy(cmd_list_copy, dev_b, b.data(),
-                                         size * size * sizeof(float), event_mem_copy2, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  // Trying to simulate oneCCL behavior we saw in traces: event is polled until it is ready
-  // No synchronization is used, just polling
-  // And destroyed as soon as it is ready
-  // This fragment could be changed after we discover more on oneCCL behavior
-  ze_result_t status1 = ZE_RESULT_NOT_READY;
-  ze_result_t status2 = ZE_RESULT_NOT_READY;
-  while (status1 != ZE_RESULT_SUCCESS && status2 != ZE_RESULT_SUCCESS) {
-    status1 = zeEventQueryStatus(event_mem_copy1);
-    status2 = zeEventQueryStatus(event_mem_copy2);
-  }
-
-  ze_group_count_t dim = {size / group_size[0], size / group_size[1], 1};
-  status = zeCommandListAppendLaunchKernel(cmd_list_kernel, kernel, &dim, event_kernel, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status1 = zeEventDestroy(event_mem_copy1);
-  PTI_ASSERT(status1 == ZE_RESULT_SUCCESS);
-  status2 = zeEventDestroy(event_mem_copy2);
-  PTI_ASSERT(status2 == ZE_RESULT_SUCCESS);
-
-  status = zeEventHostSynchronize(event_kernel, UINT32_MAX);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status2 = zeEventDestroy(event_kernel);
-  PTI_ASSERT(status2 == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list_copy, c.data(), dev_c,
-                                         size * size * sizeof(float), nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListHostSynchronize(cmd_list_copy, UINT32_MAX);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListDestroy(cmd_list_copy);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeCommandListDestroy(cmd_list_kernel);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeMemFree(context, dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeMemFree(context, dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeMemFree(context, dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeEventPoolDestroy(event_pool);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return Check(c, expected_result);
-}
-
-float RunAndCheck(ze_kernel_handle_t kernel, ze_device_handle_t device, ze_context_handle_t context,
-                  const std::vector<float>& a, const std::vector<float>& b, std::vector<float>& c,
-                  unsigned size, float expected_result) {
-  PTI_ASSERT(kernel != nullptr);
-  PTI_ASSERT(device != nullptr);
-  PTI_ASSERT(context != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  // TODO -- uncomment this test call after confirming support in L0 driver.
-  //      -- current status (loader 1.20.0) returns ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-  // status = zeContextSystemBarrier(context, device);
-  // PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  PTI_ASSERT(b.size() == size * size);
-  PTI_ASSERT(c.size() == size * size);
-
-  uint32_t group_size[3] = {0};
-  status = zeKernelSuggestGroupSize(kernel, size, size, 1, &(group_size[0]), &(group_size[1]),
-                                    &(group_size[2]));
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if ((size % group_size[0]) != 0 || (size % group_size[1]) != 0) {
-    std::cout << "Non-uniform workgroups are not supported" << std::endl;
-    return 0.0f;
-  }
-
-  void* dev_a = nullptr;
-  ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr, 0, 0};
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  void* dev_b = nullptr;
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  void* dev_c = nullptr;
-  status =
-      zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float), ALIGN, device, &dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeKernelSetGroupSize(kernel, group_size[0], group_size[1], group_size[2]);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeKernelSetArgumentValue(kernel, 0, sizeof(dev_a), &dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 1, sizeof(dev_a), &dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 2, sizeof(dev_a), &dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeKernelSetArgumentValue(kernel, 3, sizeof(size), &size);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_command_list_desc_t cmd_list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-  ze_command_list_handle_t cmd_list = nullptr;
-  status = zeCommandListCreate(context, device, &cmd_list_desc, &cmd_list);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_a, a.data(), size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  // std::vector<const void *> ranges{dev_a, a};
-  std::vector<const void*> ranges{dev_a};
-  std::vector<size_t> range_sizes{a.size()};
-  // memory_ranges_barrier for memory coherency after copy to device memory
-  status = zeCommandListAppendMemoryRangesBarrier(cmd_list, ranges.size(), range_sizes.data(),
-                                                  ranges.data(), nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_b, b.data(), size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_event_pool_desc_t event_pool_desc = {
-      ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-      ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-  ze_event_pool_handle_t event_pool = nullptr;
-  status = zeEventPoolCreate(context, &event_pool_desc, 0, nullptr, &event_pool);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0, ZE_EVENT_SCOPE_FLAG_HOST,
-                                ZE_EVENT_SCOPE_FLAG_HOST};
-  ze_event_handle_t event = nullptr;
-  status = zeEventCreate(event_pool, &event_desc, &event);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_group_count_t dim = {size / group_size[0], size / group_size[1], 1};
-  status = zeCommandListAppendLaunchKernel(cmd_list, kernel, &dim, event, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 1, &event);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  synch_input_event_number = 1;
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, c.data(), dev_c, size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListClose(cmd_list);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_command_queue_desc_t cmd_queue_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0, ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-      ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-  ze_command_queue_handle_t cmd_queue = nullptr;
-  status = zeCommandQueueCreate(context, device, &cmd_queue_desc, &cmd_queue);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS && cmd_queue != nullptr);
-  synch_input_queue = cmd_queue;
-
-  ze_fence_desc_t fence_desc = {ZE_STRUCTURE_TYPE_FENCE_DESC, nullptr, 0};
-  ze_fence_handle_t fence_handle;
-  status = zeFenceCreate(cmd_queue, &fence_desc, &fence_handle);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  queue_test_mem_copy = static_cast<ze_command_queue_handle_t>(cmd_queue);
-  queue_test_kernel = static_cast<ze_command_queue_handle_t>(cmd_queue);
-
-  status = zeCommandQueueExecuteCommandLists(cmd_queue, 1, &cmd_list, fence_handle);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeFenceHostSynchronize(fence_handle, UINT32_MAX);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeEventHostSynchronize(event, UINT32_MAX);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  synch_input_event = event;
-  synch_input_context = context;
-  status = zeCommandQueueSynchronize(cmd_queue, UINT32_MAX);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandQueueDestroy(cmd_queue);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeCommandListDestroy(cmd_list);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeMemFree(context, dev_a);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeMemFree(context, dev_b);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeMemFree(context, dev_c);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_device_properties_t props{};
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  status = zeDeviceGetProperties(device, &props);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  ze_kernel_timestamp_result_t timestamp{};
-  status = zeEventQueryKernelTimestamp(event, &timestamp);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeEventDestroy(event);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-  status = zeEventPoolDestroy(event_pool);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  double time = static_cast<double>(timestamp.global.kernelEnd - timestamp.global.kernelStart) /
-                props.timerResolution;
-  std::cout << "Matrix multiplication time: " << time << " sec" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-void ComputeUsingSycl(std::vector<float>& a, unsigned repeat_count) {
-  sycl::queue q;
-  for (auto platform : sycl::platform::get_platforms()) {
-    std::vector<sycl::device> gpu_devices = platform.get_devices();
-    if (platform.get_backend() == sycl::backend::ext_oneapi_level_zero) {
-      q = sycl::queue(gpu_devices[0]);
-    }
-  }
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    for (unsigned i = 0; i < repeat_count; ++i) {
-      sycl::event event = q.submit([&](sycl::handler& cgh) {
-        auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-        cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-      });
-      q.wait_and_throw();
-    }
-  } catch (const sycl::exception& e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-void Compute(ze_device_handle_t device, ze_driver_handle_t driver, const std::vector<float>& a,
-             const std::vector<float>& b, std::vector<float>& c, unsigned size, unsigned iterations,
-             float expected_result, bool with_polling = false) {
-  PTI_ASSERT(device != nullptr && driver != nullptr);
-  PTI_ASSERT(size > 0 && iterations > 0);
-
-  std::string module_name = "gemm.spv";
-  std::cout << utils::GetExecutablePath() + module_name << std::endl;
-  std::vector<uint8_t> binary = utils::LoadBinaryFile(utils::GetExecutablePath() + module_name);
-  if (binary.size() == 0) {
-    std::cout << "Unable to find module " << module_name << std::endl;
-    return;
-  }
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_context_handle_t context = utils::ze::GetContext(driver);
-  PTI_ASSERT(context != nullptr);
-
-  context_test = context;
-  ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                  nullptr,
-                                  ZE_MODULE_FORMAT_IL_SPIRV,
-                                  static_cast<uint32_t>(binary.size()),
-                                  binary.data(),
-                                  nullptr,
-                                  nullptr};
-  ze_module_handle_t module = nullptr;
-  status = zeModuleCreate(context, device, &module_desc, &module, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS && module != nullptr);
-
-  ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, "GEMM"};
-  ze_kernel_handle_t kernel = nullptr;
-  status = zeKernelCreate(module, &kernel_desc, &kernel);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS && kernel != nullptr);
-
-  for (unsigned i = 0; i < iterations; ++i) {
-    float eps =
-        (with_polling)
-            ? RunWithPollingAndCheck(kernel, device, context, a, b, c, size, expected_result)
-            : RunAndCheck(kernel, device, context, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-
-  status = zeKernelDestroy(kernel);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeModuleDestroy(module);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  status = zeContextDestroy(context);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-}
-
-}  // namespace
-
-class MainZeFixtureTest : public ::testing::TestWithParam<std::tuple<bool, bool, bool, bool>> {
- protected:
-  void SetUp() override {  // Called right after constructor before each test
-    buffer_cb_registered = true;
-    requested_buffer_calls = 0;
-    rejected_buffer_calls = 0;
-    completed_buffer_calls = 0;
-    completed_buffer_used_bytes = 0;
-    memory_view_record_created = false;
-    kernel_view_record_created = false;
-    memory_view_record_count = 0;
-    kernel_view_record_count = 0;
-    capture_records = false;
-    special_record_seen = false;
-    synchronization_record_seen = false;
-    synchronization_record_barrier_exec_seen = false;
-    synchronization_record_barrier_mem_seen = false;
-    synchronization_record_fence_exec_seen = false;
-    synchronization_record_event_seen = false;
-    synchronization_record_clist_seen = false;
-    synchronization_record_cqueue_seen = false;
-    synchronization_barrier_event_number = 0;
-    synchronization_record_number = 0;
-    synch_clist_record_api_group = 0;
-    synch_clist_record_context = nullptr;
-    synch_cqueue_record_queue = nullptr;
-    synch_event_record_context = nullptr;
-    synch_event_record_event = nullptr;
-    synch_fence_record_context = nullptr;
-    synch_fence_record_queue = nullptr;
-    synch_fence_record_event = nullptr;
-    synch_barrier_record_context = nullptr;
-    synch_barrier_record_event = nullptr;
-    synch_barrier_record_queue = nullptr;
-    synch_input_context = nullptr;
-    synch_input_event = nullptr;
-    synch_input_event_number = 0;
-    sycl_runtime_launch_seen = false;
-    barrier_exec_api_name = nullptr;
-    barrier_mem_ranges_api_name = nullptr;
-    fence_api_name = nullptr;
-    zecall_record_seen = false;
-    external_corrid_record_seen = false;
-    num_special_records = 0;
-    num_sycl_runtime_launch_records = 0;
-    corrid_in_special_record = 0;
-    external_corrid_in_ext_rec = 0;
-    copy_records.clear();
-    kernel_records.clear();
-    device_uuid = {};
-    context_test = nullptr;
-    device_test = nullptr;
-    queue_test_kernel = nullptr;
-    queue_test_mem_copy = nullptr;
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-
-  // Class members commonly used by all tests in the test suite for MainFixture
-  unsigned size = 1024;
-
-  unsigned repeat_count = 1;
-
-  bool buffer_cb_registered = false;
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      ::operator delete(buf);
-      return;
-    }
-
-    completed_buffer_calls += 1;
-    completed_buffer_used_bytes = used_bytes;
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        std::cerr << "Found Error Parsing Records from PTI" << '\n';
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          std::cout << "Found Invalid Record" << '\n';
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-          memory_view_record_created = true;
-          memory_view_record_count += 1;
-          if (capture_records) {
-            std::cout << "--- Record Memory Copy" << '\n';
-            pti_view_record_memory_copy_type* rec =
-                reinterpret_cast<pti_view_record_memory_copy_type*>(ptr);
-            // std::cout << "---------------------------------------------------" << '\n';
-            // samples_utils::DumpRecord(rec);
-            uint64_t duration = rec->_end_timestamp - rec->_start_timestamp;
-            std::cout << "  Start: " << rec->_start_timestamp << '\n';
-            std::cout << "  End: " << rec->_end_timestamp << '\n';
-            std::cout << "  Duration: " << duration << '\n';
-            std::cout << "  Memcpy Type: " << rec->_memcpy_type << '\n';
-            ASSERT_EQ(std::memcmp(&rec->_device_uuid, &device_uuid, sizeof(ze_device_uuid_t)), 0);
-            ASSERT_EQ(context_test, reinterpret_cast<ze_context_handle_t>(rec->_context_handle));
-            ASSERT_EQ(queue_test_mem_copy,
-                      reinterpret_cast<ze_command_queue_handle_t>(rec->_queue_handle));
-            copy_records.push_back(*rec);
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-          memory_view_record_created = true;
-          memory_view_record_count += 1;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION: {
-          pti_view_record_synchronization* rec =
-              reinterpret_cast<pti_view_record_synchronization*>(ptr);
-          // std::cout << "---------------------------------------------------" << '\n';
-          // samples_utils::DumpRecord(rec);
-          synchronization_record_seen = true;
-          switch (rec->_synch_type) {
-            case pti_view_synchronization_type::
-                PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_EXECUTION: {
-              synchronization_record_barrier_exec_seen = true;
-              synch_barrier_record_context = rec->_context_handle;
-              synch_barrier_record_queue = rec->_queue_handle;
-              synch_barrier_record_event = rec->_event_handle;
-              synchronization_barrier_event_number = rec->_number_wait_events;
-              PTI_THROW(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, rec->_api_id,
-                                            &barrier_exec_api_name));
-            }; break;
-            case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_GPU_BARRIER_MEMORY: {
-              synch_barrier_record_context = rec->_context_handle;
-              synch_barrier_record_event = rec->_event_handle;
-              synchronization_record_barrier_mem_seen = true;
-              PTI_THROW(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, rec->_api_id,
-                                            &barrier_mem_ranges_api_name));
-            }; break;
-            case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_FENCE: {
-              synchronization_record_fence_exec_seen = true;
-              synch_fence_record_context = rec->_context_handle;
-              synch_fence_record_event = rec->_event_handle;
-              synch_fence_record_queue = rec->_queue_handle;
-              PTI_THROW(ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_LEVELZERO, rec->_api_id,
-                                            &fence_api_name));
-            }; break;
-            case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_EVENT: {
-              synchronization_record_event_seen = true;
-              synch_event_record_context = rec->_context_handle;
-              synch_event_record_event = rec->_event_handle;
-            }; break;
-            case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_LIST: {
-              synchronization_record_clist_seen = true;
-              synch_clist_record_api_group = rec->_api_group;
-              if (!synch_clist_record_context)
-                synch_clist_record_context = rec->_context_handle;  // capture the 1st one for test
-            }; break;
-            case pti_view_synchronization_type::PTI_VIEW_SYNCHRONIZATION_TYPE_HOST_COMMAND_QUEUE: {
-              synchronization_record_cqueue_seen = true;
-              synch_cqueue_record_queue = rec->_queue_handle;
-              // synch_cqueue_record_context = rec->_context_handle;
-            }; break;
-            default:
-              break;
-          }
-          synchronization_record_number++;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-          pti_view_record_external_correlation* aExtRec =
-              reinterpret_cast<pti_view_record_external_correlation*>(ptr);
-          external_corrid_record_seen = true;
-          if (!special_record_seen) external_corrid_in_ext_rec = aExtRec->_correlation_id;
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-          pti_view_record_api* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          const char* api_name = nullptr;
-          if (rec->_api_group == pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_LEVELZERO) {
-            pti_result status = ptiViewGetApiIdName(
-                pti_api_group_id::PTI_API_GROUP_HYBRID_SYCL_LEVELZERO, rec->_api_id, &api_name);
-            PTI_ASSERT(status == PTI_SUCCESS);
-            std::string function_name(api_name);
-            std::cout << "--- Record Special Sycl: " << rec->_correlation_id << ": "
-                      << function_name << '\n';
-            if (strcmp(api_name, "zeCommandListAppendLaunchKernel") == 0) {
-              special_record_seen = true;
-              num_special_records++;
-              corrid_in_special_record = rec->_correlation_id;
-            }
-          } else {
-            pti_result status =
-                ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id, &api_name);
-            PTI_ASSERT(status == PTI_SUCCESS);
-            std::string function_name(api_name);
-            if ((function_name.find("EnqueueKernelLaunch") != std::string::npos)) {
-              sycl_runtime_launch_seen = true;
-              num_sycl_runtime_launch_records++;
-            }
-          }
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DRIVER_API: {
-          [[maybe_unused]] pti_view_record_api* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-          zecall_record_seen = true;
-          // std::cout << "---------------------------------------------------" << '\n';
-          // samples_utils::DumpRecord(rec);
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          kernel_view_record_created = true;
-          kernel_view_record_count += 1;
-          pti_view_record_kernel_type* rec = reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-          // std::cout << "---------------------------------------------------" << '\n';
-          // samples_utils::DumpRecord(rec);
-          if (capture_records) {
-            std::cout << "--- Record Kernel: " << rec->_name << '\n';
-            std::cout << "  Cid: " << rec->_correlation_id << '\n';
-            uint64_t duration = rec->_end_timestamp - rec->_start_timestamp;
-            std::cout << "  Start: " << rec->_start_timestamp << '\n';
-            std::cout << "  End: " << rec->_end_timestamp << '\n';
-            std::cout << "  Duration: " << duration << '\n';
-            ASSERT_EQ(std::memcmp(&rec->_device_uuid, &device_uuid, sizeof(ze_device_uuid_t)), 0);
-            ASSERT_EQ(context_test, reinterpret_cast<ze_context_handle_t>(rec->_context_handle));
-            ASSERT_EQ(queue_test_kernel,
-                      reinterpret_cast<ze_command_queue_handle_t>(rec->_queue_handle));
-            kernel_records.push_back(*rec);
-          }
-          break;
-        }
-        default: {
-          std::cerr << "This shouldn't happen" << '\n';
-          break;
-        }
-      }
-    }
-    ::operator delete(buf);
-  }
-  static void NullBufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = sizeof(pti_view_record_memory_copy_type) - sizeof(pti_view_record_memory_copy_type);
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    rejected_buffer_calls += 1;
-    *buf = static_cast<unsigned char*>(ptr);
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_memory_copy_type);
-  }
-
-  static void InadequateBufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = 1;  // buffer size should be less than the smallest size.
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    rejected_buffer_calls += 1;
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_memory_copy_type);
-  }
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-    void* ptr = ::operator new(*buf_size);
-    requested_buffer_calls += 1;
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-    buffer_size_atleast_largest_record = (*buf_size) >= sizeof(pti_view_record_memory_copy_type);
-  }
-
-  int RunGemm(bool with_polling = false, bool include_sycl_runtime = false,
-              bool include_zecalls = false, bool include_gpu_kernels = true, bool add_sycl = false,
-              bool include_synch = false) {
-    // TODO(PTI): Switch to zeInitDrivers
-    auto status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    ze_initialization_succeeded = (status == ZE_RESULT_SUCCESS);
-
-    ze_device_handle_t device = utils::ze::GetGpuDevice(kPtiDeviceId);
-    device_test = device;
-
-    ze_driver_handle_t driver = utils::ze::GetGpuDriver(kPtiDeviceId);
-    if (device == nullptr || driver == nullptr) {
-      std::cout << "Unable to find GPU device" << std::endl;
-      return 0;
-    }
-
-    if (!utils::ze::GetDeviceUuid(device, device_uuid.id)) {
-      std::cout << "Unable to get device UUID" << std::endl;
-      return 1;
-    }
-
-    if (with_polling) {
-      std::cout << "Running with Polling" << std::endl;
-    }
-
-    StartTracing(include_sycl_runtime, include_zecalls, include_gpu_kernels, include_synch);
-
-    std::cout << "Level Zero Matrix Multiplication (matrix size: " << size << " x " << size
-              << ", repeats " << repeat_count << " times)" << std::endl;
-    std::cout << "Target device: " << utils::ze::GetDeviceName(device) << std::endl;
-
-    std::vector<float> a(size * size, A_VALUE);
-    std::vector<float> b(size * size, B_VALUE);
-    std::vector<float> c(size * size, 0.0f);
-    StopTracing(include_sycl_runtime, include_zecalls, include_gpu_kernels, include_synch);
-
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * static_cast<float>(size);
-
-    StartTracing(include_sycl_runtime, include_zecalls, include_gpu_kernels, include_synch);
-    PTI_CHECK_SUCCESS(ptiViewPushExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, eid_));
-
-    Compute(device, driver, a, b, c, size, repeat_count, expected_result, with_polling);
-    if (add_sycl) {
-      ComputeUsingSycl(a, repeat_count);
-    }
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    PTI_CHECK_SUCCESS(ptiViewPopExternalCorrelationId(
-        pti_view_external_kind::PTI_VIEW_EXTERNAL_KIND_CUSTOM_3, &eid_));
-    StopTracing(include_sycl_runtime, include_zecalls, include_gpu_kernels, include_synch);
-
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-    auto flush_results = ptiFlushAllViews();
-    return flush_results;
-  }
-};
-
-/**
- * This test body uses directly L0 API to simulate one of oneCCL behaviors
- * It creates two immediate command lists, do not synchronize on events but rather poll them and
- * destroy them after they found signaled
- * so it verified that such case profiled correctly
- *
- * This test is to be skipped if Local Profiling is not available,
- * Because this test specifics are
- * 1) not having "usual" synchronization but rather rely on events polling,
- * 2) destroying events as soon as they are signaled
- * and such case is not handled by Full API Profiling mode implementation so far -
- * as Full API Profiling mode doesn't create any special events but rather relies on
- * intercepting EventPool creation and so making all events with Timestamp property
- *
- */
-TEST_F(MainZeFixtureTest, ProfilingSucceededWhenEventPolling) {
-  if (pti_result::PTI_SUCCESS != ptiViewGPULocalAvailable()) {
-    GTEST_SKIP();
-  }
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  capture_records = true;
-  repeat_count = 1;
-  EXPECT_EQ(RunGemm(true), 0);
-  EXPECT_EQ(copy_records.size(), static_cast<std::size_t>(3));
-  auto m2d_1 = static_cast<std::size_t>(-1);
-  auto m2d_2 = static_cast<std::size_t>(-1);
-  for (std::size_t i = 0; i < copy_records.size(); i++) {
-    if (copy_records[i]._memcpy_type == pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_M2D) {
-      if (m2d_1 == static_cast<std::size_t>(-1)) {
-        m2d_1 = i;
-      } else {
-        m2d_2 = i;
-        break;
-      }
-    }
-  }
-  EXPECT_EQ(m2d_1 != static_cast<std::size_t>(-1), true);
-  EXPECT_EQ(m2d_2 != static_cast<std::size_t>(-1), true);
-  EXPECT_NE(m2d_1, m2d_2);
-
-  // Check if the duration diff between the two similar H2D transfers is within some reasonable
-  // limits
-  std::cout << "Expected max difference between two similar M2D transfers: "
-            << kExpectedHeuristicMaxRelativeTimeDifference << std::endl;
-  uint64_t dur1 = copy_records[m2d_1]._end_timestamp - copy_records[m2d_1]._start_timestamp;
-  uint64_t dur2 = copy_records[m2d_2]._end_timestamp - copy_records[m2d_2]._start_timestamp;
-  std::cout << "Duration 1: " << dur1 << ", Duration 2: " << dur2 << std::endl;
-  float rel_diff = fabs(2.f * ((float)dur1 - (float)dur2) / ((float)dur1 + (float)dur2));
-  std::cout << "Relative difference between two similar M2D transfers: " << rel_diff << std::endl;
-  EXPECT_LT(rel_diff, kExpectedHeuristicMaxRelativeTimeDifference);
-  // Check if the kernel duration is greater than 0
-  EXPECT_EQ(kernel_records.size(), static_cast<std::size_t>(1));
-  EXPECT_GT(kernel_records[0]._end_timestamp, kernel_records[0]._start_timestamp);
-}
-
-TEST_F(MainZeFixtureTest, ZeInitializationSucceeded) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(ze_initialization_succeeded, true);
-}
-
-TEST_F(MainZeFixtureTest, NegTestBufferSizeAtleastLargestRecord) {
-  // Checks if ptiViewSetCallbacks rejects callback and using default
-  // or existing callbacks.
-  EXPECT_EQ(ptiViewSetCallbacks(InadequateBufferRequested, BufferCompleted),
-            pti_result::PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(RunGemm(), 0);
-  ASSERT_EQ(rejected_buffer_calls, 1 * repeat_count);
-}
-
-TEST_F(MainZeFixtureTest, BufferSizeAtleastLargestRecord) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  ASSERT_EQ(buffer_size_atleast_largest_record, true);
-}
-
-TEST_F(MainZeFixtureTest, BufferCallBacksRegistered) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(buffer_cb_registered, true);
-}
-
-TEST_F(MainZeFixtureTest, SecondCallbackCalled) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_GT(completed_buffer_used_bytes, static_cast<size_t>(0));
-}
-
-TEST_F(MainZeFixtureTest, MemoryViewRecordCreated) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(memory_view_record_created, true);
-}
-
-TEST_F(MainZeFixtureTest, KernelViewRecordCreated) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(kernel_view_record_created, true);
-}
-
-TEST_F(MainZeFixtureTest, NumberOfExpectedMemoryRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(memory_view_record_count, 3 * repeat_count);
-}
-
-TEST_F(MainZeFixtureTest, NumberOfExpectedKernelRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(kernel_view_record_count, 1 * repeat_count);
-}
-
-TEST_F(MainZeFixtureTest, RequestedAndCompletedBuffers) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(requested_buffer_calls, completed_buffer_calls);
-}
-
-TEST_F(MainZeFixtureTest, NegTestNullBufferSize) {
-  ASSERT_EQ(ptiViewSetCallbacks(NullBufferRequested, BufferCompleted),
-            pti_result::PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(RunGemm(), 0);
-  ASSERT_EQ(rejected_buffer_calls, 1 * repeat_count);
-}
-
-TEST_F(MainZeFixtureTest, TestCLImmediateSynch) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  EXPECT_EQ(RunGemm(true, true, true, true, false, true),
-            0);  // with_polling, sycl, zecalls, kernel and sych enabled
-
-  // CommandListSynchronization
-  EXPECT_EQ(synchronization_record_clist_seen, true);
-  EXPECT_EQ(synch_clist_record_context, synch_input_context);
-  EXPECT_EQ(synch_clist_record_api_group, 1ULL);
-}
-
-TEST_F(MainZeFixtureTest, AllSynchronizationRelated) {
-  // capture_records = true;
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(RunGemm(), 0);
-  const bool with_polling = false;
-  const bool sycl = false;
-  const bool zecalls = true;
-  const bool kernel = true;
-  const bool add_sycl = false;
-  const bool synch = true;
-  EXPECT_EQ(RunGemm(with_polling, sycl, zecalls, kernel, add_sycl, synch),
-            0);  // with_polling, sycl, zecalls, kernel and sych enabled
-
-  // FenceSynchronization
-  EXPECT_EQ(synchronization_record_fence_exec_seen, true);
-  EXPECT_EQ(synch_fence_record_event, nullptr);
-  EXPECT_EQ(synch_fence_record_context, synch_input_context);
-  EXPECT_EQ(synch_fence_record_queue, synch_input_queue);
-
-  // CommandQueueSynchronization
-  EXPECT_EQ(synch_cqueue_record_queue, synch_input_queue);
-
-  // EventHostSynchronization
-  EXPECT_EQ(synchronization_record_event_seen, true);
-  EXPECT_EQ(synch_event_record_event, synch_input_event);
-  EXPECT_EQ(synch_event_record_context, synch_input_context);
-
-  // BarrierExecSynchronization
-  EXPECT_EQ(synch_barrier_record_context, synch_input_context);
-  EXPECT_EQ(synch_barrier_record_queue, synch_input_queue);
-  EXPECT_EQ(synch_barrier_record_event, nullptr);
-  EXPECT_EQ(synchronization_barrier_event_number, synch_input_event_number);
-
-  // SampleSynchApiNamesSeen
-  EXPECT_EQ((std::strcmp(fence_api_name, "zeFenceHostSynchronize") == 0), true);
-  EXPECT_EQ(
-      (std::strcmp(barrier_mem_ranges_api_name, "zeCommandListAppendMemoryRangesBarrier") == 0),
-      true);
-  EXPECT_EQ((std::strcmp(barrier_exec_api_name, "zeCommandListAppendBarrier") == 0), true);
-
-  // AllSynchronizationRecordTypesSeen
-  EXPECT_EQ(synchronization_record_barrier_exec_seen, true);
-  EXPECT_EQ(synchronization_record_barrier_mem_seen, true);
-  EXPECT_EQ(synchronization_record_fence_exec_seen, true);
-  EXPECT_EQ(synchronization_record_event_seen, true);
-  EXPECT_EQ(synchronization_record_cqueue_seen, true);
-  // Since 0.15.1+ ExternalCorrelation records generated for both Sycl and Level-Zero runtime.
-  if (sycl || zecalls) {
-    EXPECT_EQ(external_corrid_record_seen, true);
-  }
-}
-
-TEST_F(MainZeFixtureTest, SyclBasedAndZeBasedKernelLaunchesPresent) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  // Enable sycl and kernel view kinds only. Additionally run Sycl based launch kernel.
-  EXPECT_EQ(RunGemm(false, true, false, true, true), 0);
-
-  // Special records feature removed - no longer generated
-  EXPECT_EQ(special_record_seen, false);
-  EXPECT_EQ(num_special_records, 0);
-
-  // SYCL runtime records still captured for SYCL-based kernel launches
-  EXPECT_EQ(sycl_runtime_launch_seen, true);
-  EXPECT_EQ(num_sycl_runtime_launch_records, repeat_count);
-
-  // Kernel view shows both SYCL-based and Ze-based launches
-  // But API records only captured for SYCL-based launches (zecalls disabled)
-  EXPECT_EQ(kernel_view_record_count, 2 * repeat_count);
-}
-
-// Zecalls Disabled, Sycl Enabled, no sycl api fires, gpu kernel enabled and fires
-TEST_P(MainZeFixtureTest, SpecialRecordPresent) {
-  // GetParam returns 4 valued tuple: values correspond to (from left to right)
-  //     whether we enable the viewkinds for --- sycl, zecalls, kernel, add_sycl.
-  auto [sycl, zecall, kernel, add_sycl] = GetParam();
-  bool with_polling = false;
-  bool synch = false;
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  // Polling, sycl, zecalls --- enabled/disabled
-  EXPECT_EQ(RunGemm(with_polling, sycl, zecall, kernel, add_sycl, synch), 0);
-  if (sycl == true && zecall == false && kernel == true) {
-    EXPECT_EQ(special_record_seen, false);
-    EXPECT_EQ(zecall_record_seen, zecall);
-  } else {
-    EXPECT_EQ(special_record_seen, false);
-    EXPECT_EQ(zecall_record_seen, zecall);
-    // Since 0.15.1+ ExternalCorrelation records generated for both Sycl and Level-Zero runtime
-    if (zecall || (sycl && add_sycl)) {
-      EXPECT_EQ(external_corrid_record_seen, true);
-    } else {
-      EXPECT_EQ(external_corrid_record_seen, false);
-      EXPECT_EQ(corrid_in_special_record, external_corrid_in_ext_rec);
-      EXPECT_EQ(corrid_in_special_record, 0UL);
-    }
-  }
-  /*
-    std::ostringstream oss;
-    oss << "SpecialRecordPresenceTest_enabled_values_" << sycl << ":" << zecall << ":" << kernel;
-    SCOPED_TRACE(oss.str());  // Set the test name for better readability on a failing test.
-  */
-}
-
-// Tuple values correspond to (from left to right) whether we enable the viewkinds for --- sycl,
-// zecalls, kernel, add_sycl
-INSTANTIATE_TEST_SUITE_P(MainZeTests, MainZeFixtureTest,
-                         ::testing::Values(std::make_tuple(true, false, true, true),
-                                           std::make_tuple(true, false, true, false),
-                                           std::make_tuple(true, false, false, false),
-                                           std::make_tuple(true, true, true, false),
-                                           std::make_tuple(false, false, true, false),
-                                           std::make_tuple(false, true, true, false)),
-
-                         [](const testing::TestParamInfo<MainZeFixtureTest::ParamType>& info) {
-                           return fmt::format("Sycl_{}_Zecall_{}_Kernel_{}_AddSycl_{}",
-                                              (std::get<0>(info.param) ? "Enabled" : "Disabled"),
-                                              (std::get<1>(info.param) ? "Enabled" : "Disabled"),
-                                              (std::get<2>(info.param) ? "Enabled" : "Disabled"),
-                                              (std::get<3>(info.param) ? "Enabled" : "Disabled"));
-                         });
-
-using pti::test::utils::CreateFullBuffer;
-using pti::test::utils::RecordInserts;
-
-class GetNextRecordTestSuite : public ::testing::Test {
- protected:
-  static constexpr std::size_t kNumMemRecs = 15;
-  static constexpr std::size_t kNumExtRecs = 100;
-  static constexpr std::size_t kNumKernelRecs = 3;
-  static constexpr std::size_t kNumOhRecs = 1;
-  static constexpr std::size_t kTotalRecs =
-      2 * kNumOhRecs + 2 * kNumMemRecs + kNumKernelRecs + kNumExtRecs;
-  GetNextRecordTestSuite()
-      : test_buf_(CreateFullBuffer<RecordInserts<pti_view_record_overhead, kNumOhRecs>,
-                                   RecordInserts<pti_view_record_memory_copy_type, kNumMemRecs>,
-                                   RecordInserts<pti_view_record_memory_fill_type, kNumMemRecs>,
-                                   RecordInserts<pti_view_record_external_correlation, kNumExtRecs>,
-                                   RecordInserts<pti_view_record_kernel_type, kNumKernelRecs>,
-                                   RecordInserts<pti_view_record_overhead, kNumOhRecs>>()) {}
-  std::vector<unsigned char> test_buf_;
-};
-
-TEST_F(GetNextRecordTestSuite, NullBufferTest) {
-  pti_view_record_base* current_record = nullptr;
-  auto result = ptiViewGetNextRecord(nullptr, 0, &current_record);
-  ASSERT_EQ(result, pti_result::PTI_STATUS_END_OF_BUFFER);
-}
-
-TEST_F(GetNextRecordTestSuite, NullBufferBadSizeTest) {
-  pti_view_record_base* current_record = nullptr;
-  auto result = ptiViewGetNextRecord(nullptr, static_cast<std::size_t>(-1), &current_record);
-  ASSERT_EQ(result, pti_result::PTI_STATUS_END_OF_BUFFER);
-}
-
-TEST_F(GetNextRecordTestSuite, NullRecordBufferTest) {
-  auto result = ptiViewGetNextRecord(test_buf_.data(), test_buf_.size(), nullptr);
-  ASSERT_EQ(result, pti_result::PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(GetNextRecordTestSuite, NullRecordBadSizeBufferTest) {
-  auto result = ptiViewGetNextRecord(nullptr, static_cast<std::size_t>(-1), nullptr);
-  ASSERT_EQ(result, pti_result::PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(GetNextRecordTestSuite, CheckBufferEndTest) {
-  pti_view_record_base* current_record = nullptr;
-  std::size_t total_records = 0;
-  while (true) {
-    auto result = ptiViewGetNextRecord(test_buf_.data(), test_buf_.size(), &current_record);
-    if (result == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      EXPECT_NE(current_record, nullptr);
-      break;
-    }
-    total_records++;
-  }
-  EXPECT_EQ(total_records, kTotalRecs);
-  auto result = ptiViewGetNextRecord(test_buf_.data(), test_buf_.size(), &current_record);
-
-  EXPECT_NE(current_record, nullptr);
-  ASSERT_EQ(result, pti_result::PTI_STATUS_END_OF_BUFFER);
-}
-
-TEST_F(GetNextRecordTestSuite, RegularParseRecordsTest) {
-  pti_view_record_base* current_record = nullptr;
-  std::size_t total_records = 0;
-  std::size_t number_of_memory_copies = 0;
-  std::size_t number_of_kernel = 0;
-  std::size_t number_of_overhead = 0;
-  while (true) {
-    auto result = ptiViewGetNextRecord(test_buf_.data(), test_buf_.size(), &current_record);
-    if (result == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (result == pti_result::PTI_ERROR_INTERNAL) {
-      FAIL();
-    }
-    if (result == pti_result::PTI_ERROR_BAD_ARGUMENT) {
-      FAIL();
-    }
-    total_records++;
-    if (current_record->_view_kind == PTI_VIEW_DEVICE_GPU_KERNEL) {
-      number_of_kernel++;
-    }
-    if (current_record->_view_kind == PTI_VIEW_DEVICE_GPU_MEM_COPY) {
-      number_of_memory_copies++;
-    }
-    if (current_record->_view_kind == PTI_VIEW_COLLECTION_OVERHEAD) {
-      number_of_overhead++;
-    }
-  }
-  EXPECT_EQ(number_of_memory_copies, kNumMemRecs);
-  EXPECT_EQ(number_of_overhead, 2 * kNumOhRecs);
-  EXPECT_EQ(number_of_kernel, kNumKernelRecs);
-  ASSERT_EQ(total_records, kTotalRecs);
-}
-
-TEST(PtiVersionTestSuite, TestVersionMacros) {
-  // Check against first public PTI version 0.1.0
-  EXPECT_GE(PTI_VERSION_MAJOR, 0);
-  EXPECT_GE(PTI_VERSION_MINOR, PTI_VERSION_MAJOR == 0 ? 1 : 0);
-  EXPECT_GE(PTI_VERSION_PATCH, 0);
-}
-
-TEST(PtiVersionTestSuite, TestVersionFunction) {
-  // Unit tests should be run against same version of header and lib
-  auto pti_ver = ptiVersion();
-  EXPECT_EQ(pti_ver._major, static_cast<uint32_t>(PTI_VERSION_MAJOR));
-  EXPECT_EQ(pti_ver._minor, static_cast<uint32_t>(PTI_VERSION_MINOR));
-  EXPECT_EQ(pti_ver._patch, static_cast<uint32_t>(PTI_VERSION_PATCH));
-}
-
-TEST(PtiVersionTestSuite, TestVersionString) {
-  using ::testing::ContainsRegex;
-  // Unit tests should be run against same version of header and lib
-#if !defined(WIN32)
-  constexpr const char* const test_version_regex = "^[0-9]+\\.[0-9]+\\.[0-9]+";
-#else
-  constexpr const char* const test_version_regex = "^\\d+\\.\\d+\\.\\d+";
-#endif
-  EXPECT_THAT(ptiVersionString(), ContainsRegex(test_version_regex));
-  EXPECT_STREQ(PTI_VERSION_STRING, ptiVersionString());
-}
diff --git a/sdk/test/mem_ops_test.cc b/sdk/test/mem_ops_test.cc
deleted file mode 100644
index d4759d6b..00000000
--- a/sdk/test/mem_ops_test.cc
+++ /dev/null
@@ -1,571 +0,0 @@
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <algorithm>
-#include <cstring>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "utils/pti_record_collection_fixture.h"
-#include "utils/sycl_config_info.h"
-#include "utils/sycl_usm_helper.h"
-
-namespace {
-constexpr uint64_t kMaxQueueId = static_cast<uint64_t>(PTI_INVALID_QUEUE_ID);
-
-constexpr const char* const kSubstringMemoryTypeDevice = "Device";
-constexpr const char* const kSubstringMemoryTypeShared = "Shared";
-constexpr const char* const kSubstringMemoryTypeHost = "Host";
-constexpr const char* const kSubstringMemoryTypeDriverAllocated = "Driver";
-constexpr const char* const kSubstringMemoryTypeUserAllocated = "User";
-
-bool p2p_d2d_record = false;
-bool p2p_d2s_record = false;
-bool p2p_s2d_record = false;
-bool p2p_s2s_record = false;
-bool memfill_m2s = false;
-bool memfill_m2d = false;
-bool sycl_memfill_seen = false;
-bool sycl_memcpy_seen = false;
-bool sycl_host_alloc_seen = false;
-bool sycl_device_alloc_seen = false;
-bool sycl_shared_alloc_seen = false;
-bool uuid_non_unique = false;
-bool memfill_uuid_zero = false;
-bool memcopy_type_valid = false;
-bool memsrc_type_valid = false;
-bool memdst_type_valid = false;
-bool non_p2p_d2d_exists = false;
-bool atleast_2_devices = false;
-bool p2p_device_access = false;
-bool memcopy_type_stringified = false;
-bool memcopy_type_p2p_stringified = false;
-bool memory_src_type_stringified = false;
-bool memory_src_type_p2p_stringified = false;
-bool memory_dst_type_stringified = false;
-bool memory_dst_type_p2p_stringified = false;
-bool queue_id_memp2p_records = false;
-}  // namespace
-
-void StartTracing() {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-void StopTracing() {
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-  *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-  void* ptr = ::operator new(*buf_size);
-  ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-  *buf = static_cast<unsigned char*>(ptr);
-}
-
-static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-  if (!buf || !used_bytes || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    ::operator delete(buf);
-    return;
-  }
-
-  pti_view_record_base* ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        [[maybe_unused]] auto* record =
-            reinterpret_cast<pti_view_record_external_correlation*>(ptr);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        [[maybe_unused]] auto* record = reinterpret_cast<pti_view_record_overhead*>(ptr);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        auto* rec = reinterpret_cast<pti_view_record_memory_copy*>(ptr);
-        std::string memcpy_name = rec->_name;
-        if (memcpy_name.find("D2D)") != std::string::npos) {
-          non_p2p_d2d_exists = true;
-          if (rec->_memcpy_type == pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_D2D) {
-            memcopy_type_valid = true;
-            memcopy_type_stringified =
-                (std::strcmp(ptiViewMemcpyTypeToString(rec->_memcpy_type), "D2D") == 0);
-          }
-          if (rec->_mem_src == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE) {
-            memsrc_type_valid = true;
-            memory_src_type_stringified = (std::strcmp(ptiViewMemoryTypeToString(rec->_mem_src),
-                                                       kSubstringMemoryTypeDevice) == 0);
-          }
-          if (rec->_mem_dst == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE) {
-            memdst_type_valid = true;
-            memory_dst_type_stringified = (std::strcmp(ptiViewMemoryTypeToString(rec->_mem_dst),
-                                                       kSubstringMemoryTypeDevice) == 0);
-          }
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P: {
-        auto* rec = reinterpret_cast<pti_view_record_memory_copy_p2p_type*>(ptr);
-        std::string memcpy_name = rec->_name;
-        if (memcpy_name.find("D2D - P2P") != std::string::npos) {
-          p2p_d2d_record = true;
-        }
-        if (memcpy_name.find("D2S - P2P") != std::string::npos) {
-          p2p_d2s_record = true;
-        }
-        if (memcpy_name.find("S2D - P2P") != std::string::npos) {
-          p2p_s2d_record = true;
-        }
-        if (memcpy_name.find("S2S - P2P") != std::string::npos) {
-          p2p_s2s_record = true;
-        }
-        if (rec->_sycl_queue_id != kMaxQueueId) {
-          queue_id_memp2p_records = true;
-        }
-        if (std::equal(std::begin(rec->_src_uuid), std::end(rec->_src_uuid),
-                       std::begin(rec->_dst_uuid))) {
-          uuid_non_unique = true;
-        }
-        if (p2p_d2s_record) {
-          if (rec->_memcpy_type == pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_D2S) {
-            memcopy_type_valid = true;
-            memcopy_type_p2p_stringified =
-                (std::strcmp(ptiViewMemcpyTypeToString(rec->_memcpy_type), "D2S") == 0);
-          }
-          if (rec->_mem_src == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE) {
-            memsrc_type_valid = true;
-            memory_src_type_p2p_stringified = (std::strcmp(ptiViewMemoryTypeToString(rec->_mem_src),
-                                                           kSubstringMemoryTypeDevice) == 0);
-          }
-          if (rec->_mem_dst == pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED) {
-            memdst_type_valid = true;
-            memory_dst_type_p2p_stringified = (std::strcmp(ptiViewMemoryTypeToString(rec->_mem_dst),
-                                                           kSubstringMemoryTypeShared) == 0);
-          }
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        const auto* rec = reinterpret_cast<const pti_view_record_memory_fill_type*>(ptr);
-        std::string tmp_str = rec->_name;
-        if (std::all_of(std::begin(rec->_device_uuid), std::end(rec->_device_uuid),
-                        [](auto raw_byte) { return raw_byte == 0; })) {
-          memfill_uuid_zero = true;
-        }
-        memfill_m2s = memfill_m2s || ((rec->_mem_type == PTI_VIEW_MEMORY_TYPE_SHARED) &&
-                                      (tmp_str.find("M2S") != std::string::npos));
-        memfill_m2d = memfill_m2d || ((rec->_mem_type == PTI_VIEW_MEMORY_TYPE_DEVICE) &&
-                                      (tmp_str.find("M2D") != std::string::npos));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        auto* rec = reinterpret_cast<pti_view_record_api*>(ptr);
-        const char* plain_function_name = nullptr;
-        pti_result status = ptiViewGetApiIdName(pti_api_group_id::PTI_API_GROUP_SYCL, rec->_api_id,
-                                                &plain_function_name);
-        ASSERT_EQ(status, pti_result::PTI_SUCCESS);
-        std::string function_name(plain_function_name);
-        if ((function_name.find("EnqueueUSMFill") != std::string::npos) ||
-            (function_name.find("USMEnqueueMemset") != std::string::npos)) {
-          sycl_memfill_seen = true;
-        } else if ((function_name.find("EnqueueUSMMemcpy") != std::string::npos) ||
-                   (function_name.find("USMEnqueueMemcpy") != std::string::npos)) {
-          sycl_memcpy_seen = true;
-        } else if ((function_name.find("DeviceAlloc") != std::string::npos)) {
-          sycl_device_alloc_seen = true;
-        } else if ((function_name.find("SharedAlloc") != std::string::npos)) {
-          sycl_shared_alloc_seen = true;
-        } else if ((function_name.find("HostAlloc") != std::string::npos)) {
-          sycl_host_alloc_seen = true;
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        [[maybe_unused]] pti_view_record_kernel_type* rec =
-            reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  ::operator delete(buf);
-}
-
-void P2pTest() {
-  StartTracing();
-
-  sycl::platform platform(sycl::gpu_selector_v);
-
-  std::vector<sycl::queue> gpu_queues;
-  std::vector<float*> host_ptrs;
-  std::vector<float*> gpu_device_ptrs;
-  std::vector<float*> gpu_shared_ptrs;
-  std::vector<sycl::context> gpu_context;
-  size_t num_root_devices = 0;
-
-  try {
-    std::vector<sycl::device> gpu_devices = platform.get_devices();
-    num_root_devices = gpu_devices.size();
-    std::cout << "Number of Root Devices: " << num_root_devices << "\n";
-    sycl::property_list prop{sycl::property::queue::in_order()};
-    for (size_t i = 0; i < num_root_devices; i++) {
-      gpu_context.push_back(sycl::context(gpu_devices[i]));
-      gpu_queues.push_back(sycl::queue(gpu_context[i], gpu_devices[i], prop));
-      gpu_device_ptrs.push_back(
-          static_cast<float*>(malloc_device(num_root_devices * sizeof(float), gpu_queues[i])));
-      gpu_shared_ptrs.push_back(
-          static_cast<float*>(malloc_shared(num_root_devices * sizeof(float), gpu_queues[i])));
-      host_ptrs.push_back(
-          static_cast<float*>(malloc_host(num_root_devices * sizeof(float), gpu_queues[i])));
-      // std::cout << "memset for root device#: " << i << std::endl;
-      gpu_queues[i].memset(gpu_device_ptrs[i], 0, num_root_devices * sizeof(float)).wait();
-      gpu_queues[i].memset(gpu_shared_ptrs[i], 0, num_root_devices * sizeof(float)).wait();
-    }
-  } catch (const sycl::exception& e) {
-    FAIL() << "[ERROR] " << e.what();
-  }
-  if (num_root_devices > 0) {
-    // This forces a non-p2p D2D record --- memcpy same device for testing purposes.
-    gpu_queues[0]
-        .memcpy(gpu_device_ptrs[0], gpu_device_ptrs[0], num_root_devices * sizeof(float))
-        .wait();
-  }
-  if (num_root_devices > 1) {
-    atleast_2_devices = true;
-    ze_bool_t p2p_access = 0;
-    uint32_t connected_dev1 = 0;
-    uint32_t connected_dev2 = 1;
-    for (uint32_t i = 0; i < num_root_devices; i++) {
-      auto* src_dev_backend_handle =
-          sycl::get_native<sycl::backend::ext_oneapi_level_zero>(gpu_queues[i].get_device());
-      for (uint32_t j = 0; j < num_root_devices; j++) {
-        if (i == j) {
-          continue;
-        }
-        auto* dst_dev_backend_handle =
-            sycl::get_native<sycl::backend::ext_oneapi_level_zero>(gpu_queues[j].get_device());
-
-        if (src_dev_backend_handle && dst_dev_backend_handle &&
-            (src_dev_backend_handle != dst_dev_backend_handle)) {
-          auto status =
-              zeDeviceCanAccessPeer(src_dev_backend_handle, dst_dev_backend_handle, &p2p_access);
-          ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-          if (p2p_access) {
-            p2p_device_access = true;
-            connected_dev1 = i;
-            connected_dev2 = j;
-            break;
-          }
-        }
-      }
-      if (p2p_device_access) {
-        std::cout << "Connected devices: " << connected_dev1 << ":" << connected_dev2 << std::endl;
-        break;
-      }
-    }
-
-    //"MemCopy D2D"
-    gpu_queues[connected_dev2]
-        .memcpy(gpu_device_ptrs[connected_dev2], gpu_device_ptrs[connected_dev1],
-                num_root_devices * sizeof(float))
-        .wait();
-    //"MemCopy D2S"
-    gpu_queues[connected_dev1]
-        .memcpy(gpu_shared_ptrs[connected_dev1], gpu_device_ptrs[connected_dev2],
-                num_root_devices * sizeof(float))
-        .wait();
-    //"MemCopy S2D"
-    gpu_queues[connected_dev1]
-        .memcpy(gpu_device_ptrs[connected_dev1], gpu_shared_ptrs[connected_dev2],
-                num_root_devices * sizeof(float))
-        .wait();
-    //"MemCopy S2S"
-    gpu_queues[connected_dev2]
-        .memcpy(gpu_shared_ptrs[connected_dev2], gpu_shared_ptrs[connected_dev1],
-                num_root_devices * sizeof(float))
-        .wait();
-  }
-  StopTracing();
-  ASSERT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-  for (uint32_t i = 0; i < num_root_devices; i++) {
-    sycl::free(gpu_device_ptrs[i], gpu_context[i]);
-    sycl::free(gpu_shared_ptrs[i], gpu_context[i]);
-    sycl::free(host_ptrs[i], gpu_context[i]);
-  }
-}
-
-class MemoryOperationFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    p2p_d2d_record = false;
-    p2p_d2s_record = false;
-    p2p_s2d_record = false;
-    p2p_s2s_record = false;
-    memfill_m2s = false;
-    memfill_m2d = false;
-    sycl_memfill_seen = false;
-    sycl_memcpy_seen = false;
-    sycl_host_alloc_seen = false;
-    sycl_device_alloc_seen = false;
-    sycl_shared_alloc_seen = false;
-    uuid_non_unique = false;
-    memfill_uuid_zero = false;
-    memcopy_type_valid = false;
-    memsrc_type_valid = false;
-    memdst_type_valid = false;
-    non_p2p_d2d_exists = false;
-    atleast_2_devices = false;
-    p2p_device_access = false;
-    memcopy_type_stringified = false;
-    memcopy_type_p2p_stringified = false;
-    memory_src_type_stringified = false;
-    memory_src_type_p2p_stringified = false;
-    memory_dst_type_stringified = false;
-    memory_dst_type_p2p_stringified = false;
-    queue_id_memp2p_records = false;
-  }
-
-  void TearDown() override {}
-};
-
-TEST_F(MemoryOperationFixtureTest, P2PMemoryCopyRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  if (!atleast_2_devices)
-    GTEST_SKIP() << "This system does not have at least 2 Level0 gpu devices for P2P tests\n";
-  if (!p2p_device_access)
-    GTEST_SKIP() << "This system does not have a direct p2p connection between devices\n";
-  ASSERT_EQ(p2p_d2d_record, true);
-  ASSERT_EQ(p2p_d2s_record, true);
-  ASSERT_EQ(p2p_s2d_record, true);
-  ASSERT_EQ(p2p_s2s_record, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, P2PuuidUniqueEachDevicePerP2P) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  if (!atleast_2_devices)
-    GTEST_SKIP() << "This system does not have at least 2 Level0 gpu devices for P2P tests\n";
-  if (!p2p_device_access)
-    GTEST_SKIP() << "This system does not have a direct p2p connection between devices\n";
-  ASSERT_EQ(uuid_non_unique, false);
-}
-
-// Detect the nonp2p -- device to same device memcpy
-TEST_F(MemoryOperationFixtureTest, NonP2PD2D) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(non_p2p_d2d_exists, true);
-}
-
-// Detect the nonp2p -- device to same device memcpy stringified types
-TEST_F(MemoryOperationFixtureTest, NonP2PD2DStringified) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memcopy_type_stringified, true);
-  ASSERT_EQ(memory_src_type_stringified, true);
-  ASSERT_EQ(memory_dst_type_stringified, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemFilluuidDeviceNonZero) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memfill_uuid_zero, false);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemCopyTypeDevice) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memcopy_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemSrcTypeDevice) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memsrc_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemDstTypeDevice) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memdst_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemCopyTypeP2PDevice) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memcopy_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemSrcTypeShared) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memsrc_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemDstTypeShared) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memdst_type_valid, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemFillDstTypeSharedPresent) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memfill_m2s, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, MemFillDstTypeDevicePresent) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  ASSERT_EQ(memfill_m2d, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, P2PD2DStringified) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  if (!atleast_2_devices)
-    GTEST_SKIP() << "This system does not have at least 2 Level0 gpu devices for P2P tests\n";
-  ASSERT_EQ(memcopy_type_p2p_stringified, true);
-  ASSERT_EQ(memory_src_type_p2p_stringified, true);
-  ASSERT_EQ(memory_dst_type_p2p_stringified, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, P2PQueueIdPresent) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  if (!atleast_2_devices)
-    GTEST_SKIP() << "This system does not have at least 2 Level0 gpu devices for P2P tests\n";
-  ASSERT_EQ(queue_id_memp2p_records, true);
-}
-
-TEST_F(MemoryOperationFixtureTest, SyclRuntimeRecordsDetected) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  P2pTest();
-  EXPECT_EQ(sycl_host_alloc_seen, true);
-  EXPECT_EQ(sycl_device_alloc_seen, true);
-  EXPECT_EQ(sycl_shared_alloc_seen, true);
-  EXPECT_EQ(sycl_memfill_seen, true);
-  EXPECT_EQ(sycl_memcpy_seen, true);
-}
-
-// TODO(PTI): Right now, each member of MemoryOperationFixtureTests runs the
-// same P2pTest, which is way overkill for simple memory functional tests. This new fixture will run
-// each scenario independently.
-class MemoryOperationTest : public ::pti::test::utils::RecordCollectionFixture {
- protected:
-  void SetUp() override {
-    try {
-      const sycl::property_list prop_list{
-          sycl::property::queue::in_order(),
-          sycl::ext::intel::property::queue::immediate_command_list()};
-      queue_ = sycl::queue(sycl::gpu_selector_v, prop_list);
-    } catch (const sycl::exception& e) {
-      GTEST_SKIP() << "No SYCL device or queue available: " << e.what();
-    } catch (...) {
-      FAIL() << "Unknown exception during SYCL device or queue creation.";
-    }
-  }
-
-  sycl::queue queue_;
-};
-
-TEST_F(MemoryOperationTest, SuccessfulMemFillDriverAllocated) {
-  InitCollection();
-  EnableViews(PTI_VIEW_DEVICE_GPU_MEM_FILL);
-  constexpr std::size_t kVecSize = 64;
-  auto host_vector = pti::test::utils::CreateHostUsmVector<int>(queue_, kVecSize);
-  queue_.memset(host_vector.get(), 0, kVecSize * sizeof(int)).wait();
-  FinalizeCollection();
-  EXPECT_EQ(std::size(record_storage_.memfill_records), 1);
-  const auto memtype = record_storage_.memfill_records[0]->_mem_type;
-  EXPECT_EQ(memtype, PTI_VIEW_MEMORY_TYPE_HOST);
-  EXPECT_THAT(ptiViewMemoryTypeToString(memtype),
-              ::testing::AllOf(::testing::HasSubstr(kSubstringMemoryTypeHost),
-                               ::testing::HasSubstr(kSubstringMemoryTypeDriverAllocated)));
-}
-
-TEST_F(MemoryOperationTest, SuccessfulMemCopyUserAllocated) {
-  const auto dev_ = queue_.get_device();
-  if (pti::test::utils::IsIntegratedGraphics(dev_)) {
-    GTEST_SKIP() << "Integrated graphics device detected. Test valid only on discrete GPUs";
-  }
-
-  InitCollection();
-  EnableViews(PTI_VIEW_DEVICE_GPU_MEM_COPY);
-
-  constexpr std::size_t kVecSize = 64;
-
-  // Force M2D with use_host_ptr and doing a memcpy
-  auto host_vector = std::vector<int>(kVecSize, 1);
-  {
-    sycl::buffer<int, 1> buf(host_vector.data(), sycl::range<1>(kVecSize),
-                             {sycl::property::buffer::use_host_ptr()});
-
-    queue_
-        .submit([&](sycl::handler& cgh) {
-          auto acc = buf.get_access<sycl::access::mode::read_write>(cgh);
-          cgh.parallel_for(sycl::range<1>(kVecSize),
-                           [=](sycl::id<1> idx) { acc[idx] = acc[idx] + 1; });
-        })
-        .wait();
-
-    buf.get_host_access();
-
-    EXPECT_TRUE(
-        std::all_of(host_vector.begin(), host_vector.end(), [](int idx) { return idx == 2; }));
-  }
-  FinalizeCollection();
-  std::sort(record_storage_.memcpy_records.begin(), record_storage_.memcpy_records.end(),
-            [](const auto* first, const auto* second) {
-              return first->_start_timestamp < second->_start_timestamp;
-            });
-  EXPECT_EQ(std::size(record_storage_.memcpy_records), 2);
-  ASSERT_GE(std::size(record_storage_.memcpy_records), 1);
-
-  EXPECT_EQ(record_storage_.memcpy_records[0]->_mem_dst, PTI_VIEW_MEMORY_TYPE_DEVICE);
-  EXPECT_EQ(record_storage_.memcpy_records[0]->_memcpy_type,
-            pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_M2D);
-  const auto memtype = record_storage_.memcpy_records[0]->_mem_src;
-  EXPECT_EQ(memtype, PTI_VIEW_MEMORY_TYPE_MEMORY);
-  EXPECT_THAT(ptiViewMemoryTypeToString(memtype),
-              ::testing::AllOf(::testing::HasSubstr(kSubstringMemoryTypeHost),
-                               ::testing::HasSubstr(kSubstringMemoryTypeUserAllocated)));
-}
-
-TEST(MemoryTypeStringificationTest, ToStringReturnsCorrectStringsForAllMemoryTypes) {
-  EXPECT_THAT(ptiViewMemoryTypeToString(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED),
-              ::testing::HasSubstr(kSubstringMemoryTypeShared));
-  EXPECT_THAT(ptiViewMemoryTypeToString(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST),
-              ::testing::AllOf(::testing::HasSubstr(kSubstringMemoryTypeHost),
-                               ::testing::HasSubstr(kSubstringMemoryTypeDriverAllocated)));
-  EXPECT_THAT(ptiViewMemoryTypeToString(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY),
-              ::testing::AllOf(::testing::HasSubstr(kSubstringMemoryTypeHost),
-                               ::testing::HasSubstr(kSubstringMemoryTypeUserAllocated)));
-  EXPECT_THAT(ptiViewMemoryTypeToString(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE),
-              ::testing::HasSubstr(kSubstringMemoryTypeDevice));
-}
diff --git a/sdk/test/metric_enable_disable_test.cc b/sdk/test/metric_enable_disable_test.cc
deleted file mode 100644
index 3979873e..00000000
--- a/sdk/test/metric_enable_disable_test.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Tests for on-demand metric enable/disable functionality
-//==============================================================
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-
-#include <vector>
-
-#include "pti/pti_metrics.h"
-#include "utils.h"
-
-namespace {
-
-class MetricEnableDisableTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    // Every test here exercises the on-demand enable/disable path, which is bypassed entirely
-    // when the loader latched ZET_ENABLE_METRICS=1 at zeInit(). Skipping from SetUp() skips the
-    // test body as well, so each test does not need to repeat this check.
-    if (utils::GetEnv("ZET_ENABLE_METRICS") == "1") {
-      GTEST_SKIP() << "ZET_ENABLE_METRICS=1 is set, skipping on-demand enable/disable test";
-    }
-
-    ze_result_t status = zeInit(0);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS) << "Failed to initialize Level Zero";
-  }
-
-  void TearDown() override {
-    // Best effort cleanup: disable metrics multiple times to reset reference count
-    for (int i = 0; i < 10; i++) {
-      pti_result status = ptiMetricsDisable(nullptr);
-      if (status != PTI_SUCCESS) {
-        break;
-      }
-    }
-  }
-};
-
-// Skips the calling test when the driver does not implement zetDeviceEnableMetricsExp. A macro
-// rather than a helper function because GTEST_SKIP() only returns from the function it appears
-// in -- calling it inside a helper would not stop the rest of the test body from running.
-#define SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status)                                        \
-  do {                                                                                    \
-    if ((status) == PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED) {                       \
-      GTEST_SKIP() << "zetDeviceEnableMetricsExp not supported by driver, skipping test"; \
-    }                                                                                     \
-  } while (0)
-
-TEST_F(MetricEnableDisableTest, SingleEnableDisable) {
-  pti_result status = ptiMetricsEnable(nullptr);
-  SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-TEST_F(MetricEnableDisableTest, MultipleEnableCalls) {
-  // Enable metrics 2 times
-  pti_result status = ptiMetricsEnable(nullptr);
-  SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  status = ptiMetricsEnable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  // Disable once - should succeed (ref count = 1)
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  // Disable again - should succeed (ref count = 0)
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-TEST_F(MetricEnableDisableTest, OneEnableTwoDisable) {
-  pti_result status = ptiMetricsEnable(nullptr);
-  SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  // Disable second time - should succeed (underflow protection)
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-TEST_F(MetricEnableDisableTest, DisableWithoutEnable) {
-  pti_result status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-TEST_F(MetricEnableDisableTest, EnableGetDevicesDisable) {
-  pti_result status = ptiMetricsEnable(nullptr);
-  SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  uint32_t device_count = 0;
-  pti_result pti_status = ptiMetricsGetDevices(nullptr, &device_count);
-  EXPECT_EQ(pti_status, PTI_SUCCESS);
-  EXPECT_GT(device_count, 0u);
-
-  std::vector<pti_device_properties_t> devices(device_count);
-  pti_status = ptiMetricsGetDevices(devices.data(), &device_count);
-  EXPECT_EQ(pti_status, PTI_SUCCESS);
-  EXPECT_FALSE(devices.empty());
-
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-TEST_F(MetricEnableDisableTest, GetDevicesWithoutMetricEnable) {
-  // Call ptiMetricsGetDevices without enabling metrics - should fail
-  uint32_t device_count = 0;
-  pti_result pti_status = ptiMetricsGetDevices(nullptr, &device_count);
-  EXPECT_NE(pti_status, PTI_SUCCESS) << "ptiMetricsGetDevices should fail without metrics enabled";
-
-  pti_result status = ptiMetricsEnable(nullptr);
-  SKIP_IF_RUNTIME_ENABLE_UNSUPPORTED(status);
-  EXPECT_EQ(status, PTI_SUCCESS);
-
-  device_count = 0;
-  pti_status = ptiMetricsGetDevices(nullptr, &device_count);
-  EXPECT_EQ(pti_status, PTI_SUCCESS);
-  EXPECT_GT(device_count, 0u);
-
-  std::vector<pti_device_properties_t> devices(device_count);
-  pti_status = ptiMetricsGetDevices(devices.data(), &device_count);
-  EXPECT_EQ(pti_status, PTI_SUCCESS);
-  EXPECT_FALSE(devices.empty());
-
-  status = ptiMetricsDisable(nullptr);
-  EXPECT_EQ(status, PTI_SUCCESS);
-}
-
-}  // namespace
diff --git a/sdk/test/metrics_multi_thread.cc b/sdk/test/metrics_multi_thread.cc
deleted file mode 100644
index 162fc6c0..00000000
--- a/sdk/test/metrics_multi_thread.cc
+++ /dev/null
@@ -1,651 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Multi-thread tests for PTI Metrics API
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <future>
-#include <iostream>
-#include <mutex>
-#include <random>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "metrics_utils.h"
-#include "pti/pti_metrics.h"
-#include "samples_utils.h"
-#include "utils.h"
-
-namespace {
-
-constexpr int kNumThreads = 8;
-constexpr int kNumIterations = 100;
-
-std::vector<pti_device_properties_t> g_devices;
-std::vector<std::vector<pti_metrics_group_properties_t>> g_metric_groups;
-std::mutex g_setup_mutex;
-std::atomic<bool> g_setup_complete{false};
-
-int GetRandomInt(int min, int max) {
-  static std::random_device rd;
-  static std::mt19937 gen(rd());
-  std::uniform_int_distribution<> dist(min, max);
-  return dist(gen);
-}
-
-// Thread-safe device discovery
-bool DiscoverDevicesThreadSafe(std::vector<pti_device_properties_t>& devices) {
-  uint32_t device_count = 0;
-  pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-  if (result != PTI_SUCCESS || device_count == 0) {
-    return false;
-  }
-
-  devices.resize(device_count);
-  result = ptiMetricsGetDevices(devices.data(), &device_count);
-  return result == PTI_SUCCESS;
-}
-
-// Thread-safe metric groups discovery
-bool DiscoverMetricGroupsThreadSafe(pti_device_handle_t device_handle,
-                                    std::vector<pti_metrics_group_properties_t>& metric_groups) {
-  uint32_t group_count = 0;
-  pti_result result = ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count);
-  if (result != PTI_SUCCESS || group_count == 0) {
-    return false;
-  }
-
-  metric_groups.resize(group_count);
-  result = ptiMetricsGetMetricGroups(device_handle, metric_groups.data(), &group_count);
-  return result == PTI_SUCCESS;
-}
-
-// Helper function to get metrics sample count
-static uint32_t GetMetricsSampleCount(pti_device_handle_t device_handle,
-                                      pti_metrics_group_handle_t metrics_group_handle) {
-  uint32_t values_count = 0;
-  pti_result result =
-      ptiMetricsGetCalculatedData(device_handle, metrics_group_handle, nullptr, &values_count);
-  if (result != PTI_SUCCESS) {
-    if (result == PTI_ERROR_METRICS_NO_DATA_COLLECTED) {
-      return 0;
-    }
-    std::cerr << "Warning: Failed to get metrics data count, result: " << result << std::endl;
-    return 0;
-  }
-
-  uint32_t metric_count = 0;
-  for (size_t device_idx = 0; device_idx < g_metric_groups.size(); ++device_idx) {
-    for (const auto& group : g_metric_groups[device_idx]) {
-      if (group._handle == metrics_group_handle) {
-        metric_count = group._metric_count;
-        break;
-      }
-    }
-    if (metric_count > 0) break;  // Found it
-  }
-
-  if (metric_count == 0) {
-    std::cerr << "Warning: Could not find metric group in global list" << std::endl;
-    return 0;
-  }
-
-  return values_count / metric_count;
-}
-
-// Helper function to submit minimal GPU compute work
-void SubmitMinimalGpuWork(const sycl::device& device) {
-  try {
-    sycl::queue queue(device);
-    constexpr size_t work_size = 10 * 1024;
-    // add randomness otherwise smart compiler might calculate it at compile time
-    std::vector<int> host_data(work_size, GetRandomInt(1, 1000));
-    sycl::buffer<int, 1> buffer(host_data.data(), sycl::range<1>(work_size));
-
-    queue.submit([&](sycl::handler& h) {
-      auto accessor = buffer.get_access<sycl::access::mode::read_write>(h);
-      h.parallel_for(sycl::range<1>(work_size),
-                     [=](sycl::id<1> idx) { accessor[idx] = accessor[idx] * 2 + 1; });
-    });
-    queue.wait_and_throw();
-  } catch (const std::exception& e) {
-    std::cerr << "Warning: Failed to submit GPU work: " << e.what() << std::endl;
-  }
-}
-
-}  // namespace
-
-class MetricsMultiThreadingTest : public ::testing::Test {
- protected:
-  std::vector<sycl::device> sycl_devices;
-  bool metrics_enabled_by_setup_ = false;
-
-  void SetUp() override {
-    bool metrics_enabled = (utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-    if (!metrics_enabled) {
-      pti_result metric_result = ptiMetricsEnable(nullptr);
-      if (metric_result == PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED ||
-          metric_result == PTI_ERROR_NOT_IMPLEMENTED) {
-        GTEST_SKIP() << "zetDeviceEnableMetricsExp not supported by driver, skipping test";
-      }
-      ASSERT_EQ(metric_result, PTI_SUCCESS)
-          << "Enable metrics via l0 API failed, set ZET_ENABLE_METRICS=1 to enable metrics";
-      metrics_enabled_by_setup_ = true;
-    }
-
-    std::lock_guard<std::mutex> lock(g_setup_mutex);
-    if (!g_setup_complete.load()) {
-      ASSERT_TRUE(DiscoverDevicesThreadSafe(g_devices)) << "Failed to discover devices";
-
-      if (!g_devices.empty()) {
-        g_metric_groups.resize(g_devices.size());
-        for (size_t i = 0; i < g_devices.size(); ++i) {
-          bool success = DiscoverMetricGroupsThreadSafe(g_devices[i]._handle, g_metric_groups[i]);
-          ASSERT_TRUE(success) << "Failed to discover metric groups for device " << i;
-        }
-      }
-      g_setup_complete.store(true);
-    }
-
-    sycl_devices = sycl::device::get_devices(sycl::info::device_type::gpu);
-    ASSERT_FALSE(sycl_devices.empty()) << "No GPU devices available for testing";
-  }
-
-  const sycl::device& GetDevice(size_t thread_id) const {
-    return sycl_devices[thread_id % sycl_devices.size()];
-  }
-
-  void TearDown() override {
-    // Release the metrics reference taken in SetUp; the rest of the cleanup is handled by
-    // global destructors.
-    if (metrics_enabled_by_setup_) {
-      ptiMetricsDisable(nullptr);
-      metrics_enabled_by_setup_ = false;
-    }
-  }
-};
-
-// Test Concurrent Device and Metric Group Discovery
-TEST_F(MetricsMultiThreadingTest, ConcurrentDiscoveryOperations) {
-  std::vector<std::future<bool>> futures;
-  std::atomic<int> device_success{0};
-  std::atomic<int> device_failure{0};
-  std::atomic<int> group_success{0};
-  std::atomic<int> group_failure{0};
-
-  for (int i = 0; i < kNumThreads; ++i) {
-    futures.push_back(std::async(std::launch::async, [&]() {
-      for (int j = 0; j < kNumIterations; ++j) {
-        // Test device discovery
-        std::vector<pti_device_properties_t> local_devices;
-        if (DiscoverDevicesThreadSafe(local_devices)) {
-          device_success++;
-          EXPECT_FALSE(local_devices.empty());
-          for (const auto& device : local_devices) {
-            EXPECT_NE(device._handle, nullptr);
-            EXPECT_NE(device._model_name, nullptr);
-          }
-        } else {
-          device_failure++;
-        }
-
-        // Test metric group discovery (if devices available)
-        if (!g_devices.empty()) {
-          std::vector<pti_metrics_group_properties_t> local_groups;
-          if (DiscoverMetricGroupsThreadSafe(g_devices[0]._handle, local_groups)) {
-            group_success++;
-            EXPECT_FALSE(local_groups.empty());
-            for (const auto& group : local_groups) {
-              EXPECT_NE(group._handle, nullptr);
-              EXPECT_NE(group._name, nullptr);
-              EXPECT_GT(group._metric_count, 0u);
-            }
-          } else {
-            group_failure++;
-          }
-        }
-      }
-      return true;
-    }));
-  }
-
-  for (auto& future : futures) {
-    EXPECT_TRUE(future.get());
-  }
-
-  std::cout << "Device discovery - Success: " << device_success.load()
-            << ", Failures: " << device_failure.load() << std::endl;
-  std::cout << "Group discovery - Success: " << group_success.load()
-            << ", Failures: " << group_failure.load() << std::endl;
-
-  EXPECT_GT(device_success.load(), 0);
-  EXPECT_GT(group_success.load(), 0);
-}
-
-// Test concurrent metric properties retrieval
-TEST_F(MetricsMultiThreadingTest, ConcurrentMetricPropertiesRetrieval) {
-  ASSERT_FALSE(g_metric_groups.empty()) << "No metric groups available for testing";
-
-  std::vector<std::future<bool>> futures;
-  std::atomic<int> success_count{0};
-  std::atomic<int> failure_count{0};
-  pti_metrics_group_handle_t group_handle = g_metric_groups[0][0]._handle;
-  uint32_t metric_count = g_metric_groups[0][0]._metric_count;
-
-  // Launch multiple threads to get metric properties concurrently
-  for (int i = 0; i < kNumThreads; ++i) {
-    futures.push_back(std::async(std::launch::async, [&]() {
-      for (int j = 0; j < kNumIterations; ++j) {
-        std::vector<pti_metric_properties_t> metric_properties(metric_count);
-        pti_result result = ptiMetricsGetMetricsProperties(group_handle, metric_properties.data());
-
-        if (result == PTI_SUCCESS) {
-          success_count++;
-          // Verify metric properties are valid
-          for (const auto& metric : metric_properties) {
-            EXPECT_NE(metric._handle, nullptr);
-            EXPECT_NE(metric._name, nullptr);
-          }
-        } else {
-          failure_count++;
-        }
-      }
-      return true;
-    }));
-  }
-
-  // Wait for all threads to complete
-  for (auto& future : futures) {
-    EXPECT_TRUE(future.get());
-  }
-
-  std::cout << "Metric properties retrieval - Success: " << success_count.load()
-            << ", Failures: " << failure_count.load() << std::endl;
-
-  EXPECT_GT(success_count.load(), 0);
-}
-
-// Test concurrent ptiMetricsStartCollection calls on different devices
-TEST_F(MetricsMultiThreadingTest, ConcurrentCollectionDifferentDevices) {
-  if (g_devices.size() < 2) {
-    GTEST_SKIP() << "Need at least 2 devices for this test";
-  }
-
-  ASSERT_FALSE(g_metric_groups.empty()) << "No metric groups available for testing";
-
-  std::cout << "Found " << sycl_devices.size() << " sycl devices\n";
-  std::cout << "Found " << g_devices.size() << " PTI metrics devices\n";
-
-  int num_devices_to_test = (std::min)(static_cast<int>(g_devices.size()), kNumThreads);
-
-  // The test failed in the strange way when all (StartCollection, Compute, StopCollection)
-  // was submitted in one async future per device:
-  // It failed 1 out of 10+ with symptoms of either zero samples for some device or hanged.
-  // Hang debugging showed that the thread deadlocked on ReadMetricDataFromBuffer call inside
-  // ptiMetricsStopCollection.
-  // It could be some bug (in L0 or still in PTI) related to "simultaneous" finishing the compute
-  // work and reading the collection data from the L0/driver buffer. After debugging and comparing
-  // behaviour of this test with similar VTune and unitrace flows, we found the current scenario
-  // that mimic VTune and unitrace collections. It proves working stably and this is the current
-  // state of this test.
-
-  std::vector<std::future<bool>> futures_start;
-  std::vector<std::future<bool>> futures_stop;
-  std::vector<std::future<bool>> futures_compute;
-  std::atomic<int> success_count{0};
-  std::atomic<int> start_stop_errors{0};
-  std::atomic<int> no_samples_count{0};
-
-  std::vector<pti_metrics_group_handle_t> device_metric_groups(num_devices_to_test);
-
-  for (int i = 0; i < num_devices_to_test; ++i) {
-    pti_device_handle_t device_handle = g_devices[i]._handle;
-
-    uint32_t group_count = 0;
-    pti_result result = ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count);
-    ASSERT_EQ(result, PTI_SUCCESS) << "Failed to get metric group count for device " << i;
-    ASSERT_GT(group_count, 0u) << "No metric groups found for device " << i;
-
-    std::vector<pti_metrics_group_properties_t> device_groups(group_count);
-    result = ptiMetricsGetMetricGroups(device_handle, device_groups.data(), &group_count);
-    ASSERT_EQ(result, PTI_SUCCESS) << "Failed to get metric groups for device " << i;
-
-    pti_metrics_group_handle_t selected_group = nullptr;
-    for (uint32_t j = 0; j < group_count; ++j) {
-      if (device_groups[j]._type == PTI_METRIC_GROUP_TYPE_TIME_BASED) {
-        selected_group = device_groups[j]._handle;
-        break;
-      }
-    }
-
-    if (selected_group == nullptr) {
-      selected_group = device_groups[0]._handle;
-    }
-
-    device_metric_groups[i] = selected_group;
-
-    std::cout << "Device " << i << " will use metric group: " << device_groups[0]._name
-              << std::endl;
-  }
-
-  // Configure collection for each device with the same metric group
-  for (int i = 0; i < num_devices_to_test; ++i) {
-    // Print device UUID to manually validate that PTI and SYCL UUIDs devices match
-    // - so the collection run on the same device where compute is submitted
-    std::cout << "Device idx: " << i << ", handle: " << g_devices[i]._handle << ",\n";
-    samples_utils::PrintUuid(g_devices[i]._uuid, "PTI  UUID: ");
-
-    const sycl::device& device = GetDevice(i);
-    if (device.has(sycl::aspect::ext_intel_device_info_uuid)) {
-      auto sycl_uuid = device.get_info<sycl::ext::intel::info::device::uuid>();
-      samples_utils::PrintUuid(sycl_uuid.data(), "Sycl UUID: ");
-    }
-
-    pti_device_handle_t device_handle = g_devices[i]._handle;
-    pti_metrics_group_handle_t group_handle = device_metric_groups[i];
-
-    pti_metrics_group_collection_params_t config_params{};
-    config_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-    config_params._group_handle = group_handle;
-    config_params._sampling_interval = 1'000'000;  // 1 ms
-
-    pti_result config_result = ptiMetricsConfigureCollection(device_handle, &config_params, 1);
-    ASSERT_EQ(config_result, PTI_SUCCESS)
-        << "Failed to configure device " << i << " with the metric group";
-  }
-
-  // Launch threads to start collection on different devices simultaneously
-  for (int i = 0; i < num_devices_to_test; ++i) {
-    futures_start.push_back(std::async(std::launch::async, [&, i]() -> bool {
-      pti_device_handle_t device_handle = g_devices[i]._handle;
-
-      pti_result start_result = ptiMetricsStartCollection(device_handle);
-      if (start_result != PTI_SUCCESS) {
-        start_stop_errors++;
-        std::cerr << "Device " << i << ", handle: " << g_devices[i]._handle
-                  << " start failed: " << start_result << std::endl;
-        return false;
-      }
-      return true;
-    }));
-  }
-
-  for (auto& future : futures_start) {
-    future.get();
-  }
-
-  for (int i = 0; i < num_devices_to_test; ++i) {
-    futures_compute.push_back(std::async(std::launch::async, [&, i]() -> bool {
-      const sycl::device& device = GetDevice(i);
-
-      SubmitMinimalGpuWork(device);
-      return true;
-    }));
-  }
-
-  for (auto& future : futures_compute) {
-    future.get();
-  }
-
-  std::mutex print_mutex;
-  for (int i = 0; i < num_devices_to_test; ++i) {
-    futures_stop.push_back(std::async(std::launch::async, [&, i]() -> bool {
-      pti_device_handle_t device_handle = g_devices[i]._handle;
-      pti_metrics_group_handle_t group_handle = device_metric_groups[i];
-
-      pti_result stop_result = ptiMetricsStopCollection(device_handle);
-      if (stop_result != PTI_SUCCESS) {
-        start_stop_errors++;
-        std::cout << "Device " << i << " stop failed: " << stop_result << std::endl;
-        return false;
-      }
-
-      uint32_t sample_count = GetMetricsSampleCount(device_handle, group_handle);
-      bool result = true;
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "Device " << i << " collected " << sample_count << " samples" << std::endl
-                  << std::flush;
-
-        if (sample_count == 0) {
-          no_samples_count++;
-          std::cout << "Device " << i << " collected no samples" << std::endl << std::flush;
-          result = false;
-        } else {
-          success_count++;
-        }
-      }
-      return result;
-    }));
-  }
-
-  for (auto& future : futures_stop) {
-    future.get();
-  }
-
-  std::cout << "Results - Success (with samples): " << success_count.load()
-            << ", Start/Stop errors: " << start_stop_errors.load()
-            << ", No samples: " << no_samples_count.load() << std::endl;
-
-  EXPECT_GT(success_count.load(), 0) << "At least some devices should collect samples successfully";
-  EXPECT_EQ(no_samples_count.load(), 0) << "All devices should collect at least one sample";
-}
-
-// Test collection state management across multiple threads
-TEST_F(MetricsMultiThreadingTest, ConcurrentCollectionManagement) {
-  ASSERT_FALSE(g_devices.empty()) << "No devices available for testing";
-  ASSERT_FALSE(g_metric_groups.empty()) << "No metric groups available for testing";
-
-  pti_device_handle_t device_handle = g_devices[0]._handle;
-  pti_metrics_group_handle_t group_handle = g_metric_groups[0][0]._handle;
-
-  // Phase 1: Test concurrent configuration
-  std::vector<std::future<pti_result>> config_futures;
-  for (int i = 0; i < kNumThreads; ++i) {
-    config_futures.push_back(std::async(std::launch::async, [&]() {
-      pti_metrics_group_collection_params_t config_params{};
-      config_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-      config_params._group_handle = group_handle;
-      config_params._sampling_interval = 100000;
-      return ptiMetricsConfigureCollection(device_handle, &config_params, 1);
-    }));
-  }
-
-  int config_success = 0;
-  for (auto& future : config_futures) {
-    if (future.get() == PTI_SUCCESS) config_success++;
-  }
-  EXPECT_GE(config_success, 1);
-
-  // Phase 2: Test concurrent start collection
-  std::atomic<int> start_success{0};
-  std::atomic<int> already_enabled{0};
-  std::atomic<int> other_errors{0};
-  std::atomic<int> collections_with_samples{0};
-  std::atomic<int> attempted_count{0};
-  std::vector<std::future<pti_result>> start_futures;
-
-  for (int i = 0; i < kNumThreads; ++i) {
-    start_futures.push_back(std::async(std::launch::async, [&, i]() {
-      const sycl::device& device = GetDevice(i);
-      pti_result result = ptiMetricsStartCollection(device_handle);
-      attempted_count++;
-
-      if (result == PTI_SUCCESS) {
-        start_success++;
-
-        SubmitMinimalGpuWork(device);
-
-        while (attempted_count.load() < kNumThreads) {
-          std::this_thread::sleep_for(std::chrono::milliseconds(1));
-        }
-        pti_result stop_result = ptiMetricsStopCollection(device_handle);
-        if (stop_result == PTI_SUCCESS) {
-          uint32_t sample_count = GetMetricsSampleCount(device_handle, group_handle);
-          std::cout << "Collected samples: " << sample_count << std::endl;
-          if (sample_count > 0) {
-            collections_with_samples++;
-          }
-        }
-      } else if (result == PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED) {
-        already_enabled++;
-      } else {
-        other_errors++;
-      }
-
-      return result;
-    }));
-  }
-
-  for (auto& future : start_futures) {
-    future.get();
-  }
-  // Phase 3: Test state management (pause/resume)
-  std::atomic<bool> pause_success{false};
-  std::atomic<bool> resume_success{false};
-  std::atomic<int> pause_resume_samples{0};
-  std::vector<std::future<void>> state_futures;
-
-  state_futures.push_back(std::async(std::launch::async, [&]() {
-    const sycl::device& device = GetDevice(0);
-    pti_result start_result = ptiMetricsStartCollection(device_handle);
-    if (start_result != PTI_SUCCESS) {
-      return;
-    }
-    SubmitMinimalGpuWork(device);
-
-    if (ptiMetricsPauseCollection(device_handle) == PTI_SUCCESS) {
-      pause_success.store(true);
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-      if (ptiMetricsResumeCollection(device_handle) == PTI_SUCCESS) {
-        resume_success.store(true);
-
-        SubmitMinimalGpuWork(device);
-
-        pti_result stop_result = ptiMetricsStopCollection(device_handle);
-        if (stop_result == PTI_SUCCESS) {
-          uint32_t sample_count = GetMetricsSampleCount(device_handle, group_handle);
-          std::cout << "Pause/Resume collected samples: " << sample_count << std::endl;
-          if (sample_count > 0) {
-            pause_resume_samples++;
-          }
-        }
-      }
-    }
-  }));
-
-  for (auto& future : state_futures) {
-    future.wait();
-  }
-
-  // Results
-  std::cout << "Config successes: " << config_success << std::endl;
-  std::cout << "Start - Success: " << start_success.load()
-            << ", Already enabled: " << already_enabled.load()
-            << ", Other errors: " << other_errors.load() << std::endl;
-  std::cout << "Collections with samples: " << collections_with_samples.load() << std::endl;
-  std::cout << "Pause/Resume - Pause success: " << pause_success.load()
-            << ", Resume success: " << resume_success.load()
-            << ", Samples after pause/resume: " << pause_resume_samples.load() << std::endl;
-
-  EXPECT_EQ(start_success.load(), 1) << "Exactly one thread should start collection successfully";
-  EXPECT_GT(collections_with_samples.load(), 0) << "At least one collection should gather samples";
-
-  // Pause/resume assertions (only if pause/resume succeeded)
-  if (pause_success.load() && resume_success.load()) {
-    EXPECT_GT(pause_resume_samples.load(), 0) << "Pause/resume cycle should collect samples";
-  }
-}
-
-// Test thread safety with invalid parameters
-TEST_F(MetricsMultiThreadingTest, ConcurrentErrorHandling) {
-  std::vector<std::future<void>> futures;
-  std::atomic<int> expected_failures{0};
-  std::atomic<int> total_operations{0};
-
-  constexpr int iterations_per_thread = 50;
-
-  for (int i = 0; i < kNumThreads; ++i) {
-    futures.push_back(std::async(std::launch::async, [&]() {
-      for (int iter = 0; iter < iterations_per_thread; ++iter) {
-        int operation = iter % 6;
-
-        switch (operation) {
-          case 0:
-          case 1: {
-            std::vector<pti_device_properties_t> devices;
-            DiscoverDevicesThreadSafe(devices);
-            if (!g_devices.empty()) {
-              std::vector<pti_metrics_group_properties_t> groups;
-              DiscoverMetricGroupsThreadSafe(g_devices[0]._handle, groups);
-            }
-            break;
-          }
-          case 2: {
-            pti_result r1 = ptiMetricsGetDevices(nullptr, nullptr);
-            pti_result r2 = ptiMetricsGetMetricGroups(nullptr, nullptr, nullptr);
-            if (r1 == PTI_ERROR_BAD_ARGUMENT && r2 == PTI_ERROR_BAD_ARGUMENT) {
-              expected_failures += 2;
-            }
-            break;
-          }
-          case 3: {
-            pti_result r1 = ptiMetricsGetMetricsProperties(nullptr, nullptr);
-            pti_result r2 = ptiMetricsConfigureCollection(nullptr, nullptr, 0);
-            if (r1 == PTI_ERROR_BAD_ARGUMENT && r2 == PTI_ERROR_BAD_ARGUMENT) {
-              expected_failures += 2;
-            }
-            break;
-          }
-          case 4: {
-            pti_result r = ptiMetricsGetCalculatedData(nullptr, nullptr, nullptr, nullptr);
-            if (r == PTI_ERROR_BAD_ARGUMENT) {
-              expected_failures++;
-            }
-            break;
-          }
-          case 5: {
-            pti_result r1 = ptiMetricsGetDevices(nullptr, nullptr);
-            pti_result r2 = ptiMetricsGetMetricGroups(nullptr, nullptr, nullptr);
-            pti_result r3 = ptiMetricsStartCollection(nullptr);
-            pti_result r4 = ptiMetricsStopCollection(nullptr);
-
-            if (r1 == PTI_ERROR_BAD_ARGUMENT && r2 == PTI_ERROR_BAD_ARGUMENT &&
-                r3 == PTI_ERROR_BAD_ARGUMENT && r4 == PTI_ERROR_BAD_ARGUMENT) {
-              expected_failures += 4;
-            }
-            break;
-          }
-        }
-
-        total_operations++;
-      }
-    }));
-  }
-
-  for (auto& future : futures) {
-    future.wait();
-  }
-  int expected_total_ops = kNumThreads * iterations_per_thread;
-  int expected_failures_count =
-      kNumThreads * ((iterations_per_thread / 6) * 9);  // 9 failures per 6-iteration cycle
-
-  std::cout << "Results:" << std::endl;
-  std::cout << "  Total operations: " << total_operations.load()
-            << " (expected: " << expected_total_ops << ")" << std::endl;
-  std::cout << "  Expected failures: " << expected_failures.load() << " (expected: ~"
-            << expected_failures_count << ")" << std::endl;
-
-  EXPECT_EQ(total_operations.load(), expected_total_ops);
-  EXPECT_GT(expected_failures.load(), 0);
-}
diff --git a/sdk/test/metrics_scope_buffer_handler.cc b/sdk/test/metrics_scope_buffer_handler.cc
deleted file mode 100644
index 4dc17846..00000000
--- a/sdk/test/metrics_scope_buffer_handler.cc
+++ /dev/null
@@ -1,1223 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Unit tests for PtiMetricsScopeBufferHandler.
-// White-box tests against the templated handler via MockBuffer.
-// No SYCL, no GPU, no PTI runtime needed.
-//==============================================================
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <iostream>
-#include <memory>
-#include <thread>
-#include <vector>
-
-#include "metrics/pti_metrics_scope_buffer_handler.h"
-#include "pti/pti.h"
-
-// Mock buffer for testing without real GPU resources
-struct MockBuffer {
-  size_t capacity;
-  pti_device_handle_t device_handle;
-  uint64_t buffer_id;
-  size_t record_count = 0;
-  bool is_finalized = false;
-  std::unique_ptr<uint8_t[]> raw_buffer_;
-
-  MockBuffer(size_t cap, pti_device_handle_t dev, uint64_t id)
-      : capacity(cap),
-        device_handle(dev),
-        buffer_id(id),
-        raw_buffer_(std::make_unique<uint8_t[]>(cap)) {}
-
-  MockBuffer(const MockBuffer&) = delete;
-  MockBuffer& operator=(const MockBuffer&) = delete;
-
-  void* GetRawBuffer() const { return raw_buffer_.get(); }
-  size_t GetCapacity() const { return capacity; }
-  pti_device_handle_t GetDeviceHandle() const { return device_handle; }
-  uint64_t GetBufferId() const { return buffer_id; }
-  size_t GetRecordCount() const { return record_count; }
-  bool IsFinalized() const { return is_finalized; }
-  void Finalize() { is_finalized = true; }
-
-  void AddMockRecord() { record_count++; }
-};
-
-/**
- * @brief Test fixture for BufferHandler Tests
- */
-class BufferHandlerTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    buffer_manager_ = std::make_unique<PtiMetricsScopeBufferHandler<MockBuffer>>();
-    device1_ = reinterpret_cast<pti_device_handle_t>(0x1000);
-    device2_ = reinterpret_cast<pti_device_handle_t>(0x2000);
-    device3_ = reinterpret_cast<pti_device_handle_t>(0x3000);
-  }
-
-  void TearDown() override { buffer_manager_.reset(); }
-
-  std::unique_ptr<PtiMetricsScopeBufferHandler<MockBuffer>> buffer_manager_;
-  pti_device_handle_t device1_;
-  pti_device_handle_t device2_;
-  pti_device_handle_t device3_;
-};
-
-TEST_F(BufferHandlerTest, RegisterDevice_SingleDevice) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  pti_result result = buffer_manager_->CreateBuffer(1024, device1_, 0);
-  EXPECT_EQ(result, PTI_SUCCESS);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  EXPECT_NE(buffer, nullptr);
-  EXPECT_EQ(buffer->GetDeviceHandle(), device1_);
-}
-
-TEST_F(BufferHandlerTest, RegisterDevice_MultipleDevices) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-  buffer_manager_->RegisterDevice(device3_);
-
-  EXPECT_EQ(buffer_manager_->CreateBuffer(1024, device1_, 0), PTI_SUCCESS);
-  EXPECT_EQ(buffer_manager_->CreateBuffer(2048, device2_, 0), PTI_SUCCESS);
-  EXPECT_EQ(buffer_manager_->CreateBuffer(4096, device3_, 0), PTI_SUCCESS);
-
-  EXPECT_NE(buffer_manager_->GetCurrentBuffer(device1_), nullptr);
-  EXPECT_NE(buffer_manager_->GetCurrentBuffer(device2_), nullptr);
-  EXPECT_NE(buffer_manager_->GetCurrentBuffer(device3_), nullptr);
-}
-
-TEST_F(BufferHandlerTest, DuplicateDeviceRegistration) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device1_);
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 0));
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  EXPECT_EQ(1, buffer_manager_->GetBufferCount());
-
-  int visible_count = 0;
-  for (size_t i = 0; i < 10; i++) {
-    if (buffer_manager_->GetBuffer(i) != nullptr) {
-      visible_count++;
-    }
-  }
-
-  EXPECT_EQ(1, visible_count) << "Duplicate registration caused buffer to appear " << visible_count
-                              << " times!";
-}
-
-TEST_F(BufferHandlerTest, CreateBuffer_UnregisteredDevice) {
-  // No RegisterDevice() call before CreateBuffer - REJECT
-  EXPECT_EQ(buffer_manager_->CreateBuffer(1024, device1_, 0), PTI_ERROR_BAD_ARGUMENT);
-
-  // No buffer should have been created
-  EXPECT_EQ(buffer_manager_->GetCurrentBuffer(device1_), nullptr);
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 0);
-  EXPECT_EQ(buffer_manager_->GetBuffer(0), nullptr);
-
-  // After registering, CreateBuffer succeeds
-  buffer_manager_->RegisterDevice(device1_);
-  EXPECT_EQ(buffer_manager_->CreateBuffer(1024, device1_, 0), PTI_SUCCESS);
-  EXPECT_NE(buffer_manager_->GetCurrentBuffer(device1_), nullptr);
-}
-
-TEST_F(BufferHandlerTest, CreateBuffer_Success) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  pti_result result = buffer_manager_->CreateBuffer(1024, device1_, 42);
-  EXPECT_EQ(result, PTI_SUCCESS);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  ASSERT_NE(buffer, nullptr);
-  EXPECT_EQ(buffer->GetBufferId(), 42);
-  EXPECT_EQ(buffer->GetCapacity(), 1024);
-}
-
-TEST_F(BufferHandlerTest, CreateBufferRejectsWhenNotFull) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1000, device1_, 0));
-
-  MockBuffer* buf = buffer_manager_->GetCurrentBuffer(device1_);
-  buf->AddMockRecord();
-  ASSERT_GT(buf->GetRecordCount(), 0u);
-
-  pti_result result = buffer_manager_->CreateBuffer(1000, device1_, 1);
-  EXPECT_EQ(PTI_WARN_BUFFER_NOT_FINALIZED, result);
-
-  EXPECT_EQ(0, buffer_manager_->GetCurrentBuffer(device1_)->GetBufferId());
-}
-
-TEST_F(BufferHandlerTest, CreateBufferReplacesEmptyCurrentBuffer) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1000, device1_, 0));
-  ASSERT_EQ(0u, buffer_manager_->GetCurrentBuffer(device1_)->GetRecordCount());
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1000, device1_, 1));
-  EXPECT_EQ(1, buffer_manager_->GetCurrentBuffer(device1_)->GetBufferId());
-  EXPECT_EQ(0u, buffer_manager_->GetBufferCount());
-}
-
-TEST_F(BufferHandlerTest, CreateBufferSucceedsAfterFinalize) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1000, device1_, 0));
-  MockBuffer* buf = buffer_manager_->GetCurrentBuffer(device1_);
-  buf->AddMockRecord();
-
-  // Caller explicitly finalizes before rotating.
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->FinalizeCurrentBuffer(device1_));
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1000, device1_, 1));
-
-  EXPECT_EQ(1, buffer_manager_->GetBufferCount());
-  EXPECT_EQ(1, buffer_manager_->GetCurrentBuffer(device1_)->GetBufferId());
-}
-
-TEST_F(BufferHandlerTest, GetBufferCount_EmptyManager) {
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 0);
-}
-
-TEST_F(BufferHandlerTest, GetBufferCount_CurrentBuffersWithData) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  buffer_manager_->CreateBuffer(1024, device2_, 0);
-
-  // Buffers without records should not count
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 0);
-
-  // Add records
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 1);
-
-  buffer_manager_->GetCurrentBuffer(device2_)->AddMockRecord();
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 2);
-}
-
-TEST_F(BufferHandlerTest, GetBufferCount_WithFinalizedBuffers) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  buffer->AddMockRecord();
-
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 1);
-
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 1);
-}
-
-TEST_F(BufferHandlerTest, GetBufferCount_MixedCurrentAndFinalized) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  // Device 1: Create and finalize
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  // Device 2: Create and keep current
-  buffer_manager_->CreateBuffer(1024, device2_, 0);
-  buffer_manager_->GetCurrentBuffer(device2_)->AddMockRecord();
-
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 2);
-}
-
-TEST_F(BufferHandlerTest, GetBuffer_InvalidIndex_ReturnsNull) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-
-  // Only 1 buffer exists
-  EXPECT_NE(buffer_manager_->GetBuffer(0), nullptr);
-  EXPECT_EQ(buffer_manager_->GetBuffer(1), nullptr);
-  EXPECT_EQ(buffer_manager_->GetBuffer(999), nullptr);
-}
-
-TEST_F(BufferHandlerTest, GetBuffer_ByGlobalIndex) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  buffer_manager_->CreateBuffer(1024, device1_, 10);
-  buffer_manager_->CreateBuffer(2048, device2_, 20);
-
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->GetCurrentBuffer(device2_)->AddMockRecord();
-
-  auto* buffer0 = buffer_manager_->GetBuffer(0);
-  auto* buffer1 = buffer_manager_->GetBuffer(1);
-
-  ASSERT_NE(buffer0, nullptr);
-  ASSERT_NE(buffer1, nullptr);
-
-  // Verify we got different buffers
-  EXPECT_NE(buffer0, buffer1);
-}
-
-TEST_F(BufferHandlerTest, GetBuffer_CurrentBufferWithoutData_NotCounted) {
-  // Test that current buffer with 0 records is correctly excluded from count and indexing
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  // Device1: finalized buffer with data
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  // Device1: current buffer with NO data (record_count = 0)
-  buffer_manager_->CreateBuffer(1024, device1_, 1);
-  auto* dev1_empty = buffer_manager_->GetCurrentBuffer(device1_);
-  EXPECT_EQ(dev1_empty->GetRecordCount(), 0);
-
-  // Device2: current buffer WITH data
-  buffer_manager_->CreateBuffer(1024, device2_, 0);
-  auto* dev2_buffer = buffer_manager_->GetCurrentBuffer(device2_);
-  dev2_buffer->AddMockRecord();
-
-  // Count should be 2 (dev1 finalized + dev2 current)
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 2);
-
-  // Index 0 should be device1 finalized
-  auto* buffer_at_0 = buffer_manager_->GetBuffer(0);
-  ASSERT_NE(buffer_at_0, nullptr);
-  EXPECT_EQ(buffer_at_0->GetDeviceHandle(), device1_);
-
-  // Index 1 should SKIP device1's empty current and go to device2
-  auto* buffer_at_1 = buffer_manager_->GetBuffer(1);
-  EXPECT_EQ(buffer_at_1, dev2_buffer);
-
-  // Index 2 should be out of bounds
-  EXPECT_EQ(buffer_manager_->GetBuffer(2), nullptr);
-}
-
-TEST_F(BufferHandlerTest, GetBuffer_DeviceWithOnlyFinalizedBuffers_SkipsEmptyCurrent) {
-  // When a device has finalized buffers but no current buffer, GetBuffer()
-  // must skip the non-existent current slot without breaking global indexing.
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  // Device1: 2 finalized buffers, NO current buffer (or empty current)
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  buffer_manager_->CreateBuffer(1024, device1_, 1);
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-  // After finalize, device1 has no current buffer
-
-  // Device2: 1 current buffer with data
-  buffer_manager_->CreateBuffer(1024, device2_, 0);
-  auto* dev2_buffer = buffer_manager_->GetCurrentBuffer(device2_);
-  dev2_buffer->AddMockRecord();
-
-  // Total should be 3: device1 (2 finalized + 0 current), device2 (0 finalized + 1 current)
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 3);
-
-  // Indices should be: 0=dev1 finalized, 1=dev1 finalized, 2=dev2 current
-  auto* buffer_at_0 = buffer_manager_->GetBuffer(0);
-  ASSERT_NE(buffer_at_0, nullptr);
-  EXPECT_EQ(buffer_at_0->GetDeviceHandle(), device1_);
-
-  auto* buffer_at_1 = buffer_manager_->GetBuffer(1);
-  ASSERT_NE(buffer_at_1, nullptr);
-  EXPECT_EQ(buffer_at_1->GetDeviceHandle(), device1_);
-
-  // GetBuffer should calculate index 2 correctly after skipping device1's empty current.
-  auto* buffer_at_2 = buffer_manager_->GetBuffer(2);
-  EXPECT_EQ(buffer_at_2, dev2_buffer);  // Should be device2's buffer
-  ASSERT_NE(buffer_at_2, nullptr);
-  EXPECT_EQ(buffer_at_2->GetDeviceHandle(), device2_);
-}
-
-TEST_F(BufferHandlerTest, AsymmetricBufferIndexCalculationEdgeCases) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-  buffer_manager_->RegisterDevice(device3_);
-
-  // Device A: 100 buffers
-  for (int i = 0; i < 100; i++) {
-    ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, i));
-    buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-    buffer_manager_->FinalizeCurrentBuffer(device1_);
-  }
-
-  // Device B: 0 buffers (skip entirely)
-
-  // Device C: 50 buffers
-  for (int i = 0; i < 50; i++) {
-    ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device3_, i));
-    buffer_manager_->GetCurrentBuffer(device3_)->AddMockRecord();
-    buffer_manager_->FinalizeCurrentBuffer(device3_);
-  }
-
-  EXPECT_EQ(150, buffer_manager_->GetBufferCount());
-
-  // Verify index calculation
-  // Indices 0-99: Device A
-  for (int i = 0; i < 100; i++) {
-    MockBuffer* buf = buffer_manager_->GetBuffer(i);
-    ASSERT_NE(nullptr, buf) << "Failed at index " << i;
-    EXPECT_EQ(device1_, buf->GetDeviceHandle()) << "Wrong device at index " << i;
-    EXPECT_EQ(i, buf->GetBufferId()) << "Wrong buffer_id at index " << i;
-  }
-
-  // Indices 100-149: Device C (skipping device B entirely)
-  for (int i = 0; i < 50; i++) {
-    size_t global_idx = 100 + i;
-    MockBuffer* buf = buffer_manager_->GetBuffer(global_idx);
-    ASSERT_NE(nullptr, buf) << "Failed at index " << global_idx;
-    EXPECT_EQ(device3_, buf->GetDeviceHandle()) << "Wrong device at index " << global_idx;
-    EXPECT_EQ(i, buf->GetBufferId()) << "Wrong buffer_id at index " << global_idx;
-  }
-
-  // Index 150: out of range
-  EXPECT_EQ(nullptr, buffer_manager_->GetBuffer(150));
-
-  std::cout << "Asymmetric buffer distribution (100-0-50) handled correctly." << std::endl;
-}
-
-TEST_F(BufferHandlerTest, InterleavedCurrentAndFinalizedBuffers) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-  buffer_manager_->RegisterDevice(device3_);
-
-  // Device A: 2 finalized, 1 current
-  ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 0));
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 1));
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 2));
-  buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-  // Keep as current
-
-  // Device B: 1 finalized, NO current
-  ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device2_, 0));
-  buffer_manager_->GetCurrentBuffer(device2_)->AddMockRecord();
-  buffer_manager_->FinalizeCurrentBuffer(device2_);
-
-  // Device C: NO finalized, 1 current
-  ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device3_, 0));
-  buffer_manager_->GetCurrentBuffer(device3_)->AddMockRecord();
-  // Keep as current
-
-  // Total: 2+1 (A) + 1 (B) + 1 (C) = 5
-  EXPECT_EQ(5, buffer_manager_->GetBufferCount());
-
-  // Verify global indexing
-  // 0-2: Device A (finalized[0], finalized[1], current)
-  EXPECT_EQ(device1_, buffer_manager_->GetBuffer(0)->GetDeviceHandle());
-  EXPECT_EQ(0, buffer_manager_->GetBuffer(0)->GetBufferId());
-
-  EXPECT_EQ(device1_, buffer_manager_->GetBuffer(1)->GetDeviceHandle());
-  EXPECT_EQ(1, buffer_manager_->GetBuffer(1)->GetBufferId());
-
-  EXPECT_EQ(device1_, buffer_manager_->GetBuffer(2)->GetDeviceHandle());
-  EXPECT_EQ(2, buffer_manager_->GetBuffer(2)->GetBufferId());
-
-  // 3: Device B (finalized[0])
-  EXPECT_EQ(device2_, buffer_manager_->GetBuffer(3)->GetDeviceHandle());
-  EXPECT_EQ(0, buffer_manager_->GetBuffer(3)->GetBufferId());
-
-  // 4: Device C (current)
-  EXPECT_EQ(device3_, buffer_manager_->GetBuffer(4)->GetDeviceHandle());
-  EXPECT_EQ(0, buffer_manager_->GetBuffer(4)->GetBufferId());
-
-  EXPECT_EQ(nullptr, buffer_manager_->GetBuffer(5));
-}
-
-TEST_F(BufferHandlerTest, FinalizeCurrentBuffer_NoCurrentBuffer_ReturnsSuccess) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  pti_result result = buffer_manager_->FinalizeCurrentBuffer(device1_);
-  EXPECT_EQ(result, PTI_SUCCESS);
-}
-
-TEST_F(BufferHandlerTest, FinalizeCurrentBuffer_MovesToFinalizedList) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  buffer->AddMockRecord();
-  void* raw_ptr = buffer->GetRawBuffer();
-
-  // Finalize
-  pti_result result = buffer_manager_->FinalizeCurrentBuffer(device1_);
-  EXPECT_EQ(result, PTI_SUCCESS);
-
-  // Current buffer should be cleared
-  EXPECT_EQ(buffer_manager_->GetCurrentBuffer(device1_), nullptr);
-
-  // Should find in finalized buffers
-  auto* found = buffer_manager_->FindBufferByRawPointer(raw_ptr);
-  ASSERT_NE(found, nullptr);
-  EXPECT_TRUE(found->IsFinalized());
-}
-
-TEST_F(BufferHandlerTest, EmptyBuffer_DiscardedOnFinalized) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 0));
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->FinalizeCurrentBuffer(device1_));
-  EXPECT_EQ(0, buffer_manager_->GetBufferCount());
-  EXPECT_EQ(nullptr, buffer_manager_->GetCurrentBuffer(device1_));
-}
-
-TEST_F(BufferHandlerTest, FinalizeFromMainThread_FinalizesWorkerThreadBuffers) {
-  // At end-of-collection, the API thread (e.g., main) calls
-  // FinalizeAllCurrentBuffers(). All threads' current buffers for that device
-  // should be finalized — not just the calling thread's slot.
-
-  buffer_manager_->RegisterDevice(device1_);
-
-  // Worker thread creates a buffer with data
-  std::thread worker([this]() {
-    ASSERT_EQ(PTI_SUCCESS, buffer_manager_->CreateBuffer(1024, device1_, 100));
-    auto* buf = buffer_manager_->GetCurrentBuffer(device1_);
-    ASSERT_NE(nullptr, buf);
-    buf->AddMockRecord();
-  });
-  worker.join();
-
-  ASSERT_EQ(1, buffer_manager_->GetBufferCount());
-
-  // Main thread (this thread) calls Finalize
-  EXPECT_EQ(PTI_SUCCESS, buffer_manager_->FinalizeAllCurrentBuffers());
-
-  auto* buf = buffer_manager_->GetBuffer(0);
-  ASSERT_NE(nullptr, buf);
-  EXPECT_TRUE(buf->IsFinalized()) << "Worker thread's current buffer was not finalized when "
-                                     "stop-collection ran on the main thread.";
-}
-
-TEST_F(BufferHandlerTest, FinalizeCurrentBuffer_AcrossManyThreads) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  constexpr int kNumThreads = 100;
-  std::vector<std::thread> threads;
-  threads.reserve(kNumThreads);
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, i]() {
-      buffer_manager_->CreateBuffer(1024, device1_, i);
-      buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-      buffer_manager_->FinalizeCurrentBuffer(device1_);
-    });
-  }
-  for (auto& t : threads) t.join();
-
-  EXPECT_EQ(static_cast<size_t>(kNumThreads), buffer_manager_->GetBufferCount());
-}
-
-TEST_F(BufferHandlerTest, FinalizeAllCurrentBuffers_AcrossManyThreads) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  constexpr int kNumThreads = 50;
-  std::vector<std::thread> threads;
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, i]() {
-      buffer_manager_->CreateBuffer(1024, device1_, i);
-      buffer_manager_->GetCurrentBuffer(device1_)->AddMockRecord();
-    });
-  }
-  for (auto& t : threads) t.join();
-
-  // All threads have non-finalized current buffers with data.
-  EXPECT_EQ(static_cast<size_t>(kNumThreads), buffer_manager_->GetBufferCount());
-
-  buffer_manager_->FinalizeAllCurrentBuffers();
-
-  // After sweep, all buffers are finalized but still counted.
-  EXPECT_EQ(static_cast<size_t>(kNumThreads), buffer_manager_->GetBufferCount());
-}
-
-TEST_F(BufferHandlerTest, FindBufferByRawPointer_FindsCurrentBuffer) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  void* raw_ptr = buffer->GetRawBuffer();
-
-  auto* found = buffer_manager_->FindBufferByRawPointer(raw_ptr);
-  EXPECT_EQ(found, buffer);
-}
-
-TEST_F(BufferHandlerTest, FindBufferByRawPointer_FindsFinalizedBuffer) {
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  buffer->AddMockRecord();
-  void* raw_ptr = buffer->GetRawBuffer();
-
-  buffer_manager_->FinalizeCurrentBuffer(device1_);
-
-  auto* found = buffer_manager_->FindBufferByRawPointer(raw_ptr);
-  EXPECT_NE(found, nullptr);
-  EXPECT_EQ(found->GetRawBuffer(), raw_ptr);
-}
-
-TEST_F(BufferHandlerTest, Multithread_ConcurrentRegisterDevice) {
-  // Test concurrent device registration from multiple threads
-  // Should not crash or corrupt device_order_
-
-  constexpr int kNumThreads = 4;
-  std::vector<std::thread> threads;
-  std::atomic<int> ready_count{0};
-  std::atomic<bool> start_flag{false};
-
-  std::vector<pti_device_handle_t> devices;
-  for (int i = 0; i < kNumThreads; ++i) {
-    devices.push_back(reinterpret_cast<pti_device_handle_t>(0x1000 + i * 0x1000));
-  }
-
-  // Launch threads that register devices concurrently
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, &ready_count, &start_flag, device = devices[i]]() {
-      ready_count++;
-      while (!start_flag.load()) {
-        std::this_thread::yield();
-      }
-      buffer_manager_->RegisterDevice(device);
-    });
-  }
-
-  while (ready_count.load() < kNumThreads) {
-    std::this_thread::yield();
-  }
-  start_flag.store(true);
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Verify all devices were registered (no data corruption)
-  // Each device should be able to create a buffer
-  for (const auto& device : devices) {
-    EXPECT_EQ(buffer_manager_->CreateBuffer(1024, device, 0), PTI_SUCCESS);
-    EXPECT_NE(buffer_manager_->GetCurrentBuffer(device), nullptr);
-  }
-}
-
-TEST_F(BufferHandlerTest, Multithread_ConcurrentCreateBufferDifferentDevices) {
-  // Test concurrent buffer creation for different devices
-  // Should handle parallel writes to different map entries
-
-  constexpr int kNumThreads = 3;
-  constexpr int kBuffersPerThread = 10;
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-  buffer_manager_->RegisterDevice(device3_);
-
-  std::vector<pti_device_handle_t> devices = {device1_, device2_, device3_};
-  std::vector<std::thread> threads;
-  std::atomic<bool> start_flag{false};
-  std::atomic<int> ready_count{0};
-
-  // Each thread works with its own device
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, &start_flag, &ready_count, device = devices[i]]() {
-      ready_count++;
-      while (!start_flag.load()) {
-        std::this_thread::yield();
-      }
-
-      // Create multiple buffers, adding records and finalizing
-      for (int j = 0; j < kBuffersPerThread; ++j) {
-        buffer_manager_->CreateBuffer(1024, device, j);
-        auto* buffer = buffer_manager_->GetCurrentBuffer(device);
-        if (buffer) {
-          buffer->AddMockRecord();
-          buffer_manager_->FinalizeCurrentBuffer(device);
-        }
-      }
-    });
-  }
-
-  while (ready_count.load() < kNumThreads) {
-    std::this_thread::yield();
-  }
-  start_flag.store(true);
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Verify: Should have kBuffersPerThread * kNumThreads finalized buffers
-  size_t expected_count = kBuffersPerThread * kNumThreads;
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), expected_count);
-}
-
-TEST_F(BufferHandlerTest, Multithread_ConcurrentCreateSameDevice_RaceCondition) {
-  // Multiple threads creating buffers for the SAME device
-  // Expected: Each (device, thread) pair has its own current buffer slot.
-  //           Concurrent CreateBuffer() from N threads on the same device should produce
-  //           N independent current buffers — no overwrites, no losses.
-
-  constexpr int kNumThreads = 10;
-  buffer_manager_->RegisterDevice(device1_);
-
-  std::vector<std::thread> threads;
-  std::atomic<bool> start_flag{false};
-  std::atomic<int> ready_count{0};
-  std::atomic<int> success_count{0};
-  std::atomic<int> got_own_buffer{0};
-
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, &start_flag, &ready_count, &success_count, &got_own_buffer, i]() {
-      ready_count++;
-      while (!start_flag.load()) {
-        std::this_thread::yield();
-      }
-
-      // All threads attempt CreateBuffer simultaneously
-      pti_result result = buffer_manager_->CreateBuffer(1024, device1_, i);
-      if (result == PTI_SUCCESS) {
-        success_count++;
-        auto* buf = buffer_manager_->GetCurrentBuffer(device1_);
-        if (buf && buf->GetBufferId() == static_cast<uint64_t>(i)) {
-          got_own_buffer++;
-        }
-      }
-    });
-  }
-
-  while (ready_count.load() < kNumThreads) {
-    std::this_thread::yield();
-  }
-  start_flag.store(true);
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // All N CreateBuffer calls should succeed
-  EXPECT_EQ(success_count.load(), kNumThreads);
-
-  // Each thread saw its own buffer — no cross-thread interference
-  EXPECT_EQ(got_own_buffer.load(), kNumThreads);
-
-  // Main thread never called CreateBuffer → its slot is empty
-  EXPECT_EQ(buffer_manager_->GetCurrentBuffer(device1_), nullptr);
-}
-
-TEST_F(BufferHandlerTest, ConcurrentCreateBufferZeroLoss) {
-  // N threads concurrently create + finalize a buffer on the same device.
-  // All N must succeed (no losses from per-(device, thread) slot collisions).
-  buffer_manager_->RegisterDevice(device1_);
-
-  constexpr int kNumThreads = 10;
-  std::atomic<int> successful_creates{0};
-
-  auto worker = [this, &successful_creates](int thread_id) {
-    if (buffer_manager_->CreateBuffer(1000, device1_, thread_id) == PTI_SUCCESS) {
-      MockBuffer* buf = buffer_manager_->GetCurrentBuffer(device1_);
-      if (buf) {
-        buf->AddMockRecord();
-        buffer_manager_->FinalizeCurrentBuffer(device1_);
-        successful_creates++;
-      }
-    }
-  };
-
-  std::vector<std::thread> threads;
-  for (int i = 0; i < kNumThreads; i++) {
-    threads.emplace_back(worker, i);
-  }
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  EXPECT_EQ(kNumThreads, successful_creates.load());
-  EXPECT_EQ(kNumThreads, buffer_manager_->GetBufferCount());
-}
-
-TEST_F(BufferHandlerTest, ThreadPerDeviceShouldNotInterfere) {
-  constexpr int kNumDevices = 4;
-  constexpr int kBuffersPerDevice = 50;
-
-  std::vector<pti_device_handle_t> devices;
-  for (int i = 0; i < kNumDevices; i++) {
-    pti_device_handle_t device = reinterpret_cast<pti_device_handle_t>(0x1000 + i * 0x1000);
-    devices.push_back(device);
-    buffer_manager_->RegisterDevice(device);
-  }
-
-  std::atomic<int> total_created{0};
-  std::vector<std::atomic<int>> per_device_count(kNumDevices);
-
-  auto worker = [this, &devices, &per_device_count, &total_created](int device_index) {
-    pti_device_handle_t device = devices[device_index];
-    int created = 0;
-
-    for (int i = 0; i < kBuffersPerDevice; i++) {
-      if (buffer_manager_->CreateBuffer(1024, device, i) == PTI_SUCCESS) {
-        MockBuffer* buf = buffer_manager_->GetCurrentBuffer(device);
-        if (buf && buf->GetDeviceHandle() == device) {
-          buf->AddMockRecord();
-          buffer_manager_->FinalizeCurrentBuffer(device);
-          created++;
-        }
-      }
-    }
-
-    per_device_count[device_index] = created;
-    total_created += created;
-  };
-
-  std::vector<std::thread> threads;
-  for (int i = 0; i < kNumDevices; i++) {
-    threads.emplace_back(worker, i);
-  }
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  size_t final_count = buffer_manager_->GetBufferCount();
-
-  std::cout << "Total created: " << total_created << std::endl;
-  std::cout << "Final count: " << final_count << std::endl;
-
-  for (int i = 0; i < kNumDevices; i++) {
-    std::cout << "Device " << i << ": " << per_device_count[i] << " buffers" << std::endl;
-  }
-
-  // Thread-per-device should work perfectly (no shared state)
-  EXPECT_EQ(kNumDevices * kBuffersPerDevice, total_created.load())
-      << "FAIL: Some buffers were not created!";
-
-  EXPECT_EQ(total_created.load(), final_count) << "FAIL: Buffer count mismatch!";
-
-  // Each device should have all its buffers
-  for (int i = 0; i < kNumDevices; i++) {
-    EXPECT_EQ(kBuffersPerDevice, per_device_count[i].load())
-        << "FAIL: Device " << i << " missing buffers!";
-  }
-}
-
-TEST_F(BufferHandlerTest, ConcurrentCreateAndFinalizeShouldNotRace) {
-  buffer_manager_->RegisterDevice(device1_);
-
-  std::atomic<bool> stop{false};
-  std::atomic<int> create_count{0};
-  std::atomic<int> finalize_count{0};
-  std::atomic<int> errors{0};
-
-  // Thread 1: Keep creating buffers
-  auto creator = [this, &stop, &create_count, &errors]() {
-    int id = 0;
-    while (!stop.load()) {
-      if (buffer_manager_->CreateBuffer(1024, device1_, id++) == PTI_SUCCESS) {
-        MockBuffer* buf = buffer_manager_->GetCurrentBuffer(device1_);
-        if (buf) {
-          buf->AddMockRecord();
-          create_count++;
-        } else {
-          errors++;
-        }
-      }
-      std::this_thread::sleep_for(std::chrono::microseconds(10));
-    }
-  };
-
-  // Thread 2: Keep finalizing buffers
-  auto finalizer = [this, &stop, &finalize_count]() {
-    while (!stop.load()) {
-      if (buffer_manager_->FinalizeCurrentBuffer(device1_) == PTI_SUCCESS) {
-        finalize_count++;
-      }
-      std::this_thread::sleep_for(std::chrono::microseconds(15));
-    }
-  };
-
-  std::thread t1(creator);
-  std::thread t2(finalizer);
-
-  // Run for 100ms
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  stop = true;
-
-  t1.join();
-  t2.join();
-
-  size_t final_count = buffer_manager_->GetBufferCount();
-
-  std::cout << "Created: " << create_count << std::endl;
-  std::cout << "Finalized: " << finalize_count << std::endl;
-  std::cout << "Final count: " << final_count << std::endl;
-  std::cout << "Errors: " << errors << std::endl;
-
-  EXPECT_EQ(0, errors.load()) << "FAIL: Race condition caused errors!";
-
-  // Final count should be reasonable (finalized buffers + maybe 1 current)
-  EXPECT_LE(final_count, finalize_count.load() + 1) << "FAIL: More buffers than expected!";
-}
-
-TEST_F(BufferHandlerTest, Multithread_ReadersAndWriters_DataIntegrity) {
-  // Test concurrent readers (GetBuffer, GetBufferCount) and writers (CreateBuffer, Finalize)
-  // Verifies that reads during writes don't crash or see corrupted data
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-
-  std::atomic<bool> stop_flag{false};
-  std::atomic<int> reader_iterations{0};
-  std::atomic<int> writer_iterations{0};
-
-  // Writer thread: Creates and finalizes buffers
-  std::thread writer([this, &stop_flag, &writer_iterations]() {
-    uint64_t buffer_id = 0;
-    while (!stop_flag.load()) {
-      // Alternate between device1 and device2
-      auto device = (buffer_id % 2 == 0) ? device1_ : device2_;
-
-      buffer_manager_->CreateBuffer(1024, device, buffer_id);
-      auto* buffer = buffer_manager_->GetCurrentBuffer(device);
-      if (buffer) {
-        buffer->AddMockRecord();
-        buffer_manager_->FinalizeCurrentBuffer(device);
-      }
-
-      buffer_id++;
-      writer_iterations++;
-      std::this_thread::sleep_for(std::chrono::microseconds(100));
-    }
-  });
-
-  // Reader threads: Constantly read buffer count and access buffers
-  std::vector<std::thread> readers;
-  for (int i = 0; i < 3; ++i) {
-    readers.emplace_back([this, &stop_flag, &reader_iterations]() {
-      while (!stop_flag.load()) {
-        // Read operations should not crash even during concurrent writes
-        size_t count = buffer_manager_->GetBufferCount();
-
-        // Try to access all visible buffers
-        for (size_t idx = 0; idx < count; ++idx) {
-          auto* buffer = buffer_manager_->GetBuffer(idx);
-          if (buffer) {
-            // Access buffer data (should not crash)
-            volatile void* ptr = buffer->GetRawBuffer();
-            (void)ptr;
-          }
-        }
-
-        reader_iterations++;
-        std::this_thread::yield();
-      }
-    });
-  }
-
-  // Let threads run for a short time
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  stop_flag.store(true);
-
-  writer.join();
-  for (auto& r : readers) {
-    r.join();
-  }
-
-  // Verify: No crashes, and both readers and writers made progress
-  EXPECT_GT(reader_iterations.load(), 0);
-  EXPECT_GT(writer_iterations.load(), 0);
-
-  // Final buffer count should match writer iterations
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), writer_iterations.load());
-}
-
-TEST_F(BufferHandlerTest, Multithread_FindBufferByRawPointer_DuringFinalization) {
-  // Test FindBufferByRawPointer while buffers are being moved from current to finalized
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->CreateBuffer(1024, device1_, 0);
-  auto* buffer = buffer_manager_->GetCurrentBuffer(device1_);
-  buffer->AddMockRecord();
-  void* raw_ptr = buffer->GetRawBuffer();
-
-  std::atomic<bool> finalized{false};
-  std::atomic<int> lookup_success_count{0};
-  std::atomic<int> lookup_attempts{0};
-
-  // Thread 1: Finalizes the buffer (moves it from current to finalized)
-  std::thread finalizer([this, &finalized]() {
-    std::this_thread::sleep_for(std::chrono::milliseconds(5));
-    buffer_manager_->FinalizeCurrentBuffer(device1_);
-    finalized.store(true);
-  });
-
-  // Thread 2: Continuously looks up the buffer by raw pointer
-  std::thread lookup([this, raw_ptr, &finalized, &lookup_success_count, &lookup_attempts]() {
-    while (!finalized.load()) {
-      auto* found = buffer_manager_->FindBufferByRawPointer(raw_ptr);
-      lookup_attempts++;
-      if (found != nullptr) {
-        lookup_success_count++;
-      }
-      std::this_thread::yield();
-    }
-
-    // After finalization, should still find it
-    auto* found = buffer_manager_->FindBufferByRawPointer(raw_ptr);
-    if (found != nullptr) {
-      lookup_success_count++;
-    }
-    lookup_attempts++;
-  });
-
-  finalizer.join();
-  lookup.join();
-
-  // Buffer should always be findable (before and after finalization)
-  // If any lookup failed, it indicates a race condition
-  EXPECT_EQ(lookup_success_count.load(), lookup_attempts.load());
-  EXPECT_GT(lookup_attempts.load(), 0);
-}
-
-TEST_F(BufferHandlerTest, Multithread_StressTest_AllOperations) {
-  // Comprehensive stress test: Multiple threads performing all operations
-
-  buffer_manager_->RegisterDevice(device1_);
-  buffer_manager_->RegisterDevice(device2_);
-  buffer_manager_->RegisterDevice(device3_);
-
-  std::atomic<bool> stop_flag{false};
-  std::vector<std::thread> threads;
-
-  // Thread 1: Creates buffers for device1
-  threads.emplace_back([this, &stop_flag]() {
-    uint64_t id = 0;
-    while (!stop_flag.load()) {
-      buffer_manager_->CreateBuffer(1024, device1_, id++);
-      auto* buf = buffer_manager_->GetCurrentBuffer(device1_);
-      if (buf && (id % 3 == 0)) {
-        buf->AddMockRecord();
-        buffer_manager_->FinalizeCurrentBuffer(device1_);
-      }
-      std::this_thread::sleep_for(std::chrono::microseconds(50));
-    }
-  });
-
-  // Thread 2: Creates buffers for device2
-  threads.emplace_back([this, &stop_flag]() {
-    uint64_t id = 0;
-    while (!stop_flag.load()) {
-      buffer_manager_->CreateBuffer(2048, device2_, id++);
-      auto* buf = buffer_manager_->GetCurrentBuffer(device2_);
-      if (buf && (id % 2 == 0)) {
-        buf->AddMockRecord();
-        buffer_manager_->FinalizeCurrentBuffer(device2_);
-      }
-      std::this_thread::sleep_for(std::chrono::microseconds(75));
-    }
-  });
-
-  // Thread 3: Reads buffer counts and accesses buffers
-  threads.emplace_back([this, &stop_flag]() {
-    while (!stop_flag.load()) {
-      size_t count = buffer_manager_->GetBufferCount();
-      for (size_t i = 0; i < (std::min)(count, size_t(5)); ++i) {
-        buffer_manager_->GetBuffer(i);
-      }
-      std::this_thread::yield();
-    }
-  });
-
-  // Thread 4: Looks up buffers by device
-  threads.emplace_back([this, &stop_flag]() {
-    std::vector<pti_device_handle_t> devices = {device1_, device2_, device3_};
-    while (!stop_flag.load()) {
-      for (auto dev : devices) {
-        buffer_manager_->GetCurrentBuffer(dev);
-      }
-      std::this_thread::yield();
-    }
-  });
-
-  std::this_thread::sleep_for(std::chrono::milliseconds(200));
-  stop_flag.store(true);
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  size_t final_count = buffer_manager_->GetBufferCount();
-  for (size_t i = 0; i < final_count; ++i) {
-    buffer_manager_->GetBuffer(i);
-  }
-}
-
-TEST_F(BufferHandlerTest, Multithread_RegisterFromDifferentThreads_IndexOrderSortedByHandle) {
-  // Verifies that device_order_ is sorted by device handle, so GetBuffer() indices
-  // are deterministic regardless of which thread registered first.
-
-  constexpr int kNumThreads = 3;
-  std::vector<pti_device_handle_t> devices = {device1_, device2_, device3_};
-  int buffers_per_device[] = {2, 3, 1};  // device1: 2, device2: 3, device3: 1
-
-  std::atomic<bool> start_flag{false};
-  std::atomic<int> ready_count{0};
-  std::vector<std::thread> threads;
-
-  // Launch threads with artificial delays to force reverse registration order
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([this, &start_flag, &ready_count, device = devices[i],
-                          num_buffers = buffers_per_device[i], thread_id = i]() {
-      std::this_thread::sleep_for(std::chrono::microseconds((kNumThreads - 1 - thread_id) * 200));
-
-      ready_count++;
-      while (!start_flag.load()) {
-        std::this_thread::yield();
-      }
-
-      buffer_manager_->RegisterDevice(device);
-
-      for (int j = 0; j < num_buffers; ++j) {
-        buffer_manager_->CreateBuffer(1024, device, j);
-        auto* buf = buffer_manager_->GetCurrentBuffer(device);
-        if (buf) {
-          buf->AddMockRecord();
-          buffer_manager_->FinalizeCurrentBuffer(device);
-        }
-      }
-    });
-  }
-
-  while (ready_count.load() < kNumThreads) {
-    std::this_thread::yield();
-  }
-  start_flag.store(true);
-
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Total: 2 + 3 + 1 = 6 buffers
-  EXPECT_EQ(buffer_manager_->GetBufferCount(), 6);
-
-  // Expected indices (sorted by device handle):
-  //   device1 (0x1000): indices 0, 1
-  //   device2 (0x2000): indices 2, 3, 4
-  //   device3 (0x3000): index 5
-
-  auto* buffer_at_0 = buffer_manager_->GetBuffer(0);
-  ASSERT_NE(buffer_at_0, nullptr);
-  EXPECT_EQ(buffer_at_0->GetDeviceHandle(), device1_);
-
-  auto* buffer_at_2 = buffer_manager_->GetBuffer(2);
-  ASSERT_NE(buffer_at_2, nullptr);
-  EXPECT_EQ(buffer_at_2->GetDeviceHandle(), device2_);
-
-  auto* buffer_at_4 = buffer_manager_->GetBuffer(4);
-  ASSERT_NE(buffer_at_4, nullptr);
-  EXPECT_EQ(buffer_at_4->GetDeviceHandle(), device2_);
-}
-
-TEST_F(BufferHandlerTest, Multithread_ConcurrentRegistration_DeviceOrderConsistent) {
-  // Verifies that concurrent device registration produces deterministic device order
-  // across multiple runs (sorted by device handle).
-
-  constexpr int kIterations = 10;
-  constexpr int kNumThreads = 3;
-
-  std::vector<std::vector<pti_device_handle_t>> observed_orders;
-
-  for (int iter = 0; iter < kIterations; ++iter) {
-    auto local_manager = std::make_unique<PtiMetricsScopeBufferHandler<MockBuffer>>();
-
-    std::vector<pti_device_handle_t> devices = {device1_, device2_, device3_};
-    int buffers_per_device = 2;
-
-    std::atomic<int> ready_count{0};
-    std::atomic<bool> start_flag{false};
-    std::vector<std::thread> threads;
-
-    // Register devices concurrently
-    for (int i = 0; i < kNumThreads; ++i) {
-      threads.emplace_back(
-          [&local_manager, &ready_count, &start_flag, device = devices[i], buffers_per_device]() {
-            ready_count++;
-            while (!start_flag.load()) {
-              std::this_thread::yield();
-            }
-
-            local_manager->RegisterDevice(device);
-
-            for (int j = 0; j < buffers_per_device; ++j) {
-              local_manager->CreateBuffer(1024, device, j);
-              auto* buf = local_manager->GetCurrentBuffer(device);
-              if (buf) {
-                buf->AddMockRecord();
-                local_manager->FinalizeCurrentBuffer(device);
-              }
-            }
-          });
-    }
-
-    while (ready_count.load() < kNumThreads) {
-      std::this_thread::yield();
-    }
-    start_flag.store(true);
-
-    for (auto& t : threads) {
-      t.join();
-    }
-
-    std::vector<pti_device_handle_t> device_order;
-    size_t total_buffers = local_manager->GetBufferCount();
-    EXPECT_EQ(total_buffers, 6);  // 3 devices * 2 buffers each
-
-    pti_device_handle_t last_device = nullptr;
-    for (size_t i = 0; i < total_buffers; ++i) {
-      auto* buf = local_manager->GetBuffer(i);
-      ASSERT_NE(buf, nullptr);
-      pti_device_handle_t current_device = buf->GetDeviceHandle();
-
-      if (current_device != last_device) {
-        device_order.push_back(current_device);
-        last_device = current_device;
-      }
-    }
-
-    EXPECT_EQ(device_order.size(), 3);
-    observed_orders.push_back(device_order);
-  }
-
-  // All iterations should produce the same device order
-  bool all_orders_match = true;
-  const auto& first_order = observed_orders[0];
-
-  for (size_t i = 1; i < observed_orders.size(); ++i) {
-    if (observed_orders[i] != first_order) {
-      all_orders_match = false;
-      break;
-    }
-  }
-
-  EXPECT_TRUE(all_orders_match) << "Device order inconsistent across iterations. "
-                                << "First iteration order: [" << static_cast<void*>(first_order[0])
-                                << ", " << static_cast<void*>(first_order[1]) << ", "
-                                << static_cast<void*>(first_order[2]) << "]";
-}
diff --git a/sdk/test/metrics_scope_gemm.cc b/sdk/test/metrics_scope_gemm.cc
deleted file mode 100644
index f92ebb85..00000000
--- a/sdk/test/metrics_scope_gemm.cc
+++ /dev/null
@@ -1,2817 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-
-// SPDX-License-Identifier: MIT
-// =============================================================
-// GEMM Metrics Scope Test Fixture
-//==============================================================
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <cassert>
-#include <chrono>
-#include <cmath>
-#include <cstring>
-#include <iomanip>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <optional>
-#include <set>
-#include <sstream>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "metrics/metrics_handler.h"
-#include "metrics_utils.h"
-#include "pti/pti_metrics_scope.h"
-#include "utils.h"
-
-struct OverheadTestStats {
-  uint64_t total_overhead_ns = 0;
-  uint64_t total_count = 0;
-  std::vector<pti_view_record_overhead> overhead_records;
-
-  size_t kernel_record_count = 0;
-  size_t mem_copy_record_count = 0;
-  size_t runtime_api_record_count = 0;
-  size_t invalid_record_count = 0;
-
-  void Reset() {
-    total_overhead_ns = 0;
-    total_count = 0;
-    overhead_records.clear();
-    kernel_record_count = 0;
-    mem_copy_record_count = 0;
-    runtime_api_record_count = 0;
-    invalid_record_count = 0;
-  }
-};
-
-// Forward declarations for callback functions
-void ProcessViewBufferWithOverhead(unsigned char* buf, std::size_t buf_size,
-                                   std::size_t used_bytes);
-void ProvideBufferWithOverhead(unsigned char** buf, std::size_t* buf_size);
-
-namespace {
-
-enum class TestType {
-  kRunAll = 0,
-};
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-std::vector<pti_device_properties_t> devices;
-std::vector<pti_metrics_group_properties_t> metric_groups;
-
-static float Check(const std::vector<float>& a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-// GEMM kernel function - exact copy from main_metrics_scope.cc
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue& queue, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    [[maybe_unused]] sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  std::cout << "Matrix multiplication done. Checking result.." << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue& queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") << "CORRECT with accuracy: " << eps
-              << std::endl;
-  }
-}
-
-void RunGemm(unsigned size = 1024, unsigned repeat_count = 1,
-             const sycl::device* target_device = nullptr) {
-  sycl::device dev;
-
-  try {
-    dev = (target_device != nullptr) ? *target_device : sycl::device(sycl::gpu_selector_v);
-
-    // Clamp size to valid range
-    size = (size < min_size) ? min_size : (size > max_size) ? max_size : size;
-  } catch (...) {
-    std::cerr << "Error: Failed to get GPU device" << std::endl;
-    return;
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::in_order()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size << " x " << size << ", repeats "
-            << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: "
-            << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-            << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  try {
-    auto start = std::chrono::steady_clock::now();
-    float expected_result = A_VALUE * B_VALUE * size;
-    Compute(queue, a, b, c, size, repeat_count, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-
-  } catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    throw;
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    throw;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    throw;
-  }
-}
-
-zet_metric_group_handle_t FindEventBasedMetricGroup(ze_device_handle_t device) {
-  uint32_t group_count = 0;
-  if (zetMetricGroupGet(device, &group_count, nullptr) != ZE_RESULT_SUCCESS || group_count == 0) {
-    return nullptr;
-  }
-
-  std::vector<zet_metric_group_handle_t> groups(group_count);
-  if (zetMetricGroupGet(device, &group_count, groups.data()) != ZE_RESULT_SUCCESS) {
-    return nullptr;
-  }
-
-  for (auto* group : groups) {
-    zet_metric_group_properties_t props = {};
-    props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    if (zetMetricGroupGetProperties(group, &props) == ZE_RESULT_SUCCESS &&
-        (props.samplingType & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED) != 0) {
-      return group;
-    }
-  }
-  return nullptr;
-}
-}  // namespace
-
-std::optional<sycl::device> FindSyclDeviceForPtiHandle(pti_device_handle_t pti_handle);
-
-class GemmMetricsScopeFixtureTest : public ::testing::Test {
- public:
-  inline static OverheadTestStats overhead_stats;
-
- protected:
-  bool metrics_enabled_by_setup_ = false;
-
-  void SetUp() override {
-    // Enable metrics first - required before calling ptiMetricsGetDevices
-    bool metrics_already_enabled = (utils::GetEnv("ZET_ENABLE_METRICS") == "1");
-    if (!metrics_already_enabled) {
-      auto status = ptiMetricsEnable(nullptr);
-      if (status != PTI_SUCCESS) {
-        GTEST_SKIP() << "Metrics cannot be enabled. ptiMetricsEnable() returned: " << status;
-      }
-      metrics_enabled_by_setup_ = true;
-    }
-
-    uint32_t device_count = 0;
-    pti_result result = PTI_SUCCESS;
-    result = ptiMetricsGetDevices(nullptr, &device_count);
-    if (result != PTI_SUCCESS) {
-      std::cout << "Failed to get devices count" << std::endl;
-    }
-
-    devices.resize(device_count);
-    result = ptiMetricsGetDevices(devices.data(), &device_count);
-    if (result != PTI_SUCCESS) {
-      std::cout << "Failed to get devices" << std::endl;
-    }
-
-    if (devices.size() > 0) {
-      // Get groups for the first device
-      uint32_t group_count = 0;
-      uint32_t device_idx = 0;
-      result = ptiMetricsGetMetricGroups(devices.at(device_idx)._handle, nullptr, &group_count);
-      if (result != PTI_SUCCESS) {
-        std::cout << "Failed to get metric group count" << std::endl;
-      }
-
-      metric_groups.resize(group_count);
-      result = ptiMetricsGetMetricGroups(devices.at(device_idx)._handle, metric_groups.data(),
-                                         &group_count);
-      if (result != PTI_SUCCESS) {
-        std::cout << "Failed to get metric groups" << std::endl;
-      }
-    }
-
-    EXPECT_EQ(ptiViewSetCallbacks(ProvideBufferWithOverhead, ProcessViewBufferWithOverhead),
-              PTI_SUCCESS);
-
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-  }
-
-  void TearDown() override {
-    devices.clear();
-    metric_groups.clear();
-
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-    if (metrics_enabled_by_setup_) {
-      ptiMetricsDisable(nullptr);
-      metrics_enabled_by_setup_ = false;
-    }
-  }
-
-  void ConfigureOrSkipIfNonUniform(pti_scope_collection_handle_t scope_handle,
-                                   pti_device_handle_t* device_handles, uint32_t device_count,
-                                   const char** metric_names, uint32_t metric_count) {
-    pti_result result =
-        ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, device_handles,
-                                 device_count, metric_names, metric_count);
-    if (result == PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM) {
-      EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(scope_handle));
-      std::ostringstream oss;
-      oss << "Devices not uniform on this host. Configured devices:";
-      const uint32_t count =
-          (device_handles == nullptr) ? static_cast<uint32_t>(devices.size()) : device_count;
-      for (uint32_t i = 0; i < count; ++i) {
-        pti_device_handle_t h =
-            (device_handles == nullptr) ? devices.at(i)._handle : device_handles[i];
-        const char* model = "<unknown>";
-        for (const auto& d : devices) {
-          if (d._handle == h) {
-            model = d._model_name;
-            break;
-          }
-        }
-        oss << "\n  [" << i << "] handle=" << h << " model=" << model;
-      }
-      GTEST_SKIP() << oss.str();
-    }
-    ASSERT_EQ(PTI_SUCCESS, result) << "Configure failed: " << result;
-  }
-
-  void RunGemmThreadsPerDevice(int threads_per_device, int kernels_per_thread,
-                               const std::vector<pti_device_handle_t>& target_devices) {
-    const int num_threads = threads_per_device * static_cast<int>(target_devices.size());
-    std::atomic<bool> all_ready{false};
-    std::atomic<int> ready_count{0};
-    std::vector<std::thread> workers;
-    std::vector<std::exception_ptr> thread_exceptions(num_threads);
-
-    for (int t = 0; t < num_threads; ++t) {
-      pti_device_handle_t target_pti = target_devices.at(t / threads_per_device);
-      auto match = FindSyclDeviceForPtiHandle(target_pti);
-      ASSERT_TRUE(match.has_value())
-          << "Could not map pti_device_handle to sycl::device for thread " << t;
-      workers.emplace_back([&, t, sycl_dev = *match, kernels_per_thread]() {
-        try {
-          ready_count.fetch_add(1);
-          while (!all_ready.load()) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
-          }
-          for (int k = 0; k < kernels_per_thread; ++k) {
-            RunGemm(128, 1, &sycl_dev);
-          }
-        } catch (...) {
-          thread_exceptions.at(t) = std::current_exception();
-        }
-      });
-    }
-
-    while (ready_count.load() < num_threads) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    }
-    all_ready.store(true);
-    for (auto& w : workers) {
-      w.join();
-    }
-
-    for (int t = 0; t < num_threads; ++t) {
-      if (thread_exceptions.at(t)) {
-        try {
-          std::rethrow_exception(thread_exceptions.at(t));
-        } catch (const std::exception& e) {
-          ADD_FAILURE() << "Thread " << t << " threw: " << e.what();
-        }
-      }
-    }
-  }
-
-  size_t IterateBuffersCheckDevices(pti_scope_collection_handle_t scope_handle,
-                                    const std::set<pti_device_handle_t>& expected_devices,
-                                    std::set<pti_device_handle_t>& seen_devices) {
-    size_t buffer_count = 0;
-    EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count));
-
-    size_t total_records = 0;
-    for (size_t i = 0; i < buffer_count; ++i) {
-      void* buffer = nullptr;
-      size_t actual_size = 0;
-      EXPECT_EQ(PTI_SUCCESS,
-                ptiMetricsScopeGetCollectionBuffer(scope_handle, i, &buffer, &actual_size));
-      pti_metrics_scope_collection_buffer_properties_t bprops;
-      bprops._struct_size = sizeof(bprops);
-      EXPECT_EQ(PTI_SUCCESS,
-                ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, &bprops));
-      EXPECT_EQ(expected_devices.count(bprops._device_handle), 1u)
-          << "Buffer " << i << " has unexpected device handle " << bprops._device_handle;
-      seen_devices.insert(bprops._device_handle);
-      EXPECT_GE(bprops._num_scopes, 1u);
-      total_records += bprops._num_scopes;
-    }
-    return total_records;
-  }
-};
-
-class GemmMetricsScopeMultiDeviceFixtureTest : public GemmMetricsScopeFixtureTest {
- protected:
-  void SetUp() override {
-    GemmMetricsScopeFixtureTest::SetUp();
-    if (devices.size() < 2) {
-      GTEST_SKIP() << "Need at least 2 devices";
-    }
-  }
-};
-
-// Overhead tracking Callbacks
-void ProcessViewBufferWithOverhead(unsigned char* buf, std::size_t /*buf_size*/,
-                                   std::size_t used_bytes) {
-  if (!buf || used_bytes == 0) {
-    if (buf) delete[] buf;
-    return;
-  }
-
-  pti_view_record_base* record = nullptr;
-  pti_result result = ptiViewGetNextRecord(buf, used_bytes, &record);
-
-  while (result == PTI_SUCCESS) {
-    if (record->_view_kind == PTI_VIEW_INVALID) {
-      std::cerr << "ERROR: Received PTI_VIEW_INVALID record in callback" << std::endl;
-      GemmMetricsScopeFixtureTest::overhead_stats.invalid_record_count++;
-    } else if (record->_view_kind == PTI_VIEW_COLLECTION_OVERHEAD) {
-      auto* overhead_rec = reinterpret_cast<pti_view_record_overhead*>(record);
-
-      GemmMetricsScopeFixtureTest::overhead_stats.overhead_records.push_back(*overhead_rec);
-
-      GemmMetricsScopeFixtureTest::overhead_stats.total_overhead_ns +=
-          overhead_rec->_overhead_duration_ns;
-      GemmMetricsScopeFixtureTest::overhead_stats.total_count += overhead_rec->_overhead_count;
-
-    } else if (record->_view_kind == PTI_VIEW_DEVICE_GPU_KERNEL) {
-      GemmMetricsScopeFixtureTest::overhead_stats.kernel_record_count++;
-    } else if (record->_view_kind == PTI_VIEW_DEVICE_GPU_MEM_COPY) {
-      GemmMetricsScopeFixtureTest::overhead_stats.mem_copy_record_count++;
-    } else if (record->_view_kind == PTI_VIEW_RUNTIME_API) {
-      GemmMetricsScopeFixtureTest::overhead_stats.runtime_api_record_count++;
-    } else {
-      std::cerr << "WARNING: Received unexpected record kind " << record->_view_kind
-                << " in callback" << std::endl;
-    }
-
-    result = ptiViewGetNextRecord(buf, used_bytes, &record);
-  }
-
-  delete[] buf;
-}
-
-static std::size_t SizeOfLargestViewRecord() {
-  return (std::max)({sizeof(pti_view_record_overhead), sizeof(pti_view_record_kernel),
-                     sizeof(pti_view_record_memory_copy), sizeof(pti_view_record_api)});
-}
-
-void ProvideBufferWithOverhead(unsigned char** buf, std::size_t* buf_size) {
-  std::size_t record_size = SizeOfLargestViewRecord();
-  if (record_size == 0) {
-    record_size = sizeof(pti_view_record_overhead);
-  }
-  *buf_size = record_size * 1000;
-  *buf = new unsigned char[*buf_size];
-  if (!*buf) {
-    std::cerr << "Failed to allocate buffer of size " << *buf_size << " bytes" << std::endl;
-    std::abort();
-  }
-}
-
-// ============================================================================
-// PARAMETERIZED TESTS
-// ============================================================================
-
-// Every public Metrics Scope API call must return PTI_ERROR_BAD_ARGUMENT when
-// the scope handle (or its output handle pointer) is null.
-TEST_F(GemmMetricsScopeFixtureTest, NullHandleAcrossApi) {
-  EXPECT_EQ(ptiMetricsScopeEnable(nullptr), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeDisable(nullptr), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeStartCollection(nullptr), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeStopCollection(nullptr), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(nullptr, 1024), PTI_ERROR_BAD_ARGUMENT);
-
-  void* dummy_collection_buffer = reinterpret_cast<void*>(0x1000);
-  void* dummy_metrics_buffer = reinterpret_cast<void*>(0x2000);
-  size_t size = 0;
-  size_t count = 0;
-  EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(nullptr, dummy_collection_buffer, &size, &count),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeCalculateMetrics(nullptr, dummy_collection_buffer, dummy_metrics_buffer,
-                                            1024, &count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-// Helper functions to detect device types
-bool hasPVCDevice() {
-  for (const auto& device : devices) {
-    std::string device_name = device._model_name;  // Assuming device has a name field
-    if (device_name.find("Data Center GPU") != std::string::npos ||
-        device_name.find("1100") != std::string::npos ||
-        device_name.find("1500") != std::string::npos) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool hasBMGDevice() {
-  for (const auto& device : devices) {
-    std::string device_name = device._model_name;  // Assuming device has a name field
-    if (device_name.find("B570") != std::string::npos ||
-        device_name.find("B580") != std::string::npos) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Parameter structure for metric configuration tests
-struct MetricConfigTestParam {
-  std::vector<std::string> metric_names;
-  std::vector<pti_result> expected_results;
-  std::string test_description;
-  std::string device_type;  // "PVC", "BMG", or "ANY"
-
-  MetricConfigTestParam(std::vector<std::string> names, std::vector<pti_result> results,
-                        std::string desc, std::string dev_type = "ANY")
-      : metric_names(std::move(names)),
-        expected_results(std::move(results)),
-        test_description(std::move(desc)),
-        device_type(std::move(dev_type)) {}
-};
-
-void PrintTo(const MetricConfigTestParam& param, std::ostream* os) {
-  *os << param.test_description;
-}
-
-class GemmMetricsScopeConfigureTest : public GemmMetricsScopeFixtureTest,
-                                      public ::testing::WithParamInterface<MetricConfigTestParam> {
-};
-
-TEST_P(GemmMetricsScopeConfigureTest, ScopeConfigureWithVariousMetrics) {
-  const auto& param = GetParam();
-
-  // Skip device-specific tests if required devices not available
-  if (param.device_type == "PVC" && !hasPVCDevice()) {
-    GTEST_SKIP() << "Skipping PVC-specific test - no PVC devices available";
-  }
-  if (param.device_type == "BMG" && !hasBMGDevice()) {
-    GTEST_SKIP() << "Skipping BMG-specific test - no BMG devices available";
-  }
-
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-
-  // Convert string vector to const char* array
-  std::vector<const char*> metric_names_cstr;
-  metric_names_cstr.reserve(param.metric_names.size());
-  for (const auto& name : param.metric_names) {
-    metric_names_cstr.push_back(name.c_str());
-  }
-
-  pti_result result = ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device,
-                                               1, metric_names_cstr.data(),
-                                               static_cast<uint32_t>(metric_names_cstr.size()));
-
-  // Check if result matches any of the expected results
-  bool result_matches = std::find(param.expected_results.begin(), param.expected_results.end(),
-                                  result) != param.expected_results.end();
-
-  EXPECT_TRUE(result_matches) << "Test: " << param.test_description << "\nActual result: " << result
-                              << "\nExpected one of: ";
-
-  if (!result_matches) {
-    for (size_t i = 0; i < param.expected_results.size(); ++i) {
-      std::cout << param.expected_results[i];
-      if (i < param.expected_results.size() - 1) std::cout << ", ";
-    }
-    std::cout << std::endl;
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    Configuration, GemmMetricsScopeConfigureTest,
-    ::testing::Values(
-        MetricConfigTestParam({"InvalidMetricName"}, {PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND},
-                              "Single invalid metric name"),
-        MetricConfigTestParam({"InvalidMetric1", "InvalidMetric2"},
-                              {PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND},
-                              "Multiple invalid metric names"),
-        MetricConfigTestParam({"SYSMEM_BYTE_READ", "SLM_BYTE_READ", "LOAD_STORE_CACHE_BYTE_WRITE"},
-                              {PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP},
-                              "Metrics from different groups PVC", "PVC"),
-        MetricConfigTestParam({"RENDER_CACHE_HIT", "COMPRESSOR_INPUT", "URB_READ"},
-                              {PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP},
-                              "Metrics from different groups BMG", "BMG"),
-        MetricConfigTestParam({"GpuTime", "GpuCoreClocks", "AvgGpuCoreFrequencyMHz",
-                               "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION", "XVE_ACTIVE", "XVE_STALL"},
-                              {PTI_SUCCESS}, "Valid metrics from ComputeBasic group"),
-        MetricConfigTestParam({"GpuTime"}, {PTI_SUCCESS}, "Single valid metric"),
-        MetricConfigTestParam({"GpuTime", "GpuCoreClocks", "AvgGpuCoreFrequencyMHz", "Counter5"},
-                              {PTI_SUCCESS}, "Valid metrics from TestOa group PVC", "PVC"),
-        MetricConfigTestParam({"GpuTime", "GpuCoreClocks", "AvgGpuCoreFrequencyMHz",
-                               "TEST_EVENT1_CYCLES_AVERAGE"},
-                              {PTI_SUCCESS}, "Valid metrics from TestOa group BMG", "BMG"),
-        MetricConfigTestParam({"GpuTime", "InvalidMetric"},
-                              {PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND},
-                              "Mix of valid and invalid metrics"),
-        MetricConfigTestParam({""}, {PTI_ERROR_BAD_ARGUMENT}, "Empty metric name"),
-        MetricConfigTestParam({"gputime", "gpuCoreclocks"},
-                              {PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND}, "Case sensitivity test")),
-    [](const ::testing::TestParamInfo<MetricConfigTestParam>& info) {
-      std::string name = info.param.test_description;
-      std::replace_if(name.begin(), name.end(), [](char c) { return !std::isalnum(c); }, '_');
-      name.erase(std::unique(name.begin(), name.end(),
-                             [](char a, char b) { return a == '_' && b == '_'; }),
-                 name.end());
-      if (!name.empty() && name.front() == '_') name.erase(0, 1);
-      if (!name.empty() && name.back() == '_') name.pop_back();
-      return name;
-    });
-
-// Parameter structure for buffer size tests
-struct BufferSizeTestParam {
-  size_t buffer_size;
-  pti_result expected_result;
-  std::string description;
-
-  BufferSizeTestParam(size_t size, pti_result result, std::string desc)
-      : buffer_size(size), expected_result(result), description(std::move(desc)) {}
-};
-
-void PrintTo(const BufferSizeTestParam& param, std::ostream* os) { *os << param.description; }
-
-class GemmMetricsScopeBufferSizeTest : public GemmMetricsScopeFixtureTest,
-                                       public ::testing::WithParamInterface<BufferSizeTestParam> {};
-
-TEST_P(GemmMetricsScopeBufferSizeTest, ScopeSetBufferSizeVariations) {
-  const auto& param = GetParam();
-
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with valid metrics first
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    pti_result result = ptiMetricsScopeSetCollectionBufferSize(scope_handle, param.buffer_size);
-    EXPECT_EQ(result, param.expected_result)
-        << "Buffer size test: " << param.description << " with size " << param.buffer_size;
-  } else {
-    std::cout << "Skipping buffer size test due to configuration failure" << std::endl;
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    BufferSize, GemmMetricsScopeBufferSizeTest,
-    ::testing::Values(BufferSizeTestParam(0, PTI_SUCCESS, "Zero_buffer_size"),
-                      BufferSizeTestParam(1, PTI_SUCCESS, "Minimum_buffer_size"),
-                      BufferSizeTestParam(1024, PTI_SUCCESS, "Standard_buffer_size"),
-                      BufferSizeTestParam(1024 * 1024, PTI_SUCCESS, "Large_buffer_size"),
-                      BufferSizeTestParam(SIZE_MAX, PTI_SUCCESS, "SIZE_MAX_clamped_to_1GB")),
-    [](const ::testing::TestParamInfo<BufferSizeTestParam>& info) {
-      return info.param.description + "_" + std::to_string(info.param.buffer_size);
-    });
-
-// Public Metrics Scope API calls must return PTI_ERROR_BAD_ARGUMENT when
-// the scope handle is non-null but bogus (not produced by ptiMetricsScopeEnable).
-TEST_F(GemmMetricsScopeFixtureTest, InvalidHandleAcrossApi) {
-  pti_scope_collection_handle_t invalid_handle =
-      reinterpret_cast<pti_scope_collection_handle_t>(0xDEADBEEF);
-  EXPECT_EQ(ptiMetricsScopeDisable(invalid_handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeStartCollection(invalid_handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeStopCollection(invalid_handle), PTI_ERROR_BAD_ARGUMENT);
-}
-
-// ============================================================================
-// REGULAR TESTS (Non-parameterized)
-// ============================================================================
-
-TEST_F(GemmMetricsScopeFixtureTest, GetDevices) {
-  // SetUp has already enabled metrics (and TearDown releases that single reference).
-  // Enabling again here would take a reference that nothing releases, leaving metrics
-  // enabled on the device for every later test in this binary.
-  uint32_t device_count = 0;
-  EXPECT_EQ(ptiMetricsGetDevices(nullptr, &device_count), PTI_SUCCESS);
-  EXPECT_NE(device_count, static_cast<uint32_t>(0));
-
-  devices.resize(device_count);
-  EXPECT_EQ(ptiMetricsGetDevices(devices.data(), &device_count), PTI_SUCCESS);
-  EXPECT_NE(devices.empty(), true);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, GetMetricGroups) {
-  for (size_t i = 0; i < devices.size(); i++) {
-    uint32_t group_count = 0;
-    EXPECT_EQ(ptiMetricsGetMetricGroups(devices.at(i)._handle, nullptr, &group_count), PTI_SUCCESS);
-    EXPECT_NE(group_count, static_cast<uint32_t>(0));
-
-    metric_groups.resize(group_count);
-    EXPECT_EQ(ptiMetricsGetMetricGroups(devices.at(i)._handle, metric_groups.data(), &group_count),
-              PTI_SUCCESS);
-    EXPECT_NE(metric_groups.empty(), true);
-  }
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeEnableDisable) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-  EXPECT_NE(scope_handle, nullptr);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureNullDevice) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  auto kMetricNames = std::array{"GpuTime"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, nullptr, 1,
-                                     kMetricNames.data(), metric_count),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureZeroDevices) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 0,
-                                     kMetricNames.data(), metric_count),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureAutoDetect_NullMetricNames_Rejected) {
-  // ValidateConfigurationArguments rejects metric_names == nullptr, including in
-  // auto-detect mode (device_count=0).
-
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Auto-detect mode: devices_to_profile=nullptr, device_count=0, metric_names=nullptr.
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL,
-                                     /*devices=*/nullptr, /*device_count=*/0,
-                                     /*metric_names=*/nullptr, /*metric_count=*/1),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureAutoDetect_ZeroMetrics_Rejected) {
-  // ValidateConfigurationArguments rejects metric_count == 0, including in
-  // auto-detect mode (device_count=0).
-
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  auto kMetricNames = std::array{"GpuTime"};
-
-  // Auto-detect mode: devices=nullptr, device_count=0, metrics_count=0.
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL,
-                                     /*devices=*/nullptr, /*device_count=*/0, kMetricNames.data(),
-                                     /*metric_count=*/0),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureUserMode) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_USER, &device, 1,
-                                     kMetricNames.data(), metric_count),
-            PTI_ERROR_NOT_IMPLEMENTED);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeQueryBufferSizeNotConfigured) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  size_t buffer_size = 0;
-  EXPECT_EQ(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, 100, &buffer_size),
-            PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeSetBufferSizeNotConfigured) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024),
-            PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeStartCollectionNotConfigured) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle),
-            PTI_ERROR_METRICS_BAD_COLLECTION_CONFIGURATION);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeStopCollectionNotStarted) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeGetBuffersCountWhileActive) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics like in client.cc
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    // Set buffer size
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-
-    // Start collection
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    size_t buffer_count = 0;
-    EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count),
-              PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED);
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeGetCollectionBufferNullParams) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  void* buffer = nullptr;
-  size_t buffer_size = 0;
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBuffer(nullptr, 0, &buffer, &buffer_size),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBuffer(scope_handle, 0, nullptr, &buffer_size),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBuffer(scope_handle, 0, &buffer, nullptr),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeGetBufferPropertiesNullParams) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  void* buffer = reinterpret_cast<void*>(0x1000);
-  pti_metrics_scope_collection_buffer_properties_t props;
-  // indeed wrong value of _struct_size in purpose
-  props._struct_size = sizeof(pti_metrics_scope_collection_buffer_properties_t) - 2;
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(nullptr, buffer, &props),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, nullptr, &props),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, nullptr),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, &props),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeQueryRecordsBufferSizeNullParams) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  void* buffer = reinterpret_cast<void*>(0x1000);
-  size_t required_size = 0;
-  size_t records_count = 0;
-
-  // Test null parameters
-  EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(nullptr, buffer, &required_size, &records_count),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(
-      ptiMetricsScopeQueryMetricsBufferSize(scope_handle, nullptr, &required_size, &records_count),
-      PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(scope_handle, buffer, nullptr, &records_count),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(scope_handle, buffer, &required_size, nullptr),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeCalculateMetricsNullParams) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  void* collection_buffer = reinterpret_cast<void*>(0x1000);
-  void* metrics_buffer = reinterpret_cast<void*>(0x2000);
-  size_t records_count = 0;
-
-  EXPECT_EQ(ptiMetricsScopeCalculateMetrics(nullptr, collection_buffer, metrics_buffer, 1024,
-                                            &records_count),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(
-      ptiMetricsScopeCalculateMetrics(scope_handle, nullptr, metrics_buffer, 1024, &records_count),
-      PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeCalculateMetrics(scope_handle, collection_buffer, nullptr, 1024,
-                                            &records_count),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeCalculateMetrics(scope_handle, collection_buffer, metrics_buffer, 1024,
-                                            nullptr),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Verify a configured handle can be restarted after Stop without re-Configure.
-TEST_F(GemmMetricsScopeFixtureTest, ScopeRestartAfterStop) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-
-    // First start/stop cycle.
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    // Second start/stop cycle on the same handle.
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeStartAlreadyStartedCollection) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics like in client.cc
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    // Set buffer size
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-
-    // Start collection twice
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle),
-              PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeSetBufferSizeWhileActive) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics like in client.cc
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    // Set buffer size and start collection
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    // Try to set buffer size while active
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 2048),
-              PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeQueryBufferSizeValid) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics like in client.cc
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    // Query buffer size for different scope counts
-    size_t buffer_size_10 = 0, buffer_size_100 = 0;
-    EXPECT_EQ(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, 10, &buffer_size_10),
-              PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, 100, &buffer_size_100),
-              PTI_SUCCESS);
-
-    // Buffer size should scale with scope count
-    EXPECT_GT(buffer_size_100, buffer_size_10);
-    EXPECT_GE(buffer_size_10, static_cast<size_t>(1024));  // At least 1KB minimum
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeCalculateMetricsInsufficientBuffer) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with valid metrics
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    // Run a small workload
-    try {
-      RunGemm(64, 1);
-    } catch (...) {
-      // Continue even if GEMM fails
-    }
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    // Get first buffer
-    size_t buffer_count = 0;
-    EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-
-    if (buffer_count > 0) {
-      void* buffer_data = nullptr;
-      size_t actual_buffer_size = 0;
-      EXPECT_EQ(
-          ptiMetricsScopeGetCollectionBuffer(scope_handle, 0, &buffer_data, &actual_buffer_size),
-          PTI_SUCCESS);
-
-      if (buffer_data != nullptr) {
-        // Query required size
-        size_t required_size = 0;
-        size_t records_count = 0;
-        EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(scope_handle, buffer_data, &required_size,
-                                                        &records_count),
-                  PTI_SUCCESS);
-
-        if (required_size > 0) {
-          // Allocate insufficient buffer
-          size_t insufficient_size = required_size / 2;
-          auto small_buffer = std::make_unique<uint8_t[]>(insufficient_size);
-          ASSERT_NE(small_buffer, nullptr);
-
-          // Should fail with insufficient buffer
-          size_t actual_records = 0;
-          pti_result result = ptiMetricsScopeCalculateMetrics(
-              scope_handle, buffer_data, small_buffer.get(), insufficient_size, &actual_records);
-
-          EXPECT_EQ(result, PTI_ERROR_METRICS_SCOPE_COLLECTION_BUFFER_TOO_SMALL);
-        }
-      }
-    }
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test exception handling in destructor paths
-TEST_F(GemmMetricsScopeFixtureTest, ScopeHandleDestructorWithActiveCollection) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    // Don't stop collection - test destructor cleanup path
-    // This tests the destructor warning paths in pti_metrics_scope_helper.h
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Stress buffer rotation by running two collection phases on the same handle:
-// phase 1 uses a tiny buffer + many small kernels, phase 2 uses a larger buffer
-// + a large kernel. Then iterate every accumulated buffer.
-TEST_F(GemmMetricsScopeFixtureTest, ScopeBufferRotationStress) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    // Phase 1: 64-byte buffer + 10 small kernels.
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 64), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    try {
-      for (int i = 0; i < 10; ++i) {
-        RunGemm(32, 1);
-      }
-    } catch (...) {
-      // Continue even if kernels fail
-    }
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    // Phase 2: 1024-byte buffer + 1 large kernel.
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    try {
-      RunGemm(1024, 10);
-    } catch (...) {
-      // Continue
-    }
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    size_t buffer_count = 0;
-    EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-    std::cout << "Buffer Count: " << buffer_count << std::endl;
-
-    for (size_t i = 0; i < buffer_count; ++i) {
-      void* buffer = nullptr;
-      size_t buffer_size = 0;
-      EXPECT_EQ(ptiMetricsScopeGetCollectionBuffer(scope_handle, i, &buffer, &buffer_size),
-                PTI_SUCCESS);
-      if (buffer != nullptr) {
-        pti_metrics_scope_collection_buffer_properties_t props;
-        props._struct_size = sizeof(props);
-        EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, &props),
-                  PTI_SUCCESS);
-      }
-    }
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Collection must survive more kernels than the query slot pool holds.
-TEST_F(GemmMetricsScopeFixtureTest, ScopeCollectsBeyondQueryPoolCapacity) {
-  if (devices.empty()) {
-    GTEST_SKIP() << "No devices available";
-  }
-
-  // Mirrors kMetricPoolEventCount in src/metrics/metrics_handler.h.
-  constexpr size_t kQueryPoolCapacity = 1000;
-  constexpr unsigned kKernelsToLaunch = 1200;
-  static_assert(kKernelsToLaunch > kQueryPoolCapacity);
-
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  ASSERT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.at(0)._handle;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  ConfigureOrSkipIfNonUniform(scope_handle, &device, 1, kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-
-  // Size one buffer to hold every record, so buffer rotation is not a variable here.
-  ASSERT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 8 * 1024 * 1024), PTI_SUCCESS);
-  ASSERT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-  auto match = FindSyclDeviceForPtiHandle(device);
-  ASSERT_TRUE(match.has_value()) << "Could not map pti_device_handle to sycl::device";
-  RunGemm(32, kKernelsToLaunch, &(*match));
-
-  ASSERT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-  std::set<pti_device_handle_t> expected_devices{device};
-  std::set<pti_device_handle_t> seen_devices;
-  const size_t total_records =
-      IterateBuffersCheckDevices(scope_handle, expected_devices, seen_devices);
-
-  std::cout << "Launched " << kKernelsToLaunch << " kernels, collected " << total_records
-            << " metric records" << std::endl;
-  EXPECT_GT(total_records, kQueryPoolCapacity)
-      << "collection stopped at the query pool capacity (" << kQueryPoolCapacity << ")";
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// A slot is released only once its kernel's data is collected, and nothing
-// appended to this command list ever executes. Every acquisition therefore needs
-// new capacity rather than reuse.
-TEST(MetricsSlotPool, AcquiresMoreSlotsThanOnePoolHolds) {
-  if (utils::GetEnv("ZET_ENABLE_METRICS") != "1") {
-    GTEST_SKIP() << "ZET_ENABLE_METRICS=1 is required to enumerate metric groups";
-  }
-  ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-
-  ze_driver_handle_t driver = utils::ze::GetGpuDriver(0);
-  ze_device_handle_t device = utils::ze::GetGpuDevice(0);
-  if (driver == nullptr || device == nullptr) {
-    GTEST_SKIP() << "No GPU device available";
-  }
-
-  zet_metric_group_handle_t metric_group = FindEventBasedMetricGroup(device);
-  if (metric_group == nullptr) {
-    GTEST_SKIP() << "No event-based metric group on this device";
-  }
-
-  const ze_context_desc_t context_desc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-  ze_context_handle_t context = nullptr;
-  ASSERT_EQ(zeContextCreate(driver, &context_desc, &context), ZE_RESULT_SUCCESS);
-
-  const ze_command_list_desc_t list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-  ze_command_list_handle_t cmd_list = nullptr;
-  ASSERT_EQ(zeCommandListCreate(context, device, &list_desc, &cmd_list), ZE_RESULT_SUCCESS);
-
-  constexpr uint64_t kSlotsToAcquire = 2ULL * kMetricPoolEventCount;
-  uint64_t first_failure = kSlotsToAcquire;
-  pti_result failure_result = PTI_SUCCESS;
-
-  {
-    PtiQueryMetricsProfiler profiler(static_cast<pti_device_handle_t>(device),
-                                     static_cast<pti_metrics_group_handle_t>(metric_group));
-    ASSERT_EQ(profiler.StartProfiling(false), PTI_SUCCESS);
-
-    // Record rather than assert, so teardown below always runs.
-    for (uint64_t operation_id = 0; operation_id < kSlotsToAcquire; ++operation_id) {
-      const pti_result result = profiler.HandleKernelAppendEnter(cmd_list, device, operation_id);
-      if (result != PTI_SUCCESS) {
-        first_failure = operation_id;
-        failure_result = result;
-        break;
-      }
-    }
-
-    EXPECT_EQ(profiler.StopProfiling(), PTI_SUCCESS);
-
-    // The command list references every query appended into it, so it has to go
-    // before the profiler destroys them.
-    EXPECT_EQ(zeCommandListDestroy(cmd_list), ZE_RESULT_SUCCESS);
-    cmd_list = nullptr;
-  }
-
-  EXPECT_EQ(zeContextDestroy(context), ZE_RESULT_SUCCESS);
-
-  EXPECT_EQ(first_failure, kSlotsToAcquire)
-      << "slot acquisition failed at operation " << first_failure << " of " << kSlotsToAcquire
-      << " with result " << static_cast<int>(failure_result) << "; a single pool holds "
-      << kMetricPoolEventCount;
-}
-
-// Test buffer access with invalid indices
-TEST_F(GemmMetricsScopeFixtureTest, ScopeInvalidBufferIndex) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    size_t buffer_count = 0;
-    EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-
-    // Test accessing buffer beyond available count
-    void* buffer = nullptr;
-    size_t buffer_size = 0;
-    EXPECT_EQ(
-        ptiMetricsScopeGetCollectionBuffer(scope_handle, buffer_count + 10, &buffer, &buffer_size),
-        PTI_ERROR_BAD_ARGUMENT);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Re-calling ptiMetricsScopeConfigure on the same handle with a different
-// metric_count (both shrinking and growing) must reset internal per-config
-// state. Otherwise stale data or out-of-bounds writes occur.
-TEST_F(GemmMetricsScopeFixtureTest, ScopeReconfigureMetricCount) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  if (devices.empty()) {
-    GTEST_SKIP() << "No devices available for metrics collection";
-  }
-  pti_device_handle_t device = devices.at(0)._handle;
-
-  // Configure 1: 2 metrics.
-  auto kTwoMetrics = std::array{"GpuTime", "GpuCoreClocks"};
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                     kTwoMetrics.data(), static_cast<uint32_t>(kTwoMetrics.size())),
-            PTI_SUCCESS);
-
-  // Configure 2: shrink to 1 metric. Metadata should report 1.
-  auto kOneMetric = std::array{"GpuTime"};
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                     kOneMetric.data(), static_cast<uint32_t>(kOneMetric.size())),
-            PTI_SUCCESS);
-  pti_metrics_scope_record_metadata_t metadata = {};
-  metadata._struct_size = sizeof(metadata);
-  EXPECT_EQ(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata), PTI_SUCCESS);
-  EXPECT_EQ(metadata._metrics_count, 1u)
-      << "After re-Configure with 1 metric, metadata still reports stale count";
-
-  // Configure 3: grow back to 2 metrics. Metadata should report 2.
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                     kTwoMetrics.data(), static_cast<uint32_t>(kTwoMetrics.size())),
-            PTI_SUCCESS);
-  metadata = {};
-  metadata._struct_size = sizeof(metadata);
-  EXPECT_EQ(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata), PTI_SUCCESS);
-  EXPECT_EQ(metadata._metrics_count, 2u)
-      << "After re-Configure with 2 metrics, metadata reports wrong count";
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Verify Configure is rejected while collection is active.
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureWhileActiveRejected) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    // Attempt to reconfigure while collection is active.
-    EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                       kMetricNames.data(), metric_count),
-              PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test metadata with zero struct size
-TEST_F(GemmMetricsScopeFixtureTest, ScopeMetadataZeroStructSize) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    pti_metrics_scope_record_metadata_t metadata;
-    metadata._struct_size = 0;  // Invalid size
-
-    EXPECT_EQ(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata), PTI_ERROR_BAD_ARGUMENT);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test configuration with null metric name in array
-TEST_F(GemmMetricsScopeFixtureTest, ScopeConfigureNullMetricInArray) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array<const char*, 3>{"GpuTime", nullptr, "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  // Should fail due to null metric name in array
-  EXPECT_EQ(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                     kMetricNames.data(), metric_count),
-            PTI_ERROR_BAD_ARGUMENT);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test query with invalid collection buffer pointer
-TEST_F(GemmMetricsScopeFixtureTest, ScopeQueryInvalidCollectionBuffer) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    // Test with invalid buffer pointer
-    void* invalid_buffer = reinterpret_cast<void*>(0xDEADBEEF);
-    size_t required_size = 0;
-    size_t records_count = 0;
-
-    EXPECT_EQ(ptiMetricsScopeQueryMetricsBufferSize(scope_handle, invalid_buffer, &required_size,
-                                                    &records_count),
-              PTI_ERROR_BAD_ARGUMENT);
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test calculation with zero-sized metrics buffer
-TEST_F(GemmMetricsScopeFixtureTest, ScopeCalculateMetricsZeroBuffer) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  if (ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                               kMetricNames.data(), metric_count) == PTI_SUCCESS) {
-    EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, 1024), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-    try {
-      RunGemm(64, 1);
-    } catch (...) {
-      // Continue
-    }
-
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-    size_t buffer_count = 0;
-    EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-
-    if (buffer_count > 0) {
-      void* collection_buffer = nullptr;
-      size_t buffer_size = 0;
-      EXPECT_EQ(
-          ptiMetricsScopeGetCollectionBuffer(scope_handle, 0, &collection_buffer, &buffer_size),
-          PTI_SUCCESS);
-
-      if (collection_buffer != nullptr) {
-        // Test with zero-sized metrics buffer
-        uint8_t dummy_buffer[1];
-        size_t records_count = 0;
-
-        EXPECT_EQ(ptiMetricsScopeCalculateMetrics(scope_handle, collection_buffer, dummy_buffer, 0,
-                                                  &records_count),
-                  PTI_ERROR_METRICS_SCOPE_COLLECTION_BUFFER_TOO_SMALL);
-      }
-    }
-  }
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test query profiler creation failures
-TEST_F(GemmMetricsScopeFixtureTest, ScopeQueryProfilerEdgeCases) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Try to configure with a potentially invalid device
-  pti_device_handle_t invalid_device = reinterpret_cast<pti_device_handle_t>(0x12345678);
-  auto kMetricNames = std::array{"GpuTime"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  // This should fail during device validation
-  EXPECT_NE(ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &invalid_device,
-                                     1, kMetricNames.data(), metric_count),
-            PTI_SUCCESS);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-}
-
-// Test double enable/disable
-TEST_F(GemmMetricsScopeFixtureTest, ScopeDoubleEnableDisable) {
-  pti_scope_collection_handle_t scope_handle1 = nullptr;
-  pti_scope_collection_handle_t scope_handle2 = nullptr;
-
-  // Test multiple enables
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle1), PTI_SUCCESS);
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle2), PTI_SUCCESS);
-
-  EXPECT_NE(scope_handle1, scope_handle2);  // Should be different handles
-
-  // Test disabling both
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle1), PTI_SUCCESS);
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle2), PTI_SUCCESS);
-
-  // Test double disable (should fail)
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle1), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeMultiThreadedDifferentKernels) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result != PTI_SUCCESS) {
-    std::cerr << "Configuration failed with error: " << config_result
-              << ", skipping multi-threaded test" << std::endl;
-    EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-    return;
-  }
-
-  // Get metadata once per scope (reusable for all buffers/records)
-  pti_metrics_scope_record_metadata_t metadata;
-
-  // Set struct size
-  metadata._struct_size = sizeof(pti_metrics_scope_record_metadata_t);
-
-  // Populate metadata
-  EXPECT_EQ(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata), PTI_SUCCESS);
-
-  const auto default_precision = std::cout.precision();
-  const auto default_fill = std::cout.fill();
-  const auto default_flags = std::cout.flags();
-  std::cout << "Metrics Metadata set to " << metadata._struct_size << " bytes\n\n";
-
-  std::cout << "Metadata for all records:\n";
-  std::cout << "  Metrics count per record: " << metadata._metrics_count << "\n";
-  EXPECT_EQ(metadata._metrics_count, metric_count);  // Should match requested count
-
-  for (uint32_t i = 0; i < metadata._metrics_count; ++i) {
-    std::cout << "  [" << i << "] " << metadata._metric_names[i];
-    if (metadata._metric_units[i]) {
-      std::cout << " (" << metadata._metric_units[i] << ")";
-    }
-    std::cout << " - Type: " << metadata._value_types[i] << "\n";
-  }
-
-  // Set buffer size for multiple kernels
-  size_t estimated_buffer_size = 0;
-  EXPECT_EQ(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, 50, &estimated_buffer_size),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, estimated_buffer_size * 3),
-            PTI_SUCCESS);
-
-  std::cout << "\n=== Starting Multi-Threaded Metrics Collection ===" << std::endl;
-  std::cout << "Buffer size set to: " << (estimated_buffer_size * 3) << " bytes" << std::endl;
-
-  // Start collection
-  EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-  std::cout << "Metrics collection started successfully" << std::endl;
-
-  // Create SYCL queue for GPU operations
-  sycl::device dev;
-  try {
-    dev = sycl::device(sycl::gpu_selector_v);
-    std::cout << "Using GPU device: " << dev.get_info<sycl::info::device::name>() << std::endl;
-  } catch (...) {
-    std::cout << "GPU device not available, skipping multi-threaded test" << std::endl;
-    EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-    return;
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::in_order()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-
-  // Thread synchronization
-  std::atomic<int> threads_completed{0};
-  std::atomic<bool> all_threads_ready{false};
-  std::atomic<int> threads_ready{0};
-  const int num_threads = 4;
-  std::vector<std::thread> threads;
-  std::vector<std::exception_ptr> thread_exceptions(num_threads);
-  std::mutex print_mutex;  // For synchronized printing
-
-  // Helper function to format metric value using metadata
-  auto FormatMetricValue = [metadata](uint32_t metric_index,
-                                      const pti_value_t& value) -> std::string {
-    std::ostringstream oss;
-
-    switch (metadata._value_types[metric_index]) {
-      case PTI_METRIC_VALUE_TYPE_UINT32:
-        oss << value.ui32;
-        break;
-      case PTI_METRIC_VALUE_TYPE_UINT64:
-        oss << value.ui64;
-        break;
-      case PTI_METRIC_VALUE_TYPE_FLOAT32:
-        oss << std::fixed << std::setprecision(3) << value.fp32;
-        break;
-      case PTI_METRIC_VALUE_TYPE_FLOAT64:
-        oss << std::fixed << std::setprecision(3) << value.fp64;
-        break;
-      case PTI_METRIC_VALUE_TYPE_BOOL8:
-        oss << (value.b8 ? "true" : "false");
-        break;
-      default:
-        oss << "unknown";
-        break;
-    }
-
-    if (metadata._metric_units[metric_index] && strlen(metadata._metric_units[metric_index]) > 0) {
-      oss << " " << metadata._metric_units[metric_index];
-    }
-
-    return oss.str();
-  };
-
-  // Thread 1: GEMM kernels
-  threads.emplace_back([&, thread_id = 0]() {
-    try {
-      threads_ready++;
-      while (!all_threads_ready.load()) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "\n[Thread " << thread_id << "] Starting GEMM kernels..." << std::endl;
-      }
-
-      const unsigned size = 128;
-      std::vector<float> a(size * size, A_VALUE);
-      std::vector<float> b(size * size, B_VALUE);
-      std::vector<float> c(size * size, 0.0f);
-
-      // Run multiple GEMM operations
-      for (int i = 0; i < 3; ++i) {
-        try {
-          sycl::buffer<float, 1> a_buf(a.data(), a.size());
-          sycl::buffer<float, 1> b_buf(b.data(), b.size());
-          sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-          auto start_time = std::chrono::high_resolution_clock::now();
-
-          queue.submit([&](sycl::handler& cgh) {
-            auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-            auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-            auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-            cgh.parallel_for<class __GEMM_MT>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-              auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-              GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-            });
-          });
-          queue.wait_and_throw();
-
-          auto end_time = std::chrono::high_resolution_clock::now();
-          auto duration =
-              std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-          {
-            std::lock_guard<std::mutex> lock(print_mutex);
-            std::cout << "[Thread " << thread_id << "] GEMM kernel " << (i + 1) << " completed in "
-                      << duration.count() << " μs" << std::endl;
-          }
-
-          std::this_thread::sleep_for(std::chrono::milliseconds(10));
-        } catch (const std::exception& e) {
-          std::lock_guard<std::mutex> lock(print_mutex);
-          std::cout << "[Thread " << thread_id << "] GEMM iteration " << i
-                    << " failed: " << e.what() << std::endl;
-        }
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "[Thread " << thread_id << "] All GEMM kernels completed" << std::endl;
-      }
-      threads_completed++;
-    } catch (...) {
-      thread_exceptions.at(thread_id) = std::current_exception();
-      threads_completed++;
-    }
-  });
-
-  // Thread 2: Vector operations
-  threads.emplace_back([&, thread_id = 1]() {
-    try {
-      threads_ready++;
-      while (!all_threads_ready.load()) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "\n[Thread " << thread_id << "] Starting vector operations..." << std::endl;
-      }
-
-      const size_t vector_size = 10000;
-      std::vector<float> vec_a(vector_size, 2.0f);
-      std::vector<float> vec_b(vector_size, 3.0f);
-      std::vector<float> vec_c(vector_size, 0.0f);
-
-      // Run vector addition kernels
-      for (int i = 0; i < 4; ++i) {
-        try {
-          sycl::buffer<float, 1> a_buf(vec_a.data(), vec_a.size());
-          sycl::buffer<float, 1> b_buf(vec_b.data(), vec_b.size());
-          sycl::buffer<float, 1> c_buf(vec_c.data(), vec_c.size());
-
-          auto start_time = std::chrono::high_resolution_clock::now();
-
-          queue.submit([&](sycl::handler& cgh) {
-            auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-            auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-            auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-            cgh.parallel_for<class __VectorAdd_MT>(
-                sycl::range<1>(vector_size),
-                [=](sycl::id<1> idx) { c_acc[idx] = a_acc[idx] + b_acc[idx]; });
-          });
-          queue.wait_and_throw();
-
-          auto end_time = std::chrono::high_resolution_clock::now();
-          auto duration =
-              std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-          {
-            std::lock_guard<std::mutex> lock(print_mutex);
-            std::cout << "[Thread " << thread_id << "] VectorAdd kernel " << (i + 1)
-                      << " completed in " << duration.count() << " μs" << std::endl;
-          }
-
-          std::this_thread::sleep_for(std::chrono::milliseconds(5));
-        } catch (const std::exception& e) {
-          std::lock_guard<std::mutex> lock(print_mutex);
-          std::cout << "[Thread " << thread_id << "] Vector iteration " << i
-                    << " failed: " << e.what() << std::endl;
-        }
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "[Thread " << thread_id << "] All vector operations completed" << std::endl;
-      }
-      threads_completed++;
-    } catch (...) {
-      thread_exceptions.at(thread_id) = std::current_exception();
-      threads_completed++;
-    }
-  });
-
-  // Thread 3: Memory operations
-  threads.emplace_back([&, thread_id = 2]() {
-    try {
-      threads_ready++;
-      while (!all_threads_ready.load()) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "\n[Thread " << thread_id << "] Starting memory operations..." << std::endl;
-      }
-
-      const size_t mem_size = 8192;
-      std::vector<int> data(mem_size, 42);
-
-      // Run memory fill/copy operations
-      for (int i = 0; i < 3; ++i) {
-        try {
-          sycl::buffer<int, 1> data_buf(data.data(), data.size());
-
-          auto start_time = std::chrono::high_resolution_clock::now();
-
-          // Memory fill operation
-          queue.submit([&](sycl::handler& cgh) {
-            auto acc = data_buf.get_access<sycl::access::mode::write>(cgh);
-            cgh.parallel_for<class __MemFill_MT>(sycl::range<1>(mem_size), [=](sycl::id<1> idx) {
-              acc[idx] = static_cast<int>(idx[0]) + i;
-            });
-          });
-          queue.wait_and_throw();
-
-          auto mid_time = std::chrono::high_resolution_clock::now();
-
-          // Memory copy-like operation
-          queue.submit([&](sycl::handler& cgh) {
-            auto acc = data_buf.get_access<sycl::access::mode::read_write>(cgh);
-            cgh.parallel_for<class __MemCopy_MT>(
-                sycl::range<1>(mem_size / 2),
-                [=](sycl::id<1> idx) { acc[idx + mem_size / 2] = acc[idx]; });
-          });
-          queue.wait_and_throw();
-
-          auto end_time = std::chrono::high_resolution_clock::now();
-          auto fill_duration =
-              std::chrono::duration_cast<std::chrono::microseconds>(mid_time - start_time);
-          auto copy_duration =
-              std::chrono::duration_cast<std::chrono::microseconds>(end_time - mid_time);
-
-          {
-            std::lock_guard<std::mutex> lock(print_mutex);
-            std::cout << "[Thread " << thread_id << "] Memory operations " << (i + 1)
-                      << " - Fill: " << fill_duration.count()
-                      << " μs, Copy: " << copy_duration.count() << " μs" << std::endl;
-          }
-
-          std::this_thread::sleep_for(std::chrono::milliseconds(8));
-        } catch (const std::exception& e) {
-          std::lock_guard<std::mutex> lock(print_mutex);
-          std::cout << "[Thread " << thread_id << "] Memory iteration " << i
-                    << " failed: " << e.what() << std::endl;
-        }
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "[Thread " << thread_id << "] All memory operations completed" << std::endl;
-      }
-      threads_completed++;
-    } catch (...) {
-      thread_exceptions.at(thread_id) = std::current_exception();
-      threads_completed++;
-    }
-  });
-
-  // Thread 4: Reduction operations
-  threads.emplace_back([&, thread_id = 3]() {
-    try {
-      threads_ready++;
-      while (!all_threads_ready.load()) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "\n[Thread " << thread_id << "] Starting reduction operations..." << std::endl;
-      }
-
-      const size_t reduce_size = 16384;
-      std::vector<float> input(reduce_size);
-      std::vector<float> output(reduce_size / 256, 0.0f);
-
-      // Initialize input data
-      for (size_t i = 0; i < reduce_size; ++i) {
-        input[i] = static_cast<float>(i % 100) / 100.0f;
-      }
-
-      // Run reduction kernels
-      for (int i = 0; i < 2; ++i) {
-        try {
-          sycl::buffer<float, 1> input_buf(input.data(), input.size());
-          sycl::buffer<float, 1> output_buf(output.data(), output.size());
-
-          auto start_time = std::chrono::high_resolution_clock::now();
-
-          queue.submit([&](sycl::handler& cgh) {
-            auto input_acc = input_buf.get_access<sycl::access::mode::read>(cgh);
-            auto output_acc = output_buf.get_access<sycl::access::mode::write>(cgh);
-
-            // Local memory for reduction
-            sycl::local_accessor<float, 1> local_mem(sycl::range<1>(256), cgh);
-
-            cgh.parallel_for<class __Reduction_MT>(
-                sycl::nd_range<1>(sycl::range<1>(reduce_size), sycl::range<1>(256)),
-                [=](sycl::nd_item<1> item) {
-                  size_t global_id = item.get_global_id(0);
-                  size_t local_id = item.get_local_id(0);
-                  size_t group_id = item.get_group(0);
-
-                  // Load data into local memory
-                  local_mem[local_id] = (global_id < reduce_size) ? input_acc[global_id] : 0.0f;
-                  sycl::group_barrier(item.get_group());
-
-                  // Reduction in local memory
-                  for (size_t stride = 128; stride > 0; stride >>= 1) {
-                    if (local_id < stride) {
-                      local_mem[local_id] += local_mem[local_id + stride];
-                    }
-                    sycl::group_barrier(item.get_group());
-                  }
-
-                  // Write result
-                  if (local_id == 0) {
-                    output_acc[group_id] = local_mem[0];
-                  }
-                });
-          });
-          queue.wait_and_throw();
-
-          auto end_time = std::chrono::high_resolution_clock::now();
-          auto duration =
-              std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-          {
-            std::lock_guard<std::mutex> lock(print_mutex);
-            std::cout << "[Thread " << thread_id << "] Reduction kernel " << (i + 1)
-                      << " completed in " << duration.count() << " μs" << std::endl;
-          }
-
-          std::this_thread::sleep_for(std::chrono::milliseconds(12));
-        } catch (const std::exception& e) {
-          std::lock_guard<std::mutex> lock(print_mutex);
-          std::cout << "[Thread " << thread_id << "] Reduction iteration " << i
-                    << " failed: " << e.what() << std::endl;
-        }
-      }
-
-      {
-        std::lock_guard<std::mutex> lock(print_mutex);
-        std::cout << "[Thread " << thread_id << "] All reduction operations completed" << std::endl;
-      }
-      threads_completed++;
-    } catch (...) {
-      thread_exceptions.at(thread_id) = std::current_exception();
-      threads_completed++;
-    }
-  });
-
-  // Wait for all threads to be ready
-  while (threads_ready.load() < num_threads) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-
-  std::cout << "\nAll threads ready, starting concurrent execution..." << std::endl;
-  all_threads_ready = true;
-
-  // Wait for all threads to complete with timeout
-  auto start_time = std::chrono::steady_clock::now();
-  const auto timeout = std::chrono::seconds(30);
-
-  while (threads_completed.load() < num_threads) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    auto elapsed = std::chrono::steady_clock::now() - start_time;
-    if (elapsed > timeout) {
-      std::cout << "Timeout waiting for threads to complete" << std::endl;
-      break;
-    }
-  }
-
-  // Join all threads
-  for (auto& thread : threads) {
-    if (thread.joinable()) {
-      thread.join();
-    }
-  }
-
-  // Check for thread exceptions
-  for (int i = 0; i < num_threads; ++i) {
-    if (thread_exceptions.at(i)) {
-      try {
-        std::rethrow_exception(thread_exceptions.at(i));
-      } catch (const std::exception& e) {
-        std::cout << "[Thread " << i << "] Exception: " << e.what() << std::endl;
-      }
-    }
-  }
-
-  std::cout << "\n=== All threads completed, stopping collection ===" << std::endl;
-
-  // Stop collection
-  EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-  // Process collected data with detailed metrics printing
-  size_t buffer_count = 0;
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-
-  std::cout << "\n=== METRICS COLLECTION RESULTS ===" << std::endl;
-  std::cout << "Total collection buffers: " << buffer_count << std::endl;
-
-  size_t total_records = 0;
-  std::map<std::string, int> kernel_type_counts;
-  std::map<std::string, std::vector<double>> metric_values_by_kernel;
-
-  if (buffer_count > 0) {
-    for (size_t i = 0; i < buffer_count; i++) {
-      std::cout << "\n--- Processing Buffer " << i << " with User Buffer---" << std::endl;
-
-      void* buffer = nullptr;
-      size_t buffer_size = 0;
-      EXPECT_EQ(ptiMetricsScopeGetCollectionBuffer(scope_handle, i, &buffer, &buffer_size),
-                PTI_SUCCESS);
-
-      if (buffer != nullptr) {
-        pti_metrics_scope_collection_buffer_properties_t props;
-        props._struct_size = sizeof(props);
-        EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, &props),
-                  PTI_SUCCESS);
-
-        total_records += props._num_scopes;
-        std::cout << "Buffer " << i << " properties:" << std::endl;
-        std::cout << "  Device: " << reinterpret_cast<void*>(props._device_handle) << std::endl;
-        std::cout << "  Records: " << props._num_scopes << std::endl;
-        std::cout << "  Size: " << buffer_size << " bytes" << std::endl;
-
-        // Query required buffer size for user buffer
-        size_t required_buffer_size = 0;
-        size_t records_count = 0;
-        pti_result query_result = ptiMetricsScopeQueryMetricsBufferSize(
-            scope_handle, buffer, &required_buffer_size, &records_count);
-
-        if (query_result == PTI_SUCCESS && records_count > 0 && required_buffer_size > 0) {
-          std::cout << "  Required user buffer size: " << required_buffer_size << " bytes"
-                    << std::endl;
-          std::cout << "  Records count: " << records_count << std::endl;
-
-          // User allocates the buffer
-          auto metrics_buffer = std::make_unique<uint8_t[]>(required_buffer_size);
-          ASSERT_NE(metrics_buffer, nullptr) << "Failed to allocate user buffer";
-
-          // Calculate metrics into user buffer for detailed analysis
-          size_t actual_records_count = 0;
-          pti_result calc_result =
-              ptiMetricsScopeCalculateMetrics(scope_handle, buffer, metrics_buffer.get(),
-                                              required_buffer_size, &actual_records_count);
-
-          if (calc_result == PTI_SUCCESS && actual_records_count > 0) {
-            std::cout << "  Successfully calculated metrics for " << actual_records_count
-                      << " kernel records using user buffer" << std::endl;
-
-            auto records = reinterpret_cast<pti_metrics_scope_record_t*>(metrics_buffer.get());
-
-            // Process each kernel record
-            for (size_t r = 0; r < actual_records_count; r++) {
-              std::cout << "\n  === Kernel Record " << r << " ===" << std::endl;
-              std::cout << "    Kernel ID: " << records[r]._kernel_id << std::endl;
-              std::cout << "    Queue: " << reinterpret_cast<void*>(records[r]._queue) << std::endl;
-
-              std::string kernel_name = "Unknown";
-              if (records[r]._kernel_name) {
-                kernel_name = std::string(records[r]._kernel_name);
-                std::cout << "    Kernel Name: " << kernel_name << std::endl;
-              }
-
-              // Count kernel types
-              std::string kernel_type = "Other";
-              if (kernel_name.find("GEMM") != std::string::npos)
-                kernel_type = "GEMM";
-              else if (kernel_name.find("VectorAdd") != std::string::npos)
-                kernel_type = "VectorAdd";
-              else if (kernel_name.find("MemFill") != std::string::npos)
-                kernel_type = "MemFill";
-              else if (kernel_name.find("MemCopy") != std::string::npos)
-                kernel_type = "MemCopy";
-              else if (kernel_name.find("Reduction") != std::string::npos)
-                kernel_type = "Reduction";
-
-              kernel_type_counts[kernel_type]++;
-
-              // Direct access to requested metrics using metadata
-              std::cout << "    Metrics (" << metadata._metrics_count << " total):" << std::endl;
-
-              // Validate that we have metric values
-              EXPECT_NE(records[r]._metrics_values, nullptr);
-
-              for (uint32_t m = 0; m < metadata._metrics_count; ++m) {
-                std::string formatted_value = FormatMetricValue(m, records[r]._metrics_values[m]);
-                std::cout << "      " << std::setw(25) << std::left << metadata._metric_names[m]
-                          << ": " << std::setw(15) << std::right << formatted_value << std::endl;
-
-                // Store metric values for summary
-                std::string metric_key = kernel_type + "::" + metadata._metric_names[m];
-
-                // Extract numeric value for averaging
-                double numeric_value = 0.0;
-                switch (metadata._value_types[m]) {
-                  case PTI_METRIC_VALUE_TYPE_UINT32:
-                    numeric_value = static_cast<double>(records[r]._metrics_values[m].ui32);
-                    break;
-                  case PTI_METRIC_VALUE_TYPE_UINT64:
-                    numeric_value = static_cast<double>(records[r]._metrics_values[m].ui64);
-                    break;
-                  case PTI_METRIC_VALUE_TYPE_FLOAT32:
-                    numeric_value = static_cast<double>(records[r]._metrics_values[m].fp32);
-                    break;
-                  case PTI_METRIC_VALUE_TYPE_FLOAT64:
-                    numeric_value = records[r]._metrics_values[m].fp64;
-                    break;
-                  default:
-                    numeric_value = 0.0;
-                    break;
-                }
-                metric_values_by_kernel[metric_key].push_back(numeric_value);
-              }
-            }
-          } else {
-            std::cout << "  Failed to calculate metrics into user buffer (result: " << calc_result
-                      << ")" << std::endl;
-          }
-        } else {
-          std::cout << "  Failed to query buffer size (result: " << query_result << ")"
-                    << std::endl;
-        }
-      }
-    }
-
-    // Print summary statistics
-    std::cout << "\n=== SUMMARY STATISTICS ===" << std::endl;
-    std::cout << "Total kernel records collected: " << total_records << std::endl;
-    std::cout << "Kernel type distribution:" << std::endl;
-
-    for (const auto& [kernel_type, count] : kernel_type_counts) {
-      std::cout << "  " << std::setw(15) << std::left << kernel_type << ": " << count << " kernels"
-                << std::endl;
-    }
-
-    if (!metric_values_by_kernel.empty()) {
-      std::cout << "\nAverage metric values by kernel type:" << std::endl;
-
-      std::map<std::string, std::map<std::string, double>> avg_metrics_by_type;
-
-      for (const auto& [metric_key, values] : metric_values_by_kernel) {
-        size_t pos = metric_key.find("::");
-        if (pos != std::string::npos) {
-          std::string kernel_type = metric_key.substr(0, pos);
-          std::string metric_name = metric_key.substr(pos + 2);
-
-          double sum = 0.0;
-          for (double val : values) sum += val;
-          double avg = values.empty() ? 0.0 : sum / values.size();
-
-          avg_metrics_by_type[kernel_type][metric_name] = avg;
-        }
-      }
-
-      for (const auto& [kernel_type, metrics] : avg_metrics_by_type) {
-        std::cout << "\n  " << kernel_type << " kernels:" << std::endl;
-        for (const auto& [metric_name, avg_value] : metrics) {
-          std::cout << "    " << std::setw(25) << std::left << metric_name << ": " << std::setw(15)
-                    << std::right << std::fixed << std::setprecision(3) << avg_value << std::endl;
-        }
-      }
-    }
-
-  } else {
-    std::cout << "\nNo data collected. This might indicate:" << std::endl;
-    std::cout << "  1. Callbacks were not triggered" << std::endl;
-    std::cout << "  2. No GPU kernels were detected" << std::endl;
-    std::cout << "  3. Query data collection failed" << std::endl;
-    std::cout << "  4. Metric group not supported on this device" << std::endl;
-  }
-
-  std::cout << "\n=== MULTI-THREADED TEST SUMMARY ===" << std::endl;
-  std::cout << "Threads completed: " << threads_completed.load() << "/" << num_threads << std::endl;
-  std::cout << "Total kernel records: " << total_records << std::endl;
-  std::cout << "Collection buffers used: " << buffer_count << std::endl;
-  std::cout << "Unique kernel types detected: " << kernel_type_counts.size() << std::endl;
-
-  // The test passes if:
-  // 1. All threads completed without crashing
-  // 2. Collection worked without errors
-  // 3. We collected some data (even if callbacks didn't trigger, the API should work)
-  EXPECT_EQ(threads_completed.load(), num_threads);
-
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-
-  std::cout << "\n=== Multi-threaded metrics scope test completed successfully ===" << std::endl;
-  std::cout << std::defaultfloat;
-  std::cout.precision(default_precision);
-  std::cout.flags(default_flags);
-  std::cout.fill(default_fill);
-}
-
-TEST_F(GemmMetricsScopeFixtureTest, ScopeWithOverheadTracking) {
-  GemmMetricsScopeFixtureTest::overhead_stats.Reset();
-
-  EXPECT_EQ(ptiViewEnableRuntimeApiClass(1, PTI_API_CLASS_GPU_OPERATION_CORE, PTI_API_GROUP_ALL),
-            PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD), PTI_SUCCESS);
-
-  // Set up metrics scope collection
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  EXPECT_EQ(ptiMetricsScopeEnable(&scope_handle), PTI_SUCCESS);
-
-  // Configure with ComputeBasic metrics
-  pti_device_handle_t device = devices.size() > 0 ? devices.at(0)._handle : nullptr;
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-  pti_result config_result = ptiMetricsScopeConfigure(
-      scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1, kMetricNames.data(), metric_count);
-
-  if (config_result != PTI_SUCCESS) {
-    std::cout << "Configuration failed with error: " << config_result << std::endl;
-    EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-    return;
-  }
-
-  // Query and set buffer size
-  size_t estimated_buffer_size = 0;
-  EXPECT_EQ(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, 10, &estimated_buffer_size),
-            PTI_SUCCESS);
-  EXPECT_GT(estimated_buffer_size, static_cast<size_t>(0));
-
-  EXPECT_EQ(ptiMetricsScopeSetCollectionBufferSize(scope_handle, estimated_buffer_size),
-            PTI_SUCCESS);
-
-  // Get metadata
-  pti_metrics_scope_record_metadata_t metadata;
-  metadata._struct_size = sizeof(pti_metrics_scope_record_metadata_t);
-  EXPECT_EQ(ptiMetricsScopeGetMetricsMetadata(scope_handle, &metadata), PTI_SUCCESS);
-
-  std::cout << "=== Testing Metrics Scope with Overhead Tracking ===" << std::endl;
-  std::cout << "Metrics count per record: " << metadata._metrics_count << std::endl;
-
-  // Start collection
-  EXPECT_EQ(ptiMetricsScopeStartCollection(scope_handle), PTI_SUCCESS);
-
-  // Run GEMM workload
-  try {
-    RunGemm(256, 2);  // Small matrix size, 2 iterations
-  } catch (...) {
-    std::cout << "GEMM workload failed, but continuing with test" << std::endl;
-  }
-
-  // Stop collection
-  EXPECT_EQ(ptiMetricsScopeStopCollection(scope_handle), PTI_SUCCESS);
-
-  // Get metrics scope buffer count
-  size_t buffer_count = 0;
-  EXPECT_EQ(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count), PTI_SUCCESS);
-
-  std::cout << "\n=== Metrics Scope Results ===" << std::endl;
-  std::cout << "Number of collection buffers: " << buffer_count << std::endl;
-
-  size_t total_metrics_records = 0;
-
-  // Process metrics scope buffers
-  if (buffer_count > 0) {
-    for (size_t i = 0; i < buffer_count; i++) {
-      void* buffer_data = nullptr;
-      size_t actual_buffer_size = 0;
-      EXPECT_EQ(
-          ptiMetricsScopeGetCollectionBuffer(scope_handle, i, &buffer_data, &actual_buffer_size),
-          PTI_SUCCESS);
-
-      if (buffer_data != nullptr) {
-        pti_metrics_scope_collection_buffer_properties_t props;
-        props._struct_size = sizeof(props);
-        EXPECT_EQ(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer_data, &props),
-                  PTI_SUCCESS);
-
-        std::cout << "  Buffer " << i << ": " << props._num_scopes << " scopes" << std::endl;
-
-        // Query and calculate metrics
-        size_t required_buffer_size = 0;
-        size_t records_count = 0;
-
-        pti_result query_result = ptiMetricsScopeQueryMetricsBufferSize(
-            scope_handle, buffer_data, &required_buffer_size, &records_count);
-
-        if (query_result == PTI_SUCCESS && records_count > 0) {
-          auto metrics_buffer = std::make_unique<uint8_t[]>(required_buffer_size);
-          size_t actual_records_count = 0;
-
-          pti_result calc_result =
-              ptiMetricsScopeCalculateMetrics(scope_handle, buffer_data, metrics_buffer.get(),
-                                              required_buffer_size, &actual_records_count);
-
-          if (calc_result == PTI_SUCCESS) {
-            std::cout << "  Calculated " << actual_records_count << " metric records" << std::endl;
-            total_metrics_records += actual_records_count;
-
-            // Validate we can access the records
-            auto records = reinterpret_cast<pti_metrics_scope_record_t*>(metrics_buffer.get());
-            for (size_t r = 0; r < actual_records_count; r++) {
-              EXPECT_NE(records[r]._metrics_values, nullptr);
-              if (records[r]._kernel_name) {
-                std::cout << "    Record " << r << ": " << records[r]._kernel_name << std::endl;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Flush all views to ensure overhead records are captured
-  EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-
-  // Display overhead tracking results
-  std::cout << "\n=== Overhead Tracking Results ===" << std::endl;
-  std::cout << "Overhead records collected: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.overhead_records.size() << std::endl;
-
-  std::cout << "\n=== View Records Summary ===" << std::endl;
-  std::cout << "GPU Kernel records: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.kernel_record_count << std::endl;
-  std::cout << "Memory Copy records: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.mem_copy_record_count << std::endl;
-  std::cout << "Runtime API records: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.runtime_api_record_count << std::endl;
-  std::cout << "Invalid records: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.invalid_record_count << std::endl;
-
-  std::cout << "\n=== Test Validation ===" << std::endl;
-
-  // Check metrics scope records
-  ASSERT_GT(total_metrics_records, static_cast<size_t>(0))
-      << "FAILURE: No metrics scope records collected. Expected at least 1 record.";
-  std::cout << "PASS: Metrics scope records collected: " << total_metrics_records << std::endl;
-
-  // Check overhead records
-  ASSERT_GT(GemmMetricsScopeFixtureTest::overhead_stats.overhead_records.size(),
-            static_cast<size_t>(0))
-      << "FAILURE: No overhead records collected. Expected at least 1 overhead record when "
-         "PTI_VIEW_COLLECTION_OVERHEAD is enabled.";
-  std::cout << "PASS: Overhead records collected: "
-            << GemmMetricsScopeFixtureTest::overhead_stats.overhead_records.size() << std::endl;
-
-  // Check for invalid records (should be zero)
-  ASSERT_EQ(GemmMetricsScopeFixtureTest::overhead_stats.invalid_record_count,
-            static_cast<size_t>(0))
-      << "FAILURE: Received " << GemmMetricsScopeFixtureTest::overhead_stats.invalid_record_count
-      << " PTI_VIEW_INVALID records.";
-  std::cout << "PASS: No invalid records received" << std::endl;
-
-  // Check each view kind - all should have records
-  ASSERT_GT(GemmMetricsScopeFixtureTest::overhead_stats.kernel_record_count, static_cast<size_t>(0))
-      << "FAILURE: No PTI_VIEW_DEVICE_GPU_KERNEL records received. Expected at least 1.";
-  std::cout << "PASS: GPU Kernel records received" << std::endl;
-
-  ASSERT_GT(GemmMetricsScopeFixtureTest::overhead_stats.mem_copy_record_count,
-            static_cast<size_t>(0))
-      << "FAILURE: No PTI_VIEW_DEVICE_GPU_MEM_COPY records received. Expected at least 1.";
-  std::cout << "PASS: Memory Copy records received" << std::endl;
-
-  ASSERT_GT(GemmMetricsScopeFixtureTest::overhead_stats.runtime_api_record_count,
-            static_cast<size_t>(0))
-      << "FAILURE: No PTI_VIEW_RUNTIME_API records received. Expected at least 1.";
-  std::cout << "PASS: Runtime API records received" << std::endl;
-
-  std::cout << "\n=== TEST PASSED: All validations successful ===" << std::endl;
-
-  // Cleanup
-  EXPECT_EQ(ptiMetricsScopeDisable(scope_handle), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD), PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), PTI_SUCCESS);
-
-  std::cout << "\n=== Overhead tracking test completed ===" << std::endl;
-}
-
-// ============================================================================
-// Multi-Device Feature Tests
-// ============================================================================
-
-std::optional<sycl::device> FindSyclDeviceForPtiHandle(pti_device_handle_t pti_handle) {
-  for (auto& platform : sycl::platform::get_platforms()) {
-    if (platform.get_backend() != sycl::backend::ext_oneapi_level_zero) {
-      continue;
-    }
-    for (auto& dev : platform.get_devices(sycl::info::device_type::gpu)) {
-      auto* native = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(dev);
-      if (static_cast<pti_device_handle_t>(native) == pti_handle) {
-        return dev;
-      }
-    }
-  }
-  return std::nullopt;
-}
-
-// Configuration argument validation for auto-detect mode.
-// (The success path is covered by AutoDetectStartStop.)
-TEST_F(GemmMetricsScopeFixtureTest, MultiDeviceConfigurationValidation) {
-  if (devices.size() < 1) {
-    GTEST_SKIP() << "Need at least 1 device";
-  }
-
-  pti_scope_collection_handle_t handle;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  auto kMetricNames = std::array{"GpuTime"};
-
-  // Invalid combination - auto-detect with non-null devices
-  pti_device_handle_t device = devices.at(0)._handle;
-  pti_result result =
-      ptiMetricsScopeConfigure(handle, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 0,
-                               kMetricNames.data(), static_cast<uint32_t>(kMetricNames.size()));
-  EXPECT_EQ(PTI_ERROR_BAD_ARGUMENT, result)
-      << "Auto-detect mode with non-null devices should return BAD_ARGUMENT";
-
-  // Invalid combination - null devices with explicit count
-  result =
-      ptiMetricsScopeConfigure(handle, PTI_METRICS_SCOPE_AUTO_KERNEL, nullptr, 1,
-                               kMetricNames.data(), static_cast<uint32_t>(kMetricNames.size()));
-  EXPECT_EQ(PTI_ERROR_BAD_ARGUMENT, result)
-      << "Null devices with explicit count should return BAD_ARGUMENT";
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 1: Smallest test that the multi-device collection block is removed.
-// Configure 2 devices, set buffer size, start, stop. No GPU work submitted —
-// keeps the failure surface focused on the StartCollection contract.
-TEST_F(GemmMetricsScopeFixtureTest, StartStopCollection) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  std::vector<pti_device_handle_t> device_handles;
-  for (const auto& d : devices) {
-    device_handles.push_back(d._handle);
-  }
-  auto kMetricNames = std::array{"GpuTime"};
-
-  ConfigureOrSkipIfNonUniform(handle, device_handles.data(),
-                              static_cast<uint32_t>(device_handles.size()), kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, 1024));
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// End-to-end collection. Submit GEMM serially to each configured device, verify
-// per-device buffer attribution, and that metrics can be calculated for each
-// buffer. Runs on every configured device (including a single-device host).
-TEST_F(GemmMetricsScopeFixtureTest, CompleteWorkflowWithGemm) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  std::vector<pti_device_handle_t> device_handles;
-  for (const auto& d : devices) {
-    device_handles.push_back(d._handle);
-  }
-  std::set<pti_device_handle_t> configured_handles(device_handles.begin(), device_handles.end());
-
-  auto kMetricNames = std::array{"GpuTime",
-                                 "GpuCoreClocks",
-                                 "AvgGpuCoreFrequencyMHz",
-                                 "XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION",
-                                 "XVE_ACTIVE",
-                                 "XVE_STALL"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  ConfigureOrSkipIfNonUniform(handle, device_handles.data(),
-                              static_cast<uint32_t>(device_handles.size()), kMetricNames.data(),
-                              metric_count);
-
-  size_t buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 50, &buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, buffer_size));
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-
-  // Submit one GEMM to each configured device.
-  for (auto pti_handle : device_handles) {
-    auto match = FindSyclDeviceForPtiHandle(pti_handle);
-    ASSERT_TRUE(match.has_value()) << "Could not map pti_device_handle to sycl::device";
-    try {
-      RunGemm(128, 1, &(*match));
-    } catch (const std::exception& e) {
-      ADD_FAILURE() << "GEMM submission failed on device " << pti_handle << ": " << e.what();
-    }
-  }
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  size_t buffer_count = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBuffersCount(handle, &buffer_count));
-  EXPECT_GE(buffer_count, device_handles.size()) << "Expected at least one buffer per device";
-
-  std::set<pti_device_handle_t> seen_devices;
-  for (size_t i = 0; i < buffer_count; ++i) {
-    void* buffer = nullptr;
-    size_t actual_size = 0;
-    ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBuffer(handle, i, &buffer, &actual_size));
-    ASSERT_NE(buffer, nullptr);
-
-    pti_metrics_scope_collection_buffer_properties_t bprops;
-    bprops._struct_size = sizeof(bprops);
-    ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBufferProperties(handle, buffer, &bprops));
-
-    EXPECT_EQ(configured_handles.count(bprops._device_handle), 1u)
-        << "Buffer " << i << " has unexpected device handle " << bprops._device_handle;
-    seen_devices.insert(bprops._device_handle);
-    EXPECT_GE(bprops._num_scopes, 1u);
-
-    size_t required = 0;
-    size_t records = 0;
-    ASSERT_EQ(PTI_SUCCESS,
-              ptiMetricsScopeQueryMetricsBufferSize(handle, buffer, &required, &records));
-    if (records > 0) {
-      auto user_buf = std::make_unique<uint8_t[]>(required);
-      size_t actual_records = 0;
-      EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeCalculateMetrics(handle, buffer, user_buf.get(),
-                                                             required, &actual_records));
-      EXPECT_GE(actual_records, 1u);
-    }
-  }
-
-  EXPECT_EQ(seen_devices.size(), device_handles.size())
-      << "Expected every configured device to produce a buffer";
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 3: Auto-detect mode (devices=nullptr, count=0) reaches start/stop.
-// The primary user-facing path for multi-device. Distinct from Test 1 in
-// argument validation; doesn't duplicate end-to-end coverage from Test 2.
-TEST_F(GemmMetricsScopeFixtureTest, AutoDetectStartStop) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  auto kMetricNames = std::array{"GpuTime"};
-  ConfigureOrSkipIfNonUniform(handle, nullptr, 0, kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, 1024));
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 4: Multi-threaded multi-device. 4 threads per device (8 total) each
-// submit 20 GEMM kernels concurrently during an active collection. Exercises
-// the per-(device, thread) buffer map and data_mutex_/buffer_id_mutex_
-// interaction under cross-device concurrency. ScopeMultiThreadedDifferentKernels
-// covers the single-device case; this is the orthogonal multi-device case.
-TEST_F(GemmMetricsScopeMultiDeviceFixtureTest, MultiDeviceMultiThreadedConcurrentSubmission) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  std::vector<pti_device_handle_t> device_handles = {devices.at(0)._handle, devices.at(1)._handle};
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  ConfigureOrSkipIfNonUniform(handle, device_handles.data(), 2, kMetricNames.data(), metric_count);
-
-  size_t buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 200, &buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, buffer_size));
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-
-  constexpr int kThreadsPerDevice = 4;
-  constexpr int kKernelsPerThread = 20;
-  RunGemmThreadsPerDevice(kThreadsPerDevice, kKernelsPerThread, device_handles);
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  std::set<pti_device_handle_t> expected_devices(device_handles.begin(), device_handles.end());
-  std::set<pti_device_handle_t> seen_devices;
-  const size_t total_records = IterateBuffersCheckDevices(handle, expected_devices, seen_devices);
-
-  EXPECT_EQ(seen_devices.size(), 2u) << "Both devices should have produced buffers";
-  const int num_threads = kThreadsPerDevice * static_cast<int>(device_handles.size());
-  EXPECT_GE(total_records, static_cast<size_t>(num_threads * kKernelsPerThread))
-      << "Total records should reflect roughly all submitted kernels";
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 5: Asymmetric load. 2 devices configured, kernel submitted only to
-// device 0. Verifies stop/finalize doesn't hang on the idle device and no
-// phantom buffers appear for the device that received no work.
-TEST_F(GemmMetricsScopeMultiDeviceFixtureTest, MultiDeviceKernelOnlyOnOneDevice) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  std::vector<pti_device_handle_t> device_handles = {devices.at(0)._handle, devices.at(1)._handle};
-  auto kMetricNames = std::array{"GpuTime"};
-
-  ConfigureOrSkipIfNonUniform(handle, device_handles.data(), 2, kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-
-  size_t buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 10, &buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, buffer_size));
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-
-  // Submit only to device 0; device 1 stays idle.
-  auto match = FindSyclDeviceForPtiHandle(devices.at(0)._handle);
-  ASSERT_TRUE(match.has_value()) << "Could not map device 0 to sycl::device";
-  try {
-    RunGemm(128, 1, &(*match));
-  } catch (const std::exception& e) {
-    ADD_FAILURE() << "GEMM submission failed: " << e.what();
-  }
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  std::set<pti_device_handle_t> expected_devices = {devices.at(0)._handle};
-  std::set<pti_device_handle_t> seen_devices;
-  IterateBuffersCheckDevices(handle, expected_devices, seen_devices);
-  EXPECT_EQ(seen_devices.size(), 1u);
-  EXPECT_EQ(seen_devices.count(devices.at(0)._handle), 1u);
-  EXPECT_EQ(seen_devices.count(devices.at(1)._handle), 0u);
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 6: Buffer rotation under pressure on both devices. Tiny buffer (~5
-// records) plus 20 kernels per device forces per-device buffer rotation.
-// Stresses next_buffer_ids_ map and rotation logic in PtiMetricsScopeBufferHandler.
-TEST_F(GemmMetricsScopeMultiDeviceFixtureTest, MultiDeviceBufferRotationBothDevices) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  std::vector<pti_device_handle_t> device_handles = {devices.at(0)._handle, devices.at(1)._handle};
-  auto kMetricNames = std::array{"GpuTime"};
-
-  ConfigureOrSkipIfNonUniform(handle, device_handles.data(), 2, kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-
-  // Small buffer (~5 records) to force rotation across 20 kernels per device.
-  size_t small_buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 5, &small_buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, small_buffer_size));
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle))
-      << "Multi-device StartCollection should succeed once the block is removed";
-
-  for (auto pti_handle : device_handles) {
-    auto match = FindSyclDeviceForPtiHandle(pti_handle);
-    ASSERT_TRUE(match.has_value());
-    for (int k = 0; k < 20; ++k) {
-      try {
-        RunGemm(128, 1, &(*match));
-      } catch (const std::exception& e) {
-        ADD_FAILURE() << "GEMM submission failed: " << e.what();
-      }
-    }
-  }
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  size_t buffer_count = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBuffersCount(handle, &buffer_count));
-  EXPECT_GT(buffer_count, 2u) << "Tiny buffer + 40 kernels should force rotation";
-
-  std::set<pti_device_handle_t> seen_devices;
-  for (size_t i = 0; i < buffer_count; ++i) {
-    void* buffer = nullptr;
-    size_t actual_size = 0;
-    ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBuffer(handle, i, &buffer, &actual_size));
-    pti_metrics_scope_collection_buffer_properties_t bprops;
-    bprops._struct_size = sizeof(bprops);
-    ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeGetCollectionBufferProperties(handle, buffer, &bprops));
-    EXPECT_TRUE(bprops._device_handle == device_handles.at(0) ||
-                bprops._device_handle == device_handles.at(1))
-        << "Buffer " << i << " has unexpected device handle " << bprops._device_handle;
-    seen_devices.insert(bprops._device_handle);
-  }
-  EXPECT_EQ(seen_devices.size(), 2u);
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Test 7: Reconfigure shrinks device set from 2 to 1. Verifies no stale state
-// from device 1's prior profiler bleeds into the second collection — every
-// buffer from cycle 2 must belong to device 0.
-TEST_F(GemmMetricsScopeMultiDeviceFixtureTest, MultiDeviceReconfigureAfterStop) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  // Cycle 1: 2 devices, no GPU work submitted.
-  std::vector<pti_device_handle_t> two_devices = {devices.at(0)._handle, devices.at(1)._handle};
-  auto kMetricNames = std::array{"GpuTime"};
-  ConfigureOrSkipIfNonUniform(handle, two_devices.data(), 2, kMetricNames.data(),
-                              static_cast<uint32_t>(kMetricNames.size()));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, 1024));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  // Cycle 2: reconfigure to 1 device (device 0 only), submit GEMM.
-  pti_device_handle_t one_device = devices.at(0)._handle;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeConfigure(handle, PTI_METRICS_SCOPE_AUTO_KERNEL,
-                                                  &one_device, 1, kMetricNames.data(),
-                                                  static_cast<uint32_t>(kMetricNames.size())))
-      << "Cycle 2 reconfigure to single device failed";
-  size_t buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 10, &buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-
-  auto match = FindSyclDeviceForPtiHandle(one_device);
-  ASSERT_TRUE(match.has_value()) << "Could not map device 0 to sycl::device";
-  try {
-    RunGemm(128, 1, &(*match));
-  } catch (const std::exception& e) {
-    ADD_FAILURE() << "GEMM submission failed: " << e.what();
-  }
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  std::set<pti_device_handle_t> expected_devices = {one_device};
-  std::set<pti_device_handle_t> seen_devices;
-  IterateBuffersCheckDevices(handle, expected_devices, seen_devices);
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
-
-// Auto-detect mode + multi-threaded stress test that scales to ALL devices on
-// the host. kThreadsPerDevice threads per device, kKernelsPerThread kernels per
-// thread, each thread bound to one device. Verifies auto-detect configures
-// every device and that buffers/records are attributed to every device under
-// cross-device cross-thread concurrency.
-TEST_F(GemmMetricsScopeFixtureTest, AutoDetectMultiThreadedAllDevices) {
-  pti_scope_collection_handle_t handle = nullptr;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeEnable(&handle));
-
-  auto kMetricNames = std::array{"GpuTime", "GpuCoreClocks"};
-  const auto metric_count = static_cast<uint32_t>(kMetricNames.size());
-
-  ConfigureOrSkipIfNonUniform(handle, nullptr, 0, kMetricNames.data(), metric_count);
-
-  std::vector<pti_device_handle_t> all_handles;
-  for (const auto& d : devices) {
-    all_handles.push_back(d._handle);
-  }
-  std::set<pti_device_handle_t> expected_devices(all_handles.begin(), all_handles.end());
-
-  size_t buffer_size = 0;
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeQueryCollectionBufferSize(handle, 200, &buffer_size));
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeSetCollectionBufferSize(handle, buffer_size));
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStartCollection(handle));
-
-  constexpr int kThreadsPerDevice = 2;
-  constexpr int kKernelsPerThread = 5;
-  RunGemmThreadsPerDevice(kThreadsPerDevice, kKernelsPerThread, all_handles);
-
-  ASSERT_EQ(PTI_SUCCESS, ptiMetricsScopeStopCollection(handle));
-
-  std::set<pti_device_handle_t> seen_devices;
-  const size_t total_records = IterateBuffersCheckDevices(handle, expected_devices, seen_devices);
-
-  EXPECT_EQ(seen_devices.size(), expected_devices.size())
-      << "Every auto-detected device should have produced buffers";
-  const int num_threads = kThreadsPerDevice * static_cast<int>(all_handles.size());
-  EXPECT_GE(total_records, static_cast<size_t>(num_threads * kKernelsPerThread))
-      << "Total records should reflect roughly all submitted kernels";
-
-  EXPECT_EQ(PTI_SUCCESS, ptiMetricsScopeDisable(handle));
-}
diff --git a/sdk/test/metrics_scope_parallel.cc b/sdk/test/metrics_scope_parallel.cc
deleted file mode 100644
index 79e0aabd..00000000
--- a/sdk/test/metrics_scope_parallel.cc
+++ /dev/null
@@ -1,798 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-//==============================================================
-// Multi-Device Parallel Metrics Scope Test
-//==============================================================
-
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <chrono>
-#include <iomanip>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "pti/pti_callback.h"
-#include "pti/pti_metrics_scope.h"
-#include "samples_utils.h"
-
-namespace {
-
-// Simple workload kernels for testing
-void SimpleVectorAdd(const float* a, const float* b, float* c, size_t size, sycl::id<1> id) {
-  size_t idx = id.get(0);
-  if (idx < size) {
-    c[idx] = a[idx] + b[idx];
-  }
-}
-
-void SimpleVectorMul(const float* a, const float* b, float* c, size_t size, sycl::id<1> id) {
-  size_t idx = id.get(0);
-  if (idx < size) {
-    c[idx] = a[idx] * b[idx];
-  }
-}
-
-void SimpleMatrixMul(const float* a, const float* b, float* c, size_t size, sycl::id<2> id) {
-  size_t i = id.get(0);
-  size_t j = id.get(1);
-  if (i < size && j < size) {
-    float sum = 0.0f;
-    for (size_t k = 0; k < size; ++k) {
-      sum += a[i * size + k] * b[k * size + j];
-    }
-    c[i * size + j] = sum;
-  }
-}
-
-// Test parameters
-constexpr size_t kVectorSize = 8192;
-constexpr size_t kMatrixSize = 64;
-constexpr int kIterationsPerDevice = 5;
-
-// Global test data
-std::vector<pti_device_properties_t> g_devices;
-std::mutex g_print_mutex;
-
-// Thread-safe printing helper
-template <typename... Args>
-void SafePrint(Args&&... args) {
-  std::lock_guard<std::mutex> lock(g_print_mutex);
-  (std::cout << ... << args) << std::endl;
-}
-
-// A PTI device handle is a Level Zero handle, so pair it with a SYCL device by native
-// handle. Position in get_devices() is not a valid pairing: other backends may
-// enumerate their GPUs first.
-sycl::device FindSyclDeviceForPtiHandle(pti_device_handle_t pti_handle) {
-  for (const auto& platform : sycl::platform::get_platforms()) {
-    if (platform.get_backend() != sycl::backend::ext_oneapi_level_zero) {
-      continue;
-    }
-    for (const auto& device : platform.get_devices(sycl::info::device_type::gpu)) {
-      auto* native = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(device);
-      if (static_cast<pti_device_handle_t>(native) == pti_handle) {
-        return device;
-      }
-    }
-  }
-  throw std::runtime_error("No Level Zero SYCL device matches the PTI device handle");
-}
-
-// Device workload runner
-class DeviceWorkloadRunner {
- private:
-  pti_device_handle_t device_handle_;
-  sycl::device sycl_device_;
-  sycl::queue queue_;
-  int device_id_;
-  std::string device_name_;
-
- public:
-  DeviceWorkloadRunner(pti_device_handle_t device_handle, int device_id)
-      : device_handle_(device_handle), device_id_(device_id) {
-    sycl_device_ = FindSyclDeviceForPtiHandle(device_handle);
-    device_name_ = sycl_device_.get_info<sycl::info::device::name>();
-
-    sycl::property_list prop_list{sycl::property::queue::in_order()};
-    queue_ = sycl::queue(sycl_device_, sycl::async_handler{}, prop_list);
-
-    SafePrint("[Device ", device_id_, "] Using device: ", device_name_);
-  }
-
-  pti_device_handle_t GetDeviceHandle() const { return device_handle_; }
-  const std::string& GetDeviceName() const { return device_name_; }
-  int GetDeviceId() const { return device_id_; }
-
-  // Run vector addition workload
-  void RunVectorAddWorkload(int iteration) {
-    try {
-      std::vector<float> a(kVectorSize, static_cast<float>(device_id_ + 1));
-      std::vector<float> b(kVectorSize, static_cast<float>(iteration + 1));
-      std::vector<float> c(kVectorSize, 0.0f);
-
-      sycl::buffer<float, 1> a_buf(a.data(), a.size());
-      sycl::buffer<float, 1> b_buf(b.data(), b.size());
-      sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-      auto start_time = std::chrono::high_resolution_clock::now();
-
-      queue_.submit([&](sycl::handler& cgh) {
-        auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-        auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-        auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-        cgh.parallel_for<class VectorAdd_MultiDevice>(
-            sycl::range<1>(kVectorSize), [=](sycl::id<1> id) {
-              auto a_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto b_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto c_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-              SimpleVectorAdd(a_ptr.get(), b_ptr.get(), c_ptr.get(), kVectorSize, id);
-            });
-      });
-      queue_.wait_and_throw();
-
-      auto end_time = std::chrono::high_resolution_clock::now();
-      auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-      SafePrint("[Device ", device_id_, "] VectorAdd iteration ", iteration, " completed in ",
-                duration.count(), " μs");
-
-    } catch (const std::exception& e) {
-      SafePrint("[Device ", device_id_, "] VectorAdd iteration ", iteration, " failed: ", e.what());
-      throw;
-    }
-  }
-
-  // Run vector multiplication workload
-  void RunVectorMulWorkload(int iteration) {
-    try {
-      std::vector<float> a(kVectorSize, static_cast<float>(device_id_ + 2));
-      std::vector<float> b(kVectorSize, static_cast<float>(iteration + 2));
-      std::vector<float> c(kVectorSize, 0.0f);
-
-      sycl::buffer<float, 1> a_buf(a.data(), a.size());
-      sycl::buffer<float, 1> b_buf(b.data(), b.size());
-      sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-      auto start_time = std::chrono::high_resolution_clock::now();
-
-      queue_.submit([&](sycl::handler& cgh) {
-        auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-        auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-        auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-        cgh.parallel_for<class VectorMul_MultiDevice>(
-            sycl::range<1>(kVectorSize), [=](sycl::id<1> id) {
-              auto a_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto b_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto c_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-              SimpleVectorMul(a_ptr.get(), b_ptr.get(), c_ptr.get(), kVectorSize, id);
-            });
-      });
-      queue_.wait_and_throw();
-
-      auto end_time = std::chrono::high_resolution_clock::now();
-      auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-      SafePrint("[Device ", device_id_, "] VectorMul iteration ", iteration, " completed in ",
-                duration.count(), " μs");
-
-    } catch (const std::exception& e) {
-      SafePrint("[Device ", device_id_, "] VectorMul iteration ", iteration, " failed: ", e.what());
-      throw;
-    }
-  }
-
-  // Run matrix multiplication workload
-  void RunMatrixMulWorkload(int iteration) {
-    try {
-      std::vector<float> a(kMatrixSize * kMatrixSize, static_cast<float>(device_id_ + 3));
-      std::vector<float> b(kMatrixSize * kMatrixSize, static_cast<float>(iteration + 3));
-      std::vector<float> c(kMatrixSize * kMatrixSize, 0.0f);
-
-      sycl::buffer<float, 1> a_buf(a.data(), a.size());
-      sycl::buffer<float, 1> b_buf(b.data(), b.size());
-      sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-      auto start_time = std::chrono::high_resolution_clock::now();
-
-      queue_.submit([&](sycl::handler& cgh) {
-        auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-        auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-        auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-        cgh.parallel_for<class MatrixMul_MultiDevice>(
-            sycl::range<2>(kMatrixSize, kMatrixSize), [=](sycl::id<2> id) {
-              auto a_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto b_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-              auto c_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-              SimpleMatrixMul(a_ptr.get(), b_ptr.get(), c_ptr.get(), kMatrixSize, id);
-            });
-      });
-      queue_.wait_and_throw();
-
-      auto end_time = std::chrono::high_resolution_clock::now();
-      auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end_time - start_time);
-
-      SafePrint("[Device ", device_id_, "] MatrixMul iteration ", iteration, " completed in ",
-                duration.count(), " μs");
-
-    } catch (const std::exception& e) {
-      SafePrint("[Device ", device_id_, "] MatrixMul iteration ", iteration, " failed: ", e.what());
-      throw;
-    }
-  }
-
-  // Run all workloads for this device
-  void RunAllWorkloads() {
-    SafePrint("[Device ", device_id_, "] Starting all workloads...");
-
-    for (int i = 0; i < kIterationsPerDevice; ++i) {
-      RunVectorAddWorkload(i);
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-      RunVectorMulWorkload(i);
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-      RunMatrixMulWorkload(i);
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
-    }
-
-    SafePrint("[Device ", device_id_, "] All workloads completed");
-  }
-};
-
-// Metrics collection results
-struct MetricsCollectionResult {
-  int device_id;
-  std::string device_name;
-  pti_result final_result;
-  uint64_t total_buffers;
-  size_t total_records;
-  std::vector<std::string> kernel_names;
-  std::map<std::string, size_t> kernel_counts;
-  std::exception_ptr exception;
-
-  MetricsCollectionResult(int id, const std::string& name)
-      : device_id(id),
-        device_name(name),
-        final_result(PTI_ERROR_INTERNAL),
-        total_buffers(0),
-        total_records(0) {}
-};
-
-// Device metrics collector
-class DeviceMetricsCollector {
- private:
-  std::unique_ptr<DeviceWorkloadRunner> workload_runner_;
-  pti_scope_collection_handle_t scope_handle_;
-  MetricsCollectionResult result_;
-
- public:
-  DeviceMetricsCollector(pti_device_handle_t device_handle, int device_id)
-      : workload_runner_(std::make_unique<DeviceWorkloadRunner>(device_handle, device_id)),
-        scope_handle_(nullptr),
-        result_(device_id, workload_runner_->GetDeviceName()) {}
-
-  const MetricsCollectionResult& GetResult() const { return result_; }
-
-  void RunMetricsCollection() {
-    try {
-      SafePrint("[Device ", result_.device_id, "] Starting metrics collection setup...");
-
-      // Step 1: Enable scope metrics collection
-      pti_result res = ptiMetricsScopeEnable(&scope_handle_);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to enable scope metrics: ", res);
-        result_.final_result = res;
-        return;
-      }
-
-      // Step 2: Configure metrics - use basic metrics that should be available on most devices
-      pti_device_handle_t device = workload_runner_->GetDeviceHandle();
-      const char* metric_names[] = {"GpuTime", "GpuCoreClocks"};
-      const uint32_t metric_count = sizeof(metric_names) / sizeof(metric_names[0]);
-
-      res = ptiMetricsScopeConfigure(scope_handle_, PTI_METRICS_SCOPE_AUTO_KERNEL, &device, 1,
-                                     metric_names, metric_count);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to configure metrics: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      // Step 3: Set buffer size
-      size_t estimated_buffer_size = 0;
-      res = ptiMetricsScopeQueryCollectionBufferSize(scope_handle_, 20, &estimated_buffer_size);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to query buffer size: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      res = ptiMetricsScopeSetCollectionBufferSize(scope_handle_, estimated_buffer_size);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to set buffer size: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      // Step 4: Get metadata
-      pti_metrics_scope_record_metadata_t metadata;
-      metadata._struct_size = sizeof(pti_metrics_scope_record_metadata_t);
-      res = ptiMetricsScopeGetMetricsMetadata(scope_handle_, &metadata);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to get metadata: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      SafePrint("[Device ", result_.device_id, "] Metrics configured:");
-      SafePrint("  Buffer size: ", estimated_buffer_size, " bytes");
-      SafePrint("  Metrics count: ", metadata._metrics_count);
-      for (uint32_t i = 0; i < metadata._metrics_count; ++i) {
-        SafePrint("    [", i, "] ", metadata._metric_names[i]);
-      }
-
-      // Step 5: Start collection
-      res = ptiMetricsScopeStartCollection(scope_handle_);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to start collection: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      SafePrint("[Device ", result_.device_id,
-                "] Metrics collection started, running workloads...");
-
-      // Step 6: Run workloads
-      workload_runner_->RunAllWorkloads();
-
-      SafePrint("[Device ", result_.device_id, "] Workloads completed, stopping collection...");
-
-      // Step 7: Stop collection
-      res = ptiMetricsScopeStopCollection(scope_handle_);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to stop collection: ", res);
-        result_.final_result = res;
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-        return;
-      }
-
-      // Step 8: Process collected data
-      ProcessCollectedData(metadata);
-
-      // Step 9: Cleanup
-      res = ptiMetricsScopeDisable(scope_handle_);
-      if (res != PTI_SUCCESS) {
-        SafePrint("[Device ", result_.device_id, "] Failed to disable scope: ", res);
-        result_.final_result = res;
-        return;
-      }
-
-      result_.final_result = PTI_SUCCESS;
-      SafePrint("[Device ", result_.device_id, "] Metrics collection completed successfully");
-
-    } catch (const std::exception& e) {
-      SafePrint("[Device ", result_.device_id, "] Exception during metrics collection: ", e.what());
-      result_.exception = std::current_exception();
-      result_.final_result = PTI_ERROR_INTERNAL;
-
-      if (scope_handle_) {
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-      }
-    } catch (...) {
-      SafePrint("[Device ", result_.device_id, "] Unknown exception during metrics collection");
-      result_.exception = std::current_exception();
-      result_.final_result = PTI_ERROR_INTERNAL;
-
-      if (scope_handle_) {
-        // Check disable result but don't override the original error
-        pti_result disable_result = ptiMetricsScopeDisable(scope_handle_);
-        if (disable_result != PTI_SUCCESS) {
-          SafePrint("[Device ", result_.device_id,
-                    "] WARNING: Failed to disable scope during cleanup: ", disable_result);
-        }
-      }
-    }
-  }
-
- private:
-  void ProcessCollectedData(const pti_metrics_scope_record_metadata_t& metadata) {
-    // Get buffer count
-    pti_result res =
-        ptiMetricsScopeGetCollectionBuffersCount(scope_handle_, &result_.total_buffers);
-    if (res != PTI_SUCCESS) {
-      SafePrint("[Device ", result_.device_id, "] Failed to get buffer count: ", res);
-      return;
-    }
-
-    SafePrint("[Device ", result_.device_id, "] Processing ", result_.total_buffers, " buffers...");
-
-    if (result_.total_buffers == 0) {
-      SafePrint("[Device ", result_.device_id, "] No data collected");
-      return;
-    }
-
-    // Process each buffer
-    for (uint64_t i = 0; i < result_.total_buffers; i++) {
-      ProcessBuffer(i, metadata);
-    }
-
-    SafePrint("[Device ", result_.device_id, "] Data processing completed:");
-    SafePrint("  Total records: ", result_.total_records);
-    SafePrint("  Unique kernels: ", result_.kernel_names.size());
-    for (const auto& [kernel_name, count] : result_.kernel_counts) {
-      SafePrint("    ", kernel_name, ": ", count, " executions");
-    }
-  }
-
-  void ProcessBuffer(uint64_t buffer_index, const pti_metrics_scope_record_metadata_t& metadata) {
-    // Get buffer data
-    void* buffer_data = nullptr;
-    size_t buffer_size = 0;
-    pti_result res =
-        ptiMetricsScopeGetCollectionBuffer(scope_handle_, buffer_index, &buffer_data, &buffer_size);
-    if (res != PTI_SUCCESS || !buffer_data) {
-      SafePrint("[Device ", result_.device_id, "] Failed to get buffer ", buffer_index, ": ", res);
-      return;
-    }
-
-    // Get buffer properties
-    pti_metrics_scope_collection_buffer_properties_t props;
-    props._struct_size = sizeof(props);
-    res = ptiMetricsScopeGetCollectionBufferProperties(scope_handle_, buffer_data, &props);
-    if (res != PTI_SUCCESS) {
-      SafePrint("[Device ", result_.device_id, "] Failed to get buffer properties ", buffer_index,
-                ": ", res);
-      return;
-    }
-
-    SafePrint("[Device ", result_.device_id, "] Buffer ", buffer_index, " properties:");
-    SafePrint("  Device: ", reinterpret_cast<void*>(props._device_handle));
-    SafePrint("  Records: ", props._num_scopes);
-    SafePrint("  Used Size: ", buffer_size, " bytes");
-    SafePrint("  Metric Group: ", props._metric_group_name);
-
-    result_.total_records += props._num_scopes;
-
-    // Query metrics buffer size
-    size_t required_size = 0;
-    size_t records_count = 0;
-    res = ptiMetricsScopeQueryMetricsBufferSize(scope_handle_, buffer_data, &required_size,
-                                                &records_count);
-    if (res != PTI_SUCCESS) {
-      SafePrint("[Device ", result_.device_id, "] Failed to query metrics buffer size for buffer ",
-                buffer_index, ": ", res);
-      return;
-    }
-
-    if (records_count == 0 || required_size == 0) {
-      SafePrint("[Device ", result_.device_id, "] Buffer ", buffer_index, " has no records");
-      return;
-    }
-
-    SafePrint("[Device ", result_.device_id, "] Buffer ", buffer_index,
-              " - Required size: ", required_size, ", Records: ", records_count);
-
-    std::vector<uint8_t> user_buffer;
-
-    try {
-      user_buffer.resize(required_size);
-    } catch (const std::exception&) {
-      SafePrint("[Device ", result_.device_id, "] Failed to allocate user buffer for buffer ",
-                buffer_index);
-      return;
-    }
-
-    // Calculate metrics
-    size_t actual_records = 0;
-    res = ptiMetricsScopeCalculateMetrics(scope_handle_, buffer_data, user_buffer.data(),
-                                          required_size, &actual_records);
-    if (res != PTI_SUCCESS) {
-      SafePrint("[Device ", result_.device_id, "] Failed to calculate metrics for buffer ",
-                buffer_index, ": ", res);
-      return;
-    }
-
-    // Process records
-    auto records = reinterpret_cast<pti_metrics_scope_record_t*>(user_buffer.data());
-    for (size_t r = 0; r < actual_records; r++) {
-      if (records[r]._kernel_name) {
-        std::string kernel_name(records[r]._kernel_name);
-
-        SafePrint("[Device ", result_.device_id, "] Kernel ", r, ":");
-        SafePrint("  ID: ", records[r]._kernel_id);
-        SafePrint("  Name: ", kernel_name);
-
-        // Add to unique kernel names if not already present
-        if (std::find(result_.kernel_names.begin(), result_.kernel_names.end(), kernel_name) ==
-            result_.kernel_names.end()) {
-          result_.kernel_names.push_back(kernel_name);
-        }
-
-        // Count kernel executions
-        result_.kernel_counts[kernel_name]++;
-      }
-
-      // Display metrics values
-      if (records[r]._metrics_values && metadata._metrics_count > 0) {
-        SafePrint("  Metrics (", metadata._metrics_count, "):");
-        for (uint32_t m = 0; m < metadata._metrics_count; ++m) {
-          std::string metric_output = "    " + std::string(metadata._metric_names[m]) + ": ";
-
-          // Format value based on metadata type
-          switch (metadata._value_types[m]) {
-            case PTI_METRIC_VALUE_TYPE_UINT32:
-              metric_output += std::to_string(records[r]._metrics_values[m].ui32);
-              break;
-            case PTI_METRIC_VALUE_TYPE_UINT64:
-              metric_output += std::to_string(records[r]._metrics_values[m].ui64);
-              break;
-            case PTI_METRIC_VALUE_TYPE_FLOAT32:
-              metric_output += std::to_string(records[r]._metrics_values[m].fp32);
-              break;
-            case PTI_METRIC_VALUE_TYPE_FLOAT64:
-              metric_output += std::to_string(records[r]._metrics_values[m].fp64);
-              break;
-            case PTI_METRIC_VALUE_TYPE_BOOL8:
-              metric_output += (records[r]._metrics_values[m].b8 ? "true" : "false");
-              break;
-            default:
-              metric_output += "unknown";
-              break;
-          }
-
-          if (metadata._metric_units[m] && strlen(metadata._metric_units[m]) > 0) {
-            metric_output += " " + std::string(metadata._metric_units[m]);
-          }
-
-          SafePrint(metric_output);
-        }
-      }
-    }
-
-    // Smart pointer automatically cleans up user_buffer
-  }
-};
-
-}  // namespace
-
-class MultiDeviceParallelTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    // Initialize PTI View (required for callbacks)
-    auto dummy_provide = [](unsigned char** buf, std::size_t* buf_size) {
-      *buf_size = sizeof(pti_view_record_kernel) * 100;
-      void* ptr = ::operator new(*buf_size);
-      *buf = static_cast<unsigned char*>(ptr);
-      if (!*buf) {
-        std::abort();
-      }
-    };
-    auto dummy_parse = [](unsigned char* buf, std::size_t, std::size_t) {
-      if (buf) ::operator delete(buf);
-    };
-
-    EXPECT_EQ(ptiViewSetCallbacks(dummy_provide, dummy_parse), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-
-    // Get available devices
-    uint32_t device_count = 0;
-    pti_result result = ptiMetricsGetDevices(nullptr, &device_count);
-    if (result != PTI_SUCCESS || device_count == 0) {
-      GTEST_SKIP() << "No devices available for testing";
-    }
-
-    g_devices.resize(device_count);
-    result = ptiMetricsGetDevices(g_devices.data(), &device_count);
-    if (result != PTI_SUCCESS) {
-      GTEST_SKIP() << "Failed to get device properties";
-    }
-
-    std::cout << "Found " << device_count << " devices for testing:" << std::endl;
-    for (uint32_t i = 0; i < device_count; ++i) {
-      std::cout << "  Device " << i << ": " << g_devices[i]._model_name << std::endl;
-    }
-  }
-
-  void TearDown() override {
-    g_devices.clear();
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), PTI_SUCCESS);
-    EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), PTI_SUCCESS);
-    EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-  }
-};
-
-TEST_F(MultiDeviceParallelTest, TwoDevicesParallelCollection) {
-  if (g_devices.size() < 2) {
-    GTEST_SKIP() << "Need at least 2 devices for parallel testing, found " << g_devices.size();
-  }
-
-  std::cout << "\n=== Starting Two-Device Parallel Metrics Collection Test ===" << std::endl;
-
-  // Create metrics collectors for first two devices
-  auto collector1 = std::make_unique<DeviceMetricsCollector>(g_devices[0]._handle, 0);
-  auto collector2 = std::make_unique<DeviceMetricsCollector>(g_devices[1]._handle, 1);
-
-  // Thread synchronization
-  std::atomic<int> threads_ready{0};
-  std::atomic<bool> start_signal{false};
-  std::atomic<int> threads_completed{0};
-
-  std::cout << "Starting parallel metrics collection on 2 devices..." << std::endl;
-
-  // Launch collection threads
-  std::thread thread1([&collector1, &threads_ready, &start_signal, &threads_completed]() {
-    threads_ready++;
-    while (!start_signal.load()) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    }
-
-    collector1->RunMetricsCollection();
-    threads_completed++;
-  });
-
-  std::thread thread2([&collector2, &threads_ready, &start_signal, &threads_completed]() {
-    threads_ready++;
-    while (!start_signal.load()) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(1));
-    }
-
-    collector2->RunMetricsCollection();
-    threads_completed++;
-  });
-
-  // Wait for threads to be ready
-  while (threads_ready.load() < 2) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-  }
-
-  std::cout << "Both threads ready, starting parallel execution..." << std::endl;
-  start_signal = true;
-
-  // Wait for completion with timeout
-  auto start_time = std::chrono::steady_clock::now();
-  const auto timeout = std::chrono::seconds(60);
-
-  while (threads_completed.load() < 2) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    auto elapsed = std::chrono::steady_clock::now() - start_time;
-    if (elapsed > timeout) {
-      std::cout << "Timeout waiting for threads to complete" << std::endl;
-      break;
-    }
-  }
-
-  // Join threads
-  if (thread1.joinable()) thread1.join();
-  if (thread2.joinable()) thread2.join();
-
-  std::cout << "\n=== Parallel Collection Results ===" << std::endl;
-
-  // Analyze results
-  const auto& result1 = collector1->GetResult();
-  const auto& result2 = collector2->GetResult();
-
-  std::cout << "\nDevice 0 (" << result1.device_name << ") Results:" << std::endl;
-  std::cout << "  Final result: " << result1.final_result << std::endl;
-  std::cout << "  Total buffers: " << result1.total_buffers << std::endl;
-  std::cout << "  Total records: " << result1.total_records << std::endl;
-  std::cout << "  Unique kernels: " << result1.kernel_names.size() << std::endl;
-  for (const auto& [kernel_name, count] : result1.kernel_counts) {
-    std::cout << "    " << kernel_name << ": " << count << " executions" << std::endl;
-  }
-
-  std::cout << "\nDevice 1 (" << result2.device_name << ") Results:" << std::endl;
-  std::cout << "  Final result: " << result2.final_result << std::endl;
-  std::cout << "  Total buffers: " << result2.total_buffers << std::endl;
-  std::cout << "  Total records: " << result2.total_records << std::endl;
-  std::cout << "  Unique kernels: " << result2.kernel_names.size() << std::endl;
-  for (const auto& [kernel_name, count] : result2.kernel_counts) {
-    std::cout << "    " << kernel_name << ": " << count << " executions" << std::endl;
-  }
-
-  // Verify results
-  EXPECT_EQ(threads_completed.load(), 2) << "Both threads should complete";
-
-  // Check for exceptions
-  if (result1.exception) {
-    try {
-      std::rethrow_exception(result1.exception);
-    } catch (const std::exception& e) {
-      FAIL() << "Device 0 threw exception: " << e.what();
-    }
-  }
-
-  if (result2.exception) {
-    try {
-      std::rethrow_exception(result2.exception);
-    } catch (const std::exception& e) {
-      FAIL() << "Device 1 threw exception: " << e.what();
-    }
-  }
-
-  // Both devices should complete successfully (or with acceptable configuration errors)
-  EXPECT_TRUE(result1.final_result == PTI_SUCCESS ||
-              result1.final_result == PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND ||
-              result1.final_result == PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP)
-      << "Device 0 should complete with acceptable result, got: " << result1.final_result;
-
-  EXPECT_TRUE(result2.final_result == PTI_SUCCESS ||
-              result2.final_result == PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND ||
-              result2.final_result == PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP)
-      << "Device 1 should complete with acceptable result, got: " << result2.final_result;
-
-  // If both succeeded, verify data collection
-  if (result1.final_result == PTI_SUCCESS && result2.final_result == PTI_SUCCESS) {
-    // We should have collected some data from both devices
-    EXPECT_GT(result1.total_records + result2.total_records, 0u)
-        << "Should collect some records from at least one device";
-
-    // Verify kernel isolation - each device should have its own kernel instances
-    // (kernel names might be similar but should be tracked separately)
-    std::cout << "\n=== Data Isolation Verification ===" << std::endl;
-    std::cout << "Device 0 collected " << result1.total_records << " records" << std::endl;
-    std::cout << "Device 1 collected " << result2.total_records << " records" << std::endl;
-
-    // The test passes if both devices can collect metrics independently
-    // without interfering with each other
-  }
-
-  std::cout << "\n=== Two-Device Parallel Test Summary ===" << std::endl;
-  std::cout << "Test completed successfully - both devices operated independently" << std::endl;
-  std::cout << "Device 0 result: " << result1.final_result << std::endl;
-  std::cout << "Device 1 result: " << result2.final_result << std::endl;
-  std::cout << "Total records collected: " << (result1.total_records + result2.total_records)
-            << std::endl;
-}
diff --git a/sdk/test/metrics_vecsqadd_fixture.cc b/sdk/test/metrics_vecsqadd_fixture.cc
deleted file mode 100644
index f2de1539..00000000
--- a/sdk/test/metrics_vecsqadd_fixture.cc
+++ /dev/null
@@ -1,807 +0,0 @@
-//==============================================================
-// Copyright © Intel Corporation
-// SPDX-License-Identifier: MIT
-// =============================================================
-// Based on Vector Add example from OneAPI samples
-//==============================================================
-
-#include <gtest/gtest.h>
-
-#include <chrono>
-#include <cmath>
-#include <iostream>
-#include <map>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <vector>
-
-#include "metrics_utils.h"
-#include "pti/pti_metrics.h"
-#include "utils.h"
-
-namespace {
-
-enum class TestType {
-  kRunAll = 0,
-};
-
-constexpr size_t kVectorSize = 5000;
-
-std::vector<pti_device_properties_t> devices;
-std::vector<pti_metrics_group_properties_t> metric_groups;
-
-//************************************
-// Vector square in SYCL on device: modifies each input vector
-//************************************
-template <typename T>
-void VecSq(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-}
-
-template <typename T>
-void VecPassThroughToVecSq(sycl::queue &q, const std::vector<T> &a_vector,
-                           const std::vector<T> &b_vector) {
-  // This external id(21) is ignored due to overriding push in the VecSq call it precedes.
-  VecSq(q, a_vector, b_vector);
-}
-
-//************************************
-// Vector add in SYCL on device: returns sum in 4th parameter "sq_add".
-//************************************
-template <typename T>
-void VecAdd(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector,
-            std::vector<T> &sq_add) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-  sycl::buffer sum_buf(sq_add.data(), num_items);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_only);
-    sycl::accessor b(b_buf, h, sycl::read_only);
-    sycl::accessor sum(sum_buf, h, sycl::write_only, sycl::no_init);
-    h.parallel_for(num_items, [=](auto i) { sum[i] = a[i] + b[i]; });
-  });
-  q.wait();
-}
-
-template <typename T>
-void PrintResults(const std::vector<T> &sq_add, int n) {
-  double sum = 0;
-  for (int i = 0; i < n; i++) sum += sq_add[i];
-  printf("final result: %f\n", sum / n);
-}
-
-template <typename T>
-void RunExternalTest(sycl::queue &q, const std::vector<T> &a, const std::vector<T> &b,
-                     const std::vector<T> &c, const std::vector<T> &d, std::vector<T> &sq_add,
-                     std::vector<T> &sq_add2) {
-  VecPassThroughToVecSq(q, a, b);
-  VecAdd(q, a, b, sq_add);
-  PrintResults(sq_add, kVectorSize);
-
-  VecAdd(q, a, b, sq_add);
-  PrintResults(sq_add, kVectorSize);
-
-  VecAdd(q, c, d, sq_add2);
-  PrintResults(sq_add2, 2 * kVectorSize);
-}
-
-template <typename T>
-void VecSqAddRouter(sycl::queue &sycl_queue, TestType a_test_type) {
-  std::vector<T> a(kVectorSize);
-  std::vector<T> b(kVectorSize);
-  std::vector<T> c(2 * kVectorSize);
-  std::vector<T> d(2 * kVectorSize);
-  std::vector<T> sq_add(kVectorSize);
-  std::vector<T> sq_add2(2 * kVectorSize);
-
-  for (size_t i = 0; i < kVectorSize; i++) {
-    a[i] = std::sin(i);
-    b[i] = std::cos(i);
-    c[2 * i] = std::sin(i) * std::sin(i);
-    c[2 * i + 1] = std::sin(i);
-    d[2 * i] = std::cos(i) * std::cos(i);
-    d[2 * i + 1] = std::cos(i);
-  }
-
-  if (a_test_type == TestType::kRunAll) {
-    RunExternalTest(sycl_queue, a, b, c, d, sq_add, sq_add2);
-  }
-}
-
-void RunVecsqadd(TestType a_test_type) {
-  auto d_selector{sycl::gpu_selector_v};
-  sycl::property_list prop{sycl::property::queue::in_order()};
-  sycl::queue q(d_selector, prop);
-
-  if (q.get_device().has(sycl::aspect::fp64)) {
-    VecSqAddRouter<double>(q, a_test_type);
-  } else {
-    VecSqAddRouter<float>(q, a_test_type);
-  }
-}
-
-}  // namespace
-
-class VecsqaddMetricsFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    if (utils::GetEnv("ZET_ENABLE_METRICS") != "1") {
-      pti_result status = ptiMetricsEnable(nullptr);
-      if (status == PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED ||
-          status == PTI_ERROR_NOT_IMPLEMENTED) {
-        GTEST_SKIP() << "zetDeviceEnableMetricsExp not supported by driver, skipping test";
-      }
-      ASSERT_EQ(status, PTI_SUCCESS) << "Failed to enable metrics, error: " << status;
-    }
-    uint32_t device_count = 0;
-    pti_result result = PTI_SUCCESS;
-    result = ptiMetricsGetDevices(nullptr, &device_count);
-    if (result != PTI_SUCCESS) {
-      std::cout << "Failed to get devices count" << std::endl;
-    }
-
-    devices.resize(device_count);
-    result = ptiMetricsGetDevices(devices.data(), &device_count);
-    if (result != PTI_SUCCESS) {
-      std::cout << "Failed to get devices" << std::endl;
-    }
-
-    if (devices.size() > 0) {
-      // just get groups for the first device
-      uint32_t group_count = 0;
-      uint32_t device_idx = 0;
-      result = ptiMetricsGetMetricGroups(devices[device_idx]._handle, nullptr, &group_count);
-      if (result != PTI_SUCCESS) {
-        std::cout << "Failed to get metric group count" << std::endl;
-      }
-
-      metric_groups.resize(group_count);
-      result = ptiMetricsGetMetricGroups(devices[device_idx]._handle, metric_groups.data(),
-                                         &group_count);
-      if (result != PTI_SUCCESS) {
-        std::cout << "Failed to get metric groups" << std::endl;
-      }
-    }
-
-    // Initialize metrics utils instance
-    if (!metrics_utils::MetricsProfiler::MetricsProfilerInstance().InitializeMetricsCollection()) {
-      std::cout << "Failed to get initialize metrics collection" << std::endl;
-    }
-
-    // Configure collection
-    std::string group_name = "ComputeBasic";
-    pti_metrics_group_type group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-    bool log_data = true;
-    std::string filename = group_name + "MetricsFixtureTest_LIB.json";
-
-    // test configure metric groups
-    if (!metrics_utils::MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-            group_name, group_type, log_data, std::move(filename))) {
-      std::cout << "Failed to configure metrics collection" << std::endl;
-    }
-  }
-
-  void TearDown() override {
-    // Stop any running collection for all devices before disabling metrics
-    for (const auto &device : devices) {
-      ptiMetricsStopCollection(device._handle);  // Ignore errors - may already be stopped
-    }
-    ptiMetricsDisable(nullptr);
-    devices.clear();
-    metric_groups.clear();
-  }
-};
-
-TEST_F(VecsqaddMetricsFixtureTest, GetDevices) {
-  uint32_t device_count = 0;
-  EXPECT_EQ(ptiMetricsGetDevices(nullptr, &device_count), PTI_SUCCESS);
-  EXPECT_NE(device_count, static_cast<uint32_t>(0));
-
-  devices.resize(device_count);
-  EXPECT_EQ(ptiMetricsGetDevices(devices.data(), &device_count), PTI_SUCCESS);
-  EXPECT_NE(devices.empty(), true);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetricGroups) {
-  for (size_t i = 0; i < devices.size(); i++) {
-    uint32_t group_count = 0;
-    EXPECT_EQ(ptiMetricsGetMetricGroups(devices[i]._handle, nullptr, &group_count), PTI_SUCCESS);
-    EXPECT_NE(group_count, static_cast<uint32_t>(0));
-
-    metric_groups.resize(group_count);
-    EXPECT_EQ(ptiMetricsGetMetricGroups(devices[i]._handle, metric_groups.data(), &group_count),
-              PTI_SUCCESS);
-    EXPECT_NE(metric_groups.empty(), true);
-  }
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetricGroupsNullDeviceHandle) {
-  uint32_t group_count = 0;
-  EXPECT_EQ(ptiMetricsGetMetricGroups(nullptr, nullptr, &group_count), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetricGroupsInvalidDeviceHandle) {
-  uint32_t group_count = 0;
-  pti_device_handle_t device_handle =
-      metric_groups.size() > 0 ? metric_groups[0]._handle
-                               : reinterpret_cast<pti_device_handle_t>(
-                                     0xDEADBEEF);  // set to a metric group handle instead of device
-                                                   // handle of random value
-  EXPECT_EQ(ptiMetricsGetMetricGroups(device_handle, nullptr, &group_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetrics) {
-  for (size_t i = 0; i < devices.size(); i++) {
-    for (size_t j = 0; j < metric_groups.size(); j++) {
-      uint32_t metric_count = metric_groups[j]._metric_count;
-      EXPECT_NE(metric_count, static_cast<uint32_t>(0));
-
-      std::vector<pti_metric_properties_t> metric_properties(metric_count);
-      metric_groups[j]._metric_properties = metric_properties.data();
-
-      EXPECT_EQ(ptiMetricsGetMetricsProperties(metric_groups[j]._handle,
-                                               metric_groups[j]._metric_properties),
-                PTI_SUCCESS);
-      EXPECT_NE(metric_groups[j]._metric_properties, nullptr);
-    }
-  }
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetricsNullMetricGroupHandle) {
-  for (size_t i = 0; i < devices.size(); i++) {
-    for (size_t j = 0; j < metric_groups.size(); j++) {
-      uint32_t metric_count = metric_groups[j]._metric_count;
-      EXPECT_NE(metric_count, static_cast<uint32_t>(0));
-
-      std::vector<pti_metric_properties_t> metric_properties(metric_count);
-      metric_groups[j]._metric_properties = metric_properties.data();
-
-      EXPECT_EQ(ptiMetricsGetMetricsProperties(nullptr, metric_groups[j]._metric_properties),
-                PTI_ERROR_BAD_ARGUMENT);
-    }
-  }
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, GetMetricsInvalidMetricGroupHandle) {
-  // test the first device and the first metric group in that device
-  uint32_t device_idx = 0;
-  uint32_t metric_group_idx = 0;
-  if (devices.size() > 0) {
-    if (metric_groups.size() > 0) {
-      uint32_t metric_count = metric_groups[metric_group_idx]._metric_count;
-      EXPECT_NE(metric_count, static_cast<uint32_t>(0));
-
-      std::vector<pti_metric_properties_t> metric_properties(metric_count);
-      metric_groups[metric_group_idx]._metric_properties = metric_properties.data();
-
-      // user device handle instead of metric group handle
-      EXPECT_EQ(ptiMetricsGetMetricsProperties(devices[device_idx]._handle,
-                                               metric_groups[metric_group_idx]._metric_properties),
-                PTI_ERROR_BAD_ARGUMENT);
-      EXPECT_NE(metric_groups[metric_group_idx]._metric_properties, nullptr);
-    }
-  }
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigureNullMetricGroupCollectionParameters) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-
-  // test null metric groups collection parameters
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, nullptr, 1), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigureEmptyMetricGroup) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-
-  // test empty metric groups collection parameters
-  std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer;
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, config_collection_params_buffer.data(), 1),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigurNullMetricGroupHandle) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-
-  // test null metric group handle
-  pti_metrics_group_collection_params_t config_collection_params{};
-  config_collection_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-  config_collection_params._group_handle = nullptr;
-  config_collection_params._sampling_interval = 100000;  // ns
-  std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer = {
-      config_collection_params};
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, config_collection_params_buffer.data(), 1),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigureInvalidMetricGroupHandle) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-
-  // test invalid metric group handle
-  pti_metrics_group_collection_params_t config_collection_params{};
-  config_collection_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-  config_collection_params._group_handle = device_handle;  // use the device handle;
-  config_collection_params._sampling_interval = 100000;    // ns
-  std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer = {
-      config_collection_params};
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, config_collection_params_buffer.data(), 1),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, Configure0MetricGroups) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-  pti_metrics_group_handle_t metric_group_handle =
-      metric_groups.size() > 0 ? metric_groups[0]._handle : nullptr;
-
-  // test 0 metric groups
-  pti_metrics_group_collection_params_t config_collection_params{};
-  config_collection_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-  config_collection_params._group_handle = metric_group_handle;  // valid metric group
-  config_collection_params._sampling_interval = 100000;          // ns
-  std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer = {
-      config_collection_params};
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, config_collection_params_buffer.data(), 0),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, Configure2MetricGroups) {
-  pti_device_handle_t device_handle = devices.size() > 0 ? devices[0]._handle : nullptr;
-  pti_metrics_group_handle_t metric_group_handle =
-      metric_groups.size() > 0 ? metric_groups[0]._handle : nullptr;
-
-  // test more than 1 metric groups
-  pti_metrics_group_collection_params_t config_collection_params{};
-  config_collection_params._struct_size = sizeof(pti_metrics_group_collection_params_t);
-  config_collection_params._group_handle = metric_group_handle;  // valid metric group
-  config_collection_params._sampling_interval = 100000;          // ns
-
-  // Add first one
-  std::vector<pti_metrics_group_collection_params_t> config_collection_params_buffer = {
-      config_collection_params};
-
-  // Add second one
-  pti_metrics_group_handle_t metric_group_handle_2 =
-      metric_groups.size() > 1 ? metric_groups[1]._handle : nullptr;
-  config_collection_params._group_handle = metric_group_handle_2;  // valid metric group 2
-  config_collection_params_buffer.push_back(config_collection_params);
-
-  // Test 2 metric groups collection parameters in the buffer
-  EXPECT_EQ(ptiMetricsConfigureCollection(device_handle, config_collection_params_buffer.data(), 2),
-            PTI_ERROR_NOT_IMPLEMENTED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, InitializeMetricsCollection) {
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().InitializeMetricsCollection(),
-            true);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigureGoodMetricGroup) {
-  std::string group_name = "ComputeBasic";
-  pti_metrics_group_type group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-  bool log_data = true;
-  std::string filename = group_name + "MetricsFixtureTest_LIB.json";
-
-  // test configure metric groups
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-                group_name, group_type, log_data, filename),
-            true);
-
-  // test multiple configure metric groups calls
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-                group_name, group_type, log_data, std::move(filename)),
-            true);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ConfigureAlreadyConfiguredMetricGroup) {
-  std::string group_name = "ComputeBasic";
-  pti_metrics_group_type group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-  bool log_data = true;
-  std::string filename = group_name + "MetricsFixtureTest_LIB.json";
-
-  // test multiple configure metric groups calls
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-                group_name, group_type, log_data, std::move(filename)),
-            true);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionAndStop) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionNullDevice) {
-  // start collection with null device
-  EXPECT_EQ(ptiMetricsStartCollection(nullptr), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionInvalidDevice) {
-  // use metric group handle instead of device handle
-  pti_device_handle_t device = static_cast<pti_device_handle_t>(
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle());
-
-  // start collection with invalid device
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartAlreadyStartedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // test start already started collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartPausedAlreadyStartedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // test start paused already running collection
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionPausedAndStop) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionPausedNullDevice) {
-  // start collection paused with null device
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(nullptr), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionPausedInvalidDevice) {
-  // use metric group handle instead of device handle
-  pti_device_handle_t device = static_cast<pti_device_handle_t>(
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle());
-
-  // start collection paused with invalid device
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartAlreadySartedInPauseModeCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // test start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartInPausedModeAlreadySartedInPausedModeCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // test start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_ERROR_METRICS_COLLECTION_ALREADY_PAUSED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ResumeAlreadyRunningCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // test resume already running collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_ERROR_METRICS_COLLECTION_ALREADY_ENABLED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ResumeNotStartedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // test resume not started collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_ERROR_METRICS_COLLECTION_NOT_PAUSED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ResumeCollectionNullDevice) {
-  // Resume collection with null device
-  EXPECT_EQ(ptiMetricsResumeCollection(nullptr), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ResumeCollectionInvalidDevice) {
-  // use metric group handle instead of device handle
-  pti_device_handle_t device = static_cast<pti_device_handle_t>(
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle());
-
-  // resume collection with invalid device
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, ResumePausedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // test resume already started collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_SUCCESS);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StopNotStartedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // test stop not started collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_ERROR_METRICS_COLLECTION_NOT_PAUSED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StopCollectionNullDevice) {
-  // stop collection with null device
-  EXPECT_EQ(ptiMetricsStopCollection(nullptr), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StopCollectionInvalidDevice) {
-  // use metric group handle instead of device handle
-  pti_device_handle_t device = static_cast<pti_device_handle_t>(
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle());
-
-  // stop collection with invalid device
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StopAlreadyStoppedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-
-  // stop already stopped collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StopPausedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // stop paused collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateNotStartedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-
-  // test calculate on not started collection
-  uint32_t metrics_values_count;
-
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, nullptr, &metrics_values_count),
-            PTI_ERROR_METRICS_NO_DATA_COLLECTED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateWith0BufferSize) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-
-  // test calculate with 0 buffer size
-  uint32_t metrics_values_count = 0;
-  pti_value_t dummy = pti_value_t();
-  std::vector<pti_value_t> metrics_values_buffer = {dummy};
-
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, metrics_values_buffer.data(),
-                                        &metrics_values_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateWithNullDevice) {
-  // test calculate with null device
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-
-  EXPECT_EQ(ptiMetricsGetCalculatedData(nullptr, group, nullptr, &metrics_values_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateWithInvalidDevice) {
-  // test calculate with invalid device, use group handle instead of device handle
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-
-  EXPECT_EQ(ptiMetricsGetCalculatedData(static_cast<pti_device_handle_t>(group), group, nullptr,
-                                        &metrics_values_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateWithNullMetricGroup) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // test calculate on not started collection
-  uint32_t metrics_values_count;
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, nullptr, nullptr, &metrics_values_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateWithInvalidMetricGroup) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // test calculate with invalid metric group, use device handle instead of metric group handle
-  uint32_t metrics_values_count;
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, static_cast<pti_metrics_group_handle_t>(device),
-                                        nullptr, &metrics_values_count),
-            PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateEnabledCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollection(device), PTI_SUCCESS);
-
-  // Test calculate on enabled collection
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, nullptr, &metrics_values_count),
-            PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculatePausedCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection paused
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // Test calculate on paused collection
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, nullptr, &metrics_values_count),
-            PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, CalculateEmptyCollection) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // stop paused collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-
-  // calculate on stopped collection before any data is collected
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, nullptr, &metrics_values_count),
-            PTI_ERROR_METRICS_NO_DATA_COLLECTED);
-
-  // test empty calculate on no data collected
-  EXPECT_EQ(metrics_values_count, static_cast<uint32_t>(0));
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionPausedAndResumeAndCalculateBeforeStop) {
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // test resume collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_SUCCESS);
-
-  // test calculate with no stop
-  uint32_t metrics_values_count;
-  pti_metrics_group_handle_t group =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredMetricGroupHandle();
-  EXPECT_EQ(ptiMetricsGetCalculatedData(device, group, nullptr, &metrics_values_count),
-            PTI_ERROR_METRICS_COLLECTION_NOT_DISABLED);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_ERROR_METRICS_COLLECTION_NOT_ENABLED);
-}
-
-TEST_F(VecsqaddMetricsFixtureTest, StartCollectionPausedAndResumeAndStopAndCalculate) {
-  std::string group_name = "ComputeBasic";
-  pti_metrics_group_type group_type = PTI_METRIC_GROUP_TYPE_TIME_BASED;
-  bool log_data = true;
-  std::string filename = group_name + "MetricsFixtureTest_LIB.json";
-
-  // test configure metric groups
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().ConfigureMetricGroups(
-                group_name, group_type, log_data, std::move(filename)),
-            true);
-
-  pti_device_handle_t device =
-      metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetConfiguredDeviceHandle();
-
-  // start collection in paused mode
-  EXPECT_EQ(ptiMetricsStartCollectionPaused(device), PTI_SUCCESS);
-
-  // test start in paused mode already started collection
-  EXPECT_EQ(ptiMetricsResumeCollection(device), PTI_SUCCESS);
-
-  // run workload
-  RunVecsqadd(TestType::kRunAll);
-
-  // stop collection
-  EXPECT_EQ(ptiMetricsStopCollection(device), PTI_SUCCESS);
-
-  std::string sample_filename = group_name + "MetricsFixtureTest_TEST.json";
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().GetCalculatedData(
-                log_data, std::move(sample_filename)),
-            true);
-
-  // Add small sleep to wait for the output files to be written
-  std::this_thread::sleep_for(std::chrono::seconds(1));
-
-  // Compare LIB generated file vs TEST generated file
-  std::string file1 = group_name + "MetricsFixtureTest_LIB.json";
-  std::string file2 = group_name + "MetricsFixtureTest_TEST.json";
-
-  EXPECT_EQ(metrics_utils::CompareFiles(file1, file2), true);
-
-  metrics_utils::DeleteFile(file1);
-  metrics_utils::DeleteFile(file2);
-
-  // Validate the data
-  EXPECT_EQ(metrics_utils::MetricsProfiler::MetricsProfilerInstance().ValidateData(), true);
-}
diff --git a/sdk/test/multi_thread_correlation.awk b/sdk/test/multi_thread_correlation.awk
deleted file mode 100644
index aaa0cb4e..00000000
--- a/sdk/test/multi_thread_correlation.awk
+++ /dev/null
@@ -1,113 +0,0 @@
-#
-#Test to match up sycl runtime EnqueueKernelLaunch function records with L0 kernel view records, via correlation id.
-#  -- checks that matched pairs on correlation_id and kernel_id have same threadid.
-#
-#To Run:
-#  <build_directory>/samples/dpc_gemm_threaded/dpc_gemm_threaded > tst.out
-#  awk -f <build_directory>/../test/multi_thread_correlation.awk tst.out
-#
-#  TBD -- auto integrate me into googletest if possible
-#
-BEGIN {
-        tid = 0;
-}
-
-/ZeCall Thread Id:/ { tid=$4 };
-/ZeCall Start Time:/ { zecall_start_ts = $4 };
-/ZeCall End Time:/ { zecall_end_ts = $4 };
-/^ZeCall Correlation Id:/ && $4 > 0 {
-	zecall[$4]= tid;
-	zecall_start_time[$4]= zecall_start_ts;
-	zecall_end_time[$4]= zecall_end_ts;
-	zecall_line_number[$4]= NR;
-       	};
-
-/Sycl Thread Id:/ { tid=$4 };
-/Sycl Start Time:/ { sycl_start_ts = $4 };
-/Sycl End Time:/ { sycl_end_ts = $4 };
-/^Sycl Correlation Id:/ && $4 > 0 {
-	sycl[$4]= tid;
-	sycl_start_time[$4]= sycl_start_ts;
-	sycl_end_time[$4]= sycl_end_ts;
-	sycl_line_number[$4]= NR;
-       	};
-
-/Correlation Id :/ { kid=$4 };
-/Ze Kernel Append Time:/ { append_time=$5 };
-/Ze Kernel Submit Time:/ { submit_time=$5 };
-/Ze Kernel Start Time:/ { start_time=$5 };
-/Ze Kernel End Time:/ { end_time=$5 };
-/Kernel Thread Id:/ {
-	kthreads[kid]=$5
-	k_type[kid]="Kernel"
-	k_append_time[kid]=append_time;
-	k_submit_time[kid]=submit_time;
-	k_start_time[kid]=start_time;
-	k_end_time[kid]=end_time;
-	k_line_number[kid]= NR;
-	};
-
-/Memory Op Id:/ { mid=$5 };
-/Memory Op Append Time:/ { append_time=$5 };
-/Memory Op Submit Time:/ { submit_time=$5 };
-/Memory Op Start Time:/ { start_time=$5 };
-/Memory Op End Time:/ { end_time=$5 };
-/Memory Op Thread Id:/ {
-	kthreads[mid]=$6
-	k_type[mid]="Memory"
-	k_append_time[mid]=append_time;
-	k_submit_time[mid]=submit_time;
-	k_start_time[mid]=start_time;
-	k_end_time[mid]=end_time;
-	k_line_number[mid]= NR;
-	};
-
-END {
-	#if (length(sycl) != length(kthreads)) {
-		#print ("Correlation Id issues --- lengths don't match: ",length(sycl),":",length(kthreads))
-		#for (corrId in kthreads) if (kthreads[corrId] != sycl[corrId]) print(corrId);
-		#};
-	for (corrId in kthreads) {
-		if (zecall[corrId] != kthreads[corrId]) {
-		  print(k_type[corrId]);
-		  print ("Correlation Id issues in zecall --- Threads don't match: ", zecall[corrId], kthreads[corrId], k_type[corrId])
-                  print("------------>for correlationId:", corrId, "- zecall line number: ",zecall_line_number[corrId],"- levelZero line number:",k_line_number[corrId]);
-		  corrErr=1;
-		};
-		if (sycl[corrId] != kthreads[corrId]) {
-		  print(k_type[corrId]);
-		  print ("Correlation Id issues in sycl --- Threads don't match: ", sycl[corrId], kthreads[corrId], k_type[corrId])
-                  print("------------>for correlationId:", corrId, "- sycl line number: ",sycl_line_number[corrId],"- levelZero line number:",k_line_number[corrId]);
-		  corrErr=1;
-		};
-		if (! (sycl_start_time[corrId] <= k_append_time[corrId] &&
-                  sycl_start_time[corrId] <= zecall_start_time[corrId] &&
-                  sycl_end_time[corrId] >= sycl_start_time[corrId] &&
-                  sycl_end_time[corrId] >= zecall_end_time[corrId] &&
-                  k_append_time[corrId] <= k_submit_time[corrId] &&
-                  k_submit_time[corrId] <= k_start_time[corrId] &&
-                  k_start_time[corrId] <= k_end_time[corrId]))
-		 {
-		  corrErr=1;
-                  print("------------>Not All monotonic for correlationId:", corrId, "- sycl line number: ",sycl_line_number[corrId],"- levelZero line number:",k_line_number[corrId]);
-		  print("Type: ",k_type[corrId]);
-		  print("Sycl start time:    ",sycl_start_time[corrId]);
-		  print("append time: ",k_append_time[corrId]);
-		  print("submit time: ",k_submit_time[corrId]);
-		  print("start time:  ",k_start_time[corrId]);
-		  print("end time:    ",k_end_time[corrId]);
-		  print("Sycl end time:      ",sycl_end_time[corrId]);
-		}
-	}
-	if (length(kthreads) == 0) {
-		print("No threads. It could be due to the test wrong output");
-		exit 1
-	}
-	if (!corrErr) {
-		print("All correlation Ids match Kernel Id Threads");
-		exit 0
-	}
-	else  {
-		exit 1
-	}
-}
diff --git a/sdk/test/multi_threaded_submission.cc b/sdk/test/multi_threaded_submission.cc
deleted file mode 100644
index 490b8fc5..00000000
--- a/sdk/test/multi_threaded_submission.cc
+++ /dev/null
@@ -1,584 +0,0 @@
-#include <gtest/gtest.h>
-#include <string.h>
-
-#include <cmath>
-#include <condition_variable>
-#include <cstdlib>
-#include <mutex>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <unordered_map>
-#include <utility>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-
-namespace {
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static bool verbose = true;
-
-static float Check(const std::vector<float>& a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static void SubmitKernel(sycl::queue queue, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c, unsigned size) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-  } catch (const sycl::exception& e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void Compute(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, unsigned repeat_count) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    SubmitKernel(queue, a, b, c, size);
-  }
-}
-
-const unsigned working_thread_count = 2;
-const unsigned repeat_count = 2;
-const unsigned size = 1024;
-
-constexpr auto kRequestedRecordCount =
-    repeat_count * 1'000ULL;  // reserving enough space
-                              // for all records in one buffer per thread
-constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-/**
- * @internal
- * The structures below is to store aggregated statistic about particular profiling record
- * count collected per a thread.
- * The test then uses this information to verify that each thread collected the same number
- * of records of a specific type.
- *
- * A record type is defined as ExtendedViewKind,
- * which is a pair of a view_kind and so-called a sub_kind
- *
- * view_kind is exactly pti_view_kind casted to uint32_t.
- *
- * But view_kind is too coarse -
- * e.g. any runtime API record has PTI_VIEW_RUNTIME_API view_kind
- * But as we want to do detail comparison - we need more specific info - e.g. ID of the API.
- * Or for a memory transfer a view_kind is PTI_VIEW_DEVICE_GPU_MEM_COPY.
- * But again - for the detail comparison we need to know the type of the transfer it is -
- * e.g. host to device or device to host, read or write, etc.
- *
- * So we define a sub_kind field to hold that additional information where we put
- * either the ID of the API or a type of the transfer, or any other enum value converted to
- * uint32_t.
- *
- * Finally we have a map { thread,  map { ExtendedViewKind, count of records} }
- */
-
-struct ExtendedViewKind {
-  ExtendedViewKind(pti_view_kind kind, uint32_t sub_kind) : value(kind, sub_kind) {}
-  ExtendedViewKind(const ExtendedViewKind& other) : value(other.value) {}
-  ExtendedViewKind& operator=(const ExtendedViewKind& other) {
-    value = other.value;
-    return *this;
-  }
-  ExtendedViewKind(ExtendedViewKind&& other) : value(other.value) {}
-  ExtendedViewKind& operator=(ExtendedViewKind&& other) {
-    value = other.value;
-    return *this;
-  }
-  ~ExtendedViewKind() {}
-  bool operator==(const ExtendedViewKind& other) const { return value == other.value; }
-  std::pair<pti_view_kind, uint32_t> value;
-};
-
-struct ExtendedViewKindHash {
-  size_t operator()(const ExtendedViewKind& v) const {
-    return static_cast<size_t>(v.value.first) << 32 | v.value.second;
-  }
-};
-
-// Map a specific ExtendedViewKind to a number of records of that kind
-using ExtendedViewKindStatMap =
-    std::unordered_map<ExtendedViewKind, uint32_t, ExtendedViewKindHash>;
-
-// Map a thread ID to a ExtendedViewKindStatMap
-std::unordered_map<uint32_t, ExtendedViewKindStatMap> thread_view_kind_stat_map;
-std::mutex thread_view_kind_stat_map_mtx;
-
-void IncrementThreadViewKindStat(uint32_t thread_id, pti_view_kind view_kind,
-                                 uint32_t sub_kind = 0) {
-  std::lock_guard<std::mutex> lock(thread_view_kind_stat_map_mtx);
-  auto it_thread = thread_view_kind_stat_map.find(thread_id);
-  if (it_thread == thread_view_kind_stat_map.end()) {
-    thread_view_kind_stat_map[thread_id] = {{ExtendedViewKind(view_kind, sub_kind), 1}};
-  } else {
-    it_thread->second[ExtendedViewKind(view_kind, sub_kind)]++;
-  }
-}
-
-void StartTracing() {
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_SYNCHRONIZATION));
-}
-
-void StopTracing() {
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_SYNCHRONIZATION));
-}
-
-void EnableIndividualRuntimeApis(bool useClassApi = false, bool useAllGroups = false) {
-  if (useClassApi) {
-    std::cout << "Using class apis:\n";
-    pti_api_class this_class = pti_api_class::PTI_API_CLASS_ALL;
-    if (useAllGroups) {
-      std::cout << "Using all groups: setting both runtime/driver: all_classes: " << this_class
-                << "\n";
-      PTI_CHECK_SUCCESS(
-          ptiViewEnableRuntimeApiClass(1, this_class, pti_api_group_id::PTI_API_GROUP_ALL));
-    }
-  } else {
-    std::cout << "NOT Using class apis: -- all granular -- runtime only.\n";
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueUSMFill_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueUSMFill2D_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueUSMMemcpy_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueUSMMemcpy2D_id));
-
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueMemBufferFill_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueMemBufferRead_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueMemBufferWrite_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueMemBufferCopy_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urUSMHostAlloc_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urUSMSharedAlloc_id));
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urUSMDeviceAlloc_id));
-
-    PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                              pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id));
-    PTI_CHECK_SUCCESS(
-        ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                pti_api_id_runtime_sycl::urEnqueueKernelLaunchCustomExp_id));
-    PTI_CHECK_SUCCESS(
-        ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                pti_api_id_runtime_sycl::urEnqueueCooperativeKernelLaunchExp_id));
-    PTI_CHECK_SUCCESS(
-        ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                pti_api_id_runtime_sycl::urEnqueueKernelLaunchWithArgsExp_id));
-  }
-}
-
-void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-
-void ParseBuffer(unsigned char* buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  std::unordered_map<uint32_t, uint32_t> corr_id_map;
-
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    samples_utils::AlignedDealloc(buf);
-    return;
-  }
-  pti_view_record_base* ptr = nullptr;
-
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      std::cout << "Reached End of buffer" << "\n";
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        pti_view_record_api* p_runtime_rec = reinterpret_cast<pti_view_record_api*>(ptr);
-        IncrementThreadViewKindStat(p_runtime_rec->_thread_id, ptr->_view_kind,
-                                    p_runtime_rec->_api_id);
-        samples_utils::DumpRecord(p_runtime_rec);
-
-        ASSERT_TRUE(corr_id_map.find(p_runtime_rec->_correlation_id) == corr_id_map.end())
-            << "ERROR: Found duplicate correlation id: " << p_runtime_rec->_correlation_id;
-        corr_id_map[p_runtime_rec->_correlation_id]++;
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DRIVER_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Lz Api Record" << '\n';
-        pti_view_record_api* p_driver_rec = reinterpret_cast<pti_view_record_api*>(ptr);
-        IncrementThreadViewKindStat(p_driver_rec->_thread_id, ptr->_view_kind);
-        samples_utils::DumpRecord(p_driver_rec);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-
-        pti_view_record_overhead* p_ovh_rec = reinterpret_cast<pti_view_record_overhead*>(ptr);
-        IncrementThreadViewKindStat(p_ovh_rec->_overhead_thread_id, ptr->_view_kind);
-        samples_utils::DumpRecord(p_ovh_rec);
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_external_correlation*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-        pti_view_record_memory_copy_type* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_copy_type*>(ptr);
-        IncrementThreadViewKindStat(p_memory_rec->_thread_id, ptr->_view_kind,
-                                    p_memory_rec->_memcpy_type);
-        samples_utils::DumpRecord(p_memory_rec);
-
-        ASSERT_TRUE(corr_id_map.find(p_memory_rec->_correlation_id) != corr_id_map.end())
-            << "ERROR: Found empty correlation id: " << p_memory_rec->_correlation_id;
-
-        if (corr_id_map.find(p_memory_rec->_correlation_id) != corr_id_map.end()) {
-          ASSERT_TRUE(corr_id_map[p_memory_rec->_correlation_id] == 1)
-              << "ERROR: Found memory copy record with unexpected correlation id: "
-              << p_memory_rec->_correlation_id << "corr_id_map"
-              << corr_id_map[p_memory_rec->_correlation_id];
-        }
-
-        auto found_issues = pti::test::utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (found_issues > 0) {
-          FAIL() << "------------>     ERROR: Not monotonic kernel timestamps";
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-
-        pti_view_record_memory_fill_type* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_fill_type*>(ptr);
-        IncrementThreadViewKindStat(p_memory_rec->_thread_id, ptr->_view_kind);
-        samples_utils::DumpRecord(p_memory_rec);
-        ASSERT_TRUE(corr_id_map.find(p_memory_rec->_correlation_id) != corr_id_map.end())
-            << "ERROR: Found empty correlation id: " << p_memory_rec->_correlation_id;
-
-        if (corr_id_map.find(p_memory_rec->_correlation_id) != corr_id_map.end()) {
-          ASSERT_TRUE(corr_id_map[p_memory_rec->_correlation_id] == 1)
-              << "ERROR: Found memory copy record with unexpected correlation id: "
-              << p_memory_rec->_correlation_id << "corr_id_map"
-              << corr_id_map[p_memory_rec->_correlation_id];
-        }
-
-        auto found_issues = pti::test::utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (found_issues > 0) {
-          FAIL() << "------------>     ERROR: Not monotonic kernel timestamps";
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-
-        pti_view_record_kernel_type* p_kernel_rec =
-            reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-        IncrementThreadViewKindStat(p_kernel_rec->_thread_id, ptr->_view_kind);
-        samples_utils::DumpRecord(p_kernel_rec);
-        ASSERT_TRUE(corr_id_map.find(p_kernel_rec->_correlation_id) != corr_id_map.end())
-            << "ERROR: Found empty correlation id: " << p_kernel_rec->_correlation_id;
-
-        if (corr_id_map.find(p_kernel_rec->_correlation_id) != corr_id_map.end()) {
-          ASSERT_TRUE(corr_id_map[p_kernel_rec->_correlation_id] == 1)
-              << "ERROR: Found memory copy record with unexpected correlation id: "
-              << p_kernel_rec->_correlation_id << "corr_id_map"
-              << corr_id_map[p_kernel_rec->_correlation_id];
-        }
-
-        auto found_issues = pti::test::utils::ValidateTimestamps(
-            p_kernel_rec->_sycl_task_begin_timestamp, p_kernel_rec->_sycl_enqk_begin_timestamp,
-            p_kernel_rec->_append_timestamp, p_kernel_rec->_submit_timestamp,
-            p_kernel_rec->_start_timestamp, p_kernel_rec->_end_timestamp);
-
-        if (found_issues > 0) {
-          FAIL() << "------------>     ERROR: Not monotonic kernel timestamps";
-        }
-
-        if (p_kernel_rec->_sycl_task_begin_timestamp == 0) {
-          FAIL() << "------------>     Something wrong: Sycl Task Begin Time is 0";
-        }
-
-        if (p_kernel_rec->_sycl_enqk_begin_timestamp == 0) {
-          FAIL() << "------------>     Something wrong: Sycl Enq Launch Kernel Time is 0";
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Device Synchronization Record" << '\n';
-        pti_view_record_synchronization* p_rec =
-            reinterpret_cast<pti_view_record_synchronization*>(ptr);
-        IncrementThreadViewKindStat(p_rec->_thread_id, ptr->_view_kind, p_rec->_synch_type);
-        samples_utils::DumpRecord(p_rec);
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-
-int SymmetricMultithreadedWithMain(bool useClassApis = false, bool useAllGroup = false) {
-  int exit_code = EXIT_SUCCESS;
-
-  try {
-    StartTracing();
-    EnableIndividualRuntimeApis(useClassApis, useAllGroup);
-    sycl::device dev;
-    dev = sycl::device(sycl::gpu_selector_v);
-    sycl::property_list prop_list{sycl::property::queue::in_order(),
-                                  sycl::property::queue::enable_profiling()};
-    sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-    float expected_result = A_VALUE * B_VALUE * size;
-
-    auto threadFunction = [&queue](unsigned _size, unsigned _repeat_count, float expected_result) {
-      std::vector<float> a(_size * _size, A_VALUE);
-      std::vector<float> b(_size * _size, B_VALUE);
-      std::vector<float> c(_size * _size, 0.0f);
-
-      [[maybe_unused]] auto start = std::chrono::steady_clock::now();
-      Compute(queue, a, b, c, _size, _repeat_count);
-
-      [[maybe_unused]] auto end = std::chrono::steady_clock::now();
-      [[maybe_unused]] std::chrono::duration<float> time = end - start;
-
-      if (verbose) {
-        std::cout << "\t-- Execution Time: " << time.count() << " sec" << std::endl;
-      }
-      ASSERT_TRUE(Check(c, expected_result) <= MAX_EPS);
-    };
-
-    if (verbose) {
-      std::cout << "DPC++ Matrix Multiplication (CPU threads: " << working_thread_count
-                << ", matrix size: " << size << " x " << size << ", repeats: " << repeat_count
-                << " times)" << std::endl;
-      std::cout << "Target device: "
-                << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-                << std::endl
-                << std::flush;
-    }
-
-    std::vector<std::thread> the_threads;
-    for (unsigned i = 0; i < working_thread_count; i++) {
-      std::thread t = std::thread(threadFunction, size, repeat_count, expected_result);
-      the_threads.push_back(std::move(t));
-    }
-
-    for (auto& th : the_threads) {
-      if (th.joinable()) {
-        th.join();
-      }
-    }
-    queue.wait_and_throw();
-
-    StopTracing();
-    PTI_THROW(ptiFlushAllViews());
-  } catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  return exit_code;
-}
-
-void ValidateViewStats() {
-  auto threads_with_records = thread_view_kind_stat_map.size();
-  std::cout << "Threads with records: " << threads_with_records << "\n";
-  EXPECT_GE(threads_with_records, working_thread_count)
-      << "ERROR: Not all working threads have records, expected: " << working_thread_count
-      << ", actual: " << threads_with_records;
-
-  uint32_t main_thread_id = 0;  // it will be thread with the least number of records
-                                // as all work - data copying, kernel submission done from
-                                // working threads
-
-  for (const auto& thread_view_kind_stat : thread_view_kind_stat_map) {
-    std::cout << "Thread id: " << thread_view_kind_stat.first << "\n";
-    if (threads_with_records > working_thread_count) {
-      if (main_thread_id == 0) {
-        main_thread_id = thread_view_kind_stat.first;
-      }
-      if (thread_view_kind_stat.second.size() < thread_view_kind_stat_map[main_thread_id].size()) {
-        main_thread_id = thread_view_kind_stat.first;
-      }
-    }
-    for (const auto& view_stat : thread_view_kind_stat.second) {
-      std::cout << " View kind: " << static_cast<uint32_t>(view_stat.first.value.first)
-                << " sub-kind: " << static_cast<uint32_t>(view_stat.first.value.second)
-                << ", Record count: " << view_stat.second << '\n';
-    }
-  }
-  if (main_thread_id == 0) {
-    // removing main_thread stats as not interested in comparing its stats with working threads
-    std::cout << "Main thread id: " << main_thread_id << "\n";
-    thread_view_kind_stat_map.erase(main_thread_id);
-  }
-
-  auto it_thread1 = thread_view_kind_stat_map.begin();
-  auto it_thread2 = it_thread1++;
-
-  for (const auto& it_view1 : it_thread1->second) {
-    std::cout << "Thread id: " << it_thread1->first
-              << " View kind: " << static_cast<uint32_t>(it_view1.first.value.first)
-              << " sub-kind: " << static_cast<uint32_t>(it_view1.first.value.second)
-              << " Record count: " << it_view1.second << '\n';
-
-    auto it_view2 = it_thread2->second.find(it_view1.first);
-    if (it_view2 != it_thread2->second.end()) {
-      EXPECT_EQ(it_view1.second, it_view2->second);
-    } else {
-      std::cout << "Thread id: " << it_thread2->first
-                << " doesn't have the same view kind as thread id: " << it_thread1->first
-                << " View kind: " << static_cast<uint32_t>(it_view1.first.value.first)
-                << " Sub-kind: " << static_cast<uint32_t>(it_view1.first.value.second)
-                << " Record count: " << it_view1.second << '\n';
-    }
-  }
-}
-
-}  // namespace
-
-class MultiThreadedSubmissionFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override { thread_view_kind_stat_map.clear(); }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-};
-
-// Test verifies that GPU ops reported in the thread buffers where ops were submitted
-// in this test all working threads did the same work - so the number of records should be the same
-// in all buffers, except for the empty buffer of the main thread
-TEST_F(MultiThreadedSubmissionFixtureTest, MultiThreadedSubmissionTestUsingGranularApis) {
-  ASSERT_TRUE(working_thread_count > 1);
-  EXPECT_EQ(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(SymmetricMultithreadedWithMain(), EXIT_SUCCESS);
-
-  ValidateViewStats();
-}
-
-// Test verifies that GPU ops reported in the thread buffers where ops were submitted
-// in this test all working threads did the same work - so the number of records should be the same
-// in all buffers, except for the empty buffer of the main thread
-TEST_F(MultiThreadedSubmissionFixtureTest,
-       MultiThreadedSubmissionTestUsingSyclOpsAllClassAllGroups) {
-  ASSERT_TRUE(working_thread_count > 1);
-  EXPECT_EQ(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(SymmetricMultithreadedWithMain(true, true), EXIT_SUCCESS);
-
-  ValidateViewStats();
-}
-
-// Test verifies an api call request for an unsupported class type for the driver api returns
-// appropriate bad error code
-TEST_F(MultiThreadedSubmissionFixtureTest, ValidateDriverApiClassReturnsAppropriateCode) {
-  ASSERT_TRUE(working_thread_count > 1);
-  EXPECT_EQ(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer), pti_result::PTI_SUCCESS);
-  pti_result status = ptiViewEnableDriverApiClass(
-      1, pti_api_class::PTI_API_CLASS_GPU_OPERATION_CORE, pti_api_group_id::PTI_API_GROUP_ALL);
-  EXPECT_EQ(status, pti_result::PTI_SUCCESS);
-}
diff --git a/sdk/test/no_kernel_overlap.cc b/sdk/test/no_kernel_overlap.cc
deleted file mode 100644
index e97d67b1..00000000
--- a/sdk/test/no_kernel_overlap.cc
+++ /dev/null
@@ -1,417 +0,0 @@
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-#include <stdarg.h>
-
-#include <chrono>
-#include <iomanip>
-#include <iostream>
-#include <ostream>
-#include <sstream>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-
-namespace {
-
-void VecAdd(sycl::queue& q, int64_t* a, int64_t* b, int64_t* res, int count) {
-  q.submit([&](sycl::handler& h) {
-    h.parallel_for(count, [=](sycl::item<1> item) {
-      int idx = item.get_id(0);
-      res[idx] = a[idx] + b[idx];
-    });
-  });
-}
-
-void CheckResults(const int64_t* result, size_t size) {
-  for (size_t i = 0; i < size; i++) {
-    ASSERT_TRUE(result[i] == static_cast<int64_t>(i * 2))
-        << "Wrong element at index " << i << ", should be " << i * 2 << ", but got " << result[i];
-  }
-}
-
-void StartTracing() {
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-void StopTracing() {
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-constexpr size_t kRepetitions = 10;
-
-float TestCore(bool do_immediate) {
-  float time_sec = 0.f;
-  try {
-    // size purposely small - it makes harder requirement to the test
-    // constexpr size_t kVectorSize = 10 * 1024 * 1024;
-    constexpr size_t kVectorSize = 1024;
-    std::cout << "Adding vectors size: " << kVectorSize << ", Repetitions: " << kRepetitions
-              << std::endl;
-    std::cout << "Evaluating latency of timing call..." << std::endl;
-    auto first_stamp = utils::GetTime();
-    auto second_stamp = utils::GetTime();
-    auto third_stamp = utils::GetTime();
-    auto forth_stamp = utils::GetTime();
-    std::cout << "Time stamp (ns):" << samples_utils::AposFormat(first_stamp) << std::endl;
-    std::cout << "Time stamp (ns):" << samples_utils::AposFormat(second_stamp) << std::endl;
-    std::cout << "Time stamp (ns):" << samples_utils::AposFormat(third_stamp) << std::endl;
-    std::cout << "Time stamp (ns):" << samples_utils::AposFormat(forth_stamp) << std::endl;
-
-    // Important that queue is in order
-    sycl::queue q;
-    if (do_immediate) {
-      sycl::property_list prop{sycl::property::queue::in_order(),
-                               sycl::ext::intel::property::queue::immediate_command_list()};
-      q = sycl::queue(sycl::gpu_selector_v, prop);
-    } else {
-      sycl::property_list prop{sycl::property::queue::in_order(),
-                               sycl::ext::intel::property::queue::no_immediate_command_list()};
-      q = sycl::queue(sycl::gpu_selector_v, prop);
-    }
-
-    int64_t* a = sycl::malloc_device<int64_t>(kVectorSize, q);
-    int64_t* b = sycl::malloc_device<int64_t>(kVectorSize, q);
-    int64_t* c = sycl::malloc_device<int64_t>(kVectorSize, q);
-
-    auto init_data_host = std::make_unique<int64_t[]>(kVectorSize);
-    auto zero_data_host = std::make_unique<int64_t[]>(kVectorSize);
-    auto outp_data_host = std::make_unique<int64_t[]>(kVectorSize);
-
-    // init values are meaningful as result will be checked afterwards
-    for (int64_t i = 0; i < static_cast<int64_t>(kVectorSize); ++i) {
-      init_data_host[i] = i;
-      zero_data_host[i] = 0LL;
-    }
-
-    // H2D - once
-    q.memcpy(a, init_data_host.get(), kVectorSize * sizeof(int64_t)).wait();
-    q.memcpy(b, init_data_host.get(), kVectorSize * sizeof(int64_t)).wait();
-    q.memcpy(c, zero_data_host.get(), kVectorSize * sizeof(int64_t)).wait();
-
-    auto start = std::chrono::steady_clock::now();
-    for (size_t iter = 0; iter < kRepetitions; iter++) {
-      VecAdd(q, a, b, c, kVectorSize);
-    }
-    q.wait();
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    time_sec = time.count();
-
-    q.memcpy(outp_data_host.get(), c, kVectorSize * sizeof(int64_t)).wait();
-
-    CheckResults(outp_data_host.get(), kVectorSize);
-
-    sycl::free(c, q);
-    sycl::free(b, q);
-    sycl::free(a, q);
-  } catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-  }
-  return time_sec;
-}
-
-enum class CollectionMode { kModeFull = 0, kModeHybrid = 1, kModeLocal = 2 };
-
-auto format_as(CollectionMode collection_mode) {
-  switch (collection_mode) {
-    case CollectionMode::kModeFull:
-      return "Full";
-    case CollectionMode::kModeHybrid:
-      return "Hybrid";
-    case CollectionMode::kModeLocal:
-      return "Local";
-    default:
-      return "Unknown";
-  }
-}
-
-std::ostream& operator<<(std::ostream& out, CollectionMode collection_mode) {
-  out << format_as(collection_mode);
-  return out;
-}
-
-}  // namespace
-
-class NoKernelOverlapParametrizedTestFixture
-    : public ::testing::TestWithParam<std::tuple<bool, CollectionMode>> {
- protected:
-  NoKernelOverlapParametrizedTestFixture() {
-    // Setup work for each test
-  }
-
-  ~NoKernelOverlapParametrizedTestFixture() override {
-    // Cleanup work for each test
-  }
-
-  static bool do_immediate;
-  static std::vector<pti_view_record_kernel> kernel_records;
-
-  void SetUp() override {  // Called right after constructor before each test
-    kernel_records.clear();
-
-    auto [immediate, collection_mode] = GetParam();
-    do_immediate = immediate;
-    if (immediate) {
-      std::cout << " ** Immediate command list mode" << std::endl;
-    } else {
-      std::cout << " ** Non-immediate command list mode" << std::endl;
-    }
-
-    // After we got more experience with this test - we can pass Gaps
-    // as test parameters.
-    // At the moment we want to test that different events of kernel life are not far away from
-    // each other.
-    //
-    // while passed ModeLocal local it is expected it will be selected automatically of course
-    // in case introspection API is available
-    if (collection_mode != CollectionMode::kModeLocal) {
-      utils::SetEnv("PTI_COLLECTION_MODE",
-                    std::to_string(static_cast<std::size_t>(collection_mode)).c_str());
-    }
-  }
-
-  void TearDown() override {
-    // Called right before destructor after each test
-  }
-
-  /**
-   * @internal
-   * Checks that all GPU kernels have the same append and submit timestamps
-   * which holds for Immediate command list
-   */
-  void TestForAppendSubmitAtImmediate() {
-    for (uint32_t kidx = 0; kidx < kernel_records.size(); ++kidx) {
-      auto kernel = kernel_records[kidx];
-      if (kernel._append_timestamp != kernel._submit_timestamp) {
-        FAIL() << "--->  ERROR: Append and Submit timestamps not equal at i: " << kidx
-               << " \t append: " << samples_utils::AposFormat(kernel._append_timestamp)
-               << ", submit: " << samples_utils::AposFormat(kernel._submit_timestamp) << std::endl;
-      }
-    }
-  }
-
-  std::stringstream PrintKernelTimeStamps(const pti_view_record_kernel& kernel) {
-    std::stringstream ss;
-    ss << "Sycl Task Begin Time:        "
-       << samples_utils::AposFormat(kernel._sycl_task_begin_timestamp) << "\n"
-       << "Sycl Enq Launch Kernel Time: "
-       << samples_utils::AposFormat(kernel._sycl_enqk_begin_timestamp) << "\n"
-       << "Append Time:                 " << samples_utils::AposFormat(kernel._append_timestamp)
-       << "\n"
-       << "Submit Time:                 " << samples_utils::AposFormat(kernel._submit_timestamp)
-       << "\n"
-       << "Start Time:                  " << samples_utils::AposFormat(kernel._start_timestamp)
-       << "\n"
-       << "End Time:                    " << samples_utils::AposFormat(kernel._end_timestamp);
-    return ss;
-  }
-
-  /**
-   * @internal
-   * Checks timestamps of GPU kernels for different types of consistency within one kernel
-   * and in relations to the neighbour kernels
-   *
-   * Extensive output helps debug speedup in case of the test failure
-   */
-  void InspectKernelRecords(uint32_t repetitions, float kernel_loop_duration_sec) {
-    // Sort by kernel records by sycl_task_begin_timestamp
-    std::sort(kernel_records.begin(), kernel_records.end(),
-              [](const pti_view_record_kernel& r1, const pti_view_record_kernel& r2) {
-                return r1._sycl_task_begin_timestamp < r2._sycl_task_begin_timestamp;
-              });
-
-    // Check that timestamps of neighbour kernels are not overlapping
-    // this holds true for kernels submitted to the same in-order queue
-    for (uint32_t kidx = 1; kidx < kernel_records.size(); ++kidx) {
-      auto k0 = kernel_records[kidx - 1];
-      auto k1 = kernel_records[kidx];
-      if (k1._start_timestamp <= k0._end_timestamp) {
-        FAIL() << "--->  ERROR: Device kernel timestamps overlap end_of_i < start_of_i-1, at i: "
-               << kidx << ", end_of_i-1: " << samples_utils::AposFormat(k0._end_timestamp)
-               << ", start_of_i: " << samples_utils::AposFormat(k1._start_timestamp) << "\n"
-               << "...Kernel  Details: i-1:" << kidx - 1 << "\n"
-               << PrintKernelTimeStamps(k0).str() << "\n"
-               << "...                   i:" << kidx << "\n"
-               << PrintKernelTimeStamps(k1).str() << "\n";
-      }
-    }
-
-    uint64_t max_gap_ns = static_cast<uint64_t>(kernel_loop_duration_sec * 1e9);
-
-    std::cout << "Repetitions: " << repetitions
-              << ", kernel loop duration: " << static_cast<uint64_t>(kernel_loop_duration_sec * 1e9)
-              << " ns" << std::endl;
-
-    // Checks for the monotonicity of different stages timestamps of a kernel
-    // as well as the "gap" between these timestamps in not "big" -
-    // top bound of the test compute loop duration time
-    for (uint32_t kidx = 0; kidx < kernel_records.size(); ++kidx) {
-      auto kernel = kernel_records[kidx];
-      auto found_issues = pti::test::utils::ValidateTimestamps(
-          kernel._sycl_task_begin_timestamp, kernel._sycl_enqk_begin_timestamp,
-          kernel._append_timestamp, kernel._submit_timestamp, kernel._start_timestamp,
-          kernel._end_timestamp);
-
-      if (found_issues > 0) {
-        FAIL() << "------------>     ERROR: Not monotonic kernel timestamps. Here are details:\n"
-               << PrintKernelTimeStamps(kernel).str() << "\n";
-      }
-
-      if (kernel._sycl_task_begin_timestamp == 0) {
-        std::cout << "WARN ------------>     Something wrong: Sycl Enq Launch Kernel Time is 0"
-                  << std::endl;
-      }
-
-      if (kernel._sycl_enqk_begin_timestamp == 0) {
-        FAIL() << "------------>     Something wrong: Sycl Enq Launch Kernel Time is 0"
-               << std::endl;
-      }
-      if (kernel._start_timestamp == kernel._end_timestamp) {
-        FAIL() << "------------>     Something wrong: Append Time is 0" << std::endl;
-      }
-      std::cout << " ** Kernel " << kidx << " Start: " << kernel._sycl_task_begin_timestamp
-                << std::setw(8) << std::right << " Full time: " << std::setw(8) << std::right
-                << kernel._end_timestamp - kernel._sycl_task_begin_timestamp << "\n"
-                << std::setw(8) << std::right
-                << "Sycl Task Begin to Sycl Enq Time: " << std::setw(8) << std::right
-                << kernel._sycl_enqk_begin_timestamp - kernel._sycl_task_begin_timestamp << "\n"
-                << "Sycl Enq to Append Time:          " << std::setw(8) << std::right
-                << kernel._append_timestamp - kernel._sycl_enqk_begin_timestamp << "\n"
-                << "Append to Submit Time:            " << std::setw(8) << std::right
-                << kernel._submit_timestamp - kernel._append_timestamp << "\n"
-                << "Submit to Start Time:             " << std::setw(8) << std::right
-                << kernel._start_timestamp - kernel._submit_timestamp << "\n"
-                << "Start to End Time:                " << std::setw(8) << std::right
-                << kernel._end_timestamp - kernel._start_timestamp << "\n";
-
-      if (kernel._sycl_task_begin_timestamp != 0) {
-        if (0 !=
-            pti::test::utils::ValidateNoBigGapBetweenTimestampsNs(
-                max_gap_ns, {kernel._sycl_task_begin_timestamp, kernel._sycl_enqk_begin_timestamp,
-                             kernel._append_timestamp, kernel._submit_timestamp,
-                             kernel._start_timestamp, kernel._end_timestamp})) {
-          FAIL() << "------------>     ERROR: Gap between timestamps more than " << max_gap_ns
-                 << " ns\n"
-                 << PrintKernelTimeStamps(kernel).str() << "\n";
-        }
-      } else {
-        if (0 != pti::test::utils::ValidateNoBigGapBetweenTimestampsNs(
-                     max_gap_ns,
-                     {kernel._sycl_enqk_begin_timestamp, kernel._append_timestamp,
-                      kernel._submit_timestamp, kernel._start_timestamp, kernel._end_timestamp})) {
-          FAIL() << "------------>     ERROR: Gap between timestamps more than " << max_gap_ns
-                 << " ns\n"
-                 << PrintKernelTimeStamps(kernel).str() << "\n";
-        }
-      }
-    }
-  }
-
-  static void BufferRequested(unsigned char** buf, size_t* buf_size) {
-    // very big buffer that would be enough for all records
-    *buf_size = sizeof(pti_view_record_kernel) * 10000;
-    void* ptr = ::operator new(*buf_size);
-    ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-    *buf = static_cast<unsigned char*>(ptr);
-    if (!*buf) {
-      std::abort();
-    }
-  }
-
-  static void BufferCompleted(unsigned char* buf, size_t buf_size, size_t used_bytes) {
-    if (!buf || !used_bytes || !buf_size) {
-      std::cerr << "Received empty buffer" << '\n';
-      ::operator delete(buf);
-      return;
-    }
-
-    pti_view_record_base* ptr = nullptr;
-    while (true) {
-      auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-      if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        std::cout << "Reached End of buffer " << '\n';
-        break;
-      }
-      if (buf_status != pti_result::PTI_SUCCESS) {
-        std::cerr << "Error Parsing Records in buffer.  PTI buf_status: " << buf_status << '\n';
-        break;
-      }
-      switch (ptr->_view_kind) {
-        case pti_view_kind::PTI_VIEW_INVALID: {
-          std::cout << "Found Invalid Record" << '\n';
-          break;
-        }
-        case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-          pti_view_record_kernel* p_kernel_rec = reinterpret_cast<pti_view_record_kernel*>(ptr);
-          kernel_records.push_back(*p_kernel_rec);
-          break;
-        }
-        default: {
-          break;
-        }
-      }
-    }
-    ::operator delete(buf);
-  }
-
-  float RunTest(bool do_immediate) {
-    StartTracing();
-    auto kernel_loop_duration = TestCore(do_immediate);
-    StopTracing();
-    EXPECT_EQ(ptiFlushAllViews(), pti_result::PTI_SUCCESS);
-    return kernel_loop_duration;
-  }
-};
-
-// static members initialization
-std::vector<pti_view_record_kernel> NoKernelOverlapParametrizedTestFixture::kernel_records{};
-bool NoKernelOverlapParametrizedTestFixture::do_immediate = true;
-
-TEST_P(NoKernelOverlapParametrizedTestFixture, NoKernelOverlapImmediate) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-
-  auto kernel_loop_duration_sec = RunTest(do_immediate);
-  EXPECT_GE(kernel_loop_duration_sec, 0.0f);
-  std::cout << "Kernel loop duration: " << kernel_loop_duration_sec << " sec, "
-            << kernel_loop_duration_sec * 1e9 << "ns" << std::endl;
-
-  EXPECT_EQ(kernel_records.size(), kRepetitions);
-
-  InspectKernelRecords(kRepetitions, kernel_loop_duration_sec);
-
-  if (do_immediate) {
-    TestForAppendSubmitAtImmediate();
-  }
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    NoKernelOverlapAndGapInSubmittingTests, NoKernelOverlapParametrizedTestFixture,
-    ::testing::Values(std::make_tuple(true, CollectionMode::kModeFull),
-                      std::make_tuple(false, CollectionMode::kModeFull),
-                      std::make_tuple(true, CollectionMode::kModeHybrid),
-                      std::make_tuple(false, CollectionMode::kModeHybrid),
-                      std::make_tuple(true, CollectionMode::kModeLocal),
-                      std::make_tuple(false, CollectionMode::kModeLocal)),
-
-    [](const testing::TestParamInfo<NoKernelOverlapParametrizedTestFixture::ParamType>& info) {
-      return fmt::format("Queue_Type_{}_PTI_COLLECTION_MODE_{}",
-                         (std::get<0>(info.param) ? "ImmediateQueue" : "NonImmediateQueue"),
-                         std::get<1>(info.param));
-    });
diff --git a/sdk/test/pc_sampling/exit_workload.cc b/sdk/test/pc_sampling/exit_workload.cc
deleted file mode 100644
index 293e8415..00000000
--- a/sdk/test/pc_sampling/exit_workload.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <string>
-
-namespace {
-
-void VerifyReportIsReady() {
-  const char* output_path = std::getenv("PTI_PC_SAMPLING_OUTPUT");
-  if (output_path == nullptr) {
-    std::cerr << "PC sampling report unavailable to application exit handlers" << std::endl;
-    return;
-  }
-
-  std::ifstream report_file(output_path);
-  const std::string report{std::istreambuf_iterator<char>(report_file),
-                           std::istreambuf_iterator<char>()};
-  if (report.find("PC Sampling collection stopped successfully") == std::string::npos) {
-    std::cerr << "PC sampling report unavailable to application exit handlers" << std::endl;
-    return;
-  }
-  std::cerr << "PC sampling report available to application exit handlers" << std::endl;
-}
-
-}  // namespace
-
-int main(int argc, char** argv) {
-  if (argc != 2) {
-    return EXIT_FAILURE;
-  }
-
-  if (std::strcmp(argv[1], "quick-exit") == 0 || std::strcmp(argv[1], "std-quick-exit") == 0) {
-    std::at_quick_exit(VerifyReportIsReady);
-  } else {
-    std::atexit(VerifyReportIsReady);
-  }
-  if (std::strcmp(argv[1], "exit") == 0) {
-    ::exit(EXIT_SUCCESS);
-  }
-  if (std::strcmp(argv[1], "std-exit") == 0) {
-    std::exit(EXIT_SUCCESS);
-  }
-  if (std::strcmp(argv[1], "quick-exit") == 0) {
-    ::quick_exit(EXIT_SUCCESS);
-  }
-  if (std::strcmp(argv[1], "std-quick-exit") == 0) {
-    std::quick_exit(EXIT_SUCCESS);
-  }
-  return EXIT_FAILURE;
-}
diff --git a/sdk/test/pc_sampling/pc_sampling_basic_test.cc b/sdk/test/pc_sampling/pc_sampling_basic_test.cc
deleted file mode 100644
index f696c2c1..00000000
--- a/sdk/test/pc_sampling/pc_sampling_basic_test.cc
+++ /dev/null
@@ -1,139 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <array>
-#include <vector>
-
-#include "pc_sampling/pti_pc_sampling_internal.h"
-#include "pc_sampling/pti_pc_sampling_raw_data_file.h"
-#include "pti/pti_pc_sampling.h"
-#include "utils/pti_filesystem.h"
-
-TEST(PcSamplingBasicTest, EnableRejectsNullHandle) {
-  EXPECT_EQ(ptiPcSamplingEnable(nullptr), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST(PcSamplingBasicTest, IsConfiguredDeviceRejectsNullHandle) {
-  EXPECT_FALSE(pti::pc_sampling::IsConfiguredDevice(nullptr, nullptr));
-}
-
-TEST(PcSamplingBasicTest, IsConfiguredDeviceRejectsNullDevice) {
-  _pti_pc_sampling_handle_t handle_storage;
-  pti_pc_sampling_handle_t handle = &handle_storage;
-
-  EXPECT_FALSE(pti::pc_sampling::IsConfiguredDevice(handle, nullptr));
-}
-
-TEST(PcSamplingBasicTest, RejectsForeignHandle) {
-  _pti_pc_sampling_handle_t foreign_handle;
-
-  EXPECT_EQ(ptiPcSamplingConfigure(&foreign_handle, nullptr, 0, 0), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingStartCollection(&foreign_handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingDisable(&foreign_handle), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST(PcSamplingBasicTest, ValidateStartableHandleRejectsNullAndForeignHandles) {
-  using pti::pc_sampling::PcSamplingState;
-
-  EXPECT_EQ(pti::pc_sampling::ValidateStartableHandle(nullptr), PTI_ERROR_BAD_ARGUMENT);
-
-  _pti_pc_sampling_handle_t foreign_handle;
-  EXPECT_EQ(pti::pc_sampling::ValidateStartableHandle(&foreign_handle), PTI_ERROR_BAD_ARGUMENT);
-
-  // A rejected handle must not pick up the default configuration that
-  // ptiPcSamplingStartCollection applies when ptiPcSamplingConfigure was skipped.
-  EXPECT_EQ(ptiPcSamplingStartCollection(&foreign_handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(foreign_handle.state_, PcSamplingState::kEnabled);
-  EXPECT_TRUE(foreign_handle.configured_devices_.empty());
-}
-
-TEST(PcSamplingBasicTest, ResultTypeToStringSupportsPcSamplingSpecificErrors) {
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED),
-               "PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED),
-               "PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED),
-               "PTI_ERROR_PC_SAMPLING_NOT_CONFIGURED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_ALREADY_STARTED),
-               "PTI_ERROR_PC_SAMPLING_ALREADY_STARTED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_NOT_STARTED),
-               "PTI_ERROR_PC_SAMPLING_NOT_STARTED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED),
-               "PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_NOT_STOPPED),
-               "PTI_ERROR_PC_SAMPLING_NOT_STOPPED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL),
-               "PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED),
-               "PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED");
-  EXPECT_STREQ(ptiResultTypeToString(PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV),
-               "PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV");
-}
-
-TEST(PcSamplingBasicTest, PcSamplingStateToStringReturnsCorrectStrings) {
-  using pti::pc_sampling::PcSamplingState;
-  using pti::pc_sampling::PcSamplingStateToString;
-
-  EXPECT_STREQ(PcSamplingStateToString(PcSamplingState::kEnabled), "ENABLED");
-  EXPECT_STREQ(PcSamplingStateToString(PcSamplingState::kConfigured), "CONFIGURED");
-  EXPECT_STREQ(PcSamplingStateToString(PcSamplingState::kStarted), "STARTED");
-  EXPECT_STREQ(PcSamplingStateToString(PcSamplingState::kStopped), "STOPPED");
-  EXPECT_STREQ(PcSamplingStateToString(PcSamplingState::kForceUint32), "FORCE_UINT32");
-}
-
-TEST(PcSamplingBasicTest, TempRawDataFileRoundTripsAndRemovesTempFile) {
-  pti::pc_sampling::TempRawDataFile raw_data;
-
-  ASSERT_TRUE(raw_data.OpenTemp());
-  ASSERT_TRUE(raw_data.IsOpen());
-  ASSERT_TRUE(raw_data.HasPath());
-
-  const std::string path = raw_data.path();
-  EXPECT_TRUE(pti::utils::filesystem::exists(path));
-
-  constexpr std::array<uint8_t, 4> expected_data = {1, 2, 3, 4};
-  ASSERT_TRUE(raw_data.Append(expected_data.data(), expected_data.size()));
-  EXPECT_EQ(raw_data.size(), expected_data.size());
-
-  ASSERT_TRUE(raw_data.Finalize());
-  EXPECT_FALSE(raw_data.IsOpen());
-  EXPECT_TRUE(pti::utils::filesystem::exists(path));
-
-  std::vector<uint8_t> actual_data;
-  ASSERT_TRUE(raw_data.ReadAll(&actual_data));
-  EXPECT_EQ(actual_data.size(), expected_data.size());
-  EXPECT_TRUE(std::equal(actual_data.begin(), actual_data.end(), expected_data.begin()));
-
-  raw_data.Reset();
-  EXPECT_FALSE(raw_data.IsOpen());
-  EXPECT_FALSE(raw_data.HasPath());
-  EXPECT_EQ(raw_data.size(), 0U);
-  EXPECT_FALSE(pti::utils::filesystem::exists(path));
-}
-
-TEST(PcSamplingBasicTest, TempRawDataFileReadRangeReadsRequestedSlice) {
-  pti::pc_sampling::TempRawDataFile raw_data;
-  ASSERT_TRUE(raw_data.OpenTemp());
-
-  constexpr std::array<uint8_t, 8> full = {5, 6, 7, 8, 9, 10, 11, 12};
-  ASSERT_TRUE(raw_data.Append(full.data(), full.size()));
-  ASSERT_TRUE(raw_data.Finalize());
-
-  std::array<uint8_t, 3> slice = {};
-  ASSERT_TRUE(raw_data.ReadRange(2, slice.size(), slice.data()));
-  EXPECT_EQ(slice, (std::array<uint8_t, 3>{7, 8, 9}));
-
-  EXPECT_TRUE(raw_data.ReadRange(full.size(), 0, nullptr));
-  EXPECT_FALSE(raw_data.ReadRange(full.size() - 1, 2, slice.data()));
-  EXPECT_FALSE(raw_data.ReadRange(0, 1, nullptr));
-}
-
-TEST(PcSamplingBasicTest, ResolveKernelNameReturnsUnknownForNullHandle) {
-  EXPECT_STREQ(pti::pc_sampling::ResolveKernelName(nullptr), "<unknown>");
-}
diff --git a/sdk/test/pc_sampling/pc_sampling_functional_test.cc b/sdk/test/pc_sampling/pc_sampling_functional_test.cc
deleted file mode 100644
index 92afc77f..00000000
--- a/sdk/test/pc_sampling/pc_sampling_functional_test.cc
+++ /dev/null
@@ -1,868 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Public-API functional tests for PC Sampling.
-//
-// =============================================================
-
-#include <cstdlib>
-#include <limits>
-#include <memory>
-#include <random>
-#include <stdexcept>
-#include <string>
-#include <sycl/sycl.hpp>
-
-#include "pc_sampling_test_fixture.h"
-
-namespace {
-
-constexpr size_t kElementCount = 1 << 22;
-constexpr uint32_t kKernelLaunchCount = 256;
-constexpr uint32_t kInnerIterations = 64;
-constexpr uint32_t kSamplingPeriodNs = 10'000;
-
-class PcSamplingCollectionKernel;
-class PcSamplingCollectionKernelAlt;
-
-class ScopedCollectionBufferSizeEnvironment {
- public:
-  ScopedCollectionBufferSizeEnvironment() {
-#if defined(_WIN32)
-    char* value = nullptr;
-    if (_dupenv_s(&value, nullptr, kName) != 0) {
-      throw std::runtime_error("Failed to read PC sampling collection buffer environment");
-    }
-    std::unique_ptr<char, decltype(&std::free)> value_buffer(value, &std::free);
-    if (value_buffer != nullptr) {
-      saved_value_ = value_buffer.get();
-      was_set_ = true;
-    }
-#else
-    const char* value = std::getenv(kName);
-    if (value != nullptr) {
-      saved_value_ = value;
-      was_set_ = true;
-    }
-#endif
-  }
-
-  ~ScopedCollectionBufferSizeEnvironment() {
-    if (was_set_) {
-      Set(saved_value_.c_str());
-    } else {
-      Unset();
-    }
-  }
-
-  void Set(const char* value) {
-#if defined(_WIN32)
-    _putenv_s(kName, value);
-#else
-    setenv(kName, value, 1);
-#endif
-  }
-
-  void Unset() {
-#if defined(_WIN32)
-    // An empty value removes the variable on Windows.
-    _putenv_s(kName, "");
-#else
-    unsetenv(kName);
-#endif
-  }
-
- private:
-  static constexpr const char* kName = "PTI_PC_SAMPLING_COLLECTION_BUFFER_SIZE";
-
-  std::string saved_value_;
-  bool was_set_ = false;
-};
-
-// Odd, so repeated multiplication never collapses the value to zero.
-uint32_t RuntimeMultiplier() { return static_cast<uint32_t>(std::random_device{}()) | 1u; }
-
-// These workloads are only intended to run long enough to generate PC samples.
-void RunLargeKernelWorkload(sycl::queue& queue) {
-  const uint32_t multiplier = RuntimeMultiplier();
-  std::vector<uint32_t> values(kElementCount);
-  for (size_t i = 0; i < values.size(); ++i) {
-    values[i] = static_cast<uint32_t>(i + 1);
-  }
-
-  {
-    sycl::buffer<uint32_t, 1> values_buffer(values.data(), sycl::range<1>(values.size()));
-    for (uint32_t launch_index = 0; launch_index < kKernelLaunchCount; ++launch_index) {
-      queue.submit([&](sycl::handler& cgh) {
-        auto values_acc = values_buffer.get_access<sycl::access::mode::read_write>(cgh);
-        cgh.parallel_for<PcSamplingCollectionKernel>(
-            sycl::range<1>(values.size()), [=](sycl::id<1> index) {
-              uint32_t value = values_acc[index];
-              const uint32_t lane = static_cast<uint32_t>(index[0]);
-              for (uint32_t iteration = 0; iteration < kInnerIterations; ++iteration) {
-                // Some arbitrary arithmetic to generate PC samples.
-                value = value * 1664525u + 1013904223u + lane + iteration;
-                value ^= value >> 15;
-                value *= multiplier;
-              }
-              values_acc[index] = value;
-            });
-      });
-    }
-  }
-
-  queue.wait();
-}
-
-void RunAlternateKernelWorkload(sycl::queue& queue) {
-  const uint32_t multiplier = RuntimeMultiplier();
-  std::vector<uint32_t> values(kElementCount);
-  for (size_t i = 0; i < values.size(); ++i) {
-    values[i] = static_cast<uint32_t>((i % 97) + 3);
-  }
-
-  {
-    sycl::buffer<uint32_t, 1> values_buffer(values.data(), sycl::range<1>(values.size()));
-    for (uint32_t launch_index = 0; launch_index < kKernelLaunchCount; ++launch_index) {
-      queue.submit([&](sycl::handler& cgh) {
-        auto values_acc = values_buffer.get_access<sycl::access::mode::read_write>(cgh);
-        cgh.parallel_for<PcSamplingCollectionKernelAlt>(
-            sycl::range<1>(values.size()), [=](sycl::id<1> index) {
-              uint32_t value = values_acc[index];
-              const uint32_t lane = static_cast<uint32_t>(index[0]);
-              for (uint32_t iteration = 0; iteration < kInnerIterations; ++iteration) {
-                // Some arbitrary arithmetic to generate PC samples.
-                value += (lane ^ iteration) + 0x9e3779b9u;
-                value = (value << 7) | (value >> 25);
-                value ^= lane * 40503u + iteration;
-                value *= multiplier;
-              }
-              values_acc[index] = value;
-            });
-      });
-    }
-  }
-
-  queue.wait();
-}
-
-}  // namespace
-
-TEST_F(PcSamplingTest, EnableRejectsSecondLiveHandle) {
-  pti_pc_sampling_handle_t first_handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&first_handle, PTI_SUCCESS);
-
-  pti_pc_sampling_handle_t second_handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&second_handle, PTI_ERROR_PC_SAMPLING_ALREADY_ENABLED);
-  EXPECT_EQ(second_handle, nullptr);
-
-  EXPECT_EQ(ptiPcSamplingDisable(first_handle), PTI_SUCCESS);
-
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&second_handle, PTI_SUCCESS);
-  EXPECT_NE(second_handle, nullptr);
-  EXPECT_EQ(ptiPcSamplingDisable(second_handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, RejectsDisabledHandleAfterRegistryRemoval) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(PcSamplingTest, IsConfiguredDeviceMatchesOnlyConfiguredDevice) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_ERROR_BAD_ARGUMENT);
-}
-
-TEST_F(PcSamplingTest, QueryApisReturnSpecificLifecycleErrors) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_NE(handle, nullptr);
-
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0), PTI_SUCCESS);
-
-  size_t kernel_count = 0;
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, nullptr, nullptr, &kernel_count),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-
-  pti_pc_sampling_kernel_info_t kernel_info{};
-  kernel_info._struct_size = sizeof(kernel_info);
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, nullptr, 1, &kernel_info),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-  EXPECT_EQ(ptiPcSamplingGetSamplesPerInstruction(handle, nullptr, 1, nullptr, 0, nullptr, 0),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, nullptr, nullptr, &kernel_count),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, nullptr, 1, &kernel_info),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-  EXPECT_EQ(ptiPcSamplingGetSamplesPerInstruction(handle, nullptr, 1, nullptr, 0, nullptr, 0),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-//-----------------------------------------------------------------------------
-// Empty Query Tests
-//-----------------------------------------------------------------------------
-
-TEST_F(PcSamplingTest, LifecycleSupportsEmptyQueries) {
-  ScopedCollectionBufferSizeEnvironment environment;
-  environment.Unset();
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  size_t buffer_size = 0;
-  EXPECT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, nullptr), PTI_ERROR_BAD_ARGUMENT);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_GT(buffer_size, 0u);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, buffer_size), PTI_SUCCESS);
-
-  size_t device_count = devices_.size() > 0 ? 1 : 0;
-  pti_device_handle_t device_handle[1] = {
-      (devices_.size() > 0) ? reinterpret_cast<pti_device_handle_t>(devices_[0]) : nullptr};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, device_count, 0), PTI_SUCCESS);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, buffer_size), PTI_SUCCESS);
-  // No kernels profiled, we expect a valid, empty results.
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, buffer_size),
-            PTI_ERROR_PC_SAMPLING_ALREADY_STARTED);
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, buffer_size),
-            PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED);
-
-  // After a real collection the stall-reason table is derived from the
-  // EuStallSampling metric group and must be non-empty.
-  size_t reason_count = 0;
-  EXPECT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  EXPECT_GT(reason_count, 0u);
-
-  size_t profiled_device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &profiled_device_count), PTI_SUCCESS);
-  ASSERT_EQ(profiled_device_count, 1u);
-
-  size_t kernel_count = 1;
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device_handle[0], nullptr, &kernel_count),
-            PTI_SUCCESS);
-  EXPECT_EQ(kernel_count, 0u);
-
-  pti_pc_sampling_device_status_t device_status{};
-  device_status._struct_size = sizeof(device_status);
-  EXPECT_EQ(ptiPcSamplingGetDeviceStatus(handle, device_handle[0], &device_status), PTI_SUCCESS);
-  EXPECT_EQ(device_status._device, device_handle[0]);
-  EXPECT_EQ(device_status._samples_dropped, 0u);
-  EXPECT_EQ(device_status._total_sample_count, 0u);
-  EXPECT_EQ(device_status._total_pc_count, 0u);
-
-  kernel_count = 10;
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device_handle[0], nullptr, &kernel_count),
-            PTI_SUCCESS);
-  EXPECT_EQ(kernel_count, 0u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, RejectsInvalidOrdering) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  // Configuration is optional, so only stopping is invalid on a freshly enabled handle.
-  EXPECT_EQ(ptiPcSamplingStopCollection(handle), PTI_ERROR_PC_SAMPLING_NOT_STARTED);
-
-  pti_device_handle_t device_handle[1] = {reinterpret_cast<pti_device_handle_t>(devices_.front())};
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, device_handle, 0, 0), PTI_ERROR_BAD_ARGUMENT);
-
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, 1, 0), PTI_SUCCESS);
-
-  size_t device_count = 0;
-  EXPECT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, device_handle, 1, 0),
-            PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0),
-            PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED);
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STARTED);
-  EXPECT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count),
-            PTI_ERROR_PC_SAMPLING_NOT_STOPPED);
-
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  EXPECT_EQ(ptiPcSamplingStopCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED);
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0),
-            PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED);
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-//-----------------------------------------------------------------------------
-// Optional Configuration Tests
-//-----------------------------------------------------------------------------
-
-TEST_F(PcSamplingTest, StartAppliesDefaultConfigurationWhenConfigureSkipped) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_NE(handle, nullptr);
-
-  // enable -> start, without any ptiPcSamplingConfigure call.
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-
-  // The implicit configuration owns the handle from now on, exactly like an explicit one.
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0),
-            PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED);
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STARTED);
-
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0),
-            PTI_ERROR_PC_SAMPLING_ALREADY_CONFIGURED);
-
-  // Results queries must be valid on the default configuration, the same way they are
-  // after an explicitly configured collection.
-  size_t reason_count = 0;
-  EXPECT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  EXPECT_GT(reason_count, 0u);
-
-  size_t profiled_device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &profiled_device_count), PTI_SUCCESS);
-  ASSERT_EQ(profiled_device_count, 1u);
-  pti_device_handle_t profiled_device = nullptr;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, &profiled_device, &profiled_device_count),
-            PTI_SUCCESS);
-  ASSERT_NE(profiled_device, nullptr);
-
-  // No workload ran, so a valid and empty result set is expected.
-  size_t kernel_count = 0;
-  EXPECT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, profiled_device, nullptr, &kernel_count),
-            PTI_SUCCESS);
-  EXPECT_EQ(kernel_count, 0u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, CollectsDataWhenConfigureSkipped) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_NE(handle, nullptr);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  RunLargeKernelWorkload(queue);
-  ASSERT_PC_SAMPLING_STOP_SUCCESS(handle);
-
-  size_t device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count), PTI_SUCCESS);
-  ASSERT_EQ(device_count, 1u);
-  std::vector<pti_device_handle_t> profiled_devices(device_count);
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, profiled_devices.data(), &device_count),
-            PTI_SUCCESS);
-  pti_device_handle_t device = profiled_devices[0];
-
-  size_t reason_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  ASSERT_GT(reason_count, 0u);
-
-  pti_pc_sampling_device_status_t device_status{};
-  device_status._struct_size = sizeof(device_status);
-  ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &device_status), PTI_SUCCESS);
-  EXPECT_GT(device_status._total_sample_count, 0u);
-  EXPECT_GT(device_status._total_pc_count, 0u);
-
-  size_t kernel_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &kernel_count),
-            PTI_SUCCESS);
-  ASSERT_EQ(kernel_count, 1u);
-  std::vector<uint64_t> kernel_handles(kernel_count);
-  ASSERT_EQ(
-      ptiPcSamplingGetObservedKernelHandles(handle, device, kernel_handles.data(), &kernel_count),
-      PTI_SUCCESS);
-
-  pti_pc_sampling_kernel_info_t kernel_info{};
-  kernel_info._struct_size = sizeof(kernel_info);
-  std::vector<uint64_t> kernel_aggregated_samples(reason_count, 0);
-  kernel_info._aggregated_samples = kernel_aggregated_samples.data();
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, device, kernel_handles[0], &kernel_info),
-            PTI_SUCCESS);
-  EXPECT_EQ(kernel_info._reason_count, reason_count);
-  EXPECT_NE(kernel_info._kernel_name, nullptr);
-  EXPECT_GT(kernel_info._instructions_with_samples_count, 0u);
-  EXPECT_TRUE(std::any_of(kernel_aggregated_samples.begin(), kernel_aggregated_samples.end(),
-                          [](uint64_t value) { return value != 0; }));
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, CollectsDataWithEnvironmentConfiguredCollectionBuffer) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  ScopedCollectionBufferSizeEnvironment environment;
-  environment.Set("2048");
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  size_t effective_buffer_size = 0;
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &effective_buffer_size), PTI_SUCCESS);
-  ASSERT_EQ(effective_buffer_size, 2048u);
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0), PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  RunLargeKernelWorkload(queue);
-  ASSERT_EQ(ptiPcSamplingStopCollection(handle), PTI_SUCCESS);
-
-  size_t device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count), PTI_SUCCESS);
-  ASSERT_EQ(device_count, 1u);
-  pti_device_handle_t device = nullptr;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, &device, &device_count), PTI_SUCCESS);
-  ASSERT_NE(device, nullptr);
-
-  pti_pc_sampling_device_status_t device_status{};
-  device_status._struct_size = sizeof(device_status);
-  ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &device_status), PTI_SUCCESS);
-  EXPECT_GT(device_status._total_sample_count, 0u);
-  EXPECT_GT(device_status._total_pc_count, 0u);
-
-  size_t reason_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  ASSERT_GT(reason_count, 0u);
-
-  size_t kernel_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &kernel_count),
-            PTI_SUCCESS);
-  ASSERT_EQ(kernel_count, 1u);
-  uint64_t kernel_handle = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, &kernel_handle, &kernel_count),
-            PTI_SUCCESS);
-
-  pti_pc_sampling_kernel_info_t kernel_info{};
-  kernel_info._struct_size = sizeof(kernel_info);
-  std::vector<uint64_t> aggregated_samples(reason_count, 0);
-  kernel_info._aggregated_samples = aggregated_samples.data();
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, device, kernel_handle, &kernel_info),
-            PTI_SUCCESS);
-  ASSERT_GT(kernel_info._instructions_with_samples_count, 0u);
-  EXPECT_TRUE(std::any_of(aggregated_samples.begin(), aggregated_samples.end(),
-                          [](uint64_t value) { return value != 0; }));
-
-  std::vector<pti_pc_sampling_instruction_t> instructions(
-      kernel_info._instructions_with_samples_count);
-  std::vector<uint64_t> samples(kernel_info._instructions_with_samples_count * reason_count, 0);
-  ASSERT_EQ(
-      ptiPcSamplingGetSamplesPerInstruction(handle, device, kernel_handle, instructions.data(),
-                                            instructions.size(), samples.data(), samples.size()),
-      PTI_SUCCESS);
-  EXPECT_TRUE(
-      std::any_of(samples.begin(), samples.end(), [](uint64_t value) { return value != 0; }));
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, CollectsDataWithApiConfiguredCollectionBuffer) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  ScopedCollectionBufferSizeEnvironment environment;
-  environment.Unset();
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 2048), PTI_SUCCESS);
-  size_t effective_buffer_size = 0;
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &effective_buffer_size), PTI_SUCCESS);
-  ASSERT_EQ(effective_buffer_size, 2048u);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  environment.Set("1024");
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &effective_buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(effective_buffer_size, 2048u);
-
-  RunLargeKernelWorkload(queue);
-  ASSERT_EQ(ptiPcSamplingStopCollection(handle), PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &effective_buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(effective_buffer_size, 2048u);
-
-  size_t device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count), PTI_SUCCESS);
-  ASSERT_EQ(device_count, 1u);
-  pti_device_handle_t device = nullptr;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, &device, &device_count), PTI_SUCCESS);
-  ASSERT_NE(device, nullptr);
-
-  pti_pc_sampling_device_status_t device_status{};
-  device_status._struct_size = sizeof(device_status);
-  ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &device_status), PTI_SUCCESS);
-  EXPECT_GT(device_status._total_sample_count, 0u);
-  EXPECT_GT(device_status._total_pc_count, 0u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, CollectionBufferEnvironmentControlsEffectiveSize) {
-  ScopedCollectionBufferSizeEnvironment environment;
-  environment.Unset();
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  size_t buffer_size = 0;
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  const size_t default_buffer_size = buffer_size;
-  ASSERT_GT(default_buffer_size, 0u);
-
-  // Invalid sizes are rejected and leave the effective size unchanged.
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(nullptr, 2048), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 0), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 63), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 65), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 1025), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 64 * 1024 * 1024 + 64),
-            PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, (std::numeric_limits<size_t>::max)() - 63),
-            PTI_ERROR_BAD_ARGUMENT);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, default_buffer_size);
-
-  // Without the environment variable, the API sets the effective size.
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 2048), PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 2048u);
-
-  // A valid environment value overrides the API value.
-  environment.Set("1024");
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 1024u);
-
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 4096),
-            PTI_WARN_PC_SAMPLING_BUFFER_SIZE_OVERRIDDEN_BY_ENV);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 1024u);
-
-  environment.Set("67108864");
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 64u * 1024 * 1024);
-
-  environment.Set("64");
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 64u);
-
-  // Invalid environment values are ignored in favor of the API value.
-  for (const char* invalid_value :
-       {"", "0", "63", "1025", "67108928", "-1", " -64", "+1024", " 1024", "1024 ", "1k",
-        "18446744073709551552", "99999999999999999999999"}) {
-    SCOPED_TRACE(invalid_value);
-    environment.Set(invalid_value);
-    ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-    EXPECT_EQ(buffer_size, 2048u);
-  }
-
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 8192), PTI_SUCCESS);
-  environment.Unset();
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 8192u);
-
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 64), PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingQueryCollectionBufferSize(handle, &buffer_size), PTI_SUCCESS);
-  EXPECT_EQ(buffer_size, 64u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, ReturnsEmptyAllDeviceQueryAfterStoppedCollection) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_NE(handle, nullptr);
-  size_t device_count = devices_.size() > 0 ? 1 : 0;
-  pti_device_handle_t device_handle[1] = {
-      (devices_.size() > 0) ? reinterpret_cast<pti_device_handle_t>(devices_[0]) : nullptr};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, device_count, 0), PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-
-  size_t profiled_device_count = 1;
-  EXPECT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &profiled_device_count), PTI_SUCCESS);
-  EXPECT_EQ(profiled_device_count, 1u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, ReturnsConfiguredDeviceAfterStoppedCollection) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  pti_device_handle_t device_handle[1] = {reinterpret_cast<pti_device_handle_t>(devices_.front())};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, 1, 0), PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-
-  size_t profiled_device_count = 1;
-  EXPECT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &profiled_device_count), PTI_SUCCESS);
-  EXPECT_EQ(profiled_device_count, 1u);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, AggregatesPerKernelAndPerInstructionData) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_NE(handle, nullptr);
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, kSamplingPeriodNs), PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  RunLargeKernelWorkload(queue);
-  ASSERT_PC_SAMPLING_STOP_SUCCESS(handle);
-
-  // Profiled device.
-  size_t device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count), PTI_SUCCESS);
-  ASSERT_EQ(device_count, 1u);
-  std::vector<pti_device_handle_t> profiled_devices(device_count);
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, profiled_devices.data(), &device_count),
-            PTI_SUCCESS);
-  pti_device_handle_t device = profiled_devices[0];
-
-  // Stall reasons (two-call pattern).
-  size_t reason_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  ASSERT_GT(reason_count, 0u);
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& reason : reasons) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-  size_t filled_reason_count = reason_count;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons.data(), &filled_reason_count),
-            PTI_SUCCESS);
-  EXPECT_EQ(filled_reason_count, reason_count);
-  for (const auto& reason : reasons) {
-    EXPECT_NE(reason._name, nullptr);
-    EXPECT_NE(reason._description, nullptr);
-  }
-
-  // Device totals.
-  pti_pc_sampling_device_status_t device_status{};
-  device_status._struct_size = sizeof(device_status);
-  ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &device_status), PTI_SUCCESS);
-  ASSERT_GT(device_status._total_sample_count, 0u);
-  ASSERT_GT(device_status._total_pc_count, 0u);
-
-  // Observed kernels (two-call pattern).
-  size_t kernel_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &kernel_count),
-            PTI_SUCCESS);
-  ASSERT_EQ(kernel_count, 1u);
-  std::vector<uint64_t> kernel_handles(kernel_count);
-  size_t filled_kernel_count = kernel_count;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, kernel_handles.data(),
-                                                  &filled_kernel_count),
-            PTI_SUCCESS);
-  EXPECT_EQ(filled_kernel_count, kernel_count);
-
-  uint64_t device_total_pc_count = 0;
-  uint64_t summed_kernel_samples = 0;
-  std::vector<const char*> returned_kernel_names;
-  std::vector<std::string> expected_kernel_names;
-  for (uint64_t kernel_handle : kernel_handles) {
-    pti_pc_sampling_kernel_info_t kernel_info{};
-    kernel_info._struct_size = sizeof(kernel_info);
-    std::vector<uint64_t> kernel_aggregated_samples(reason_count, 0);
-    kernel_info._aggregated_samples = kernel_aggregated_samples.data();
-    ASSERT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, device, kernel_handle, &kernel_info),
-              PTI_SUCCESS);
-    EXPECT_EQ(kernel_info._device, device);
-    EXPECT_EQ(kernel_info._kernel_handle, kernel_handle);
-    ASSERT_NE(kernel_info._kernel_name, nullptr)
-        << "Kernel name is null for kernel handle: " << kernel_handle;
-
-    // Kernel name must end with the expected suffix and must be demangled.
-    const std::string kernel_name = kernel_info._kernel_name;
-    EXPECT_FALSE(kernel_name.empty())
-        << "Kernel name is empty for kernel handle: " << kernel_handle;
-
-    // TODO(PTI-358): Figure out if demangling can be supported on Windows.
-#if !defined(_WIN32)
-    constexpr char kExpectedKernelName[] = "PcSamplingCollectionKernel";
-    constexpr size_t expected_kernel_name_length = sizeof(kExpectedKernelName) - 1;
-    ASSERT_GE(kernel_name.size(), expected_kernel_name_length)
-        << "Kernel name is shorter than expected suffix: " << kernel_name;
-    const size_t expected_kernel_name_offset = kernel_name.size() - expected_kernel_name_length;
-    const int suffix_compare_result = kernel_name.compare(
-        expected_kernel_name_offset, expected_kernel_name_length, kExpectedKernelName);
-    EXPECT_EQ(suffix_compare_result, 0)
-        << "Kernel name does not end with expected suffix: " << kernel_name;
-    EXPECT_NE(kernel_name.rfind("_Z", 0), 0u) << "Kernel name is not demangled: " << kernel_name;
-#endif
-
-    returned_kernel_names.push_back(kernel_info._kernel_name);
-    expected_kernel_names.push_back(kernel_name);
-
-    EXPECT_EQ(kernel_info._reason_count, reason_count);
-    EXPECT_GT(kernel_info._instructions_with_samples_count, 0u);
-
-    const uint64_t kernel_aggregate_total = std::accumulate(
-        kernel_aggregated_samples.begin(), kernel_aggregated_samples.end(), uint64_t{0});
-    summed_kernel_samples += kernel_aggregate_total;
-    device_total_pc_count += kernel_info._instructions_with_samples_count;
-
-    // Per-instruction data.
-    const size_t instruction_count = kernel_info._instructions_with_samples_count;
-    std::vector<pti_pc_sampling_instruction_t> instructions(instruction_count);
-    std::vector<uint64_t> samples(instruction_count * reason_count, 0);
-    ASSERT_EQ(
-        ptiPcSamplingGetSamplesPerInstruction(handle, device, kernel_handle, instructions.data(),
-                                              instructions.size(), samples.data(), samples.size()),
-        PTI_SUCCESS);
-
-    // Source correlation is currently not implemented.
-    for (const auto& instruction : instructions) {
-      EXPECT_EQ(instruction._source_info, nullptr);
-    }
-
-    // Per-instruction reason sums must equal the kernel aggregate per reason.
-    std::vector<uint64_t> reconstructed(reason_count, 0);
-    for (size_t i = 0; i < instruction_count; ++i) {
-      bool has_non_zero_sample = false;
-      for (size_t j = 0; j < reason_count; ++j) {
-        const uint64_t sample_count = samples[i * reason_count + j];
-        reconstructed[j] += sample_count;
-        has_non_zero_sample = has_non_zero_sample || sample_count != 0;
-      }
-      EXPECT_TRUE(has_non_zero_sample);
-    }
-    for (size_t j = 0; j < reason_count; ++j) {
-      EXPECT_EQ(reconstructed[j], kernel_aggregated_samples[j]);
-    }
-  }
-
-  // Sum over kernels must match the device total sample count.
-  EXPECT_EQ(summed_kernel_samples, device_status._total_sample_count);
-  // Per-kernel instruction counts sum to the device unique-PC count (one bucket
-  // per unique mapped PC).
-  EXPECT_EQ(device_total_pc_count, device_status._total_pc_count);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-
-  ASSERT_EQ(returned_kernel_names.size(), expected_kernel_names.size());
-  for (size_t index = 0; index < returned_kernel_names.size(); ++index) {
-    ASSERT_NE(returned_kernel_names[index], nullptr)
-        << "Kernel name at index " << index << " is null after ptiPcSamplingDisable";
-    EXPECT_STREQ(returned_kernel_names[index], expected_kernel_names[index].c_str())
-        << "Kernel name at index " << index
-        << " does not match expected after ptiPcSamplingDisable";
-  }
-}
-
-TEST_F(PcSamplingTest, DistinctKernelsEachExposeStallReasonData) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  ScopedCollectionBufferSizeEnvironment environment;
-  environment.Unset();
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingSetCollectionBufferSize(handle, 1024 * 1024), PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, kSamplingPeriodNs), PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  RunLargeKernelWorkload(queue);
-  RunAlternateKernelWorkload(queue);
-  ASSERT_PC_SAMPLING_STOP_SUCCESS(handle);
-
-  size_t reason_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  ASSERT_GT(reason_count, 0u);
-
-  size_t device_count = 1;
-  std::vector<pti_device_handle_t> profiled_devices(1);
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, profiled_devices.data(), &device_count),
-            PTI_SUCCESS);
-  pti_device_handle_t device = profiled_devices[0];
-
-  size_t kernel_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &kernel_count),
-            PTI_SUCCESS);
-  ASSERT_EQ(kernel_count, 2u);
-
-  std::vector<uint64_t> kernel_handles(kernel_count);
-  ASSERT_EQ(
-      ptiPcSamplingGetObservedKernelHandles(handle, device, kernel_handles.data(), &kernel_count),
-      PTI_SUCCESS);
-
-  for (uint64_t kernel_handle : kernel_handles) {
-    pti_pc_sampling_kernel_info_t kernel_info{};
-    kernel_info._struct_size = sizeof(kernel_info);
-    std::vector<uint64_t> kernel_aggregated_samples(reason_count, 0);
-    kernel_info._aggregated_samples = kernel_aggregated_samples.data();
-
-    ASSERT_EQ(ptiPcSamplingGetObservedKernelInfo(handle, device, kernel_handle, &kernel_info),
-              PTI_SUCCESS);
-    ASSERT_EQ(kernel_info._reason_count, reason_count);
-    EXPECT_NE(kernel_info._kernel_name, nullptr);
-    EXPECT_GT(kernel_info._instructions_with_samples_count, 0u);
-    EXPECT_TRUE(std::any_of(kernel_aggregated_samples.begin(), kernel_aggregated_samples.end(),
-                            [](uint64_t value) { return value != 0; }));
-  }
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, AggregationIsIdempotentAcrossRepeatedQueries) {
-  sycl::queue queue = sycl::queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, kSamplingPeriodNs), PTI_SUCCESS);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  RunLargeKernelWorkload(queue);
-  ASSERT_PC_SAMPLING_STOP_SUCCESS(handle);
-
-  size_t device_count = 1;
-  std::vector<pti_device_handle_t> profiled_devices(1);
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, profiled_devices.data(), &device_count),
-            PTI_SUCCESS);
-  pti_device_handle_t device = profiled_devices[0];
-
-  pti_pc_sampling_device_status_t first_status{};
-  first_status._struct_size = sizeof(first_status);
-  ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &first_status), PTI_SUCCESS);
-
-  size_t first_kernel_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &first_kernel_count),
-            PTI_SUCCESS);
-
-  // Repeated queries must return identical cached results (single aggregation).
-  for (int repeat = 0; repeat < 3; ++repeat) {
-    pti_pc_sampling_device_status_t status{};
-    status._struct_size = sizeof(status);
-    ASSERT_EQ(ptiPcSamplingGetDeviceStatus(handle, device, &status), PTI_SUCCESS);
-    EXPECT_EQ(status._total_sample_count, first_status._total_sample_count);
-    EXPECT_EQ(status._total_pc_count, first_status._total_pc_count);
-
-    size_t kernel_count = 0;
-    ASSERT_EQ(ptiPcSamplingGetObservedKernelHandles(handle, device, nullptr, &kernel_count),
-              PTI_SUCCESS);
-    EXPECT_EQ(kernel_count, first_kernel_count);
-  }
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
diff --git a/sdk/test/pc_sampling/pc_sampling_internal_test.cc b/sdk/test/pc_sampling/pc_sampling_internal_test.cc
deleted file mode 100644
index 7d6e0432..00000000
--- a/sdk/test/pc_sampling/pc_sampling_internal_test.cc
+++ /dev/null
@@ -1,372 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Internal-facing functional tests for PC Sampling.
-// Tests cover:
-//   - Validation that currently relies on internal handle state
-//   - Comparisons against internal metric-group helpers
-//   - White-box behavior not exposed through the public API alone
-//
-// =============================================================
-
-#include "pc_sampling/pti_pc_sampling_internal.h"
-#include "pc_sampling_test_fixture.h"
-
-namespace {
-
-std::vector<std::pair<std::string, std::string>> GetExpectedStallReasonsFromL0(
-    pti_pc_sampling_handle_t handle) {
-  EXPECT_NE(handle, nullptr);
-  EXPECT_FALSE(handle->supported_devices_.empty());
-
-  constexpr char kPcSamplingMetricGroupName[] = "EuStallSampling";
-  pti_device_handle_t device_handle = handle->supported_devices_.front();
-
-  EXPECT_NE(device_handle, nullptr);
-
-  const auto device = reinterpret_cast<ze_device_handle_t>(device_handle);
-  uint32_t group_count = 0;
-  if (zetMetricGroupGet(device, &group_count, nullptr) != ZE_RESULT_SUCCESS || group_count == 0) {
-    return {};
-  }
-
-  std::vector<zet_metric_group_handle_t> groups(group_count);
-  if (zetMetricGroupGet(device, &group_count, groups.data()) != ZE_RESULT_SUCCESS) {
-    return {};
-  }
-
-  for (const auto group : groups) {
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    if (zetMetricGroupGetProperties(group, &group_props) != ZE_RESULT_SUCCESS) {
-      continue;
-    }
-
-    if (std::string(group_props.name) != kPcSamplingMetricGroupName ||
-        (group_props.samplingType & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED) == 0) {
-      continue;
-    }
-
-    uint32_t metric_count = 0;
-    if (zetMetricGet(group, &metric_count, nullptr) != ZE_RESULT_SUCCESS || metric_count == 0) {
-      return {};
-    }
-
-    std::vector<zet_metric_handle_t> metrics(metric_count);
-    if (zetMetricGet(group, &metric_count, metrics.data()) != ZE_RESULT_SUCCESS) {
-      return {};
-    }
-
-    std::vector<std::pair<std::string, std::string>> metric_names;
-    metric_names.reserve(metric_count);
-    bool found_ip_metric = false;
-    for (const auto metric : metrics) {
-      zet_metric_properties_t metric_props{};
-      metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-      if (zetMetricGetProperties(metric, &metric_props) != ZE_RESULT_SUCCESS) {
-        return {};
-      }
-
-      if (metric_props.metricType == ZET_METRIC_TYPE_IP) {
-        if (found_ip_metric) {
-          return {};
-        }
-        found_ip_metric = true;
-        continue;
-      }
-
-      if (metric_props.metricType != ZET_METRIC_TYPE_EVENT) {
-        return {};
-      }
-
-      metric_names.emplace_back(metric_props.name, metric_props.description);
-    }
-
-    if (!found_ip_metric) {
-      return {};
-    }
-
-    return metric_names;
-  }
-
-  return {};
-}
-
-TEST_F(PcSamplingTest, RejectsDeviceFilteredConfigurationForUnsupportedDevices) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  pti_device_handle_t configured_device[1] = {reinterpret_cast<pti_device_handle_t>(0x1)};
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, configured_device, 1, 0),
-            PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL);
-
-  handle->configured_devices_.push_back(configured_device[0]);
-  EXPECT_TRUE(pti::pc_sampling::IsConfiguredDevice(handle, configured_device[0]));
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-//-----------------------------------------------------------------------------
-// Sampling Period Configuration Tests
-//-----------------------------------------------------------------------------
-
-TEST_F(PcSamplingTest, ConfigureUsesDefaultSamplingPeriodWhenZero) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  size_t device_count = devices_.size() > 0 ? 1 : 0;
-  pti_device_handle_t device_handle[1] = {
-      (devices_.size() > 0) ? reinterpret_cast<pti_device_handle_t>(devices_[0]) : nullptr};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, device_count, 0), PTI_SUCCESS);
-  EXPECT_EQ(handle->sampling_period_ns_, pti::pc_sampling::kDefaultSamplingPeriodNs);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, ConfigurePreservesExplicitSamplingPeriod) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  constexpr uint32_t kExplicitSamplingPeriodNs = 42'000;
-  size_t device_count = devices_.size() > 0 ? 1 : 0;
-  pti_device_handle_t device_handle[1] = {
-      (devices_.size() > 0) ? reinterpret_cast<pti_device_handle_t>(devices_[0]) : nullptr};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, device_count, kExplicitSamplingPeriodNs),
-            PTI_SUCCESS);
-  EXPECT_EQ(handle->sampling_period_ns_, kExplicitSamplingPeriodNs);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, StartWithoutConfigureAppliesDefaultDeviceAndSamplingPeriod) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  ASSERT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kEnabled);
-  ASSERT_TRUE(handle->configured_devices_.empty());
-  ASSERT_FALSE(handle->supported_devices_.empty());
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-
-  // Start must resolve the same configuration as ptiPcSamplingConfigure(handle, nullptr, 0, 0):
-  // the first supported device and the default sampling period.
-  EXPECT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kStarted);
-  EXPECT_EQ(handle->sampling_period_ns_, pti::pc_sampling::kDefaultSamplingPeriodNs);
-  ASSERT_EQ(handle->configured_devices_.size(), 1u);
-  EXPECT_EQ(handle->configured_devices_.front(), handle->supported_devices_.front());
-
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, StartKeepsExplicitConfigurationInsteadOfDefaults) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  constexpr uint32_t kExplicitSamplingPeriodNs = 42'000;
-  ASSERT_FALSE(handle->supported_devices_.empty());
-  pti_device_handle_t device_handle[1] = {handle->supported_devices_.front()};
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, device_handle, 1, kExplicitSamplingPeriodNs),
-            PTI_SUCCESS);
-  ASSERT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kConfigured);
-
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-
-  // An explicitly configured handle must not be overwritten by the default configuration.
-  EXPECT_EQ(handle->sampling_period_ns_, kExplicitSamplingPeriodNs);
-  ASSERT_EQ(handle->configured_devices_.size(), 1u);
-  EXPECT_EQ(handle->configured_devices_.front(), device_handle[0]);
-
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, ConfigureRejectsDeviceFilterWithZeroCount) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  pti_device_handle_t device_handle[1] = {reinterpret_cast<pti_device_handle_t>(0x1)};
-  EXPECT_EQ(ptiPcSamplingConfigure(handle, device_handle, 0, 0), PTI_ERROR_BAD_ARGUMENT);
-  EXPECT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kEnabled);
-
-  // A failed configuration must keep the handle configurable with the defaults.
-  ASSERT_FALSE(handle->supported_devices_.empty());
-  ASSERT_EQ(ptiPcSamplingConfigure(handle, nullptr, 0, 0), PTI_SUCCESS);
-  EXPECT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kConfigured);
-  EXPECT_EQ(handle->sampling_period_ns_, pti::pc_sampling::kDefaultSamplingPeriodNs);
-  ASSERT_EQ(handle->configured_devices_.size(), 1u);
-  EXPECT_EQ(handle->configured_devices_.front(), handle->supported_devices_.front());
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, StartCollectionRejectsStartedAndStoppedStates) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  // ENABLED is startable because configuration is optional; the CONFIGURED case is
-  // covered by StartKeepsExplicitConfigurationInsteadOfDefaults.
-  ASSERT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kEnabled);
-  ASSERT_EQ(ptiPcSamplingStartCollection(handle), PTI_SUCCESS);
-  ASSERT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kStarted);
-
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STARTED);
-  EXPECT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kStarted);
-
-  ASSERT_TRUE(IsStopSuccess(ptiPcSamplingStopCollection(handle)));
-  ASSERT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kStopped);
-
-  EXPECT_EQ(ptiPcSamplingStartCollection(handle), PTI_ERROR_PC_SAMPLING_ALREADY_STOPPED);
-  EXPECT_EQ(handle->state_, pti::pc_sampling::PcSamplingState::kStopped);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, GetStallReasons) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  const auto expected_reasons = GetExpectedStallReasonsFromL0(handle);
-  size_t reason_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, nullptr, &reason_count), PTI_SUCCESS);
-  ASSERT_EQ(reason_count, expected_reasons.size());
-  ASSERT_FALSE(expected_reasons.empty());
-
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& reason : reasons) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons.data(), &reason_count), PTI_SUCCESS);
-  ASSERT_EQ(reason_count, expected_reasons.size());
-
-  for (size_t index = 0; index < expected_reasons.size(); ++index) {
-    EXPECT_STREQ(reasons[index]._name, expected_reasons[index].first.c_str());
-    EXPECT_STREQ(reasons[index]._description, expected_reasons[index].second.c_str());
-  }
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, GetStallReasonsSupportsPartialCallerBuffer) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  const auto expected_reasons = GetExpectedStallReasonsFromL0(handle);
-  ASSERT_FALSE(expected_reasons.empty());
-  size_t reason_count = 1;
-  pti_pc_sampling_stall_reason_info_t reason = {};
-  reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, &reason, &reason_count), PTI_SUCCESS);
-  EXPECT_EQ(reason_count, 1u);
-  EXPECT_STREQ(reason._name, expected_reasons[0].first.c_str());
-  EXPECT_STREQ(reason._description, expected_reasons[0].second.c_str());
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, GetStallReasonsNotReturnTooMuchData) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  const auto expected_reasons = GetExpectedStallReasonsFromL0(handle);
-  const size_t expected_reason_count = expected_reasons.size();
-  ASSERT_GT(expected_reason_count, 0u);
-
-  size_t reason_count = expected_reason_count + 1;
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& reason : reasons) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons.data(), &reason_count), PTI_SUCCESS);
-  EXPECT_EQ(reason_count, expected_reason_count);
-  EXPECT_EQ(reasons[0]._name, nullptr);
-  EXPECT_EQ(reasons[0]._description, nullptr);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, GetStallReasonsMultipleCallsReturnSamePointers) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  const auto expected_reasons = GetExpectedStallReasonsFromL0(handle);
-  ASSERT_FALSE(expected_reasons.empty());
-
-  size_t reason_count = expected_reasons.size();
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& reason : reasons) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons.data(), &reason_count), PTI_SUCCESS);
-  EXPECT_EQ(reason_count, expected_reasons.size());
-
-  size_t reason_count2 = expected_reasons.size();
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons2(reason_count2);
-  for (auto& reason : reasons2) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons2.data(), &reason_count2), PTI_SUCCESS);
-  EXPECT_EQ(reason_count2, expected_reasons.size());
-
-  EXPECT_EQ(reasons[0]._name, reasons2[0]._name);
-  EXPECT_EQ(reasons[0]._description, reasons2[0]._description);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-TEST_F(PcSamplingTest, GetStallReasonsPointersRemainValidAfterDisable) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  const auto expected_reasons = GetExpectedStallReasonsFromL0(handle);
-  ASSERT_FALSE(expected_reasons.empty());
-
-  size_t reason_count = expected_reasons.size();
-  std::vector<pti_pc_sampling_stall_reason_info_t> reasons(reason_count);
-  for (auto& reason : reasons) {
-    reason._struct_size = sizeof(pti_pc_sampling_stall_reason_info_t);
-  }
-
-  ASSERT_EQ(ptiPcSamplingGetStallReasons(handle, reasons.data(), &reason_count), PTI_SUCCESS);
-  ASSERT_EQ(reason_count, expected_reasons.size());
-
-  const char* first_name = reasons[0]._name;
-  const char* first_description = reasons[0]._description;
-  ASSERT_NE(first_name, nullptr);
-  ASSERT_NE(first_description, nullptr);
-
-  ASSERT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-
-  EXPECT_STREQ(first_name, expected_reasons[0].first.c_str());
-  EXPECT_STREQ(first_description, expected_reasons[0].second.c_str());
-}
-
-TEST_F(PcSamplingTest, GetProfiledDevicesReturnsConfiguredSingleDevice) {
-  pti_pc_sampling_handle_t handle = nullptr;
-  ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(&handle, PTI_SUCCESS);
-
-  pti_device_handle_t configured_device = reinterpret_cast<pti_device_handle_t>(0x1);
-  handle->configured_devices_.push_back(configured_device);
-  handle->state_ = pti::pc_sampling::PcSamplingState::kStopped;
-
-  size_t device_count = 0;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, nullptr, &device_count), PTI_SUCCESS);
-  ASSERT_EQ(device_count, 1u);
-
-  pti_device_handle_t profiled_device = nullptr;
-  ASSERT_EQ(ptiPcSamplingGetProfiledDevices(handle, &profiled_device, &device_count), PTI_SUCCESS);
-  EXPECT_EQ(device_count, 1u);
-  EXPECT_EQ(profiled_device, configured_device);
-
-  EXPECT_EQ(ptiPcSamplingDisable(handle), PTI_SUCCESS);
-}
-
-}  // namespace
diff --git a/sdk/test/pc_sampling/pc_sampling_test_fixture.h b/sdk/test/pc_sampling/pc_sampling_test_fixture.h
deleted file mode 100644
index a0d59531..00000000
--- a/sdk/test/pc_sampling/pc_sampling_test_fixture.h
+++ /dev/null
@@ -1,93 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_PC_SAMPLING_TEST_FIXTURE_H_
-#define PTI_PC_SAMPLING_TEST_FIXTURE_H_
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <cstdlib>
-#include <vector>
-
-#include "pti/pti_pc_sampling.h"
-#include "pti/pti_view.h"
-
-inline constexpr size_t kBufferSize = 64 * 1024;
-
-inline void BufferRequested(unsigned char** buf, size_t* size) {
-  *buf = static_cast<unsigned char*>(std::malloc(kBufferSize));
-  *size = (*buf == nullptr) ? 0 : kBufferSize;
-}
-
-inline void BufferCompleted(unsigned char* buf, size_t /*size*/, size_t /*used*/) {
-  std::free(buf);
-}
-
-// Macro for conditionally skipping tests if PC sampling is unsupported on the current system.
-// Note that using a helper function does not skip the test, so we use a macro instead.
-#define ASSERT_PC_SAMPLING_ENABLE_EQ_OR_SKIP(HANDLE, EXPECTED_RESULT)                      \
-  do {                                                                                     \
-    ASSERT_NE((HANDLE), nullptr) << "Invalid handle pointer passed to AssertEnableResult"; \
-    pti_result status = ptiPcSamplingEnable((HANDLE));                                     \
-    if (status == PTI_ERROR_PC_SAMPLING_UNSUPPORTED) {                                     \
-      GTEST_SKIP() << "PC sampling unsupported by the installed driver - skipping";        \
-    }                                                                                      \
-    ASSERT_EQ(status, (EXPECTED_RESULT))                                                   \
-        << "Failed to enable PC sampling, status = " << ptiResultTypeToString(status)      \
-        << " (expected = " << ptiResultTypeToString(EXPECTED_RESULT) << ")";               \
-  } while (0)
-
-// For tests that do not require collected data.
-inline bool IsStopSuccess(pti_result result) {
-  return result == PTI_SUCCESS || result == PTI_WARN_PC_SAMPLING_NO_DATA_COLLECTED;
-}
-
-#define ASSERT_PC_SAMPLING_STOP_SUCCESS(HANDLE)                                     \
-  do {                                                                              \
-    pti_result stop_status = ptiPcSamplingStopCollection((HANDLE));                 \
-    if (stop_status != PTI_SUCCESS) {                                               \
-      ptiPcSamplingDisable((HANDLE));                                               \
-      GTEST_FAIL() << "Failed to stop PC sampling collection, status = "            \
-                   << ptiResultTypeToString(stop_status)                            \
-                   << " (expected = " << ptiResultTypeToString(PTI_SUCCESS) << ")"; \
-    }                                                                               \
-  } while (0)
-
-class PcSamplingTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    ASSERT_EQ(zeInit(ZE_INIT_FLAG_GPU_ONLY), ZE_RESULT_SUCCESS);
-    uint32_t driver_count = 0;
-    ASSERT_EQ(zeDriverGet(&driver_count, nullptr), ZE_RESULT_SUCCESS);
-    if (driver_count == 0) {
-      GTEST_SKIP() << "No L0 driver";
-    }
-
-    std::vector<ze_driver_handle_t> drivers(driver_count);
-    ASSERT_EQ(zeDriverGet(&driver_count, drivers.data()), ZE_RESULT_SUCCESS);
-    ASSERT_FALSE(drivers.empty());
-
-    uint32_t device_count = 0;
-    ASSERT_EQ(zeDeviceGet(drivers[0], &device_count, nullptr), ZE_RESULT_SUCCESS);
-    ASSERT_GT(device_count, 0) << "No L0 GPU device found under driver";
-
-    devices_.resize(device_count);
-    ASSERT_EQ(zeDeviceGet(drivers[0], &device_count, devices_.data()), ZE_RESULT_SUCCESS);
-
-    ASSERT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), PTI_SUCCESS);
-    ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), PTI_SUCCESS);
-  }
-
-  void TearDown() override {
-    ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL);
-    ptiFlushAllViews();
-  }
-
-  std::vector<ze_device_handle_t> devices_;
-};
-
-#endif  // PTI_PC_SAMPLING_TEST_FIXTURE_H_
diff --git a/sdk/test/pc_sampling/run_sample_test.py b/sdk/test/pc_sampling/run_sample_test.py
deleted file mode 100644
index 1b34a5d7..00000000
--- a/sdk/test/pc_sampling/run_sample_test.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-"""Smoke test for the pc_sampling_profiler sample.
-
-Runs the launcher on the bundled GEMM workload and checks that a stall report with
-samples was produced. Exits with 77 (CTest SKIP_RETURN_CODE) when the platform does
-not offer EU stall sampling, for example when the perf stream is restricted.
-"""
-
-import os
-import re
-import subprocess
-import sys
-import tempfile
-
-SKIP_EXIT_CODE = 77
-TIMEOUT_S = 300
-
-ENVIRONMENT_FAILURES = {
-    "PTI_ERROR_PC_SAMPLING_UNSUPPORTED": "no supported GPU/driver or sampling permission",
-    "PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL": "no supported sampling device",
-}
-
-
-def environment_skip_reason(output):
-    for line in output.splitlines():
-        match = re.search(
-            r"Failed to (?:enable|configure|start) PC sampling(?: collection)?: "
-            r"(PTI_ERROR_PC_SAMPLING_[A-Z_]+)(?: \(\d+\))?",
-            line,
-        )
-        if match and match.group(1) in ENVIRONMENT_FAILURES:
-            return f"{match.group(1)}: {ENVIRONMENT_FAILURES[match.group(1)]}"
-    return None
-
-
-def run_check(launcher, workload, module=None, expected_output=None, kernel_name=None):
-    with tempfile.TemporaryDirectory() as work_dir:
-        output_path = os.path.join(work_dir, "stalls.txt")
-        command = [launcher, "--output", output_path, "--", workload]
-        if module is None:
-            command += ["--size", "2048", "--repeat", "3"]
-        else:
-            command.append(module)
-        completed = subprocess.run(
-            command,
-            capture_output=True,
-            text=True,
-            timeout=TIMEOUT_S,
-            check=False,
-        )
-        sys.stdout.write(completed.stdout)
-        sys.stderr.write(completed.stderr)
-        if module is not None and "no Level Zero GPU found" in completed.stderr:
-            return SKIP_EXIT_CODE
-        if expected_output is None:
-            expected_output = (
-                "Level Zero GEMM: 20 launches, valid output"
-                if module is not None
-                else "GEMM results are CORRECT"
-            )
-        if completed.returncode != 0 or expected_output not in completed.stdout:
-            if completed.returncode == SKIP_EXIT_CODE:
-                return SKIP_EXIT_CODE
-            print(f"FAILED: workload exited with {completed.returncode}")
-            return 1
-        if not os.path.exists(output_path):
-            print("FAILED: workload produced no profiler report")
-            return 1
-        with open(output_path, "r", encoding="utf-8", errors="replace") as report_file:
-            report = report_file.read()
-        skip_reason = environment_skip_reason(
-            completed.stdout + completed.stderr + report
-        )
-        if skip_reason:
-            print(f"PC sampling unavailable on this system ({skip_reason}), skipping")
-            return SKIP_EXIT_CODE
-    if kernel_name is None and module is not None:
-        kernel_name = "]: GEMM"
-    return check_report(report, kernel_name)
-
-
-def run_exit_check(launcher, workload, exit_mode):
-    with tempfile.TemporaryDirectory() as work_dir:
-        output_path = os.path.join(work_dir, "stalls.txt")
-        completed = subprocess.run(
-            [launcher, "--output", output_path, "--", workload, exit_mode],
-            capture_output=True,
-            text=True,
-            timeout=TIMEOUT_S,
-            check=False,
-        )
-        sys.stdout.write(completed.stdout)
-        sys.stderr.write(completed.stderr)
-        report = ""
-        if os.path.exists(output_path):
-            with open(
-                output_path, "r", encoding="utf-8", errors="replace"
-            ) as report_file:
-                report = report_file.read()
-        skip_reason = environment_skip_reason(
-            completed.stdout + completed.stderr + report
-        )
-        if skip_reason:
-            print(f"PC sampling unavailable on this system ({skip_reason}), skipping")
-            return SKIP_EXIT_CODE
-        if completed.returncode != 0:
-            print(f"FAILED: workload exited with {completed.returncode}")
-            return 1
-        if (
-            "PC sampling report available to application exit handlers"
-            not in completed.stderr
-        ):
-            print(
-                "FAILED: PC sampling report was not ready before application exit handlers"
-            )
-            return 1
-        if "PC Sampling collection stopped successfully" not in report:
-            print("FAILED: exit path produced no PC sampling stop report")
-            return 1
-        print("PASSED: exit path produced a PC sampling report")
-        return 0
-
-
-def main():
-    if len(sys.argv) == 5 and sys.argv[1] == "--exit":
-        return run_exit_check(sys.argv[2], sys.argv[3], sys.argv[4])
-    if len(sys.argv) == 4 and sys.argv[1] == "--sycl":
-        return run_check(sys.argv[2], sys.argv[3], kernel_name="GEMMKernel")
-    if len(sys.argv) == 5 and sys.argv[1] == "--pytorch":
-        return run_check(
-            sys.argv[2],
-            sys.argv[3],
-            sys.argv[4],
-            expected_output="PyTorch XPU training:",
-            kernel_name="",
-        )
-    if len(sys.argv) == 4:
-        return run_check(*sys.argv[1:])
-    print(
-        f"Usage: {sys.argv[0]} <pc_sampling_profiler> <workload> <module.spv>\n"
-        f"       {sys.argv[0]} --sycl <pc_sampling_profiler> <workload>\n"
-        f"       {sys.argv[0]} --pytorch <pc_sampling_profiler> <python> <script>"
-    )
-    return 1
-
-
-def check_report(report, kernel_name):
-    expected_entries = (
-        "=== Initializing Profiling Environment ===",
-        "PC Sampling collection started successfully",
-        "PC Sampling collection stopped successfully",
-        "PC Sampling disabled and resources freed successfully",
-        "=== PC Sampling Stall Data ===",
-        "Stall reasons (",
-        "Kernels with samples:",
-        "Per-instruction stall samples:",
-    )
-    if kernel_name:
-        expected_entries += (kernel_name,)
-    for expected in expected_entries:
-        if expected not in report:
-            print(f"FAILED: '{expected}' missing from the report")
-            return 1
-
-    total_samples = 0
-    for line in report.splitlines():
-        if "Total samples collected" in line:
-            total_samples += int(line.split(":")[1].strip())
-    if total_samples == 0:
-        print("FAILED: report contains no samples")
-        return 1
-
-    if not kernel_name and not re.search(
-        r"^\s*Kernel \[\d+/\d+\]:\s+.+$", report, re.MULTILINE
-    ):
-        print("FAILED: report contains no sampled kernels")
-        return 1
-
-    print(f"PASSED: {total_samples} samples collected")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/sdk/test/perf_dpc_gemm_threaded.cc b/sdk/test/perf_dpc_gemm_threaded.cc
deleted file mode 100644
index 49bb8142..00000000
--- a/sdk/test/perf_dpc_gemm_threaded.cc
+++ /dev/null
@@ -1,632 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-//
-// Based on dpc_gemm sample. Added multithreading
-//
-
-#include <stdarg.h>
-#include <string.h>
-
-#include <atomic>
-#include <cmath>
-#include <cstdlib>
-#include <iomanip>
-#include <memory>
-#include <sycl/sycl.hpp>
-#include <thread>
-
-#if !defined(NO_PTI)
-#include "pti/pti_metrics_scope.h"
-#include "pti/pti_view.h"
-#include "samples_utils.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-#endif
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static bool verbose = false;
-
-static float Check(const std::vector<float>& a, float value) {
-  assert(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c, unsigned size,
-                         float expected_result) {
-  assert(size > 0);
-  assert(a.size() == size * size);
-  assert(b.size() == size * size);
-  assert(c.size() == size * size);
-
-  double time = 0.0;
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size), [=](sycl::id<2> id) {
-        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-        GEMM(a_acc_ptr.get(), b_acc_ptr.get(), c_acc_ptr.get(), size, id);
-      });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception& e) {
-    std::cerr << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-
-  if (verbose) {
-    std::cout << "\tMatrix multiplication time: " << time << " sec" << std::endl;
-  }
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue, const std::vector<float>& a, const std::vector<float>& b,
-                    std::vector<float>& c, unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    if (eps > MAX_EPS) {
-      std::cerr << "[ERROR] Results are " << "INCORRECT with accuracy: " << eps
-                << "while expected less than " << MAX_EPS << std::endl;
-    }
-    if (verbose) {
-      std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN")
-                << "CORRECT with accuracy: " << eps << std::endl;
-    }
-  }
-}
-
-#if !defined(NO_PTI)
-
-enum class CollectionType : uint8_t {
-  kNone = 0x00,
-  kGpu = 0x01,
-  kOverheadL0 = 0x02,
-  kSyclMin = 0x04,
-  kScope = 0x08,
-};
-
-inline CollectionType operator|(CollectionType left, CollectionType right) {
-  return static_cast<CollectionType>(static_cast<std::underlying_type_t<CollectionType>>(left) |
-                                     static_cast<std::underlying_type_t<CollectionType>>(right));
-}
-
-inline constexpr bool operator&(CollectionType left, CollectionType right) {
-  return static_cast<std::underlying_type_t<CollectionType>>(left) &
-         static_cast<std::underlying_type_t<CollectionType>>(right);
-}
-
-std::ostream& operator<<(std::ostream& os, CollectionType type) {
-  std::string collect_string;
-  if (type & CollectionType::kGpu) {
-    collect_string += "Gpu_Ops";
-  }
-  if (type & CollectionType::kSyclMin) {
-    collect_string += " Sycl_Min";
-  }
-  if (type & CollectionType::kOverheadL0) {
-    collect_string += " Overhead_L0";
-  }
-  if (type & CollectionType::kScope) {
-    collect_string += " Metrics_Scope";
-  }
-  return os << collect_string;
-}
-
-CollectionType collection_type = CollectionType::kGpu;
-
-constexpr auto kRequestedRecordCount = 1'000ULL;
-constexpr auto kRequestedBufferSize = kRequestedRecordCount * sizeof(pti_view_record_kernel);
-
-std::atomic<uint64_t> g_record_count{0};
-
-[[maybe_unused]] std::atomic<uint64_t> overhead_time_ns{0};
-
-void EnableIndividualRuntimeApis() {
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueUSMFill_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueUSMFill2D_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueUSMMemcpy_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueUSMMemcpy2D_id));
-
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueMemBufferFill_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueMemBufferRead_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueMemBufferWrite_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueMemBufferCopy_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urUSMHostAlloc_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urUSMSharedAlloc_id));
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urUSMDeviceAlloc_id));
-
-  PTI_CHECK_SUCCESS(ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                                            pti_api_id_runtime_sycl::urEnqueueKernelLaunch_id));
-  PTI_CHECK_SUCCESS(
-      ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                              pti_api_id_runtime_sycl::urEnqueueKernelLaunchCustomExp_id));
-  PTI_CHECK_SUCCESS(
-      ptiViewEnableRuntimeApi(1, pti_api_group_id::PTI_API_GROUP_SYCL,
-                              pti_api_id_runtime_sycl::urEnqueueCooperativeKernelLaunchExp_id));
-}
-
-void StartTracing() {
-  if (collection_type & CollectionType::kGpu) {
-    PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL));
-    PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-    PTI_THROW(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  }
-  if (collection_type & CollectionType::kSyclMin) {
-    PTI_THROW(ptiViewEnable(PTI_VIEW_RUNTIME_API));
-    // This is what we are doing in PyTorch/Kineto  - so lets' measure overhead on this typical flow
-    EnableIndividualRuntimeApis();
-  }
-  if (collection_type & CollectionType::kOverheadL0) {
-    PTI_THROW(ptiViewEnable(PTI_VIEW_COLLECTION_OVERHEAD));
-  }
-}
-
-void StopTracing() {
-  if (collection_type & CollectionType::kGpu) {
-    PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL));
-    PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY));
-    PTI_THROW(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL));
-  }
-  if (collection_type & CollectionType::kSyclMin) {
-    PTI_THROW(ptiViewDisable(PTI_VIEW_RUNTIME_API));
-  }
-  if (collection_type & CollectionType::kOverheadL0) {
-    PTI_THROW(ptiViewDisable(PTI_VIEW_COLLECTION_OVERHEAD));
-  }
-}
-
-constexpr int kSkipReturnCode = 77;
-
-// Statuses meaning HW metrics are not available on this host; any other failure is a test failure.
-bool IsScopeUnavailable(pti_result status) {
-  switch (status) {
-    case PTI_ERROR_DRIVER:
-    case PTI_ERROR_METRICS_RUNTIME_ENABLE_UNSUPPORTED:
-    case PTI_ERROR_METRICS_SCOPE_METRIC_NOT_FOUND:
-    case PTI_ERROR_METRICS_SCOPE_NOT_A_SINGLE_GROUP:
-    case PTI_ERROR_METRICS_SCOPE_DEVICE_TYPE_NOT_UNIFORM:
-      return true;
-    default:
-      return false;
-  }
-}
-
-// Returns nullptr when HW metrics are unavailable, so the caller can skip.
-pti_scope_collection_handle_t StartScope(size_t expected_kernels) {
-  pti_scope_collection_handle_t scope_handle = nullptr;
-  pti_result status = ptiMetricsScopeEnable(&scope_handle);
-  if (IsScopeUnavailable(status)) {
-    return nullptr;
-  }
-  PTI_THROW(status);
-  const char* metric_names[] = {"XVE_ACTIVE"};
-  status = ptiMetricsScopeConfigure(scope_handle, PTI_METRICS_SCOPE_AUTO_KERNEL, nullptr, 0,
-                                    metric_names, 1);
-  if (status != PTI_SUCCESS) {
-    PTI_THROW(ptiMetricsScopeDisable(scope_handle));
-    if (IsScopeUnavailable(status)) {
-      return nullptr;
-    }
-    PTI_THROW(status);
-  }
-  size_t buffer_size = 0;
-  PTI_THROW(ptiMetricsScopeQueryCollectionBufferSize(scope_handle, expected_kernels, &buffer_size));
-  PTI_THROW(ptiMetricsScopeSetCollectionBufferSize(scope_handle, buffer_size));
-  PTI_THROW(ptiMetricsScopeStartCollection(scope_handle));
-  return scope_handle;
-}
-
-size_t CountScopeRecordsAndDisable(pti_scope_collection_handle_t scope_handle) {
-  size_t buffer_count = 0;
-  PTI_THROW(ptiMetricsScopeGetCollectionBuffersCount(scope_handle, &buffer_count));
-  size_t record_count = 0;
-  for (size_t i = 0; i < buffer_count; ++i) {
-    void* buffer = nullptr;
-    size_t buffer_size = 0;
-    PTI_THROW(ptiMetricsScopeGetCollectionBuffer(scope_handle, i, &buffer, &buffer_size));
-    pti_metrics_scope_collection_buffer_properties_t props{};
-    props._struct_size = sizeof(props);
-    PTI_THROW(ptiMetricsScopeGetCollectionBufferProperties(scope_handle, buffer, &props));
-    record_count += props._num_scopes;
-  }
-  PTI_THROW(ptiMetricsScopeDisable(scope_handle));
-  return record_count;
-}
-
-void ProvideBuffer(unsigned char** buf, std::size_t* buf_size) {
-  *buf = samples_utils::AlignedAlloc<unsigned char>(kRequestedBufferSize);
-  if (!*buf) {
-    std::cerr << "Unable to allocate buffer for PTI tracing " << '\n';
-    std::abort();
-  }
-  *buf_size = kRequestedBufferSize;
-}
-void ParseBuffer(unsigned char* buf, std::size_t buf_size, std::size_t valid_buf_size) {
-  if (!buf || !valid_buf_size || !buf_size) {
-    std::cout << "Received empty buffer" << '\n';
-    samples_utils::AlignedDealloc(buf);
-    return;
-  }
-  pti_view_record_base* ptr = nullptr;
-
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, valid_buf_size, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-#if defined(RECORD_PARSE_AND_PRINT)
-      std::cout << "Reached End of buffer" << '\n';
-#endif
-      break;
-    }
-    g_record_count++;
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        pti_view_record_overhead* record = reinterpret_cast<pti_view_record_overhead*>(ptr);
-        overhead_time_ns += record->_overhead_duration_ns;
-        // Keep commented lines around for the purpose of reviewing latency of L0 calls
-        // std::cout << " ======== Overhead Time: " << std::setw(7) << std::right
-        //           << record->_overhead_duration_ns << " ns"
-        //           << "\t API Id: " << record->_api_id << '\n';
-        break;
-      }
-#if defined(RECORD_PARSE_AND_PRINT)
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Sycl Runtime Record" << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_api*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        samples_utils::DumpRecord(reinterpret_cast<pti_view_record_external_correlation*>(ptr));
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-
-        pti_view_record_memory_copy_type* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_copy_type*>(ptr);
-        samples_utils::DumpRecord(p_memory_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Memcopy Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Memory Record" << '\n';
-
-        pti_view_record_memory_fill_type* p_memory_rec =
-            reinterpret_cast<pti_view_record_memory_fill_type*>(ptr);
-        samples_utils::DumpRecord(p_memory_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_memory_rec->_append_timestamp, p_memory_rec->_submit_timestamp,
-            p_memory_rec->_start_timestamp, p_memory_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Memfill Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        std::cout << "Found Kernel Record" << '\n';
-
-        pti_view_record_kernel_type* p_kernel_rec =
-            reinterpret_cast<pti_view_record_kernel_type*>(ptr);
-        samples_utils::DumpRecord(p_kernel_rec);
-        std::cout << "---------------------------------------------------"
-                     "-----------------------------"
-                  << '\n';
-        auto issues = samples_utils::ValidateTimestamps(
-            p_kernel_rec->_sycl_task_begin_timestamp, p_kernel_rec->_sycl_enqk_begin_timestamp,
-            p_kernel_rec->_append_timestamp, p_kernel_rec->_submit_timestamp,
-            p_kernel_rec->_start_timestamp, p_kernel_rec->_end_timestamp);
-        if (issues) {
-          std::cerr << "Kernel Timestamp error on line: " << __LINE__ << '\n';
-          std::exit(EXIT_FAILURE);
-        }
-        break;
-      }
-#endif  // RECORD_PARSE_AND_PRINT
-      default: {
-        break;
-      }
-    }
-  }
-  samples_utils::AlignedDealloc(buf);
-}
-#endif
-
-const unsigned max_thread_count = 64;
-const unsigned max_size = 8192;
-const unsigned min_size = 32;
-
-const unsigned default_size = 1024;
-const unsigned default_thread_count = 2;
-const unsigned default_repetition_per_thread = 4;
-
-void Usage(const char* name) {
-  std::cout << " Calculating floating point matrix multiply on gpu, submitting the work from many "
-               "CPU threads\n"
-            << "  Usage " << name << "  [ options ]" << std::endl;
-  std::cout << "--threads [-t]  integer        "
-            << "Threads number, default: " << default_thread_count << std::endl;
-  std::cout << "--size [-s]     integer        " << "Matrix size, default: " << default_size
-            << std::endl;
-  std::cout << "--repeat [-r]   integer        "
-            << "Repetition number per thread, default: " << default_repetition_per_thread
-            << std::endl;
-  std::cout << "--verbose [-v]                 "
-            << "Enable verbose mode to report the app progress, default: off" << std::endl;
-#if !defined(NO_PTI)
-  std::cout << "--collect [-c]  string         "
-            << "Enable PTI profiling. Could be passed several times with <gpu|overhead|sycl>,"
-               " default: gpu"
-            << std::endl;
-#endif
-}
-
-int main(int argc, char* argv[]) {
-  int exit_code = EXIT_SUCCESS;
-  unsigned thread_count = default_thread_count;
-  unsigned repeat_count = default_repetition_per_thread;
-  unsigned size = default_size;
-
-  try {
-    for (int i = 1; i < argc; i++) {
-      if (strcmp(argv[i], "-s") == 0 || strcmp(argv[i], "--size") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        size = (temp < min_size) ? min_size : (temp > max_size) ? max_size : temp;
-      } else if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--threads") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        thread_count = (temp < 1) ? 1 : (temp > max_thread_count) ? max_thread_count : temp;
-      } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--repeat") == 0) {
-        i++;
-        auto temp = std::stoul(argv[i]);
-        repeat_count = (temp < 1) ? 1 : temp;
-      } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
-        // verbosity off makes minimal the sample self output -
-        // so profiling output won't be intermixed with the sample output
-        // and could be analyzed by tests
-        verbose = true;
-#if !defined(NO_PTI)
-      } else if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--collect") == 0) {
-        i++;
-        auto temp = std::string(argv[i]);
-        if (temp.find("gpu") != std::string::npos) {
-          collection_type = collection_type | CollectionType::kGpu;
-        } else if (temp.find("over") != std::string::npos) {
-          collection_type = collection_type | CollectionType::kOverheadL0;
-        } else if (temp.find("sycl") != std::string::npos) {
-          collection_type = collection_type | CollectionType::kSyclMin;
-        } else if (temp.find("scope") != std::string::npos) {
-          collection_type = collection_type | CollectionType::kScope;
-        } else {
-          std::cerr << "Unknown collection type (ignoring): " << temp << '\n';
-          Usage(argv[0]);
-          return EXIT_FAILURE;
-        }
-#endif
-      } else {
-        Usage(argv[0]);
-        return EXIT_SUCCESS;
-      }
-    }
-  } catch (...) {
-    Usage(argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  try {
-#if !defined(NO_PTI)
-    PTI_THROW(ptiViewSetCallbacks(ProvideBuffer, ParseBuffer));
-
-    StartTracing();
-
-    // The warm-up iteration of each thread is collected too.
-    const size_t expected_kernels = static_cast<size_t>(thread_count) * (repeat_count + 1);
-    pti_scope_collection_handle_t scope_handle = nullptr;
-    if (collection_type & CollectionType::kScope) {
-      scope_handle = StartScope(expected_kernels);
-      if (scope_handle == nullptr) {
-        std::cerr << "HW metrics scope collection unavailable, skipping" << '\n';
-        return kSkipReturnCode;
-      }
-    }
-#endif
-    sycl::device dev;
-    dev = sycl::device(sycl::gpu_selector_v);
-    sycl::property_list prop_list{sycl::property::queue::in_order()};
-    sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-
-    float expected_result = A_VALUE * B_VALUE * size;
-
-    auto threadFunction = [&queue](unsigned _size, unsigned _repeat_count, float _expected_result) {
-      std::vector<float> a(_size * _size, A_VALUE);
-      std::vector<float> b(_size * _size, B_VALUE);
-      std::vector<float> c(_size * _size, 0.0f);
-
-      auto start = std::chrono::steady_clock::now();
-      Compute(queue, a, b, c, _size, _repeat_count, _expected_result);
-      auto end = std::chrono::steady_clock::now();
-      std::chrono::duration<float> time = end - start;
-
-      if (verbose) {
-        std::cout << "\t-- Total execution time: " << time.count() << " sec" << std::endl;
-      }
-    };
-
-    std::cout << "DPC++ Matrix Multiplication (CPU threads: " << thread_count
-              << ", matrix size: " << size << " x " << size << ", repeats: " << repeat_count
-              << " times, preceded by one warm-up iteration)" << std::endl;
-    std::cout << "Target device: "
-              << queue.get_info<sycl::info::queue::device>().get_info<sycl::info::device::name>()
-              << std::endl
-              << std::flush;
-
-    auto start = std::chrono::steady_clock::now();
-
-    if (thread_count > 1) {
-      std::vector<std::thread> the_threads;
-
-      // Warm-up phase: 1 iteration per thread - to warm up caches and JIT
-      the_threads.reserve(thread_count);
-      for (unsigned i = 0; i < thread_count; i++) {
-        the_threads.emplace_back(threadFunction, size, 1, expected_result);
-      }
-
-      for (auto& th : the_threads) {
-        if (th.joinable()) {
-          th.join();
-        }
-      }
-
-      // Clear threads from warm-up phase
-      the_threads.clear();
-
-      the_threads.reserve(thread_count);
-      // Measurement phase: actual repeat_count iterations per thread
-      start = std::chrono::steady_clock::now();
-      for (unsigned i = 0; i < thread_count; i++) {
-        the_threads.emplace_back(threadFunction, size, repeat_count, expected_result);
-      }
-
-      for (auto& th : the_threads) {
-        if (th.joinable()) {
-          th.join();
-        }
-      }
-
-    } else {
-      // Warm-up for single-threaded case
-      threadFunction(size, 1, expected_result);
-
-      // Measurement phase
-      start = std::chrono::steady_clock::now();
-      threadFunction(size, repeat_count, expected_result);
-    }
-
-#if defined(NO_PTI)
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    auto gemm_count = thread_count * repeat_count;
-#endif /* NO_PTI */
-
-#if !defined(NO_PTI)
-    StopTracing();
-    PTI_THROW(ptiFlushAllViews());
-    if (collection_type & CollectionType::kScope) {
-      PTI_THROW(ptiMetricsScopeStopCollection(scope_handle));
-    }
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-    auto gemm_count = thread_count * repeat_count;
-    std::cout << "-- PTI tracing was enabled (" << collection_type
-              << "), Record count: " << g_record_count << '\n';
-    if (collection_type & CollectionType::kOverheadL0) {
-      std::cout << "-- Summed from Overhead View records Overhead time: "
-                << static_cast<float>(overhead_time_ns) / static_cast<float>(NSEC_IN_SEC) << " sec"
-                << '\n';
-    }
-    if (collection_type & CollectionType::kScope) {
-      std::cout << "-- Scope records: " << CountScopeRecordsAndDisable(scope_handle) << '\n';
-      std::cout << "-- Scope kernels: " << expected_kernels << '\n';
-    }
-#endif /* ! NO_PTI */
-
-    std::cout << "-- Total execution time: " << time.count() << " sec" << std::endl;
-    std::cout << "-- Throughput: "
-              << static_cast<int>(static_cast<float>(gemm_count) / time.count())
-              << " gemms of size " << size << "x" << size << " in sec" << std::endl;
-
-  } catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception& e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  return exit_code;
-}
diff --git a/sdk/test/perf_pc_sampling.cc b/sdk/test/perf_pc_sampling.cc
deleted file mode 100644
index a9db8571..00000000
--- a/sdk/test/perf_pc_sampling.cc
+++ /dev/null
@@ -1,295 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <chrono>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#if defined(__linux__)
-#include <sys/resource.h>
-#endif
-
-#if defined(PC_SAMPLING)
-#include "pc_sampling_client.h"
-#endif
-
-namespace {
-
-constexpr float kAValue = 0.128f;
-constexpr float kBValue = 0.256f;
-constexpr float kMaxEps = 1.0e-4f;
-constexpr unsigned kDefaultSize = 4096;
-constexpr unsigned kDefaultRepeatCount = 4;
-
-#if defined(PC_SAMPLING)
-constexpr uint32_t kPcSamplingPeriodNs = 50'000;
-constexpr int kSkipReturnCode = 77;
-#endif
-
-class PcSamplingPerfGemmKernel;
-
-using Clock = std::chrono::steady_clock;
-
-void PrintDuration(const char* name, Clock::time_point start, Clock::time_point end) {
-  const std::chrono::duration<float> elapsed = end - start;
-  std::cout << "-- " << name << ": " << elapsed.count() << " sec" << '\n';
-}
-
-#if defined(__linux__)
-struct CpuTimes {
-  double user;
-  double system;
-};
-
-double ToSeconds(const timeval& time) {
-  return static_cast<double>(time.tv_sec) + static_cast<double>(time.tv_usec) / 1'000'000;
-}
-
-CpuTimes GetCpuTimes() {
-  rusage usage{};
-  if (getrusage(RUSAGE_SELF, &usage) != 0) {
-    throw std::runtime_error("Failed to read process CPU time");
-  }
-  return {ToSeconds(usage.ru_utime), ToSeconds(usage.ru_stime)};
-}
-
-void PrintCpuTimes(CpuTimes start, CpuTimes end, Clock::time_point wallStart,
-                   Clock::time_point wallEnd) {
-  const double user = end.user - start.user;
-  const double system = end.system - start.system;
-  const double total = user + system;
-  const std::chrono::duration<double> wallTime = wallEnd - wallStart;
-  const double utilization = wallTime.count() > 0.0 ? total / wallTime.count() * 100.0 : 0.0;
-
-  std::cout << "-- Workload user CPU time: " << user << " sec" << '\n';
-  std::cout << "-- Workload system CPU time: " << system << " sec" << '\n';
-  std::cout << "-- Workload total CPU time: " << total << " sec" << '\n';
-  std::cout << "-- Workload CPU utilization: " << utilization << " %" << '\n';
-}
-#endif
-
-void Gemm(const float* a, const float* b, float* c, unsigned size, sycl::id<2> id) {
-  const int row = id.get(0);
-  const int column = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[row * size + k] * b[k * size + column];
-  }
-  c[row * size + column] = sum;
-}
-
-bool Check(const std::vector<float>& values, float expectedValue) {
-  float error = 0.0f;
-  for (float value : values) {
-    error += std::fabs((value - expectedValue) / expectedValue);
-  }
-  return error / values.size() < kMaxEps;
-}
-
-bool RunWorkload(sycl::queue& queue, unsigned size, unsigned repeatCount) {
-  std::vector<float> a(size * size, kAValue);
-  std::vector<float> b(size * size, kBValue);
-  std::vector<float> c(size * size, 0.0f);
-
-  try {
-    {
-      sycl::buffer<float, 1> aBuffer(a.data(), a.size());
-      sycl::buffer<float, 1> bBuffer(b.data(), b.size());
-      sycl::buffer<float, 1> cBuffer(c.data(), c.size());
-
-      for (unsigned repeat = 0; repeat < repeatCount; ++repeat) {
-        queue.submit([&](sycl::handler& commandGroupHandler) {
-          auto aAccessor = aBuffer.get_access<sycl::access::mode::read>(commandGroupHandler);
-          auto bAccessor = bBuffer.get_access<sycl::access::mode::read>(commandGroupHandler);
-          auto cAccessor = cBuffer.get_access<sycl::access::mode::write>(commandGroupHandler);
-
-          commandGroupHandler.parallel_for<PcSamplingPerfGemmKernel>(
-              sycl::range<2>(size, size), [=](sycl::id<2> id) {
-                Gemm(aAccessor.get_multi_ptr<sycl::access::decorated::no>().get(),
-                     bAccessor.get_multi_ptr<sycl::access::decorated::no>().get(),
-                     cAccessor.get_multi_ptr<sycl::access::decorated::no>().get(), size, id);
-              });
-        });
-      }
-      queue.wait_and_throw();
-    }
-  } catch (const sycl::exception& exception) {
-    std::cerr << "SYCL workload failed: " << exception.what() << '\n';
-    return false;
-  }
-
-  return Check(c, kAValue * kBValue * size);
-}
-
-bool ParseArguments(int argc, char* argv[], unsigned& size, unsigned& repeatCount) {
-  for (int index = 1; index < argc; ++index) {
-    if ((std::string(argv[index]) == "-s" || std::string(argv[index]) == "--size") &&
-        ++index < argc) {
-      size = std::stoul(argv[index]);
-    } else if ((std::string(argv[index]) == "-r" || std::string(argv[index]) == "--repeat") &&
-               ++index < argc) {
-      repeatCount = std::stoul(argv[index]);
-    } else {
-      std::cerr << "Usage: " << argv[0] << " [-s size] [-r repeat]" << '\n';
-      return false;
-    }
-  }
-  return size > 0 && repeatCount > 0;
-}
-
-}  // namespace
-
-int main(int argc, char* argv[]) {
-  unsigned size = kDefaultSize;
-  unsigned repeatCount = kDefaultRepeatCount;
-  if (!ParseArguments(argc, argv, size, repeatCount)) {
-    return EXIT_FAILURE;
-  }
-
-  try {
-    std::cout << std::fixed << std::setprecision(6);
-    const auto benchmarkStart = Clock::now();
-    sycl::queue queue(sycl::gpu_selector_v, sycl::property::queue::in_order{});
-    const auto queueReady = Clock::now();
-    PrintDuration("Queue creation time", benchmarkStart, queueReady);
-
-#if defined(PC_SAMPLING)
-    const auto profilingSetupStart = Clock::now();
-    if (!InitializeProfilingEnvironment()) {
-      std::cerr << "Failed to initialize PC Sampling" << '\n';
-      return EXIT_FAILURE;
-    }
-    const pti_result enableStatus = EnablePcSampling();
-    if (enableStatus == PTI_ERROR_PC_SAMPLING_UNSUPPORTED) {
-      std::cout << "PC Sampling is unsupported on this system" << '\n';
-      CleanupProfilingEnvironment();
-      return kSkipReturnCode;
-    }
-    if (enableStatus != PTI_SUCCESS) {
-      std::cerr << "Failed to enable PC Sampling" << '\n';
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    const auto device = static_cast<pti_device_handle_t>(
-        sycl::get_native<sycl::backend::ext_oneapi_level_zero>(queue.get_device()));
-    const pti_result configureStatus = ConfigurePcSampling(&device, 1, kPcSamplingPeriodNs);
-    if (configureStatus == PTI_ERROR_PC_SAMPLING_CONFIGURATION_FAIL) {
-      std::cout << "Selected GPU does not support PC Sampling" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return kSkipReturnCode;
-    }
-    if (configureStatus != PTI_SUCCESS) {
-      std::cerr << "Failed to configure PC Sampling" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    const auto profilingConfigured = Clock::now();
-    PrintDuration("PC Sampling enable and configure time", profilingSetupStart,
-                  profilingConfigured);
-#endif
-
-    const auto warmUpStart = Clock::now();
-    if (!RunWorkload(queue, size, 1)) {
-      return EXIT_FAILURE;
-    }
-    const auto warmUpEnd = Clock::now();
-    PrintDuration("Warm-up time", warmUpStart, warmUpEnd);
-
-#if defined(PC_SAMPLING)
-    const auto collectionStartBegin = Clock::now();
-    if (!StartPcSamplingCollection()) {
-      std::cerr << "Failed to start PC Sampling collection" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    const auto collectionStartEnd = Clock::now();
-    PrintDuration("PC Sampling start collection time", collectionStartBegin, collectionStartEnd);
-#endif
-
-    const auto workloadStart = Clock::now();
-#if defined(__linux__)
-    const CpuTimes workloadCpuStart = GetCpuTimes();
-#endif
-    if (!RunWorkload(queue, size, repeatCount)) {
-#if defined(PC_SAMPLING)
-      StopPcSamplingCollection();
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-#endif
-      return EXIT_FAILURE;
-    }
-    const auto workloadEnd = Clock::now();
-#if defined(__linux__)
-    const CpuTimes workloadCpuEnd = GetCpuTimes();
-#endif
-    PrintDuration("Workload execution time", workloadStart, workloadEnd);
-#if defined(__linux__)
-    PrintCpuTimes(workloadCpuStart, workloadCpuEnd, workloadStart, workloadEnd);
-#endif
-
-#if defined(PC_SAMPLING)
-    const auto collectionStopBegin = Clock::now();
-    if (!StopPcSamplingCollection()) {
-      std::cerr << "Failed to stop PC Sampling collection" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    const auto collectionStopEnd = Clock::now();
-    PrintDuration("PC Sampling stop collection time", collectionStopBegin, collectionStopEnd);
-
-    const auto postProcessingStart = Clock::now();
-    std::ostream nullOutput(nullptr);
-    const bool postProcessingSucceeded = PrintPcSamplingData(nullOutput);
-    if (!postProcessingSucceeded) {
-      std::cerr << "Failed to post-process PC Sampling data" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    if (!HasObservedPcSamplingKernels()) {
-      std::cerr << "No kernels were profiled during PC Sampling collection" << '\n';
-      DisablePcSampling();
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    const auto postProcessingEnd = Clock::now();
-    PrintDuration("PC Sampling post-processing time", postProcessingStart, postProcessingEnd);
-
-    const auto teardownStart = Clock::now();
-    if (!DisablePcSampling()) {
-      std::cerr << "Failed to disable PC Sampling" << '\n';
-      CleanupProfilingEnvironment();
-      return EXIT_FAILURE;
-    }
-    CleanupProfilingEnvironment();
-    const auto teardownEnd = Clock::now();
-    PrintDuration("PC Sampling teardown time", teardownStart, teardownEnd);
-#endif
-
-    const auto timedEnd = Clock::now();
-    PrintDuration("Total execution time", benchmarkStart, timedEnd);
-  } catch (const sycl::exception& exception) {
-    std::cerr << "Failed to create GPU queue: " << exception.what() << '\n';
-    return EXIT_FAILURE;
-  } catch (const std::exception& exception) {
-    std::cerr << "PC Sampling benchmark failed: " << exception.what() << '\n';
-    return EXIT_FAILURE;
-  }
-
-  return EXIT_SUCCESS;
-}
diff --git a/sdk/test/perf_test.py b/sdk/test/perf_test.py
deleted file mode 100644
index 06b64b95..00000000
--- a/sdk/test/perf_test.py
+++ /dev/null
@@ -1,801 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from collections.abc import Callable
-from enum import Enum, auto
-import os
-import re
-import shutil
-import statistics
-import subprocess
-import sys
-import time
-import tempfile
-import io
-
-# reconfigure stdout/stderr to utf-8 to support unicode characters in output
-if isinstance(sys.stdout, io.TextIOWrapper):
-    sys.stdout.reconfigure(encoding="utf-8")
-if isinstance(sys.stderr, io.TextIOWrapper):
-    sys.stderr.reconfigure(encoding="utf-8")
-
-# Sometimes we might run it with different number of threads
-num_threads_str = "5"
-skip_return_code = 77
-
-# fmt: off
-test_profiled = ["dpc_gemm_threaded_profiled", "-t", num_threads_str, "-r", "50", "-s", "32",
-                 "-c", "gpu", "-c", "sycl", "-c" , "overhead"]
-test_prof_gpu = ["dpc_gemm_threaded_profiled", "-t", num_threads_str, "-r", "50", "-s", "32",
-                 "-c", "gpu"]
-test_linkonly = ["dpc_gemm_threaded_linkonly", "-t", num_threads_str, "-r", "50", "-s", "32"]
-test_baseline = ["dpc_gemm_threaded_baseline", "-t", num_threads_str, "-r", "50", "-s", "32"]
-
-# For Overhead View test, we run the baseline with 1 thread and bigger GPU kernel.
-# The test checks if the accumulated Overhead View time is at least
-# the threshold ratio (test parameter) multiplied by the difference between
-# the elapsed times of the baseline and the test under profiling.
-test_overhead = ["dpc_gemm_threaded_profiled", "-t", "1", "-r", "200", "-s", "32",
-                 "-c", "gpu", "-c",  "overhead"]
-test_baseline_t_1 = ["dpc_gemm_threaded_baseline", "-t", "1", "-r", "200", "-s", "32"]
-
-# Metrics Scope: the baseline is the same binary with GPU tracing only, so the
-# measured overhead is the scope profiler alone. Each run launches more than
-# 1000 kernels, past the per-pool query count, so coverage drops if query
-# slots stop being recycled.
-test_scope_baseline_t_1 = ["dpc_gemm_threaded_profiled", "-t", "1", "-r", "1200", "-s", "32",
-                           "-c", "gpu"]
-test_scope_t_1 = ["dpc_gemm_threaded_profiled", "-t", "1", "-r", "1200", "-s", "32",
-                  "-c", "gpu", "-c", "scope"]
-test_scope_baseline_t_2 = ["dpc_gemm_threaded_profiled", "-t", "2", "-r", "600", "-s", "32",
-                           "-c", "gpu"]
-test_scope_t_2 = ["dpc_gemm_threaded_profiled", "-t", "2", "-r", "600", "-s", "32",
-                  "-c", "gpu", "-c", "scope"]
-min_scope_coverage = 0.99
-
-test_pc_sampling = ["pc_sampling_perf_profiled", "-r", "10", "-s", "2048"]
-test_pc_sampling_baseline = ["pc_sampling_perf_baseline", "-r", "10", "-s", "2048"]
-
-pc_sampling_profiled_phases = [
-    "PC Sampling enable and configure time",
-    "PC Sampling start collection time",
-    "Workload execution time",
-    "PC Sampling stop collection time",
-    "PC Sampling post-processing time",
-    "PC Sampling teardown time",
-    "Total execution time",
-]
-pc_sampling_baseline_phases = ["Workload execution time", "Total execution time"]
-pc_sampling_collection_phases = [
-    "PC Sampling start collection time",
-    "Workload execution time",
-    "PC Sampling stop collection time",
-]
-pc_sampling_cpu_metrics = [
-    "Workload user CPU time",
-    "Workload system CPU time",
-    "Workload total CPU time",
-    "Workload CPU utilization",
-]
-# fmt: on
-
-
-def analyze_default(threshold_overhead, _results, diff_med):
-    if diff_med > threshold_overhead:
-        print(
-            f"\nTest failed - Measured overhead {diff_med:.2f}% exceeds threshold {threshold_overhead}%"
-        )
-        return 1
-
-    print(
-        f"\nTest passed - Measured overhead {diff_med:.2f}% is within threshold {threshold_overhead}%"
-    )
-    return 0
-
-
-def collect_default_test_specific_values(_stdout_b, _stdout_t):
-    return {}
-
-
-def get_phase_timings(text, phases):
-    timings = {phase: get_value(phase, text) for phase in phases}
-    return timings if all(value is not None for value in timings.values()) else None
-
-
-def collect_pc_sampling_values(stdout_b, stdout_t):
-    profiled_timings = get_phase_timings(stdout_t, pc_sampling_profiled_phases)
-    baseline_timings = get_phase_timings(stdout_b, pc_sampling_baseline_phases)
-    if profiled_timings is None or baseline_timings is None:
-        return None
-
-    values = {
-        "PC Sampling profiled " + phase: value
-        for phase, value in profiled_timings.items()
-    }
-    values.update(
-        {
-            "PC Sampling baseline " + phase: value
-            for phase, value in baseline_timings.items()
-        }
-    )
-
-    profiled_cpu_timings = get_phase_timings(stdout_t, pc_sampling_cpu_metrics)
-    baseline_cpu_timings = get_phase_timings(stdout_b, pc_sampling_cpu_metrics)
-    if profiled_cpu_timings is not None and baseline_cpu_timings is not None:
-        values.update(
-            {
-                "PC Sampling profiled " + metric: value
-                for metric, value in profiled_cpu_timings.items()
-            }
-        )
-        values.update(
-            {
-                "PC Sampling baseline " + metric: value
-                for metric, value in baseline_cpu_timings.items()
-            }
-        )
-
-    return values
-
-
-@dataclass(frozen=True)
-class TestConfig:
-    baseline_command: list[str]
-    test_command: list[str]
-    repetitions: int = 15
-    warm_up_runs: int = 1
-    analyze: Callable[[float, "TestResults", float], int] = analyze_default
-    collect_test_specific_values: Callable[[str, str], dict[str, float] | None] = (
-        collect_default_test_specific_values
-    )
-    requires_throughput: bool = True
-    # Pause after each test process, before the next baseline starts.
-    settle_after_test_sec: float = 0.0
-
-
-@dataclass
-class TestResults:
-    throughput_baseline: list[float]
-    throughput_test: list[float]
-    elapsed_baseline: list[float]
-    elapsed_test: list[float]
-    test_specific_values: dict[str, list[float]]
-
-
-class CommandStatus(Enum):
-    PASS = auto()
-    FAIL = auto()
-    SKIPPED = auto()
-    HANGED = auto()
-
-
-@dataclass
-class CommandResult:
-    status: CommandStatus
-    stdout: str
-    stderr: str
-
-
-def analyze_overhead_view(threshold_overhead, results, _diff_med):
-    captured_overhead_values = results.test_specific_values.get("Overhead time", [])
-    if not (
-        len(captured_overhead_values) == 1
-        and len(results.elapsed_test) == 1
-        and len(results.elapsed_baseline) == 1
-    ):
-        print("Test failed - Overhead analysis expects exactly one measurement")
-        return 1
-    captured_overhead_elapsed = captured_overhead_values[0]
-
-    elapsed_diff = (float)(results.elapsed_test[0]) - (float)(
-        results.elapsed_baseline[0]
-    )
-    print("\nElapsed time diff:                                 " + str(elapsed_diff))
-
-    threshold_ratio = 0.01 * (  # percent -> ratio
-        threshold_overhead  # collected L0 overhead expected to account,
-    )
-    print(
-        "Expect captured Overhead View time to be at least: "
-        + str(threshold_ratio * elapsed_diff)
-        + " sec, Ratio: "
-        + str(threshold_ratio)
-    )
-    if elapsed_diff <= 0.0:
-        print("Test failed - Non-positive elapsed diff captured")
-        return 1
-    print(
-        "Captured by PTI Overhead View overhead time:       "
-        + str(captured_overhead_elapsed)
-        + " sec, Ratio: "
-        + str(captured_overhead_elapsed / elapsed_diff)
-    )
-    if captured_overhead_elapsed < threshold_ratio * elapsed_diff:
-        print("Test failed - Too small Overhead View captured")
-        return 1
-    return 0
-
-
-def collect_overhead_view_values(_stdout_b, stdout_t):
-    captured_overhead = get_value("Overhead time", stdout_t)
-    if captured_overhead is None:
-        print("FAILED (no overhead data)")
-        return None
-    print(
-        "Overhead due to profiling reported by PTI Overhead View (sec): "
-        + str(captured_overhead)
-    )
-    return {"Overhead time": captured_overhead}
-
-
-def format_duration(value):
-    if value >= 1.0:
-        return f"{value:.2f} s"
-    return f"{value * 1_000.0:.1f} ms"
-
-
-def print_pc_sampling_summary(results):
-    profiled_medians = {
-        phase: statistics.median(
-            results.test_specific_values["PC Sampling profiled " + phase]
-        )
-        for phase in pc_sampling_profiled_phases
-    }
-    baseline_medians = {
-        phase: statistics.median(
-            results.test_specific_values["PC Sampling baseline " + phase]
-        )
-        for phase in pc_sampling_baseline_phases
-    }
-
-    print("\nPC Sampling phase summary (median):")
-    for label, phase in [
-        ("PC Sampling enable/configure", "PC Sampling enable and configure time"),
-        ("Start collection", "PC Sampling start collection time"),
-        ("Workload execution", "Workload execution time"),
-        ("Stop collection", "PC Sampling stop collection time"),
-        ("Post-processing", "PC Sampling post-processing time"),
-        ("Teardown", "PC Sampling teardown time"),
-        ("Total execution time", "Total execution time"),
-    ]:
-        print("  " + label.ljust(32) + format_duration(profiled_medians[phase]))
-
-    print("\nNo PC Sampling (median):")
-    for label, phase in [
-        ("Workload execution", "Workload execution time"),
-        ("Total execution time", "Total execution time"),
-    ]:
-        print("  " + label.ljust(32) + format_duration(baseline_medians[phase]))
-
-
-def print_pc_sampling_cpu_summary(results):
-    prefix = "PC Sampling profiled "
-    if any(
-        prefix + metric not in results.test_specific_values
-        for metric in pc_sampling_cpu_metrics
-    ):
-        return
-
-    print("\nWorkload CPU usage (median):")
-    for label, metric in [
-        ("User CPU time", "Workload user CPU time"),
-        ("System CPU time", "Workload system CPU time"),
-        ("Total CPU time", "Workload total CPU time"),
-    ]:
-        baseline = statistics.median(
-            results.test_specific_values["PC Sampling baseline " + metric]
-        )
-        profiled = statistics.median(results.test_specific_values[prefix + metric])
-        print(
-            "  "
-            + label.ljust(20)
-            + format_duration(baseline)
-            + " baseline, "
-            + format_duration(profiled)
-            + " PC Sampling"
-        )
-
-    baseline_utilization = statistics.median(
-        results.test_specific_values["PC Sampling baseline Workload CPU utilization"]
-    )
-    profiled_utilization = statistics.median(
-        results.test_specific_values[prefix + "Workload CPU utilization"]
-    )
-    print(
-        f"  CPU utilization     {baseline_utilization:.1f}% baseline, "
-        f"{profiled_utilization:.1f}% PC Sampling"
-    )
-
-
-def analyze_pc_sampling(threshold_overhead, results, _diff_med):
-    profiled_values = [
-        results.test_specific_values["PC Sampling profiled " + phase]
-        for phase in pc_sampling_collection_phases
-    ]
-    profiled_elapsed = [sum(values) for values in zip(*profiled_values)]
-    baseline_elapsed = results.test_specific_values[
-        "PC Sampling baseline Workload execution time"
-    ]
-    median_profiled = statistics.median(remove_extreme_outliers(profiled_elapsed))
-    median_baseline = statistics.median(remove_extreme_outliers(baseline_elapsed))
-    diff_med = 100.0 * (median_profiled - median_baseline) / median_baseline
-
-    print_pc_sampling_summary(results)
-    print_pc_sampling_cpu_summary(results)
-    return analyze_default(threshold_overhead, results, diff_med)
-
-
-def collect_scope_values(_stdout_b, stdout_t):
-    records = get_value("Scope records", stdout_t)
-    kernels = get_value("Scope kernels", stdout_t)
-    if records is None or not kernels:
-        print("FAILED (no scope data)")
-        return None
-    return {"Scope coverage": records / kernels}
-
-
-def analyze_scope(threshold_overhead, results, _diff_med):
-    # Collecting fewer records makes a run faster, so check coverage before overhead.
-    coverage = min(results.test_specific_values.get("Scope coverage", [0.0]))
-    print(
-        f"\nLowest scope record coverage: {coverage:.4f} (minimum {min_scope_coverage})"
-    )
-    if coverage < min_scope_coverage:
-        print("\nTest failed - Scope records do not cover all kernels")
-        return 1
-
-    elapsed_baseline = statistics.median(results.elapsed_baseline)
-    elapsed_test = statistics.median(results.elapsed_test)
-    print("\nEnd-to-end latency, median across runs (sec):")
-    print(f"  baseline {elapsed_baseline:.4f}  test {elapsed_test:.4f}")
-    latency_increase = 100.0 * (elapsed_test - elapsed_baseline) / elapsed_baseline
-    print("\n  baseline = PTI GPU tracing only (-c gpu)")
-    print("  test     = PTI GPU tracing + Metrics Scope, XVE_ACTIVE (-c gpu -c scope)")
-    print(
-        "  => the increase is the cost of Metrics Scope on top of tracing, not vs. no PTI"
-    )
-    print(f"\nEnd-to-end latency increase (%): {latency_increase:.2f} (PRIMARY)")
-    return analyze_default(threshold_overhead, results, latency_increase)
-
-
-test_configs = {
-    "profiled": TestConfig(test_baseline, test_profiled),
-    "prof-gpu": TestConfig(test_baseline, test_prof_gpu),
-    "linkonly": TestConfig(test_baseline, test_linkonly),
-    "overhead": TestConfig(
-        test_baseline_t_1,
-        test_overhead,
-        repetitions=1,
-        warm_up_runs=0,
-        analyze=analyze_overhead_view,
-        collect_test_specific_values=collect_overhead_view_values,
-    ),
-    "scope": TestConfig(
-        test_scope_baseline_t_1,
-        test_scope_t_1,
-        repetitions=9,
-        analyze=analyze_scope,
-        collect_test_specific_values=collect_scope_values,
-        requires_throughput=False,
-        settle_after_test_sec=1.0,
-    ),
-    "scope-mt": TestConfig(
-        test_scope_baseline_t_2,
-        test_scope_t_2,
-        repetitions=9,
-        analyze=analyze_scope,
-        collect_test_specific_values=collect_scope_values,
-        requires_throughput=False,
-        settle_after_test_sec=1.0,
-    ),
-    "pc-sampling": TestConfig(
-        test_pc_sampling_baseline,
-        test_pc_sampling,
-        repetitions=10,
-        analyze=analyze_pc_sampling,
-        collect_test_specific_values=collect_pc_sampling_values,
-        requires_throughput=False,
-    ),
-}
-
-
-def get_value(name, text):
-    pattern = re.compile(
-        name + r"\s*:\s+(\d*.?\d*e?-?\d*)"
-    )  # number in float or exponential notation
-    match = pattern.search(text)
-    if match:
-        return float(match.group(1))
-    else:
-        return None
-
-
-def kill_process_tree(p):
-    if sys.platform == "win32":
-        # p.kill() only terminates the direct child; /T also takes its descendants
-        try:
-            result = subprocess.run(
-                ["taskkill", "/F", "/T", "/PID", str(p.pid)],
-                capture_output=True,
-                check=False,
-                timeout=30,
-            )
-            if result.returncode == 0:
-                return
-            print(
-                f"WARNING: taskkill failed for process {p.pid} "
-                f"(exit code {result.returncode})"
-            )
-        except subprocess.TimeoutExpired:
-            print(f"WARNING: taskkill timed out for process {p.pid}")
-    p.kill()
-
-
-def read_output(f):
-    f.seek(0)
-    return f.read().decode("latin-1")
-
-
-def run_process(command, path, work_dir, timeout_sec, environ=None):
-    command = command.copy()
-    command[0] = os.path.join(os.path.abspath(path), command[0])
-
-    # Output goes to temp files, not pipes: with pipes, a killed process that
-    # is stuck in the GPU driver keeps the pipe open and reading its output
-    # blocks forever (the test then hangs until the CI job is cancelled).
-    # The process runs in work_dir, not in the binaries dir, so a stuck
-    # process does not also hold that dir as its current directory.
-    with tempfile.TemporaryFile() as out, tempfile.TemporaryFile() as err:
-        p = subprocess.Popen(command, cwd=work_dir, env=environ, stdout=out, stderr=err)
-        try:
-            p.wait(timeout=timeout_sec)
-        except subprocess.TimeoutExpired:
-            kill_process_tree(p)
-            try:
-                p.wait(timeout=10)
-            except subprocess.TimeoutExpired:
-                print(f"WARNING: process {p.pid} did not exit after kill")
-            print(f"ERROR: process timed out after {timeout_sec}s: {command[0]}")
-            return CommandResult(
-                CommandStatus.HANGED, read_output(out), read_output(err)
-            )
-        stdout, stderr = read_output(out), read_output(err)
-
-    if p.returncode == 0:
-        status = CommandStatus.PASS
-    elif p.returncode == skip_return_code:
-        status = CommandStatus.SKIPPED
-    else:
-        status = CommandStatus.FAIL
-    return CommandResult(status, stdout, stderr)
-
-
-def check_process_status(baseline_result, test_result):
-    results = (baseline_result, test_result)
-    if any(result.status == CommandStatus.FAIL for result in results):
-        print("FAILED (benchmark process failed)")
-        status = CommandStatus.FAIL
-    elif any(result.status == CommandStatus.SKIPPED for result in results):
-        print("SKIPPED (benchmark reported unsupported configuration)")
-        status = CommandStatus.SKIPPED
-    elif any(result.status == CommandStatus.HANGED for result in results):
-        print("FAILED (benchmark process timed out)")
-        status = CommandStatus.HANGED
-    else:
-        status = CommandStatus.PASS
-
-    stderr_output = [result.stderr for result in results if result.stderr]
-    if stderr_output:
-        if status in (CommandStatus.PASS, CommandStatus.SKIPPED):
-            print("WARNING (Detected stderr output)")
-        for output in stderr_output:
-            print(output)
-
-    return status
-
-
-def run_warm_up(config, path, work_dir, timeout_sec, environ):
-    """Warm-up phase to stabilize CPU frequency and thermal state.
-
-    Returns PASS, or the status of the first warm-up run that did not pass.
-    """
-    if config.warm_up_runs > 0:
-        print("\nWarm-up phase:")
-    for i in range(config.warm_up_runs):
-        print("  Warm-up run " + str(i + 1) + "...", end=" ", flush=True)
-        baseline_result = run_process(
-            config.baseline_command, path, work_dir, timeout_sec, environ
-        )
-        test_result = run_process(
-            config.test_command, path, work_dir, timeout_sec, environ
-        )
-        time.sleep(config.settle_after_test_sec)
-        status = check_process_status(baseline_result, test_result)
-        if status != CommandStatus.PASS:
-            print("Warm-up terminated the test")
-            return status
-        print("✓")
-    return CommandStatus.PASS
-
-
-def run_test(path, work_dir, test_type, test_timeout=60):
-    config = test_configs[test_type]
-    environ = None
-    if test_type == "pc-sampling":
-        environ = {**os.environ, "ONEAPI_DEVICE_SELECTOR": "level_zero:0"}
-    total_invocations = (config.repetitions + config.warm_up_runs) * 2
-    timeout_sec = max(10, test_timeout // total_invocations)
-
-    print("Test baseline command:    ", config.baseline_command)
-    print("Test type " + test_type + " command: ", config.test_command)
-    print("Repetitions: " + str(config.repetitions))
-    print("Warm-up runs: " + str(config.warm_up_runs))
-    print(
-        f"Process timeout: {timeout_sec}s per invocation "
-        f"(total budget: {test_timeout}s, invocations: {total_invocations})"
-    )
-
-    warm_up_status = run_warm_up(config, path, work_dir, timeout_sec, environ)
-    if warm_up_status == CommandStatus.SKIPPED:
-        return CommandStatus.SKIPPED, None
-    if warm_up_status != CommandStatus.PASS:
-        return CommandStatus.FAIL, None
-
-    print("\nMeasurement phase - runs: ")
-    throughput_test = []
-    throughput_baseline = []
-    elapsed_test = []
-    elapsed_baseline = []
-    test_specific_values = {}
-    failed_measurements = 0
-    for i in range(config.repetitions):
-        # Test fails below anyway; stop so repeated hangs don't eat the
-        # CI job timeout
-        if failed_measurements * 2 >= config.repetitions:
-            break
-        print(str(i + 1) + "/" + str(config.repetitions) + ", ", end="", flush=True)
-        # Interleaved: baseline first, then test (keeps CPU state similar)
-        baseline_result = run_process(
-            config.baseline_command, path, work_dir, timeout_sec, environ
-        )
-        test_result = run_process(
-            config.test_command, path, work_dir, timeout_sec, environ
-        )
-        time.sleep(config.settle_after_test_sec)
-        status = check_process_status(baseline_result, test_result)
-        if status == CommandStatus.SKIPPED:
-            return CommandStatus.SKIPPED, None
-        elif status != CommandStatus.PASS:
-            failed_measurements += 1
-            continue
-
-        tp_t = get_value("Throughput", test_result.stdout)
-        tp_b = get_value("Throughput", baseline_result.stdout)
-        el_t = get_value("Total execution time", test_result.stdout)
-        el_b = get_value("Total execution time", baseline_result.stdout)
-
-        if (
-            el_t is None
-            or el_b is None
-            or (config.requires_throughput and (tp_t is None or tp_b is None))
-        ):
-            print("FAILED (no data)")
-            failed_measurements += 1
-            continue
-
-        captured_test_values = config.collect_test_specific_values(
-            baseline_result.stdout, test_result.stdout
-        )
-        if captured_test_values is None:
-            failed_measurements += 1
-            continue
-
-        if config.requires_throughput:
-            throughput_test.append(tp_t)
-            throughput_baseline.append(tp_b)
-        elapsed_test.append(el_t)
-        elapsed_baseline.append(el_b)
-        for name, value in captured_test_values.items():
-            test_specific_values.setdefault(name, []).append(value)
-    print()
-
-    valid_measurements = config.repetitions - failed_measurements
-    if valid_measurements * 2 <= config.repetitions:
-        print(
-            f"Too many measurement runs failed: {failed_measurements}/"
-            f"{config.repetitions}"
-        )
-        return CommandStatus.FAIL, None
-    if failed_measurements:
-        print(
-            f"Warning: some measurement runs failed: {failed_measurements}/"
-            f"{config.repetitions}"
-        )
-
-    return CommandStatus.PASS, TestResults(
-        throughput_baseline,
-        throughput_test,
-        elapsed_baseline,
-        elapsed_test,
-        test_specific_values,
-    )
-
-
-def remove_extreme_outliers(values):
-    """
-    Remove top and bottom 2.5% extreme outliers.
-    This handles occasional context switches, thermal spikes, etc.
-
-    With fewer than 4 values, percentile-based trimming is not meaningful:
-    we would either remove too much data or skew the results, so in that
-    case the input is returned unchanged.
-    """
-    if len(values) < 4:
-        return values
-
-    sorted_vals = sorted(values)
-    cutoff = max(1, len(sorted_vals) // 40)  # ~2.5% on each end
-    removed = 2 * cutoff
-    if removed > 0:
-        print(f"removed {removed} extreme outliers")
-    return sorted_vals[cutoff:-cutoff]
-
-
-def process_data(values):
-    filtered_values = remove_extreme_outliers(values)
-    standard_deviation = (
-        statistics.stdev(filtered_values) if len(filtered_values) > 1 else 0.0
-    )
-    return (
-        min(filtered_values),
-        statistics.mean(filtered_values),
-        statistics.median(filtered_values),
-        max(filtered_values),
-        standard_deviation,
-    )
-
-
-def analyze_results(
-    test_type,
-    threshold_overhead,
-    results,
-):
-    config = test_configs[test_type]
-    if not config.requires_throughput:
-        return config.analyze(threshold_overhead, results, 0.0)
-
-    print("Processing baseline results: ", end="")
-    min_base, avg_base, med_base, max_base, std_base = process_data(
-        results.throughput_baseline
-    )
-    print("Processing test results: ", end="")
-    min_test, avg_test, med_test, max_test, std_test = process_data(
-        results.throughput_test
-    )
-
-    units_str = "items/s"
-    if test_type != "overhead":
-        print("\nThreshold Overhead to pass: " + str(threshold_overhead) + "% =>")
-        print(" Measured overhead should not exceed Threshold Overhead\n")
-    else:
-        units_str = "sec"
-        print("\nThreshold Ratio to pass: " + str(threshold_overhead * 0.01) + " =>")
-        print(
-            " Reported PTI Overhead View time should account for at least for "
-            "Threshold Ratio of the Elapsed Time Diff between the test and the baseline\n"
-        )
-
-    print(
-        "Baseline ("
-        + units_str
-        + "): min "
-        + format(min_base, ".2f")
-        + " avg: "
-        + format(avg_base, ".2f")
-        + " ± "
-        + format(std_base, ".2f")
-        + " med: "
-        + format(med_base, ".2f")
-        + " max: "
-        + format(max_base, ".2f")
-    )
-    print(
-        "Test ("
-        + units_str
-        + "):     min "
-        + format(min_test, ".2f")
-        + " avg: "
-        + format(avg_test, ".2f")
-        + " ± "
-        + format(std_test, ".2f")
-        + " med: "
-        + format(med_test, ".2f")
-        + " max: "
-        + format(max_test, ".2f")
-    )
-
-    diff_med = 100.0 * (float)(med_base - med_test) / (float(med_base))
-    diff_min = 100.0 * (float)(min_base - min_test) / (float(min_base))
-    diff_max = 100.0 * (float)(max_base - max_test) / (float(max_base))
-    diff_avg = 100.0 * (float)(avg_base - avg_test) / (float(avg_base))
-
-    print(
-        "\nOverhead (%): med: "
-        + format(diff_med, ".2f")
-        + " (PRIMARY) avg: "
-        + format(diff_avg, ".2f")
-        + " min: "
-        + format(diff_min, ".2f")
-        + " max: "
-        + format(diff_max, ".2f")
-    )
-
-    return config.analyze(threshold_overhead, results, diff_med)
-
-
-def parse_arguments(argv):
-    if len(argv) < 4:
-        print(
-            f"Usage: {sys.argv[0]} <executable_path> <threshold> <test_type> [timeout]"
-        )
-        print("  executable_path  directory containing test binaries (required)")
-        print("  threshold        overhead threshold % to pass (required)")
-        print(f"  test_type        {' | '.join(test_configs)} (required)")
-        print(
-            "  timeout          approximate budget in seconds divided across all process invocations"
-            " (10s floor per process), default: 60"
-        )
-        return None
-
-    executable_path = argv[1]
-    # An empty or missing directory almost always means the caller expanded an
-    # undefined CMake variable. Report it here, otherwise the run dies in a bare
-    # Popen traceback that never names the directory it was handed.
-    if not executable_path:
-        print("Empty executable_path: expected a directory containing test binaries")
-        return None
-    if not os.path.isdir(executable_path):
-        print(f"executable_path '{executable_path}' is not an existing directory")
-        return None
-
-    threshold_overhead = float(argv[2])
-    test_type = argv[3]
-    if test_type not in test_configs:
-        print(
-            f"Invalid test type '{test_type}'. Expected one of: "
-            f"{' | '.join(test_configs)}"
-        )
-        return None
-    test_timeout = int(argv[4]) if len(argv) > 4 else 60
-    return executable_path, threshold_overhead, test_type, test_timeout
-
-
-def main():
-    arguments = parse_arguments(sys.argv)
-    if arguments is None:
-        return 1
-
-    executable_path, threshold_overhead, test_type, test_timeout = arguments
-    print(" executable path: " + executable_path)
-
-    work_dir = tempfile.mkdtemp(prefix="pti_perf_")
-    try:
-        result, test_results = run_test(
-            executable_path, work_dir, test_type, test_timeout
-        )
-    finally:
-        # A process that did not exit after kill may still hold the dir
-        shutil.rmtree(work_dir, ignore_errors=True)
-    if result is CommandStatus.SKIPPED:
-        print("Test skipped")
-        return skip_return_code
-    if result is CommandStatus.FAIL:
-        print("Test failed")
-        return 1
-    print("Test completed successfully")
-
-    return analyze_results(test_type, threshold_overhead, test_results)
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/sdk/test/prof_time_diff/prof_time_diff.py b/sdk/test/prof_time_diff/prof_time_diff.py
deleted file mode 100755
index d73c4aee..00000000
--- a/sdk/test/prof_time_diff/prof_time_diff.py
+++ /dev/null
@@ -1,690 +0,0 @@
-#!/usr/bin/env python3
-"""
-Profile Time Difference (prof_time_diff.py)
-
-Test script to validate that kernel durations between two consecutive runs
-of an application differ by no more than a specified threshold percentage.
-
-Usage:
-    python3 prof_time_diff.py <binary_path> [-dp PERCENT] [-da NANOSECONDS] [-s SKIP]
-
-Arguments:
-    binary_path: Path to the target executable
-
-Options:
-    -dp, --diff-percent PERCENT   Maximum allowed duration difference in percent
-    -da, --diff-abs NANOSECONDS   Maximum allowed duration difference in nanoseconds
-    -s, --skip COUNT              Number of first kernels to skip (warmup kernels) (default: 0)
-    -e1 VAR=VALUE                 Environment variable(s) for run 1 (can be specified multiple times)
-    -e2 VAR=VALUE                 Environment variable(s) for run 2 (can be specified multiple times)
-
-    Note: If neither -dp nor -da is specified, defaults to -dp 20.0
-          You can use -dp alone, -da alone, or both together.
-          When both are specified, a kernel violates if it exceeds EITHER threshold.
-
-Examples:
-    python3 prof_time_diff.py /path/to/application
-    python3 prof_time_diff.py /path/to/application -dp 25.0
-    python3 prof_time_diff.py /path/to/application -dp 20.0 -s 10
-    python3 prof_time_diff.py /path/to/application --diff-percent 15.5 --skip 5
-    python3 prof_time_diff.py /path/to/application -da 1000
-    python3 prof_time_diff.py /path/to/application --diff-abs 5000 -s 20
-    python3 prof_time_diff.py /path/to/application -e1 SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS=1
-    python3 prof_time_diff.py /path/to/application -e1 VAR1=value1 -e1 VAR2=value2 -e2 VAR1=value3
-"""
-
-import sys
-import subprocess
-import re
-import os
-import argparse
-import math
-from pathlib import Path
-from typing import List, Tuple, Optional
-
-
-class KernelRecord:
-    """Represents a single kernel execution record."""
-
-    def __init__(self, name: str, duration_ns: int, position: int):
-        self.name = name
-        self.duration_ns = duration_ns
-        self.position = position  # Position in execution order
-
-    def __repr__(self):
-        return f"KernelRecord(name='{self.name}', duration={self.duration_ns}ns, pos={self.position})"
-
-
-class Violation:
-    """Represents a kernel duration violation."""
-
-    def __init__(
-        self,
-        position: int,
-        name: str,
-        duration1_ns: int,
-        duration2_ns: int,
-        diff_percent: float,
-        diff_abs: int,
-    ):
-        self.position = position
-        self.name = name
-        self.duration1_ns = duration1_ns
-        self.duration2_ns = duration2_ns
-        self.diff_percent = diff_percent
-        self.diff_abs = diff_abs
-
-    def __repr__(self):
-        return (
-            f"Violation at position {self.position}: {self.name}\n"
-            f"  Run1: {self.duration1_ns:,}ns, Run2: {self.duration2_ns:,}ns, "
-            f"Diff: {self.diff_percent:.2f}% ({self.diff_abs:,}ns)"
-        )
-
-
-def parse_kernel_records(output: str) -> List[KernelRecord]:
-    """
-    Parse PTI kernel records from application output.
-
-    Expected format:
-        Found Kernel Record
-        Kernel Name: <name>
-        Kernel Execution Time: <duration> ns
-        ...
-
-    Returns:
-        List of KernelRecord objects in order of appearance.
-    """
-    records = []
-    lines = output.split("\n")
-    i = 0
-    position = 0
-
-    while i < len(lines):
-        line = lines[i].strip()
-
-        # Look for kernel record marker
-        if line == "Found Kernel Record":
-            kernel_name = None
-            kernel_duration = None
-            j = i  # Initialize j in case the for loop doesn't execute
-
-            # Parse the next few lines for kernel name and duration
-            for j in range(i + 1, min(i + 20, len(lines))):
-                curr_line = lines[j].strip()
-
-                # Extract kernel name
-                name_match = re.match(r"Kernel Name:\s*(.+)$", curr_line)
-                if name_match:
-                    kernel_name = name_match.group(1).strip()
-
-                # Extract duration (format: "Kernel Execution Time: 1'234'567 ns")
-                duration_match = re.match(
-                    r"Kernel Execution Time:\s*([\d']+)\s*ns", curr_line
-                )
-                if duration_match:
-                    # Remove apostrophes (thousands separator) and convert to int
-                    duration_str = duration_match.group(1).replace("'", "")
-                    kernel_duration = int(duration_str)
-
-                # If we have both, create record and move on
-                if kernel_name and kernel_duration is not None:
-                    records.append(KernelRecord(kernel_name, kernel_duration, position))
-                    position += 1
-                    break
-
-            # Move past the processed lines (or just past "Found Kernel Record" if incomplete)
-            i = j + 1
-        else:
-            i += 1
-
-    return records
-
-
-def run_target_binary(
-    binary_path: str, output_file: str, env_vars: Optional[dict] = None
-) -> Tuple[int, str]:
-    """
-    Run target binary and capture output.
-
-    Args:
-        binary_path: Path to the target executable
-        output_file: File to save the output
-        env_vars: Optional dictionary of environment variables to set for this run
-
-    Returns:
-        (return_code, output_text)
-    """
-    binary_name = os.path.basename(binary_path)
-    try:
-        # Prepare environment
-        env = os.environ.copy()
-        if env_vars:
-            env.update(env_vars)
-
-        # Redirect stderr to stdout to preserve chronological order of records
-        # (PTI records may be emitted to both streams, and order matters for comparison)
-        result = subprocess.run(
-            [binary_path],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            timeout=300,  # 5 minute timeout
-            env=env,
-        )
-
-        # All output is now in stdout with correct chronological order
-        full_output = result.stdout
-
-        # Save to file
-        with open(output_file, "w") as f:
-            f.write(full_output)
-
-        return result.returncode, full_output
-
-    except subprocess.TimeoutExpired:
-        print(
-            f"ERROR: Target binary '{binary_name}' execution timed out after 300 seconds",
-            file=sys.stderr,
-        )
-        return -1, ""
-    except Exception as e:
-        print(
-            f"ERROR: Failed to run target binary '{binary_name}': {e}", file=sys.stderr
-        )
-        return -1, ""
-
-
-def compare_kernel_durations(
-    run1_records: List[KernelRecord],
-    run2_records: List[KernelRecord],
-    threshold_percent: Optional[float] = None,
-    threshold_abs: Optional[int] = None,
-    skip_first: int = 0,
-) -> Tuple[List[Violation], List[str]]:
-    """
-    Compare kernel durations between two runs.
-
-    Args:
-        run1_records: Kernel records from first run
-        run2_records: Kernel records from second run
-        threshold_percent: Maximum allowed duration difference in percent (optional)
-        threshold_abs: Maximum allowed duration difference in nanoseconds (optional)
-        skip_first: Number of first kernels to skip (warmup)
-
-    Returns:
-        (violations, errors)
-        - violations: List of kernels exceeding threshold
-        - errors: List of error messages (mismatched names, counts, etc.)
-    """
-    violations = []
-    errors = []
-
-    # Check if kernel counts match
-    if len(run1_records) != len(run2_records):
-        errors.append(
-            f"Kernel count mismatch: Run1={len(run1_records)}, Run2={len(run2_records)}"
-        )
-        # Continue comparison up to the shorter list
-
-    # Compare kernels sequentially, starting after skip_first
-    min_count = min(len(run1_records), len(run2_records))
-
-    # Check if skip_first is valid
-    if skip_first >= min_count:
-        errors.append(
-            f"skip_first ({skip_first}) is >= total kernels ({min_count}), no kernels to compare"
-        )
-        return violations, errors
-
-    for i in range(skip_first, min_count):
-        kernel1 = run1_records[i]
-        kernel2 = run2_records[i]
-
-        # Check if kernel names match
-        if kernel1.name != kernel2.name:
-            errors.append(
-                f"Position {i}: Kernel name mismatch - Run1='{kernel1.name}', Run2='{kernel2.name}'"
-            )
-            continue
-
-        # Calculate differences
-        if kernel1.duration_ns == 0:
-            errors.append(f"Position {i}: {kernel1.name} has zero duration in Run1")
-            continue
-
-        diff_ns = abs(kernel2.duration_ns - kernel1.duration_ns)
-        diff_percent = (diff_ns / kernel1.duration_ns) * 100.0
-
-        # Check if exceeds threshold(s)
-        violates = False
-        if threshold_percent is not None and diff_percent > threshold_percent:
-            violates = True
-        if threshold_abs is not None and diff_ns > threshold_abs:
-            violates = True
-
-        if violates:
-            violations.append(
-                Violation(
-                    position=i,
-                    name=kernel1.name,
-                    duration1_ns=kernel1.duration_ns,
-                    duration2_ns=kernel2.duration_ns,
-                    diff_percent=diff_percent,
-                    diff_abs=diff_ns,
-                )
-            )
-
-    return violations, errors
-
-
-def validate_threshold(value: Optional[float], name: str) -> bool:
-    """
-    Validate a threshold value.
-
-    Args:
-        value: The threshold value to validate (can be None)
-        name: Human-readable name for error messages (e.g., "Percentage threshold")
-
-    Returns:
-        True if valid or None, False if invalid (error message printed to stderr)
-    """
-    if value is None:
-        return True
-
-    if not math.isfinite(value):
-        print(
-            f"ERROR: {name} must be a finite number (not NaN or infinity)",
-            file=sys.stderr,
-        )
-        return False
-
-    if value <= 0:
-        print(f"ERROR: {name} must be a positive number", file=sys.stderr)
-        return False
-
-    return True
-
-
-def parse_env_vars(env_list: Optional[List[str]], run_name: str) -> dict:
-    """
-    Parse environment variable specifications from command line.
-
-    Args:
-        env_list: List of environment variable specifications in VAR=VALUE format
-        run_name: Name of the run (for error messages, e.g., "run 1")
-
-    Returns:
-        Dictionary of environment variables
-
-    Raises:
-        SystemExit: If any environment variable specification is invalid
-    """
-    env_vars = {}
-    if env_list:
-        for env_spec in env_list:
-            if "=" not in env_spec:
-                print(
-                    f"ERROR: Invalid environment variable format for {run_name}: '{env_spec}'. Must be VAR=VALUE",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-            key, value = env_spec.split("=", 1)
-            if not key:
-                print(
-                    f"ERROR: Invalid environment variable format for {run_name}: '{env_spec}'. Variable name cannot be empty",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-            env_vars[key] = value
-    return env_vars
-
-
-def main():
-    # Set up argument parser
-    parser = argparse.ArgumentParser(
-        description="Test script to validate that kernel durations between two consecutive runs "
-        "of an application differ by no more than a specified threshold percentage "
-        "or/and absolute value of nanoseconds.",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  %(prog)s /path/to/application
-  %(prog)s /path/to/application -dp 25.0
-  %(prog)s /path/to/application -dp 20.0 -s 10
-  %(prog)s /path/to/application --diff-percent 15.5 --skip 5
-  %(prog)s /path/to/application -da 1000
-  %(prog)s /path/to/application --diff-abs 5000 -s 20
-  %(prog)s /path/to/application -s 50 -dp 30
-  %(prog)s /path/to/application -e1 SYCL_DEVICE_FILTER=level_zero:gpu
-  %(prog)s /path/to/application -e1 VAR1=value1 -e2 VAR1=value2
-  %(prog)s /path/to/application -e1 A=1 -e1 B=2 -e2 A=3 -e2 B=4
-        """,
-    )
-
-    parser.add_argument(
-        "binary", metavar="BINARY_PATH", help="Path to the target executable"
-    )
-
-    parser.add_argument(
-        "-dp",
-        "--diff-percent",
-        type=float,
-        metavar="PERCENT",
-        dest="diff_percent",
-        help="Maximum allowed duration difference in percent",
-    )
-
-    parser.add_argument(
-        "-da",
-        "--diff-abs",
-        type=int,
-        metavar="NANOSECONDS",
-        dest="diff_abs",
-        help="Maximum allowed duration difference in nanoseconds",
-    )
-
-    parser.add_argument(
-        "-s",
-        "--skip",
-        type=int,
-        default=0,
-        metavar="COUNT",
-        help="Number of first kernels to skip (warmup kernels) (default: 0)",
-    )
-
-    parser.add_argument(
-        "-e1",
-        action="append",
-        metavar="VAR=VALUE",
-        dest="env1",
-        help="Environment variable for run 1 in format VAR=VALUE (can be specified multiple times)",
-    )
-
-    parser.add_argument(
-        "-e2",
-        action="append",
-        metavar="VAR=VALUE",
-        dest="env2",
-        help="Environment variable for run 2 in format VAR=VALUE (can be specified multiple times)",
-    )
-
-    # Parse arguments
-    args = parser.parse_args()
-
-    binary_path = args.binary
-    threshold_percent = args.diff_percent
-    threshold_abs = args.diff_abs
-    skip_first = args.skip
-
-    # If neither threshold is specified, default to 20% for backwards compatibility
-    if threshold_percent is None and threshold_abs is None:
-        threshold_percent = 20.0
-
-    # Parse environment variables
-    env1_vars = parse_env_vars(args.env1, "run 1")
-    env2_vars = parse_env_vars(args.env2, "run 2")
-
-    # Validate thresholds
-    if not validate_threshold(threshold_percent, "Percentage threshold"):
-        return 1
-
-    if not validate_threshold(threshold_abs, "Absolute threshold"):
-        return 1
-
-    # Validate skip_first
-    if skip_first < 0:
-        print("ERROR: skip_first must be a non-negative integer", file=sys.stderr)
-        return 1
-
-    # Validate binary exists
-    if not os.path.isfile(binary_path):
-        print(f"ERROR: Binary not found: {binary_path}", file=sys.stderr)
-        return 1
-
-    if not os.access(binary_path, os.X_OK):
-        print(f"ERROR: Binary is not executable: {binary_path}", file=sys.stderr)
-        return 1
-
-    print("=" * 80)
-    print("Profile Time Difference Test (prof_time_diff)")
-    print("=" * 80)
-    print(f"Binary: {binary_path}")
-
-    # Display threshold(s)
-    thresholds_str = []
-    if threshold_percent is not None:
-        thresholds_str.append(f"{threshold_percent}% (percent)")
-    if threshold_abs is not None:
-        thresholds_str.append(f"{threshold_abs:,} ns (absolute)")
-    print(f"Threshold: {', '.join(thresholds_str)}")
-
-    print(f"Skip first: {skip_first} kernel(s)")
-    if env1_vars:
-        print(f"Run 1 env vars: {', '.join(f'{k}={v}' for k, v in env1_vars.items())}")
-    if env2_vars:
-        print(f"Run 2 env vars: {', '.join(f'{k}={v}' for k, v in env2_vars.items())}")
-    print()
-
-    # Create output directory for intermediate files based on executable name
-    binary_name = os.path.basename(binary_path)
-    output_dir = Path(f"{binary_name}_test_output")
-    output_dir.mkdir(exist_ok=True)
-
-    run1_file = output_dir / "run1_output.txt"
-    run2_file = output_dir / "run2_output.txt"
-
-    # Run binary twice
-    print(f"Running {binary_name} (Run 1)...")
-    ret1, output1 = run_target_binary(
-        binary_path, str(run1_file), env_vars=env1_vars if env1_vars else None
-    )
-    if ret1 != 0:
-        print(f"ERROR: Run 1 failed with return code {ret1}", file=sys.stderr)
-        print(f"Output saved to: {run1_file}")
-        return 1
-    print(f"  Completed. Output saved to: {run1_file}")
-
-    print(f"\nRunning {binary_name} (Run 2)...")
-    ret2, output2 = run_target_binary(
-        binary_path, str(run2_file), env_vars=env2_vars if env2_vars else None
-    )
-    if ret2 != 0:
-        print(f"ERROR: Run 2 failed with return code {ret2}", file=sys.stderr)
-        print(f"Output saved to: {run2_file}")
-        return 1
-    print(f"  Completed. Output saved to: {run2_file}")
-
-    # Parse kernel records
-    print("\nParsing kernel records...")
-    run1_records = parse_kernel_records(output1)
-    run2_records = parse_kernel_records(output2)
-
-    print(f"  Run 1: Found {len(run1_records)} kernel executions")
-    print(f"  Run 2: Found {len(run2_records)} kernel executions")
-
-    if len(run1_records) == 0 or len(run2_records) == 0:
-        print("\nERROR: No kernel records found in one or both runs.", file=sys.stderr)
-        print("This may indicate:")
-        print("  - PTI tracing is not enabled")
-        print(f"  - {binary_name} is not executing GPU kernels")
-        print("  - Output parsing failed")
-        return 1
-
-    # Check for zero duration kernels
-    print("\nValidating kernel durations...")
-    zero_duration_kernels = []
-
-    for i, kernel in enumerate(run1_records):
-        if kernel.duration_ns == 0:
-            zero_duration_kernels.append(f"Run 1, Position {i}: {kernel.name}")
-
-    for i, kernel in enumerate(run2_records):
-        if kernel.duration_ns == 0:
-            zero_duration_kernels.append(f"Run 2, Position {i}: {kernel.name}")
-
-    if zero_duration_kernels:
-        print(
-            f"\nERROR: Found {len(zero_duration_kernels)} kernel(s) with zero duration:",
-            file=sys.stderr,
-        )
-        for kernel_info in zero_duration_kernels:
-            print(f"  - {kernel_info}", file=sys.stderr)
-        print("\nThis indicates a timing or instrumentation issue.", file=sys.stderr)
-        return 1
-
-    print("  All kernels have non-zero durations")
-
-    # Validate skip_first doesn't exceed total kernels
-    min_count = min(len(run1_records), len(run2_records))
-    if skip_first > 0:
-        if skip_first >= min_count:
-            print(
-                f"\nERROR: skip_first ({skip_first}) is >= total kernels ({min_count})",
-                file=sys.stderr,
-            )
-            return 1
-        print(f"  Skipping first {skip_first} kernel(s) (warmup)")
-        print(f"  Comparing {min_count - skip_first} kernel(s)")
-
-    # Compare kernel durations
-    print("\nComparing kernel durations...")
-    violations, errors = compare_kernel_durations(
-        run1_records,
-        run2_records,
-        threshold_percent=threshold_percent,
-        threshold_abs=threshold_abs,
-        skip_first=skip_first,
-    )
-
-    # Report results
-    print("\n" + "=" * 80)
-    print("RESULTS")
-    print("=" * 80)
-
-    # Report errors first
-    if errors:
-        print("\nERRORS:")
-        for error in errors:
-            print(f"  - {error}")
-
-    # Report violations
-    if violations:
-        # Build violation header based on active thresholds
-        threshold_desc = []
-        if threshold_percent is not None:
-            threshold_desc.append(f"{threshold_percent}%")
-        if threshold_abs is not None:
-            threshold_desc.append(f"{threshold_abs:,}ns")
-        threshold_str = " or ".join(threshold_desc)
-
-        print(
-            f"\nVIOLATIONS: {len(violations)} kernel(s) exceeded threshold ({threshold_str}):"
-        )
-        print()
-        for v in violations:
-            print(f"  Position {v.position}: {v.name}")
-            print(f"    Run1: {v.duration1_ns:>15,} ns")
-            print(f"    Run2: {v.duration2_ns:>15,} ns")
-            print(f"    Diff: {v.diff_percent:>15.2f}% ({v.diff_abs:,} ns)")
-            print()
-    else:
-        # Build success message based on active thresholds
-        threshold_desc = []
-        if threshold_percent is not None:
-            threshold_desc.append(f"{threshold_percent}%")
-        if threshold_abs is not None:
-            threshold_desc.append(f"{threshold_abs:,}ns")
-        threshold_str = " and ".join(threshold_desc)
-        print(
-            f"\nNo violations found. All kernels are within threshold ({threshold_str})."
-        )
-
-    # Summary
-    print("=" * 80)
-    print("SUMMARY")
-    print("=" * 80)
-    total_kernels = min(len(run1_records), len(run2_records))
-    kernels_compared = total_kernels - skip_first
-    if skip_first > 0:
-        print(f"Total kernels found: {total_kernels}")
-        print(f"Kernels skipped: {skip_first}")
-        print(f"Kernels compared: {kernels_compared}")
-    else:
-        print(f"Total kernels compared: {kernels_compared}")
-
-    # Print comparison criteria
-    criteria_parts = []
-    if threshold_percent is not None:
-        criteria_parts.append(f"Percentage difference {threshold_percent}%")
-    if threshold_abs is not None:
-        criteria_parts.append(f"Absolute difference {threshold_abs:,} ns")
-    criteria_str = " OR ".join(criteria_parts)
-    print(f"Comparison criteria: {criteria_str}")
-
-    # Build violation summary based on active thresholds
-    threshold_desc = []
-    if threshold_percent is not None:
-        threshold_desc.append(f">{threshold_percent}%")
-    if threshold_abs is not None:
-        threshold_desc.append(f">{threshold_abs:,}ns")
-    threshold_str = " or ".join(threshold_desc)
-    print(f"Violations ({threshold_str}): {len(violations)}")
-
-    # Categorize errors by type for summary
-    if errors:
-        error_counts = {
-            "count_mismatch": 0,
-            "name_mismatch": 0,
-            "zero_duration": 0,
-            "skip_first": 0,
-        }
-        for err in errors:
-            if "Kernel count mismatch" in err:
-                error_counts["count_mismatch"] += 1
-            elif "Kernel name mismatch" in err:
-                error_counts["name_mismatch"] += 1
-            elif "zero duration" in err:
-                error_counts["zero_duration"] += 1
-            elif "skip_first" in err:
-                error_counts["skip_first"] += 1
-
-        # Build error summary string
-        error_types = []
-        if error_counts["count_mismatch"] > 0:
-            error_types.append("count mismatch")
-        if error_counts["name_mismatch"] > 0:
-            error_types.append(f"{error_counts['name_mismatch']} name mismatch")
-        if error_counts["zero_duration"] > 0:
-            error_types.append(f"{error_counts['zero_duration']} zero duration")
-        if error_counts["skip_first"] > 0:
-            error_types.append("invalid skip_first")
-
-        error_detail = ", ".join(error_types) if error_types else ""
-        print(f"Errors: {len(errors)} ({error_detail})")
-    else:
-        print(f"Errors: 0 (checked: count, name, zero duration)")
-
-    # Report biggest violation
-    if violations:
-        max_violation = max(violations, key=lambda v: v.diff_percent)
-        print(f"\nBiggest violation:")
-        print(f"  Position: {max_violation.position}")
-        print(f"  Kernel: {max_violation.name}")
-        print(f"  Run 1: {max_violation.duration1_ns:,} ns")
-        print(f"  Run 2: {max_violation.duration2_ns:,} ns")
-        print(
-            f"  Difference: {max_violation.diff_percent:.2f}% ({max_violation.diff_abs:,} ns)"
-        )
-
-    # Determine exit code
-    if errors or violations:
-        print("\nStatus: FAIL")
-        return 1
-    else:
-        print("\nStatus: PASS")
-        return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/sdk/test/prof_time_diff/prof_time_diff_README.md b/sdk/test/prof_time_diff/prof_time_diff_README.md
deleted file mode 100644
index 87489fc3..00000000
--- a/sdk/test/prof_time_diff/prof_time_diff_README.md
+++ /dev/null
@@ -1,82 +0,0 @@
-# Profile Time Difference Test (prof_time_diff)
-
-## Overview
-
-This test validates that GPU kernel execution durations remain consistent between consecutive runs of a target application. It captures kernel timing from PTI records and ensures variations don't exceed specified thresholds.
-
-**Use cases:**
-- Detect performance regressions or unexpected timing changes
-- Validate PTI tracing accuracy
-- Compare performance under different runtime configurations (via environment variables)
-- Test kernel execution stability
-
-## Quick Start
-
-```bash
-# Basic usage with default 20% threshold
-python3 prof_time_diff.py /path/to/application
-
-# With absolute threshold (3000 nanoseconds)
-python3 prof_time_diff.py /path/to/application -da 3000
-
-# Skip first 50 kernels (warmup) and use percentage threshold
-python3 prof_time_diff.py /path/to/application -dp 20 -s 50
-
-# Compare with different environment variables
-python3 prof_time_diff.py /path/to/application -e1 PTI_DEVICE_SYNC_DELTA=50000 -e2 PTI_DEVICE_SYNC_DELTA=100000
-```
-
-## Threshold Types
-
-- **`-dp, --diff-percent`**: Percentage difference (e.g., `-dp 20` = 20% variation allowed)
-- **`-da, --diff-abs`**: Absolute difference in nanoseconds (e.g., `-da 3000` = 3μs variation allowed)
-- **Both**: Can use both together - violation if EITHER threshold is exceeded
-- **Default**: If neither specified, defaults to `-dp 20.0`
-
-## Common Options
-
-- `-s, --skip COUNT`: Skip first N kernels (warmup/initialization)
-- `-e1 VAR=VALUE`: Environment variable for first run (repeatable)
-- `-e2 VAR=VALUE`: Environment variable for second run (repeatable)
-
-## Exit Codes
-
-- **0**: PASS - All kernel durations within threshold
-- **1**: FAIL - Violations found or errors detected
-
-## How It Works
-
-1. Runs the target application twice
-2. Captures PTI kernel records from both runs (stderr redirected to stdout to preserve chronological order)
-3. Validates all kernels have non-zero durations
-4. Compares corresponding kernels by position (after optional warmup skip)
-5. Reports violations and biggest outlier
-
-## Output
-
-The test creates a `<binary_name>_test_output/` directory with:
-- `run1_output.txt`: Full output from first run
-- `run2_output.txt`: Full output from second run
-
-Results are printed to console showing:
-- Number of kernels compared
-- Violations exceeding threshold
-- Biggest violation with both run durations
-- Pass/Fail status
-
-## Full Documentation
-
-For complete documentation including all options, examples, and troubleshooting:
-
-```bash
-python3 prof_time_diff.py --help
-```
-
-## CTest Integration
-
-The test is integrated with CTest as `prof-time-diff-dlworkload`:
-
-```bash
-# From build directory
-ctest -R prof-time-diff-dlworkload -V
-```
diff --git a/sdk/test/pti_assert_test.cc b/sdk/test/pti_assert_test.cc
deleted file mode 100644
index f06ea252..00000000
--- a/sdk/test/pti_assert_test.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "pti_assert.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-TEST(PtiAssertTest, CheckCorrectAssertion) {
-  const int value_1 = 0;
-  const int value_2 = 0;
-  EXPECT_EQ(value_1, value_2);
-  PTI_ASSERT(value_1 == value_2);
-}
-
-TEST(PtiAssertTest, CheckIncorrectAssertion) {
-  const int value_1 = 0;
-  const int value_2 = 1;
-  EXPECT_NE(value_1, value_2);
-  // clang-format off
-  EXPECT_DEATH_IF_SUPPORTED(PTI_ASSERT(value_1 == value_2), ::testing::HasSubstr(__FILE__ ":"));
-  // clang-format on
-  PTI_ASSERT(value_1 != value_2);
-}
diff --git a/sdk/test/pti_memory_route_test.cc b/sdk/test/pti_memory_route_test.cc
deleted file mode 100644
index 254da7a3..00000000
--- a/sdk/test/pti_memory_route_test.cc
+++ /dev/null
@@ -1,124 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pti_memory_route.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <array>
-
-#include "pti/pti_view.h"
-
-namespace {
-
-constexpr std::array kAllMemoryTypes = {
-    pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY,
-    pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST,
-    pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-    pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED,
-};
-
-}  // namespace
-
-TEST(PtiMemoryCommandRouteTest, GetCharReturnsExpectedLettersForEachMemoryType) {
-  EXPECT_EQ(PtiMemoryCommandRoute::GetChar(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY), 'M');
-  EXPECT_EQ(PtiMemoryCommandRoute::GetChar(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST), 'H');
-  EXPECT_EQ(PtiMemoryCommandRoute::GetChar(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE), 'D');
-  EXPECT_EQ(PtiMemoryCommandRoute::GetChar(pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED), 'S');
-}
-
-TEST(PtiMemoryCommandRouteTest, DefaultRoute) {
-  PtiMemoryCommandRoute default_route{};
-  EXPECT_EQ(default_route.GetCompactStringForTypes(), "M2M");
-  EXPECT_EQ(default_route.is_peer_2_peer, false);
-  EXPECT_EQ(default_route.GetCompactStringForP2P(), "");
-  EXPECT_EQ(default_route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_M2M);
-  EXPECT_FALSE(default_route.IsMainDeviceSrc());
-}
-
-TEST(PtiMemoryCommandRouteTest, GetCompactStringForTypesFormatsRoute) {
-  PtiMemoryCommandRoute device_2_host{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-                                      pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST, false};
-  EXPECT_EQ(device_2_host.GetCompactStringForTypes(), "D2H");
-
-  PtiMemoryCommandRoute shared_2_device{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED,
-                                        pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE, false};
-  EXPECT_EQ(shared_2_device.GetCompactStringForTypes(), "S2D");
-
-  PtiMemoryCommandRoute host_2_memory{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST,
-                                      pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY, false};
-  EXPECT_EQ(host_2_memory.GetCompactStringForTypes(), "H2M");
-}
-
-TEST(PtiMemoryCommandRouteTest, GetCompactStringForP2PTogglesOnFlag) {
-  PtiMemoryCommandRoute route;
-  route.is_peer_2_peer = false;
-  EXPECT_EQ(route.GetCompactStringForP2P(), "");
-  route.is_peer_2_peer = true;
-  EXPECT_EQ(route.GetCompactStringForP2P(), " - P2P");
-}
-
-TEST(PtiMemoryCommandRouteTest, GetMemcpyTypeCoverPairs) {
-  PtiMemoryCommandRoute route{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY,
-                              pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED, false};
-  EXPECT_EQ(route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_M2S);
-
-  route.src_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST;
-  route.dst_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE;
-  EXPECT_EQ(route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_H2D);
-
-  route.src_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE;
-  route.dst_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST;
-  EXPECT_EQ(route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_D2H);
-
-  route.src_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE;
-  route.dst_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE;
-  EXPECT_EQ(route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_D2D);
-
-  route.src_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED;
-  route.dst_type = pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED;
-  EXPECT_EQ(route.GetMemcpyType(), pti_view_memcpy_type::PTI_VIEW_MEMCPY_TYPE_S2S);
-}
-
-TEST(PtiMemoryCommandRouteTest, IsMainDeviceSrcTrueForDeviceSrcExceptD2D) {
-  PtiMemoryCommandRoute device_2_host{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-                                      pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST, false};
-  EXPECT_TRUE(device_2_host.IsMainDeviceSrc());
-
-  PtiMemoryCommandRoute device_2_shared{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-                                        pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED, false};
-  EXPECT_TRUE(device_2_shared.IsMainDeviceSrc());
-
-  PtiMemoryCommandRoute device_2_memory_unknown{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-                                                pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY,
-                                                false};
-  EXPECT_TRUE(device_2_memory_unknown.IsMainDeviceSrc());
-
-  PtiMemoryCommandRoute device_2_device{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE,
-                                        pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_DEVICE, false};
-  EXPECT_FALSE(device_2_device.IsMainDeviceSrc());
-}
-
-TEST(PtiMemoryCommandRouteTest, IsMainDeviceSrcTrueForSharedSrc) {
-  for (pti_view_memory_type dst : kAllMemoryTypes) {
-    PtiMemoryCommandRoute route{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_SHARED, dst, false};
-    EXPECT_TRUE(route.IsMainDeviceSrc())
-        << "Expected true for SHARED src with dst=" << static_cast<int>(dst);
-  }
-}
-
-TEST(PtiMemoryCommandRouteTest, IsMainDeviceSrcFalseForHostOrMemorySrc) {
-  for (pti_view_memory_type dst : kAllMemoryTypes) {
-    PtiMemoryCommandRoute host_src{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_HOST, dst, false};
-    EXPECT_FALSE(host_src.IsMainDeviceSrc())
-        << "Expected false for HOST src with dst=" << static_cast<int>(dst);
-
-    PtiMemoryCommandRoute mem_src{pti_view_memory_type::PTI_VIEW_MEMORY_TYPE_MEMORY, dst, false};
-    EXPECT_FALSE(mem_src.IsMainDeviceSrc())
-        << "Expected false for MEMORY src with dst=" << static_cast<int>(dst);
-  }
-}
diff --git a/sdk/test/pti_string_pool_test.cc b/sdk/test/pti_string_pool_test.cc
deleted file mode 100644
index 02ec8cf2..00000000
--- a/sdk/test/pti_string_pool_test.cc
+++ /dev/null
@@ -1,110 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "pti_string_pool.h"
-
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <string>
-#include <thread>
-#include <vector>
-
-namespace {
-
-// Get deduplicates (same string -> same pointer, different -> different) and
-// returns content matching the input (incl. empty); Size counts unique strings
-// only and Contains reflects membership.
-TEST(StringPoolTest, BasicContract) {
-  StringPool pool;
-
-  EXPECT_EQ(pool.Size(), 0u);
-  EXPECT_FALSE(pool.Contains("kernelA"));
-
-  const char* a1 = pool.Get("kernelA");
-  const char* a2 = pool.Get("kernelA");  // duplicate must not grow the pool
-  const char* b = pool.Get("kernelB");
-  const char* empty = pool.Get("");
-
-  EXPECT_EQ(a1, a2) << "repeated string should return the same pointer";
-  EXPECT_NE(a1, b) << "different strings should return different pointers";
-
-  EXPECT_STREQ(a1, "kernelA");
-  EXPECT_STREQ(b, "kernelB");
-  EXPECT_STREQ(empty, "");
-
-  EXPECT_EQ(pool.Size(), 3u);  // "kernelA", "kernelB", ""
-  EXPECT_TRUE(pool.Contains("kernelA"));
-  EXPECT_TRUE(pool.Contains("kernelB"));
-  EXPECT_FALSE(pool.Contains("kernelC"));
-}
-
-// The core lifetime guarantee: a pointer handed out earlier stays valid and
-// keeps its content even after many more insertions force the underlying
-// container to rehash.
-TEST(StringPoolTest, PointersStableAcrossRehash) {
-  StringPool pool;
-
-  const char* first = pool.Get("stable_name");
-
-  // Insert far more entries than the default bucket count to trigger rehashing.
-  for (int i = 0; i < 10000; ++i) {
-    pool.Get("filler_" + std::to_string(i));
-  }
-
-  EXPECT_EQ(pool.Get("stable_name"), first)
-      << "pointer changed after rehash; existing pointers must stay valid";
-  EXPECT_STREQ(first, "stable_name");
-}
-
-// Drives shared and exclusive locking under contention: every thread inserts
-// its own unique keys (write path / emplace) while all threads also race to
-// emplace and re-read a set of shared keys. Verifies content correctness, an
-// exact unique count (no lost or duplicated insertions), and that every thread
-// observes the same pointer for a given shared key.
-TEST(StringPoolTest, ConcurrentAccessUnderContention) {
-  StringPool pool;
-
-  constexpr int kThreads = 8;
-  constexpr int kKeysPerThread = 1000;
-
-  std::vector<std::vector<const char*>> shared_pointers(kThreads,
-                                                        std::vector<const char*>(kKeysPerThread));
-  std::vector<std::thread> threads;
-  std::atomic<int> ready{0};
-
-  for (int t = 0; t < kThreads; ++t) {
-    threads.emplace_back([&, t]() {
-      ready++;
-      while (ready.load() < kThreads) {
-        std::this_thread::yield();
-      }
-      for (int i = 0; i < kKeysPerThread; ++i) {
-        const std::string unique_key = "t" + std::to_string(t) + "_k" + std::to_string(i);
-        EXPECT_STREQ(pool.Get(unique_key), unique_key.c_str());
-
-        const std::string shared_key = "shared_k" + std::to_string(i);
-        shared_pointers[t][i] = pool.Get(shared_key);
-        EXPECT_STREQ(shared_pointers[t][i], shared_key.c_str());
-      }
-    });
-  }
-  for (auto& th : threads) {
-    th.join();
-  }
-
-  EXPECT_EQ(pool.Size(), static_cast<size_t>(kThreads * kKeysPerThread + kKeysPerThread));
-
-  // Every thread must have observed the same pointer for each shared key.
-  for (int i = 0; i < kKeysPerThread; ++i) {
-    for (int t = 1; t < kThreads; ++t) {
-      EXPECT_EQ(shared_pointers[t][i], shared_pointers[0][i])
-          << "threads observed inconsistent pointers for a shared key";
-    }
-  }
-}
-
-}  // namespace
diff --git a/sdk/test/subscribers_unit_test.cc b/sdk/test/subscribers_unit_test.cc
deleted file mode 100644
index 8961ae56..00000000
--- a/sdk/test/subscribers_unit_test.cc
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <list>
-#include <thread>
-#include <vector>
-
-#include "ze_collector_cb_helpers.h"
-
-class DummySubscriber : public ZeCollectorCBSubscriber {};
-
-TEST(SubscribersCollectionTest, ThreadSafetyAndIteration) {
-  SubscribersCollection collection;
-  constexpr int num_threads = 8;
-  constexpr int subs_per_thread = 100;
-  std::vector<std::unique_ptr<DummySubscriber>> subscribers;
-  std::vector<_pti_callback_subscriber*> handles(num_threads * subs_per_thread);
-  std::atomic<int> ready{0};
-
-  // Prepare subscribers
-  for (int i = 0; i < num_threads * subs_per_thread; ++i) {
-    subscribers.emplace_back(new DummySubscriber());
-  }
-
-  // Add external subscribers in parallel
-  std::vector<std::thread> threads;
-  for (int t = 0; t < num_threads; ++t) {
-    threads.emplace_back([&, t]() {
-      ready++;
-      while (ready.load() < num_threads) {
-      }
-      for (int i = 0; i < subs_per_thread; ++i) {
-        // Storing handles as will need to remove providing a handle
-        handles[t * subs_per_thread + i] =
-            collection.AddExternalSubscriber(std::move(subscribers[t * subs_per_thread + i]));
-      }
-    });
-  }
-  for (auto& th : threads) th.join();
-  ASSERT_EQ(collection.GetSubscriberCount(), num_threads * subs_per_thread);
-
-  // Remove half in parallel
-  ready = 0;
-  threads.clear();
-  for (int t = 0; t < num_threads; ++t) {
-    threads.emplace_back([&, t]() {
-      ready++;
-      while (ready.load() < num_threads) {
-      }
-      for (int i = 0; i < subs_per_thread / 2; ++i) {
-        collection.RemoveExternalSubscriber(handles[t * subs_per_thread + i]);
-      }
-    });
-  }
-  for (auto& th : threads) th.join();
-  ASSERT_EQ(collection.GetSubscriberCount(), num_threads * subs_per_thread / 2);
-
-  collection.AddInternalSubscriber(std::make_unique<DummySubscriber>());
-  collection.AddInternalSubscriber(std::make_unique<DummySubscriber>());
-
-  ASSERT_EQ(collection.GetSubscriberCount(), 2 + num_threads * subs_per_thread / 2);
-
-  // Check that we can iterate over collection as of std::list
-  // iterating over remaining subscribers
-  size_t count = 0;
-  for ([[maybe_unused]] const auto& sub : collection) {
-    count++;
-  }
-  ASSERT_EQ(count, 2 + num_threads * subs_per_thread / 2);
-}
diff --git a/sdk/test/suppressions/ASan.supp b/sdk/test/suppressions/ASan.supp
deleted file mode 100644
index 30ac46a9..00000000
--- a/sdk/test/suppressions/ASan.supp
+++ /dev/null
@@ -1,13 +0,0 @@
-# File to suppress results from AddressSanitizer
-
-# Usage:
-#  * ASAN_OPTIONS=suppressions=<path_to_this_dir>/ASan.supp ./your-program
-
-# Additions should rarely be added, meant to suppress errors from libpti.so
-# dependencies.
-
-# This does not seem to work. However, in spirit, we want it.
-interceptor_via_lib:libigc.so
-interceptor_via_fun:L0::KernelImp::setArgImmediate
-interceptor_via_fun:SourceInfo::initStr
-interceptor_via_fun:llvm::omp::target::plugin::KernelPropertiesTy::reuseGroupParams
diff --git a/sdk/test/suppressions/LSan.supp b/sdk/test/suppressions/LSan.supp
deleted file mode 100644
index bc72523f..00000000
--- a/sdk/test/suppressions/LSan.supp
+++ /dev/null
@@ -1,31 +0,0 @@
-# File to suppress results from LeakSanitizer
-
-# Usage:
-#  * LSAN_OPTIONS=suppressions=<path_to_this_dir>/LSan.supp ./your-program
-
-# Additions should rarely be added, meant to suppress errors from libpti.so
-# dependencies.
-
-# libigc.so has a memory leak in strdup somewhere.
-leak:libigc.so
-
-# strange leak reported - nothing of app on the stack, compiler LSAN issue?
-# while it might hide other leaks
-# temp workaround
-leak:stdlib_new_delete.cpp
-
-# libmkl_sycl.so in zero_pool.cpp.
-leak:oneapi::mkl::gpu::calloc_device
-
-# libmkl_sycl.so (unknown file)
-leak:oneapi::mkl::gpu::cache_program
-
-leak:libmkl_sycl.so
-
-leak:libze_intel_gpu.so.1*
-
-leak:libigdmd.so.1*
-
-leak:libdrm.so.2*
-
-leak:ze*
diff --git a/sdk/test/suppressions/TSan.supp b/sdk/test/suppressions/TSan.supp
deleted file mode 100644
index 8d54a4e3..00000000
--- a/sdk/test/suppressions/TSan.supp
+++ /dev/null
@@ -1,22 +0,0 @@
-# File to suppress results from ThreadSanitizer
-
-# Usage:
-#  * TSAN_OPTIONS=suppressions=<path_to_this_dir>/TSan.supp ./your-program
-
-# Additions should rarely be added, meant to suppress errors from libpti.so
-# dependencies.
-
-# TODO: Fixed in compiler >= 2024.0.0? Definitely an issue on == 2023.2.1
-race:libsycl.so.6*
-
-# compute-runtime bug
-# I believe I saw recent fixes for this in the repository. They may not have
-# been released yet or added to our test machines.
-mutex:*ze_intel_gpu.so*
-deadlock:*ze_intel_gpu.so*
-
-# Need to file a bug, might be related to above.
-called_from_lib:libigdgmm.so*
-
-#TODO: Fixed in compiler >= 2024.0.0? Definitely an issue on == 2023.2.1
-deadlock:libigdrcl*
diff --git a/sdk/test/suppressions/UBSan.supp b/sdk/test/suppressions/UBSan.supp
deleted file mode 100644
index 7a974dc4..00000000
--- a/sdk/test/suppressions/UBSan.supp
+++ /dev/null
@@ -1,9 +0,0 @@
-# File to suppress results from UndefinedBehaviorSanitizer
-
-# Usage:
-#  * UBSAN_OPTIONS=suppressions=<path_to_this_dir>/UBSan.supp ./your-program
-
-# ISO sample has some undefined overflow behavior. However, we did not write
-# this code.
-pointer-overflow:iso3dfd
-pointer-overflow:metrics_iso3dfd
diff --git a/sdk/test/sycl_experimental_tests.cc b/sdk/test/sycl_experimental_tests.cc
deleted file mode 100644
index cd5bd402..00000000
--- a/sdk/test/sycl_experimental_tests.cc
+++ /dev/null
@@ -1,149 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <gtest/gtest.h>
-
-#include <cstdio>
-#include <cstdlib>
-#include <memory>
-#include <sycl/ext/oneapi/experimental/enqueue_functions.hpp>
-#include <sycl/sycl.hpp>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "utils/pti_record_collection_fixture.h"
-#include "utils/sycl_usm_helper.h"
-
-// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-template <typename T>
-inline void SyclSubmitTestKernel(sycl::queue* queue, T* buf, std::size_t number_of_elements) {
-  namespace syclex = sycl::ext::oneapi::experimental;
-  constexpr int kComputeIterations = 5324;
-  constexpr T kScale = 1.000001f;
-  constexpr T kOffset = 1e-6f;
-  queue->memset(buf, 0, number_of_elements * sizeof(T));
-  queue->wait();
-  syclex::submit(*queue, [&](sycl::handler& handler) {  // submitted WITHOUT an event
-    handler.parallel_for(number_of_elements, [=](sycl::id<1> idx) {
-      T val = buf[idx];
-      for (int iter = 0; iter < kComputeIterations; ++iter) {
-        val = (val * kScale) + kOffset;
-      }
-      buf[idx] = val;
-    });
-  });
-}
-
-template <typename T>
-inline void SyclNdLaunchAndCopyTestKernels(sycl::queue* queue, T* dst, T* tmp,
-                                           std::size_t number_of_elements, uint32_t seed) {
-  namespace syclex = sycl::ext::oneapi::experimental;
-  constexpr std::size_t kWorkGroupSize = 256;
-  constexpr uint32_t kHashMultiplier = 0x9E3779B9u;
-  constexpr uint32_t kHashShift = 8;
-  syclex::nd_launch(
-      *queue, sycl::nd_range<1>{number_of_elements, kWorkGroupSize}, [=](sycl::nd_item<1> item) {
-        const std::size_t idx = item.get_global_id(0);
-        const uint32_t hash = ((static_cast<uint32_t>(idx) ^ seed) * kHashMultiplier) >> kHashShift;
-        tmp[idx] = sycl::sqrt(static_cast<T>(hash));
-      });
-  queue->parallel_for(sycl::range<1>(number_of_elements),
-                      [=](sycl::id<1> idx) { dst[idx] = tmp[idx]; });
-  queue->wait();
-}
-// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-
-template <typename T>
-inline void ExpectNonEmptyTimestamps(const std::vector<const T*>& records) {
-  for (std::size_t idx = 0; idx < std::size(records); ++idx) {
-    const auto* record = records.at(idx);
-    EXPECT_NE(record->_start_timestamp, 0ULL) << "record " << idx;
-    EXPECT_NE(record->_end_timestamp, 0ULL) << "record " << idx;
-    EXPECT_GT(record->_end_timestamp, record->_start_timestamp)
-        << "record " << idx << " has zero duration";
-  }
-}
-
-class SyclExperimentalFeaturesTest : public ::pti::test::utils::RecordCollectionFixture {
- protected:
-  void SetUp() override {
-    try {
-      const sycl::property_list prop_list{sycl::property::queue::in_order()};
-      queue_ = std::make_unique<sycl::queue>(sycl::gpu_selector_v, prop_list);
-    } catch (const sycl::exception& e) {
-      GTEST_SKIP() << "No SYCL device or queue available: " << e.what();
-    } catch (...) {
-      FAIL() << "Unknown exception during SYCL device or queue creation.";
-    }
-  }
-
-  std::unique_ptr<sycl::queue> queue_ =
-      nullptr;  // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
-};
-
-TEST_F(SyclExperimentalFeaturesTest, EventlessSubmission) {
-  InitCollection();
-  EnableViews(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-  constexpr std::size_t kNumberElements = 1 << 20;
-  using BufType = float;
-
-  auto device_buffer = pti::test::utils::CreateDeviceUsmVector<BufType>(*queue_, kNumberElements);
-  SyclSubmitTestKernel(queue_.get(), device_buffer.get(), kNumberElements);
-  queue_->wait();
-
-  FinalizeCollection();
-  ASSERT_EQ(std::size(record_storage_.kernel_records), std::size_t{1});
-  ExpectNonEmptyTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(SyclExperimentalFeaturesTest, MultiEventlessSubmission) {
-  InitCollection();
-  EnableViews(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-  constexpr std::size_t kNumberElements = 1 << 20;
-  using BufType = float;
-  constexpr std::size_t kNumberOfSubmissions = 8;
-
-  auto device_buffer = pti::test::utils::CreateDeviceUsmVector<BufType>(*queue_, kNumberElements);
-  for (std::size_t submission_number = 0; submission_number < kNumberOfSubmissions;
-       ++submission_number) {
-    SyclSubmitTestKernel(queue_.get(), device_buffer.get(), kNumberElements);
-  }
-  queue_->wait();
-
-  FinalizeCollection();
-  ASSERT_EQ(std::size(record_storage_.kernel_records), std::size_t{kNumberOfSubmissions});
-  ExpectNonEmptyTimestamps(record_storage_.kernel_records);
-}
-
-TEST_F(SyclExperimentalFeaturesTest, EventlessNdLaunchFollowedByCopyKernel) {
-  constexpr std::size_t kNumberElements = 4 * 128 * 1024;
-  using BufType = float;
-  constexpr uint32_t kNumberOfWarmupSteps = 3;
-  constexpr uint32_t kNumberOfSteps = 300;
-  constexpr std::size_t kKernelsPerStep = 2;
-  constexpr uint32_t kSeedStart = 100;
-
-  auto device_buffer = pti::test::utils::CreateDeviceUsmVector<BufType>(*queue_, kNumberElements);
-  auto tmp_buffer = pti::test::utils::CreateDeviceUsmVector<BufType>(*queue_, kNumberElements);
-  for (uint32_t warmup_step = 0; warmup_step < kNumberOfWarmupSteps; ++warmup_step) {
-    SyclNdLaunchAndCopyTestKernels(queue_.get(), device_buffer.get(), tmp_buffer.get(),
-                                   kNumberElements, warmup_step);
-  }
-
-  InitCollection();
-  EnableViews(PTI_VIEW_DEVICE_GPU_KERNEL);
-
-  for (uint32_t step = 0; step < kNumberOfSteps; ++step) {
-    SyclNdLaunchAndCopyTestKernels(queue_.get(), device_buffer.get(), tmp_buffer.get(),
-                                   kNumberElements, kSeedStart + step);
-  }
-
-  FinalizeCollection();
-  ASSERT_EQ(std::size(record_storage_.kernel_records), kNumberOfSteps * kKernelsPerStep);
-  ExpectNonEmptyTimestamps(record_storage_.kernel_records);
-}
diff --git a/sdk/test/sycl_queue_id.cc b/sdk/test/sycl_queue_id.cc
deleted file mode 100644
index 4a8b6b63..00000000
--- a/sdk/test/sycl_queue_id.cc
+++ /dev/null
@@ -1,653 +0,0 @@
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cstring>
-#include <sycl/sycl.hpp>
-#include <thread>
-#include <utility>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "utils.h"
-#include "utils/test_helpers.h"
-
-namespace {
-constexpr int kVectorSize = 1024;
-constexpr auto kMaxQueueId = static_cast<uint64_t>(PTI_INVALID_QUEUE_ID);
-constexpr uint32_t kThreadCount = 5;
-constexpr auto kAValue = 0.128f;
-
-bool queue_id_kernel_records = false;
-bool queue_id_memcpy_records = false;
-bool queue_id_memfill_records = false;
-std::set<uint64_t> mt_q_ids;
-auto queue_id_k1 = static_cast<uint64_t>(PTI_INVALID_QUEUE_ID);
-uint64_t queue_id_k2 = 0;
-auto queue_id = static_cast<uint64_t>(PTI_INVALID_QUEUE_ID);
-bool use_same_q = false;
-bool use_same_kernel = false;
-[[maybe_unused]] bool use_stacked_q = false;
-[[maybe_unused]] bool templated_run = false;
-}  // namespace
-
-void StartTracing() {
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  ASSERT_EQ(ptiViewEnable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-void StopTracing() {
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_KERNEL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_DEVICE_GPU_MEM_FILL), pti_result::PTI_SUCCESS);
-  EXPECT_EQ(ptiViewDisable(PTI_VIEW_RUNTIME_API), pti_result::PTI_SUCCESS);
-}
-
-static void BufferRequested(unsigned char **buf, size_t *buf_size) {
-  *buf_size = pti::test::utils::SizeOfLargestViewRecord();
-  void *ptr = ::operator new(*buf_size);
-  ptr = std::align(8, sizeof(unsigned char), ptr, *buf_size);
-  *buf = static_cast<unsigned char *>(ptr);
-}
-
-static void BufferCompleted(unsigned char *buf, size_t buf_size, size_t used_bytes) {
-  if (!buf || !used_bytes || !buf_size) {
-    std::cerr << "Received empty buffer" << '\n';
-    ::operator delete(buf);
-    return;
-  }
-
-  pti_view_record_base *ptr = nullptr;
-  while (true) {
-    auto buf_status = ptiViewGetNextRecord(buf, used_bytes, &ptr);
-    if (buf_status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-      break;
-    }
-    if (buf_status != pti_result::PTI_SUCCESS) {
-      std::cerr << "Found Error Parsing Records from PTI" << '\n';
-      break;
-    }
-    switch (ptr->_view_kind) {
-      case pti_view_kind::PTI_VIEW_INVALID: {
-        std::cout << "Found Invalid Record" << '\n';
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-        auto *rec = reinterpret_cast<pti_view_record_memory_copy_type *>(ptr);
-        if (rec->_sycl_queue_id != kMaxQueueId) {
-          queue_id_memcpy_records = true;
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-        auto *rec = reinterpret_cast<pti_view_record_memory_fill_type *>(ptr);
-        if (rec->_sycl_queue_id != kMaxQueueId) {
-          queue_id_memfill_records = true;
-        }
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-        break;
-      }
-      case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-        auto *rec = reinterpret_cast<pti_view_record_kernel_type *>(ptr);
-        if (rec->_sycl_queue_id != kMaxQueueId) {
-          queue_id_kernel_records = true;
-        }
-        queue_id = rec->_sycl_queue_id;
-        mt_q_ids.insert(queue_id);
-        break;
-      }
-      default: {
-        std::cerr << "This shouldn't happen" << '\n';
-        break;
-      }
-    }
-  }
-  ::operator delete(buf);
-}
-
-sycl::property_list GetSyclPropList(bool use_immediate_command_lists) {
-  sycl::property_list prop_list;
-
-  if (use_immediate_command_lists) {
-    sycl::property_list prop{sycl::property::queue::in_order(),
-                             sycl::property::queue::enable_profiling(),
-                             sycl::ext::intel::property::queue::immediate_command_list()};
-    prop_list = std::move(prop);
-  } else {
-    sycl::property_list prop{sycl::property::queue::in_order(),
-                             sycl::property::queue::enable_profiling(),
-                             sycl::ext::intel::property::queue::no_immediate_command_list()};
-    prop_list = std::move(prop);
-  }
-
-  return prop_list;
-}
-
-template <typename T>
-static void InitKernel(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  [[maybe_unused]] T dummy_variable = 1;
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelA(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelAStackedQ(bool use_immediate_command_list, std::vector<float> &a,
-                                unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  sycl::device dev;
-  dev = sycl::device(sycl::gpu_selector_v);
-
-  auto prop_list = GetSyclPropList(use_immediate_command_list);
-  sycl::queue q(dev, sycl::async_handler{}, prop_list);
-
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = q.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    q.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelB(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelC(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelD(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelE(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-static void InitKernelF(sycl::queue queue, std::vector<float> &a, unsigned size) {
-  PTI_ASSERT(size > 0);
-  PTI_ASSERT(a.size() == size * size);
-  try {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::range<1> num_items{a.size()};
-    sycl::event event = queue.submit([&](sycl::handler &cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::write>(cgh);
-      cgh.parallel_for(num_items, [=](auto i) { a_acc[i] = i; });
-    });
-    queue.wait_and_throw();
-  } catch (const sycl::exception &e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-    throw;
-  }
-}
-
-//************************************
-// Vector square in SYCL on device: modifies each input vector
-//************************************
-template <typename T>
-void VecSq(sycl::queue &q, const std::vector<T> &a_vector, const std::vector<T> &b_vector) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-}
-
-template <typename T>
-void VecSqStackedQ(bool use_immediate_command_list, const std::vector<T> &a_vector,
-                   const std::vector<T> &b_vector) {
-  sycl::range<1> num_items{a_vector.size()};
-  sycl::buffer a_buf(a_vector);
-  sycl::buffer b_buf(b_vector);
-
-  sycl::device dev;
-  dev = sycl::device(sycl::gpu_selector_v);
-
-  auto prop_list = GetSyclPropList(use_immediate_command_list);
-  sycl::queue q(dev, sycl::async_handler{}, prop_list);
-
-  q.submit([&](sycl::handler &h) {
-    sycl::accessor a(a_buf, h, sycl::read_write);
-    sycl::accessor b(b_buf, h, sycl::read_write);
-    h.parallel_for(num_items, [=](auto i) {
-      a[i] = a[i] * a[i];
-      b[i] = b[i] * b[i];
-    });
-  });
-  q.wait();
-}
-
-template <typename T>
-void SyclQueueIdMtTestsRouted(bool use_immediate_command_list, std::vector<sycl::queue> &queues,
-                              bool stacked_q) {
-  std::vector<T> a(kVectorSize);
-  std::vector<T> b(kVectorSize);
-  auto thread_function = [](sycl::queue &q, const auto &a, const auto &b) { VecSq(q, a, b); };
-  auto thread_function_stacked_q = [&use_immediate_command_list](const auto &a, const auto &b) {
-    VecSqStackedQ(use_immediate_command_list, a, b);
-  };
-
-  std::vector<std::thread> the_threads;
-  for (uint32_t i = 0; i < kThreadCount; i++) {
-    if (stacked_q) {
-      std::thread t = std::thread(thread_function_stacked_q, a, b);
-      the_threads.push_back(std::move(t));
-    } else {
-      std::thread t = std::thread(thread_function, std::ref(queues[i]), a, b);
-      the_threads.push_back(std::move(t));
-    }
-  }
-
-  for (auto &th : the_threads) {
-    if (th.joinable()) {
-      th.join();
-    }
-  }
-}
-
-int RunSyclQueueIdMtTests(bool use_immediate_command_list, bool stacked_q = false) {
-  int exit_code = EXIT_SUCCESS;
-
-  StartTracing();
-  sycl::device dev;
-  dev = sycl::device(sycl::gpu_selector_v);
-
-  auto prop_list = GetSyclPropList(use_immediate_command_list);
-
-  std::vector<sycl::queue> mt_queues;
-  unsigned int queue_size = 5;
-
-  for (uint32_t i = 0; i < queue_size; i++) {
-    mt_queues.push_back(sycl::queue(dev, sycl::async_handler{}, prop_list));
-  }
-
-  auto *device_alloc =
-      static_cast<float *>(malloc_device(kVectorSize * sizeof(float), mt_queues[2]));
-  mt_queues[2]
-      .memset(device_alloc, 0, kVectorSize * sizeof(float))
-      .wait();  // force a memfill pti record to test.
-
-  if (dev.has(sycl::aspect::fp64)) {
-    SyclQueueIdMtTestsRouted<double>(use_immediate_command_list, mt_queues, stacked_q);
-  } else {
-    SyclQueueIdMtTestsRouted<float>(use_immediate_command_list, mt_queues, stacked_q);
-  }
-
-  StopTracing();
-  auto res = ptiFlushAllViews();
-  if (res != pti_result::PTI_SUCCESS) {
-    std::cerr << "Error flushing PTI views" << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-  return exit_code;
-}
-
-int RunSyclQueueIdTests(bool use_immediate_command_lists, bool use_same_q = false,
-                        bool use_same_kernel = false, bool templated_run = false,
-                        bool use_stacked_q = false) {
-  int exit_code = EXIT_SUCCESS;
-  unsigned size = 1024;
-  std::vector<float> a(size * size, kAValue);
-
-  if (use_stacked_q) {
-    StartTracing();
-    for (unsigned i = 0; i < kThreadCount; i++) {
-      InitKernelAStackedQ(use_immediate_command_lists, a, size);
-    }
-    StopTracing();
-    auto res = ptiFlushAllViews();
-    if (res != pti_result::PTI_SUCCESS) {
-      std::cerr << "Error flushing PTI views" << '\n';
-      exit_code = EXIT_FAILURE;
-    }
-    return exit_code;
-  }
-  StartTracing();
-  auto dev = sycl::device(sycl::gpu_selector_v);
-
-  auto prop_list = GetSyclPropList(use_immediate_command_lists);
-
-  std::vector<sycl::queue> queues;
-  std::vector<sycl::queue> mt_queues;
-  unsigned int queue_size = 5;
-
-  for (uint32_t i = 0; i < queue_size; i++) {
-    queues.push_back(sycl::queue(dev, sycl::async_handler{}, prop_list));
-  }
-
-  auto *device_alloc = static_cast<float *>(malloc_device(size * sizeof(float), queues[2]));
-  queues[2]
-      .memset(device_alloc, 0, size * sizeof(float))
-      .wait();  // force a memfill pti record to test.
-  try {
-    if (!templated_run) {
-      if (use_same_q && use_same_kernel) {
-        // same kernel, same Q
-        InitKernelA(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernelA(queues[1], a, size);
-        queue_id_k2 = queue_id;
-      } else if (use_same_q && !use_same_kernel) {  // Do not use KernelA or queue2 in below paths
-        // different kernel, same Q
-        InitKernelB(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernelC(queues[1], a, size);
-        queue_id_k2 = queue_id;
-      } else if (!use_same_q &&
-                 use_same_kernel) {  // Do not use KernelA/B/C or queue2/3 in below paths
-        // same kernel, different Q
-        InitKernelD(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernelD(queues[2], a, size);
-        queue_id_k2 = queue_id;
-      } else if (!use_same_q &&
-                 !use_same_kernel) {  // Do not use KernelA/B/C/D or queue2/3/4/5 in below paths
-        // different kernel, different Q
-        InitKernelE(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernelF(queues[2], a, size);
-        queue_id_k2 = queue_id;
-      }
-    } else {
-      if (use_same_q && use_same_kernel) {
-        InitKernel<uint32_t>(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernel<uint32_t>(queues[1], a, size);
-        queue_id_k2 = queue_id;
-      } else if (!use_same_q && use_same_kernel) {
-        InitKernel<uint64_t>(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernel<uint64_t>(queues[2], a, size);
-        queue_id_k2 = queue_id;
-      } else if (!use_same_q && !use_same_kernel) {
-        InitKernel<double>(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernel<float>(queues[2], a, size);
-        queue_id_k2 = queue_id;
-      } else if (use_same_q && !use_same_kernel) {
-        InitKernel<char>(queues[1], a, size);
-        queue_id_k1 = queue_id;
-        InitKernel<uint8_t>(queues[1], a, size);
-        queue_id_k2 = queue_id;
-      }
-    }
-    StopTracing();
-    PTI_ASSERT(ptiFlushAllViews() == PTI_SUCCESS);
-  } catch (const sycl::exception &e) {
-    std::cerr << "Error: Exception while executing SYCL " << e.what() << '\n';
-    std::cerr << "\tError code: " << e.code().value() << "\n\tCategory: " << e.category().name()
-              << "\n\tMessage: " << e.code().message() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (const std::exception &e) {
-    std::cerr << "Error: Exception caught " << e.what() << '\n';
-    exit_code = EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Error: Unknown exception caught." << '\n';
-    exit_code = EXIT_FAILURE;
-  }
-
-  return exit_code;
-}
-
-class SyclQueueIdFixtureTest : public ::testing::TestWithParam<bool> {
- protected:
-  void SetUp() override {
-    queue_id_kernel_records = false;
-    queue_id_memcpy_records = false;
-    queue_id_memfill_records = false;
-    mt_q_ids.clear();
-    queue_id_k1 = PTI_INVALID_QUEUE_ID;
-    queue_id_k2 = 0;
-    queue_id = PTI_INVALID_QUEUE_ID;
-    use_immediate_command_lists_ = GetParam();
-  }
-
-  void TearDown() override {}
-
-  bool use_immediate_command_lists_ = false;
-};
-
-//
-// Test sequence is important due to queue_id being bound to kernel location (and NOT the queue
-// itself).
-//
-TEST_P(SyclQueueIdFixtureTest, SameQSameKernelSameQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = true, use_same_kernel = true,
-                      templated_run = false);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_EQ(queue_id_k1, queue_id_k2);
-}
-
-TEST_P(SyclQueueIdFixtureTest, SameQDifferentKernelSameQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = true, use_same_kernel = false,
-                      templated_run = false);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_EQ(queue_id_k1, queue_id_k2);
-}
-
-#if __INTEL_LLVM_COMPILER >= 20240101 || __LIBSYCL_MAJOR_VERSION >= 8
-TEST_P(SyclQueueIdFixtureTest, DifferentQSameKernelDifferentQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = true,
-                      templated_run = false);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_NE(queue_id_k1, queue_id_k2);
-}
-
-TEST_P(SyclQueueIdFixtureTest, DifferentQDifferentKernelDifferentQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = false,
-                      templated_run = false);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_NE(queue_id_k1, queue_id_k2);
-}
-#endif
-
-TEST_P(SyclQueueIdFixtureTest, SameQSameTemplatedKernelSameQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = true, use_same_kernel = true,
-                      templated_run = true);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_EQ(queue_id_k1, queue_id_k2);
-}
-
-TEST_P(SyclQueueIdFixtureTest, SameQDifferentTemplatedKernelSameQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = true, use_same_kernel = false,
-                      templated_run = true);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-#if __INTEL_LLVM_COMPILER >= 20240101 || __LIBSYCL_MAJOR_VERSION >= 8
-  ASSERT_NE(queue_id_k1, (kMaxQueueId - 1));
-#endif
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_EQ(queue_id_k1, queue_id_k2);
-}
-
-#if __INTEL_LLVM_COMPILER >= 20240101 || __LIBSYCL_MAJOR_VERSION >= 8
-TEST_P(SyclQueueIdFixtureTest, DifferentQSameTemplatedKernelDifferentQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = true,
-                      templated_run = true);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_NE(queue_id_k1, queue_id_k2);
-}
-
-TEST_P(SyclQueueIdFixtureTest, DifferentQDifferentTemplatedKernelDifferentQID) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = false,
-                      templated_run = true);
-  ASSERT_NE(queue_id_k1, kMaxQueueId);
-  ASSERT_NE(queue_id_k2, 0ULL);
-  ASSERT_NE(queue_id_k1, queue_id_k2);
-}
-#else
-TEST_P(SyclQueueIdFixtureTest, InvalidQueueIDGeneratedAndUsed) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = false,
-                      templated_run = true);
-  ASSERT_EQ(queue_id_k1, (kMaxQueueId - 1));
-}
-#endif
-
-TEST_P(SyclQueueIdFixtureTest, QueueIDPresentInAllRecords) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = false,
-                      templated_run = false);
-  ASSERT_EQ(queue_id_kernel_records, true);
-  ASSERT_EQ(queue_id_memcpy_records, true);
-  ASSERT_EQ(queue_id_memfill_records, true);
-}
-
-#if __INTEL_LLVM_COMPILER >= 20240101 || __LIBSYCL_MAJOR_VERSION >= 8
-TEST_P(SyclQueueIdFixtureTest, STQueueIDsUniqueInLoopInstancesStackedQ) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdTests(use_immediate_command_lists_, use_same_q = false, use_same_kernel = false,
-                      templated_run = false, use_stacked_q = true);
-  ASSERT_EQ(mt_q_ids.size(), kThreadCount);
-}
-TEST_P(SyclQueueIdFixtureTest, MTQueueIDsUniqueInAllThreads) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdMtTests(use_immediate_command_lists_);
-  ASSERT_EQ(mt_q_ids.size(), kThreadCount);
-}
-
-TEST_P(SyclQueueIdFixtureTest, MTQueueIDsUniqueInAllThreadsStackedQ) {
-  EXPECT_EQ(ptiViewSetCallbacks(BufferRequested, BufferCompleted), pti_result::PTI_SUCCESS);
-  RunSyclQueueIdMtTests(use_immediate_command_lists_, use_stacked_q = true);
-  ASSERT_EQ(mt_q_ids.size(), kThreadCount);
-}
-#endif
-
-INSTANTIATE_TEST_SUITE_P(SyclQueueIdTests, SyclQueueIdFixtureTest, ::testing::Values(false, true),
-                         [](const testing::TestParamInfo<SyclQueueIdFixtureTest::ParamType> &info) {
-                           return fmt::format("Queue_Type_{}", (info.param ? "ImmediateQueue"
-                                                                           : "NonImmediateQueue"));
-                         });
-
-TEST(SyclInvalidQueueIdTest, InvalidQueueIdIsCorrect) {
-  constexpr uint64_t kValueFromDocComment = static_cast<uint64_t>(UINT64_MAX - 1);
-  constexpr auto kValueFromDocCommentStl = (std::numeric_limits<uint64_t>::max)() - 1;
-  constexpr uint64_t kIntegerValueForInvalidQueueId = static_cast<uint64_t>(-2);
-  EXPECT_EQ(PTI_INVALID_QUEUE_ID, kValueFromDocComment);
-  EXPECT_EQ(PTI_INVALID_QUEUE_ID, kValueFromDocCommentStl);
-  EXPECT_EQ(PTI_INVALID_QUEUE_ID, kIntegerValueForInvalidQueueId);
-  ASSERT_EQ(PTI_INVALID_QUEUE_ID, kMaxQueueId);
-}
diff --git a/sdk/test/test_metrics_scope_multiprocess.py b/sdk/test/test_metrics_scope_multiprocess.py
deleted file mode 100644
index 7c2d2413..00000000
--- a/sdk/test/test_metrics_scope_multiprocess.py
+++ /dev/null
@@ -1,303 +0,0 @@
-#!/usr/bin/env python3
-# ============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ============================================================
-#
-# Multi-process Metrics Scope test driver. Spawns two instances of the
-# metrics_scope sample concurrently, both running in auto-detect mode
-# (--devices=auto) but pinning the workload to different GPUs (--workload=0
-# and --workload=1). This exercises the auto-mode lazy profiler construction
-# path under genuine cross-process concurrency. Asserts that:
-#   1. both processes exited successfully,
-#   2. each captured exactly --repeat kernel records (one per GEMM repetition)
-#      and both workers produced the same record count,
-#   3. the wall-clock collection windows reported by the two processes overlap
-#      (i.e. they were collecting metrics at the same time).
-#
-# Skip (CTest SKIP_RETURN_CODE = 77) when the host has fewer than 2 L0 GPUs.
-
-import argparse
-import re
-import subprocess
-import sys
-from typing import List, Optional, Tuple
-
-PTI_MP_PREFIX = "[PTI_MP] "
-GPU_COUNT_KEY = "gpu_count"
-WINDOW_START_KEY = "collection_window_start_ns"
-WINDOW_STOP_KEY = "collection_window_stop_ns"
-# 77 is the GNU Autotools / CTest convention for "test skipped".
-SKIP_EXIT = 77
-
-
-def parse_pti_mp(stdout: str) -> dict:
-    out = {}
-    for line in stdout.splitlines():
-        if not line.startswith(PTI_MP_PREFIX):
-            continue
-        kv = line[len(PTI_MP_PREFIX) :]
-        if "=" not in kv:
-            continue
-        key, val = kv.split("=", 1)
-        out[key.strip()] = val.strip()
-    return out
-
-
-def count_collection_buffers(stdout: str) -> int:
-    m = re.search(r"Number of collection buffers used:\s*(\d+)", stdout)
-    return int(m.group(1)) if m else 0
-
-
-_KERNEL_HDR = re.compile(r"^\s*Kernel\s+(\d+):\s*$")
-_FIELD = re.compile(r"^\s+([^:]+?):\s*(.+?)\s*$")
-
-
-def parse_kernel_records(stdout: str) -> List[dict]:
-    # Walk the sample's "Kernel N:" / "      <field>: <value>" blocks. A
-    # blank line ends a record. We keep just ID + Kernel Name + metric values.
-    records: List[dict] = []
-    cur: Optional[dict] = None
-    for line in stdout.splitlines():
-        m = _KERNEL_HDR.match(line)
-        if m:
-            if cur is not None:
-                records.append(cur)
-            cur = {"index": int(m.group(1)), "fields": {}}
-            continue
-        if cur is None:
-            continue
-        if line.strip() == "":
-            records.append(cur)
-            cur = None
-            continue
-        fm = _FIELD.match(line)
-        if fm:
-            cur["fields"][fm.group(1)] = fm.group(2)
-    if cur is not None:
-        records.append(cur)
-    return records
-
-
-def short_kernel_name(name: str) -> str:
-    # Sample logs the full mangled SYCL kernel name; the trailing "::__GEMM_*"
-    # is the useful bit.
-    last = name.rsplit("::", 1)[-1]
-    return last if last else name
-
-
-def probe_gpu_count(binary: str) -> int:
-    proc = subprocess.run(
-        [
-            binary,
-            "--devices",
-            "auto",
-            "--workload",
-            "auto",
-            "--size",
-            "32",
-            "--repeat",
-            "1",
-        ],
-        capture_output=True,
-        text=True,
-        timeout=120,
-    )
-    info = parse_pti_mp(proc.stdout)
-    if GPU_COUNT_KEY not in info:
-        print(
-            f"[driver] probe could not parse {GPU_COUNT_KEY} from sample output. "
-            f"rc={proc.returncode}",
-            file=sys.stderr,
-        )
-        print("---- probe stdout ----", file=sys.stderr)
-        print(proc.stdout, file=sys.stderr)
-        print("---- probe stderr ----", file=sys.stderr)
-        print(proc.stderr, file=sys.stderr)
-        return 0
-    try:
-        return int(info[GPU_COUNT_KEY])
-    except ValueError:
-        return 0
-
-
-def spawn_worker(
-    binary: str, workload_index: int, size: int, repeat: int
-) -> subprocess.Popen:
-    cmd = [
-        binary,
-        "--devices",
-        "auto",
-        "--workload",
-        str(workload_index),
-        "--size",
-        str(size),
-        "--repeat",
-        str(repeat),
-    ]
-    return subprocess.Popen(
-        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-    )
-
-
-def windows_overlap(
-    a_start: int, a_stop: int, b_start: int, b_stop: int
-) -> Tuple[bool, int]:
-    overlap_start = max(a_start, b_start)
-    overlap_stop = min(a_stop, b_stop)
-    return overlap_start < overlap_stop, max(0, overlap_stop - overlap_start)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--sample-binary", required=True, help="Path to the metrics_scope executable"
-    )
-    parser.add_argument(
-        "--size",
-        type=int,
-        default=2048,
-        help="Matrix size; larger keeps the collection window open longer",
-    )
-    parser.add_argument(
-        "--repeat",
-        type=int,
-        default=4,
-        help="Per-device GEMM repetitions; larger widens the collection window",
-    )
-    parser.add_argument(
-        "--timeout",
-        type=int,
-        default=60,
-        help="Per-process wall-clock timeout in seconds; on expiry the "
-        "worker is killed and the test fails",
-    )
-    args = parser.parse_args()
-
-    gpu_count = probe_gpu_count(args.sample_binary)
-    if gpu_count < 2:
-        print(f"[driver] need >= 2 GPUs, found {gpu_count}; skipping", file=sys.stderr)
-        return SKIP_EXIT
-
-    procs = [
-        spawn_worker(
-            args.sample_binary, workload_index=0, size=args.size, repeat=args.repeat
-        ),
-        spawn_worker(
-            args.sample_binary, workload_index=1, size=args.size, repeat=args.repeat
-        ),
-    ]
-    workload_indices = [0, 1]
-
-    outs, errs, rcs = [], [], []
-    failed = False
-    for w_id, p in enumerate(procs):
-        try:
-            stdout, stderr = p.communicate(timeout=args.timeout)
-        except subprocess.TimeoutExpired:
-            p.kill()
-            stdout, stderr = p.communicate()
-            print(
-                f"[driver] worker {w_id} timed out after {args.timeout}s",
-                file=sys.stderr,
-            )
-            failed = True
-        outs.append(stdout)
-        errs.append(stderr)
-        rcs.append(p.returncode)
-
-    info = [parse_pti_mp(s) for s in outs]
-    buffers = [count_collection_buffers(s) for s in outs]
-    records = [parse_kernel_records(s) for s in outs]
-
-    starts: Optional[List[int]] = None
-    stops: Optional[List[int]] = None
-    try:
-        starts = [int(info[w][WINDOW_START_KEY]) for w in range(2)]
-        stops = [int(info[w][WINDOW_STOP_KEY]) for w in range(2)]
-    except (KeyError, ValueError) as e:
-        print(
-            f"[driver] failed to parse collection window markers: {e}", file=sys.stderr
-        )
-        failed = True
-
-    for w_id in range(2):
-        wl_handles = [
-            v for k, v in info[w_id].items() if k.startswith("workload_device_handle")
-        ]
-        wl_handle_str = ", ".join(wl_handles) if wl_handles else "?"
-        print(f"\n[driver] -- worker {w_id} ---------------------------------------")
-        print(f"[driver]   exit_code        = {rcs[w_id]}")
-        print(f"[driver]   profiled device  = auto")
-        print(
-            f"[driver]   workload device  = {workload_indices[w_id]} (handle {wl_handle_str})"
-        )
-        if starts is not None and stops is not None:
-            duration_ms = (stops[w_id] - starts[w_id]) / 1e6
-            print(
-                f"[driver]   window           = {starts[w_id]} -> {stops[w_id]} "
-                f"({duration_ms:.1f} ms)"
-            )
-        print(f"[driver]   buffers          = {buffers[w_id]}")
-        print(f"[driver]   records          = {len(records[w_id])}")
-        for rec in records[w_id]:
-            f = rec["fields"]
-            kid = f.get("ID", "?")
-            kname = short_kernel_name(f.get("Kernel Name", ""))
-            metrics = {k: v for k, v in f.items() if k not in {"ID", "Kernel Name"}}
-            metric_str = "  ".join(f"{k}={v}" for k, v in metrics.items())
-            print(
-                f"[driver]     kernel {rec['index']}  ID={kid}  {kname}  {metric_str}"
-            )
-
-    for w_id, rc in enumerate(rcs):
-        if rc != 0:
-            print(f"\n[driver] worker {w_id} exited with {rc}", file=sys.stderr)
-            failed = True
-    expected_records = args.repeat
-    for w_id, n in enumerate(records):
-        if len(n) != expected_records:
-            print(
-                f"[driver] worker {w_id} collected {len(n)} records, expected "
-                f"{expected_records}",
-                file=sys.stderr,
-            )
-            failed = True
-    if len(records[0]) != len(records[1]):
-        print(
-            f"[driver] worker record counts differ: {len(records[0])} vs "
-            f"{len(records[1])}",
-            file=sys.stderr,
-        )
-        failed = True
-
-    if starts is not None and stops is not None:
-        overlap_ok, overlap_ns = windows_overlap(
-            starts[0], stops[0], starts[1], stops[1]
-        )
-        overlap_ms = overlap_ns / 1_000_000.0
-        print(
-            f"\n[driver] overlap = {overlap_ms:.1f} ms"
-            + ("" if overlap_ok else "  [WORKERS DID NOT RUN IN PARALLEL]")
-        )
-        if not overlap_ok:
-            failed = True
-
-    if failed:
-        for w_id in range(2):
-            print(
-                f"\n========== worker {w_id} stdout (rc={rcs[w_id]}) ==========",
-                file=sys.stderr,
-            )
-            print(outs[w_id], file=sys.stderr)
-            if errs[w_id].strip():
-                print(f"========== worker {w_id} stderr ==========", file=sys.stderr)
-                print(errs[w_id], file=sys.stderr)
-        return 1
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/sdk/test/utils/gtest_helpers.h b/sdk/test/utils/gtest_helpers.h
deleted file mode 100644
index a7c95ad1..00000000
--- a/sdk/test/utils/gtest_helpers.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef TEST_UTILS_GTEST_HELPERS_H_
-#define TEST_UTILS_GTEST_HELPERS_H_
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#define ZE_ASSERT_SUCCESS_BUT_SKIP_UNSUPPORTED(X)                          \
-  do {                                                                     \
-    auto result = (X);                                                     \
-    if (result == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE ||                   \
-        result == ZE_RESULT_ERROR_UNSUPPORTED_VERSION) {                   \
-      GTEST_SKIP() << "Skipping test due to unsupported driver call: " #X; \
-    }                                                                      \
-    ASSERT_EQ(result, ZE_RESULT_SUCCESS);                                  \
-  } while (0)
-
-#endif  // TEST_UTILS_GTEST_HELPERS_H_
diff --git a/sdk/test/utils/pti_record_collection_fixture.h b/sdk/test/utils/pti_record_collection_fixture.h
deleted file mode 100644
index 58b287d1..00000000
--- a/sdk/test/utils/pti_record_collection_fixture.h
+++ /dev/null
@@ -1,144 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef TEST_UTILS_PTI_RECORD_COLLECTION_FIXTURE_H_
-#define TEST_UTILS_PTI_RECORD_COLLECTION_FIXTURE_H_
-
-#include <gtest/gtest.h>
-
-#include <cstddef>
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "test_helpers.h"
-
-namespace pti::test::utils {
-
-class RecordCollectionFixture : public virtual ::testing::Test {
- protected:
-  RecordCollectionFixture() { record_storage_.Reset(); }
-
-  struct CollectedRecords {
-    void Reset() {
-      kernel_records.clear();
-      memcpy_records.clear();
-      p2p_memcpy_records.clear();
-      memfill_records.clear();
-      api_records.clear();
-      const std::lock_guard<std::mutex> lock(buffers_mtx);
-      buffers.clear();
-    }
-
-    mutable std::mutex buffers_mtx;
-    std::unordered_map<unsigned char*, PtiViewBuffer> buffers;
-    std::vector<const pti_view_record_kernel*> kernel_records;
-    std::vector<const pti_view_record_memory_copy*> memcpy_records;
-    std::vector<const pti_view_record_memory_copy_p2p*> p2p_memcpy_records;
-    std::vector<const pti_view_record_memory_fill*> memfill_records;
-    std::vector<const pti_view_record_api*> api_records;
-  };
-
-  static void ProvideBuffer(unsigned char** buf, size_t* buf_size) {
-    auto buffer = PtiViewBuffer(kRequestedBufferSize);
-    if (!buffer.Valid()) {
-      FAIL() << "Unable to allocate buffer for PTI tracing";
-    }
-    *buf = buffer.data();
-    *buf_size = buffer.size();
-
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    record_storage_.buffers[*buf] = std::move(buffer);
-  }
-
-  static void MarkBuffer(unsigned char* buf, size_t /*buf_size*/, size_t used_bytes) {
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    if (auto it = record_storage_.buffers.find(buf); it != record_storage_.buffers.end()) {
-      it->second.SetUsedBytes(used_bytes);
-    }
-  }
-
-  static void HandleView(pti_view_record_base* view) {
-    switch (view->_view_kind) {
-      case PTI_VIEW_DEVICE_GPU_KERNEL:
-        record_storage_.kernel_records.push_back(
-            reinterpret_cast<const pti_view_record_kernel*>(view));
-        break;
-      case PTI_VIEW_DEVICE_GPU_MEM_COPY:
-        record_storage_.memcpy_records.push_back(
-            reinterpret_cast<const pti_view_record_memory_copy*>(view));
-        break;
-      case PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P:
-        record_storage_.p2p_memcpy_records.push_back(
-            reinterpret_cast<const pti_view_record_memory_copy_p2p*>(view));
-        break;
-      case PTI_VIEW_DEVICE_GPU_MEM_FILL:
-        record_storage_.memfill_records.push_back(
-            reinterpret_cast<const pti_view_record_memory_fill*>(view));
-        break;
-      case PTI_VIEW_RUNTIME_API:
-        record_storage_.api_records.push_back(reinterpret_cast<const pti_view_record_api*>(view));
-        break;
-      case PTI_VIEW_DRIVER_API:
-        record_storage_.api_records.push_back(reinterpret_cast<const pti_view_record_api*>(view));
-        break;
-      default:
-        break;
-    }
-  }
-
-  static void ParseBuffer(unsigned char* buf, size_t used_bytes) {
-    pti_view_record_base* record = nullptr;
-    while (true) {
-      auto status = ptiViewGetNextRecord(buf, used_bytes, &record);
-      if (status == pti_result::PTI_STATUS_END_OF_BUFFER) {
-        break;
-      }
-      if (status != pti_result::PTI_SUCCESS) {
-        FAIL() << "Failed to parse PTI record";
-        break;
-      }
-      HandleView(record);
-    }
-  }
-
-  static void ParseAllBuffers() {
-    const std::lock_guard<std::mutex> lock(record_storage_.buffers_mtx);
-    for (auto& [_, buffer] : record_storage_.buffers) {
-      ParseBuffer(buffer.data(), buffer.UsedBytes());
-    }
-  }
-
-  // Intentionally left out of constructor for flexibility.
-  static void InitCollection() {
-    EXPECT_EQ(ptiViewSetCallbacks(ProvideBuffer, MarkBuffer), PTI_SUCCESS);
-  }
-
-  template <typename... E>
-  void EnableViews(E... view_kinds) {
-    ([&] { EXPECT_EQ(ptiViewEnable(view_kinds), PTI_SUCCESS); }(), ...);
-    (enabled_views_.push_back(view_kinds), ...);
-  }
-
-  void FinalizeCollection() {
-    for (auto view_kind : enabled_views_) {
-      EXPECT_EQ(ptiViewDisable(view_kind), PTI_SUCCESS);
-    }
-    EXPECT_EQ(ptiFlushAllViews(), PTI_SUCCESS);
-    ParseAllBuffers();
-  }
-
-  inline static CollectedRecords record_storage_{};
-
-  constexpr static std::size_t kRequestedBufferSize = 1024 * 10;  // 10 KB should be fine. We're
-                                                                  // storing the buffers anyways.
-  std::vector<pti_view_kind> enabled_views_;
-};
-
-}  // namespace pti::test::utils
-
-#endif  // TEST_UTILS_PTI_RECORD_COLLECTION_FIXTURE_H_
diff --git a/sdk/test/utils/sycl_config_info.h b/sdk/test/utils/sycl_config_info.h
deleted file mode 100644
index 37f78730..00000000
--- a/sdk/test/utils/sycl_config_info.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef TEST_UTILS_SYCL_CONFIG_INFO_H_
-#define TEST_UTILS_SYCL_CONFIG_INFO_H_
-
-#include <level_zero/ze_api.h>
-
-#include <sycl/ext/oneapi/backend/level_zero.hpp>
-#include <sycl/sycl.hpp>
-#include <variant>
-
-#include "pti/pti_view.h"
-#include "ze_config_info.h"
-
-#if defined(__SYCL_COMPILER_VERSION) && defined(__LIBSYCL_MAJOR_VERSION)
-#if __SYCL_COMPILER_VERSION >= 20260724 && __LIBSYCL_MAJOR_VERSION >= 9
-#define PTI_TEST_NATIVE_GRAPH_RECORDING_API_AVAILABLE
-#endif
-#endif
-
-namespace pti::test::utils {
-[[nodiscard]] inline bool IsIntegratedGraphics(const sycl::device& device) {
-  if (!device.is_gpu()) {
-    return false;
-  }
-
-  // Ideally, we want get_info<sycl::info::device::host_unified_memory> or
-  // to do this via sycl but that seems to be deprecated with no replacement.
-  bool result = false;
-  if (device.get_backend() == sycl::backend::ext_oneapi_level_zero) {
-    auto* device_handle = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(device);
-    result = level_zero::CheckIntegratedGraphics(device_handle);
-  }
-
-  // TODO(PTI): add supported backends as they come and move implementation to .cc
-
-  return result;
-}
-
-[[nodiscard]] inline bool CommandListVisitAvailable() {
-  return level_zero::CommandListVisitAvailable();
-}
-
-[[nodiscard]] inline bool NativeGraphApisAvailable() {
-  return level_zero::NativeGraphApisAvailable();
-}
-
-[[nodiscard]] inline pti_backend_queue_t GetLevelZeroBackendQueue(sycl::queue& queue) {
-  pti_backend_queue_t backend_queue = nullptr;
-  auto queue_type = sycl::get_native<sycl::backend::ext_oneapi_level_zero>(queue);
-
-  if (auto* ptr_queue_handle = std::get_if<ze_command_list_handle_t>(&queue_type)) {
-    backend_queue = static_cast<pti_backend_queue_t>(*ptr_queue_handle);
-  } else if (auto* ptr_queue_handle = std::get_if<ze_command_queue_handle_t>(&queue_type)) {
-    backend_queue = static_cast<pti_backend_queue_t>(*ptr_queue_handle);
-  }
-  return backend_queue;
-}
-
-}  // namespace pti::test::utils
-
-#endif  // TEST_UTILS_SYCL_CONFIG_INFO_H_
diff --git a/sdk/test/utils/sycl_usm_helper.h b/sdk/test/utils/sycl_usm_helper.h
deleted file mode 100644
index f811f114..00000000
--- a/sdk/test/utils/sycl_usm_helper.h
+++ /dev/null
@@ -1,39 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_UTILS_SYCL_USM_HELPER_H_
-#define TEST_UTILS_SYCL_USM_HELPER_H_
-
-#include <cstddef>
-#include <memory>
-#include <sycl/sycl.hpp>
-
-namespace pti::test::utils {
-
-struct SyclUsmFree {
-  sycl::queue queue_;
-  void operator()(void* ptr) const { sycl::free(ptr, queue_); }
-};
-
-template <typename T>
-using SyclUsmVector = std::unique_ptr<T, SyclUsmFree>;
-
-template <typename T>
-SyclUsmVector<T> CreateDeviceUsmVector(sycl::queue& queue, std::size_t vector_size) {
-  return SyclUsmVector<T>(sycl::malloc_device<T>(vector_size, queue), SyclUsmFree{queue});
-}
-
-template <typename T>
-SyclUsmVector<T> CreateSharedUsmVector(sycl::queue& queue, std::size_t vector_size) {
-  return SyclUsmVector<T>(sycl::malloc_shared<T>(vector_size, queue), SyclUsmFree{queue});
-}
-
-template <typename T>
-SyclUsmVector<T> CreateHostUsmVector(sycl::queue& queue, std::size_t vector_size) {
-  return SyclUsmVector<T>(sycl::malloc_host<T>(vector_size, queue), SyclUsmFree{queue});
-}
-
-}  // namespace pti::test::utils
-#endif  // TEST_UTILS_SYCL_USM_HELPER_H_
diff --git a/sdk/test/utils/test_helpers.h b/sdk/test/utils/test_helpers.h
deleted file mode 100644
index edbfafb3..00000000
--- a/sdk/test/utils/test_helpers.h
+++ /dev/null
@@ -1,337 +0,0 @@
-#ifndef TEST_UTILS_TEST_HELPERS_H_
-#define TEST_UTILS_TEST_HELPERS_H_
-
-#include <stdlib.h>
-
-#include <algorithm>
-#include <array>
-#include <cstdlib>
-#include <cstring>
-#include <functional>
-#include <initializer_list>
-#include <iostream>
-#include <memory>
-#include <ostream>
-#include <type_traits>
-#include <vector>
-
-#include "pti/pti_version.h"
-#include "pti/pti_view.h"
-
-// Use V2 record types when PTI version > 0.17
-#if (PTI_VERSION_MAJOR > 0) || (PTI_VERSION_MAJOR == 0 && PTI_VERSION_MINOR > 17)
-using pti_view_record_kernel_type = pti_view_record_kernel_v2;
-using pti_view_record_memory_copy_type = pti_view_record_memory_copy_v2;
-using pti_view_record_memory_fill_type = pti_view_record_memory_fill_v2;
-using pti_view_record_memory_copy_p2p_type = pti_view_record_memory_copy_p2p_v2;
-#else
-using pti_view_record_kernel_type = pti_view_record_kernel;
-using pti_view_record_memory_copy_type = pti_view_record_memory_copy;
-using pti_view_record_memory_fill_type = pti_view_record_memory_fill;
-using pti_view_record_memory_copy_p2p_type = pti_view_record_memory_copy_p2p;
-#endif
-
-// Needs to be in the same namespace as pti_result so leave it outside.
-inline std::ostream& operator<<(std::ostream& out, pti_result result_val) {
-  out << ptiResultTypeToString(result_val);
-  return out;
-}
-
-inline std::ostream& operator<<(std::ostream& out, pti_view_kind view_kind) {
-  switch (view_kind) {
-    case pti_view_kind::PTI_VIEW_INVALID: {
-      out << "PTI_VIEW_INVALID";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL: {
-      out << "PTI_VIEW_DEVICE_GPU_KERNEL";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_CPU_KERNEL: {
-      out << "PTI_VIEW_DEVICE_CPU_KERNEL";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY: {
-      out << "PTI_VIEW_DEVICE_GPU_MEM_COPY";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P: {
-      out << "PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD: {
-      out << "PTI_VIEW_COLLECTION_OVERHEAD";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL: {
-      out << "PTI_VIEW_DEVICE_GPU_MEM_FILL";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DRIVER_API: {
-      out << "PTI_VIEW_DRIVER_API";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_RUNTIME_API: {
-      out << "PTI_VIEW_RUNTIME_API";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_RESERVED: {
-      out << "PTI_VIEW_RESERVED";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_DEVICE_SYNCHRONIZATION: {
-      out << "PTI_VIEW_DEVICE_SYNCHRONIZATION";
-      break;
-    }
-    case pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION: {
-      out << "PTI_VIEW_EXTERNAL_CORRELATION";
-      break;
-    }
-    default: {
-      out << "UNKNOWN_VIEW";
-      break;
-    }
-  }
-  return out;
-}
-
-namespace pti::test::utils {
-
-template <typename... T>
-constexpr std::size_t ValidateTimestamps(T... args) {
-  using TimestampType = std::common_type_t<T...>;
-  constexpr auto count = sizeof...(args);
-  static_assert(count > 1, "Must provide more than one timestamp to validate");
-  std::size_t found_issues = 0;
-  TimestampType prev_stamp = 0;
-  (
-      [&] {
-        auto next_stamp = args;
-        if (!(prev_stamp <= next_stamp)) {
-          found_issues++;
-        }
-        prev_stamp = next_stamp;
-      }(),
-      ...);
-  return found_issues;
-}
-
-constexpr auto SizeOfLargestViewRecord() {
-  constexpr std::array kViewSizeLookupTable{
-      sizeof(pti_view_record_kernel_v2),             // PTI_VIEW_DEVICE_GPU_KERNEL
-      sizeof(pti_view_record_api),                   // PTI_VIEW_LEVEL_ZERO_CALLS
-      sizeof(pti_view_record_overhead),              // PTI_VIEW_COLLECTION_OVERHEAD
-      sizeof(pti_view_record_api),                   // PTI_VIEW_SYCL_RUNTIME_CALLS
-      sizeof(pti_view_record_external_correlation),  // PTI_VIEW_EXTERNAL_CORRELATION
-      sizeof(pti_view_record_memory_copy_v2),        // PTI_VIEW_DEVICE_GPU_MEM_COPY
-      sizeof(pti_view_record_memory_fill_v2),        // PTI_VIEW_DEVICE_GPU_MEM_FILL
-      sizeof(pti_view_record_memory_copy_p2p_v2),    // PTI_VIEW_DEVICE_GPU_MEM_COPY_P2P
-      sizeof(pti_view_record_synchronization),       // PTI_VIEW_DEVICE_SYNCHRONIZATION
-      sizeof(pti_view_record_comms),                 // PTI_VIEW_COMMUNICATION
-  };
-  return *std::max_element(kViewSizeLookupTable.begin(), kViewSizeLookupTable.end());
-}
-
-constexpr int ValidateNoBigGapBetweenTimestampsNs(uint64_t gap_in_ns,
-                                                  std::initializer_list<uint64_t> stamps) {
-  if (stamps.size() < 2) {
-    return -1;
-  }
-  int found_issues = 0;
-  auto it = stamps.begin();
-  auto prev_stamp = *it;
-  for (++it; it != stamps.end(); it++) {
-    auto next_stamp = *it;
-    if (next_stamp > prev_stamp + gap_in_ns) {
-      std::cout << "prev_stamp: " << prev_stamp << "\n"
-                << "next_stamp: " << next_stamp << std::endl;
-      found_issues++;
-    }
-    prev_stamp = next_stamp;
-  }
-  return found_issues;
-}
-
-[[nodiscard]] inline std::string GetEnv(const char* name) {
-  if (name == nullptr) {
-    return std::string();
-  }
-#if defined(_WIN32)
-  char* value = nullptr;
-  size_t env_buf_size = 0;
-  auto status = _dupenv_s(&value, &env_buf_size, name);
-  std::unique_ptr<std::remove_pointer_t<decltype(value)>, decltype(&free)> value_buf(value, &free);
-  if (status || value == nullptr || env_buf_size == 0) {
-    return std::string();
-  }
-  auto result = std::string(value_buf.get(), env_buf_size - 1);
-  return result;
-#else
-  const char* value = getenv(name);
-  if (value == nullptr) {
-    return std::string();
-  }
-  return std::string(value);
-#endif
-}
-
-inline constexpr auto kDefaultPtiBufferAlignment = std::align_val_t{1};
-
-template <typename T>
-[[nodiscard]] inline T* AlignedAlloc(std::size_t size, std::align_val_t align) {
-  try {
-    return static_cast<T*>(::operator new(size, align));
-  } catch (const std::bad_alloc& e) {
-    std::cerr << "Alloc failed " << e.what() << '\n';
-    return nullptr;
-  }
-}
-
-template <typename T>
-inline void AlignedDealloc(T* buf_ptr, std::align_val_t align) {
-  try {
-    ::operator delete(buf_ptr, align);
-  } catch (...) {
-    std::cerr << "DeAlloc failed, abort" << '\n';
-    std::abort();
-  }
-}
-
-template <typename T>
-[[nodiscard]] inline T* AlignedAlloc(std::size_t size) {
-  return AlignedAlloc<T>(size, kDefaultPtiBufferAlignment);
-}
-
-template <typename T>
-inline void AlignedDealloc(T* buf_ptr) {
-  return AlignedDealloc<T>(buf_ptr, kDefaultPtiBufferAlignment);
-}
-
-class PtiViewBuffer {
- public:
-  using UnderlyingType = unsigned char;
-  using BufferType = std::unique_ptr<UnderlyingType, std::function<void(UnderlyingType*)>>;
-
-  PtiViewBuffer() = default;
-
-  explicit PtiViewBuffer(size_t size) : size_(size) {
-    UnderlyingType* pti_buffer = AlignedAlloc<UnderlyingType>(size);
-    if (pti_buffer) {
-      buffer_ = BufferType{pti_buffer, [](UnderlyingType* ptr) { AlignedDealloc(ptr); }};
-    }
-  }
-
-  UnderlyingType* data() {  // NOLINT
-    return buffer_.get();
-  }
-
-  size_t size() const {  // NOLINT
-    return size_;
-  }
-
-  bool Valid() const { return buffer_ != nullptr; }
-
-  void SetUsedBytes(std::size_t used_bytes) { used_bytes_ = used_bytes; }
-
-  std::size_t UsedBytes() const { return used_bytes_; }
-
- private:
-  std::size_t size_ = 0;
-  std::size_t used_bytes_ = 0;
-  BufferType buffer_ = nullptr;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Helper functions for creating "empty" view records.
-template <typename T>
-inline void Zeroize(T& item) {
-  static_assert(std::is_trivially_copyable<T>::value,
-                "Can't zeroize an object that's not trivially copyable");
-  std::memset(&item, 0, sizeof(T));
-}
-
-template <typename T, pti_view_kind E>
-inline auto CreateRecord() {
-  T record = {};
-  Zeroize(record);
-  record._view_kind._view_kind = E;
-  return record;
-}
-
-template <typename T>
-inline T CreateRecord() {
-  return CreateRecord<T, pti_view_kind::PTI_VIEW_INVALID>();
-}
-
-template <pti_view_kind E>
-inline auto CreateRecord() {
-  return CreateRecord<pti_view_record_kernel_type, E>();
-}
-
-template <>
-inline pti_view_record_memory_copy_type CreateRecord() {
-  return CreateRecord<pti_view_record_memory_copy_type,
-                      pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_COPY>();
-}
-
-template <>
-inline pti_view_record_memory_fill_type CreateRecord() {
-  return CreateRecord<pti_view_record_memory_fill_type,
-                      pti_view_kind::PTI_VIEW_DEVICE_GPU_MEM_FILL>();
-}
-
-template <>
-inline pti_view_record_kernel_type CreateRecord() {
-  return CreateRecord<pti_view_record_kernel_type, pti_view_kind::PTI_VIEW_DEVICE_GPU_KERNEL>();
-}
-
-template <>
-inline pti_view_record_overhead CreateRecord() {
-  return CreateRecord<pti_view_record_overhead, pti_view_kind::PTI_VIEW_COLLECTION_OVERHEAD>();
-}
-
-template <>
-inline pti_view_record_api CreateRecord() {
-  return CreateRecord<pti_view_record_api, pti_view_kind::PTI_VIEW_RUNTIME_API>();
-}
-
-template <>
-inline pti_view_record_external_correlation CreateRecord() {
-  return CreateRecord<pti_view_record_external_correlation,
-                      pti_view_kind::PTI_VIEW_EXTERNAL_CORRELATION>();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Helper functions for creating buffers based on view record type.
-template <typename T, std::size_t N>
-struct RecordInserts {
-  using Type = T;
-  constexpr static std::size_t kNumber = N;
-};
-
-template <typename... RecordInsert>
-inline std::vector<unsigned char> CreateEmptyBuffer() {
-  std::size_t buffer_size = 0;
-  ((buffer_size += (RecordInsert::kNumber * sizeof(typename RecordInsert::Type))), ...);
-  return std::vector<unsigned char>(buffer_size);
-}
-
-template <typename... RecordInsert>
-inline std::vector<unsigned char> CreateFullBuffer() {
-  auto result_vec = CreateEmptyBuffer<RecordInsert...>();
-  std::size_t buffer_pos = 0;
-  (
-      [&] {
-        for (std::size_t i = 0; i < RecordInsert::kNumber; ++i) {
-          const auto record = CreateRecord<typename RecordInsert::Type>();
-          constexpr auto record_size = sizeof(typename RecordInsert::Type);
-          std::memcpy(result_vec.data() + buffer_pos, &record, record_size);
-          buffer_pos += record_size;
-        }
-      }(),
-      ...);
-  return result_vec;
-}
-}  // namespace pti::test::utils
-
-#endif  // TEST_UTILS_TEST_HELPERS_H_
diff --git a/sdk/test/utils/ze_config_info.h b/sdk/test/utils/ze_config_info.h
deleted file mode 100644
index 80732ee6..00000000
--- a/sdk/test/utils/ze_config_info.h
+++ /dev/null
@@ -1,108 +0,0 @@
-#ifndef TEST_UTILS_ZE_CONFIG_INFO_H_
-#define TEST_UTILS_ZE_CONFIG_INFO_H_
-
-#include <level_zero/loader/ze_loader.h>
-#include <level_zero/ze_api.h>
-
-#include <algorithm>
-#include <cstdint>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <vector>
-
-#include "pti_assert.h"
-#include "test_helpers.h"
-#include "utils/ze_utils.h"
-
-inline bool operator>=(const zel_version_t& left, const zel_version_t& right) {
-  bool same_major_version = left.major == right.major;
-  return (same_major_version && left.minor > right.minor) ||
-         (same_major_version && left.minor == right.minor && left.patch >= right.patch) ||
-         (left.major > right.major);
-}
-
-namespace pti::test::utils::level_zero {
-
-inline constexpr zel_version_t kProperLoaderVersionForZeInitDrivers = {1, 19, 2};
-inline constexpr zel_version_t kProperLoaderVersionForZesInit = {1, 16, 0};
-inline constexpr uint32_t kBmgIpVersion = 0x05004000;
-inline constexpr std::string_view kCommandVisitExtName = "ZE_extension_command_visit";
-inline constexpr std::string_view kNativeGraphExt = "ZE_extension_record_replay_graph";
-
-[[nodiscard]] inline bool FlatCommandListRecordingEnabled() {
-  static constexpr std::string_view kPositiveValue = "1";
-  return GetEnv("NEOReadDebugKeys") == kPositiveValue &&
-         GetEnv("ExperimentalFlatCommandListApiRecording") == kPositiveValue;
-}
-
-[[nodiscard]] inline bool CommandListVisitSupported() {
-  const auto drivers = ::utils::ze::GetDriverList();
-  return std::any_of(std::cbegin(drivers), std::cend(drivers), [](auto* const driver) {
-    return ::utils::ze::IsDriverExtensionSupported(driver, kCommandVisitExtName);
-  });
-}
-
-[[nodiscard]] inline bool CommandListVisitAvailable() {
-  return FlatCommandListRecordingEnabled() && CommandListVisitSupported();
-}
-
-[[nodiscard]] inline bool NativeGraphApisSupported() {
-  const auto drivers = ::utils::ze::GetDriverList();
-  return std::any_of(std::cbegin(drivers), std::cend(drivers), [](auto* const driver) {
-    return ::utils::ze::IsDriverExtensionSupported(driver, kNativeGraphExt);
-  });
-}
-
-[[nodiscard]] inline bool NativeGraphApisAvailable() { return NativeGraphApisSupported(); }
-
-[[nodiscard]] inline bool CheckIntegratedGraphics(ze_device_handle_t device) {
-  ze_device_properties_t device_props{};
-  auto return_cd = zeDeviceGetProperties(device, &device_props);
-  if (return_cd != ZE_RESULT_SUCCESS) {
-    std::string err_msg =
-        "Failed to get device properties, device returned: " + std::to_string(return_cd);
-    throw std::runtime_error(err_msg);
-  }
-  return static_cast<bool>(device_props.flags & ZE_DEVICE_PROPERTY_FLAG_INTEGRATED);
-}
-
-[[nodiscard]] inline int GetGroupOrdinals(ze_device_handle_t device, uint32_t& compute_ordinal,
-                                          uint32_t& copy_ordinal) {
-  // Discover all command queue groups
-  uint32_t cmdqueue_group_count = 0;
-  ze_result_t status =
-      zeDeviceGetCommandQueueGroupProperties(device, &cmdqueue_group_count, nullptr);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  std::vector<ze_command_queue_group_properties_t> cmdqueue_group_props(cmdqueue_group_count);
-  for (auto& prop : cmdqueue_group_props) {
-    prop.stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_GROUP_PROPERTIES;
-    prop.pNext = nullptr;
-  }
-  status = zeDeviceGetCommandQueueGroupProperties(device, &cmdqueue_group_count,
-                                                  cmdqueue_group_props.data());
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  // Find command queues that support compute and copy
-  compute_ordinal = cmdqueue_group_count;
-  copy_ordinal = cmdqueue_group_count;
-  for (uint32_t i = 0; i < cmdqueue_group_count; ++i) {
-    if (cmdqueue_group_props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
-      compute_ordinal = i;
-    }
-    if (cmdqueue_group_props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY) {
-      copy_ordinal = i;
-    }
-  }
-  if (compute_ordinal == cmdqueue_group_count || copy_ordinal == cmdqueue_group_count) {
-    std::cout << "No compute or copy command queue group found" << std::endl;
-    return 1;
-  }
-  return 0;
-}
-
-}  // namespace pti::test::utils::level_zero
-
-#endif  // TEST_UTILS_ZE_CONFIG_INFO_H_
diff --git a/sdk/test/utils/ze_memory_helper.h b/sdk/test/utils/ze_memory_helper.h
deleted file mode 100644
index 3b9e77f5..00000000
--- a/sdk/test/utils/ze_memory_helper.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef TEST_UTILS_ZE_MEMORY_HELPER_H_
-#define TEST_UTILS_ZE_MEMORY_HELPER_H_
-
-#include <level_zero/ze_api.h>
-
-#include <cstddef>
-#include <memory>
-
-namespace pti::test::utils {
-
-struct ZeMemFree {
-  ze_context_handle_t context_ = nullptr;
-  void operator()(void* ptr) const {
-    if (context_ && ptr) {
-      zeMemFree(context_, ptr);
-    }
-  }
-};
-
-template <typename T>
-using ZeMemVector = std::unique_ptr<T, ZeMemFree>;
-
-template <typename T>
-ZeMemVector<T> CreateDeviceMemVector(ze_context_handle_t context, ze_device_handle_t device,
-                                     std::size_t vector_size, std::size_t alignment = alignof(T)) {
-  void* storage = nullptr;
-  const ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr,
-                                                 0, 0};
-  auto result =
-      zeMemAllocDevice(context, &alloc_desc, vector_size * sizeof(T), alignment, device, &storage);
-
-  if (result != ZE_RESULT_SUCCESS) {
-    return ZeMemVector<T>(nullptr, ZeMemFree{context});
-  }
-
-  return ZeMemVector<T>(static_cast<T*>(storage), ZeMemFree{context});
-}
-
-template <typename T>
-ZeMemVector<T> CreateSharedMemVector(ze_context_handle_t context, ze_device_handle_t device,
-                                     std::size_t vector_size, std::size_t alignment = alignof(T)) {
-  void* storage = nullptr;
-  const ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr,
-                                                 0, 0};
-  const ze_host_mem_alloc_desc_t host_alloc_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr,
-                                                    0};
-  auto result = zeMemAllocShared(context, &alloc_desc, &host_alloc_desc, vector_size * sizeof(T),
-                                 alignment, device, &storage);
-
-  if (result != ZE_RESULT_SUCCESS) {
-    return ZeMemVector<T>(nullptr, ZeMemFree{context});
-  }
-
-  return ZeMemVector<T>(static_cast<T*>(storage), ZeMemFree{context});
-}
-
-template <typename T>
-ZeMemVector<T> CreateHostMemVector(ze_context_handle_t context, std::size_t vector_size,
-                                   std::size_t alignment = alignof(T)) {
-  void* storage = nullptr;
-  const ze_host_mem_alloc_desc_t host_alloc_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr,
-                                                    0};
-  auto result =
-      zeMemAllocHost(context, &host_alloc_desc, vector_size * sizeof(T), alignment, &storage);
-  if (result != ZE_RESULT_SUCCESS) {
-    return ZeMemVector<T>(nullptr, ZeMemFree{context});
-  }
-  return ZeMemVector<T>(static_cast<T*>(storage), ZeMemFree{context});
-}
-
-}  // namespace pti::test::utils
-#endif  // TEST_UTILS_ZE_MEMORY_HELPER_H_
diff --git a/sdk/test/utils/ze_symbol_loader.h b/sdk/test/utils/ze_symbol_loader.h
deleted file mode 100644
index d76edaa9..00000000
--- a/sdk/test/utils/ze_symbol_loader.h
+++ /dev/null
@@ -1,49 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef TEST_UTILS_ZE_SYMBOL_LOADER_H_
-#define TEST_UTILS_ZE_SYMBOL_LOADER_H_
-
-#include <level_zero/ze_api.h>
-
-#include <exception>
-
-#include "utils/library_loader.h"
-
-namespace pti::test::utils::level_zero {
-
-#if defined(_WIN32)
-inline constexpr const char* const kZeLoaderName = "ze_loader.dll";
-#else
-inline constexpr const char* const kZeLoaderName = "libze_loader.so.1";
-#endif
-
-class ZeSymbolLoader {
- public:
-  [[nodiscard]] bool Loaded() const { return loaded_; }
-
-  template <typename ZeSym>
-  [[nodiscard]] ZeSym Get(const char* name) {
-    return Loaded() ? loader_.GetSymbol<ZeSym>(name) : nullptr;
-  }
-
-  ZeSymbolLoader() {
-    try {
-      loader_ = LibraryLoader{kZeLoaderName};
-      loaded_ = true;
-    } catch (const std::exception&) {
-      loaded_ = false;
-    }
-  }
-
- private:
-  LibraryLoader loader_;
-  bool loaded_ = false;
-};
-
-}  // namespace pti::test::utils::level_zero
-
-#endif  // TEST_UTILS_ZE_SYMBOL_LOADER_H_
diff --git a/sdk/test/validate_sycl_api_ids.py b/sdk/test/validate_sycl_api_ids.py
deleted file mode 100644
index cc772751..00000000
--- a/sdk/test/validate_sycl_api_ids.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-"""
-Utility script for validating PTI and SYCL API IDs.
-
-This script can validate SYCL API IDs against the PTI IDs for SYCL APIs. The
-current PTI IDs are Unified Runtime (UR) IDs. We parse the UR headers and
-generate interoperable IDs.
-
-TODO: Extend for Intel(R) Level Zero API IDs?
-"""
-
-import argparse
-import pathlib
-import sys
-import typing
-
-DEFAULT_PTI_SYCL_API_ID_PUBLIC_HEADER = ["pti/pti_runtime_sycl_api_ids.h"]
-DEFAULT_UNIFIED_RUNTIME_PUBLIC_HEADERS = ["ur_api.h", "sycl/ur_api.h"]
-
-
-def get_public_header_file_path(
-    include_dir: pathlib.Path, header_names: typing.List[str]
-) -> pathlib.Path:
-    """Get the full path to a public header file.
-
-    Args:
-        include_dir (pathlib.Path): The base include directory.
-        header_names (typing.List[str]): The name of the header file. The first
-                                        element in the list takes priority,
-                                        the rest are fallbacks. If none of the
-                                        files are found, an exception is raised.
-
-    Returns:
-        Full path to the header file
-
-    """
-
-    if not include_dir.exists():
-        raise FileNotFoundError(f"Include directory {include_dir} does not exist")
-
-    if include_dir.is_file():  # If a file is given, return it directly
-        return include_dir
-
-    path_to_header = None
-    for header in header_names:
-        header_path = include_dir / header
-        if header_path.exists() and header_path.is_file():
-            path_to_header = header_path
-            break
-
-    if not path_to_header:
-        raise FileNotFoundError(
-            f"None of the specified headers {header_names} were found in {include_dir}"
-        )
-
-    return path_to_header
-
-
-class InternalParsingError(Exception):
-    pass
-
-
-class ApiIdRulesViolationError(Exception):
-    pass
-
-
-class DuplicatedApiIdError(ApiIdRulesViolationError):
-    pass
-
-
-def extract_c_enum_and_value(line: str) -> typing.Tuple[str, int]:
-    """Extract enum name and value from a line.
-
-    Args:
-        line (str): Line containing enum definition.
-
-    Returns:
-        Tuple of enum name and value.
-    """
-    # Example: ApiName_id = 123, -> ('ApiName_id', '123')
-    # i.e., remove everything after comma (avoid comments) and split by '='
-    processed_line = tuple("".join(line.strip().split(",")[:-1]).split("="))
-    api_name = processed_line[0].strip()
-    api_id_value = int(processed_line[1].strip())
-
-    return api_name, api_id_value
-
-
-class PtiApiIdValidator:
-    """
-    Class for validating SYCL API IDs against PTI API IDs.
-    """
-
-    # PTI Defaults.
-    DEFAULT_PTI_SYCL_API_ID_ENUM_START = "typedef enum _pti_api_id_runtime_sycl"
-
-    # SYCL/UR Defaults.
-    DEFAULT_UR_API_NAME_COMMENT_PREFIX = "Enumerator for ::"
-    DEFAULT_UR_API_ID_ENUM_START = "typedef enum ur_function_t"
-
-    # 'Recycled' (Broken!) API Ids due to URT-967.
-    UR_API_RECYCLE_LIST = [
-        "urCommandBufferEnqueueExp",  # 2025.0 (id: 128) -> 2025.1 (id: 242) -> 2025.2 (doesn't exist, however, changed to urEnqueueCommandBufferExp)
-        "urBindlessImagesMapExternalLinearMemoryExp",  # 2025.0 (id: 231) -> 2025.1 (id: 245)
-    ]
-
-    def __init__(
-        self,
-        pti_include_file: pathlib.Path,
-    ):
-        self.__pti_ur_api_ids_to_api_map: typing.Dict[int, str] = dict()
-        self.__pti_ur_api_to_ids_map: typing.Dict[str, int] = dict()
-        self.__load_pti_api_ids(pti_include_file)
-
-    def load_sycl_api_ids(self, ur_include_file: pathlib.Path, raise_on_error: bool):
-        found_api_id_enum = False
-        current_api_name = None
-        with ur_include_file.open("r") as include_file:
-            for number, line in enumerate(include_file, 1):
-                if not found_api_id_enum and self.DEFAULT_UR_API_ID_ENUM_START in line:
-                    found_api_id_enum = True
-                elif found_api_id_enum and "FORCE_UINT32" in line:
-                    break
-                elif found_api_id_enum and line.strip().startswith(
-                    "/// " + self.DEFAULT_UR_API_NAME_COMMENT_PREFIX
-                ):
-                    current_api_name = self.__get_api_name_from_header_line(line)
-                elif found_api_id_enum and "=" in line:
-                    _, api_id_value = extract_c_enum_and_value(line)
-                    if not current_api_name:
-                        current_api_name = self.__get_api_name_from_header_line(line)
-                        if not current_api_name:
-                            raise InternalParsingError(
-                                f"{api_id_value} has no associated API name (should never happen!)"
-                            )
-                    initial_error_msg = f"SYCL/UR API ID value {api_id_value} for {current_api_name} on line {ur_include_file}:{number}"
-                    if not f"{current_api_name}_id" in self.__pti_ur_api_to_ids_map:
-                        error_msg = (
-                            f"{initial_error_msg} not found in PTI SYCL API IDs."
-                        )
-                        self.__log_or_throw(error_msg, raise_on_error, warning=True)
-                    else:
-                        pti_existing_api_name = self.__pti_ur_api_ids_to_api_map.get(
-                            api_id_value, ""
-                        )
-                        pti_existing_api_id = self.__pti_ur_api_to_ids_map.get(
-                            f"{current_api_name}_id", 0
-                        )
-                        # If the API ID value exists in PTI, it must match the
-                        # 'current' (SYCL/UR) name. However, some API ids can be
-                        # versioned. Check if its one of those too.
-                        if (
-                            pti_existing_api_id != api_id_value
-                            and not pti_existing_api_name.startswith(current_api_name)
-                            and current_api_name not in self.UR_API_RECYCLE_LIST
-                        ):
-                            error_msg = f"{initial_error_msg} does not match PTI SYCL API ID value {self.__pti_ur_api_to_ids_map[f'{current_api_name}_id']}."
-                            self.__log_or_throw(
-                                error_msg, raise_on_error, warning=False
-                            )
-                            if api_id_value in self.__pti_ur_api_ids_to_api_map:
-                                error_msg = f"[FATAL] {initial_error_msg} HAS CHANGED in PTI SYCL API IDs."
-                                self.__log_or_throw(
-                                    error_msg, raise_on_error, warning=False
-                                )
-                    current_api_name = None
-
-    def __get_api_name_from_header_line(self, line: str) -> str:
-        """Extract API name from a line in the header file.
-
-        Args:
-            line (str): Line containing API name.
-
-        Returns:
-            API name.
-        """
-        # Example: /// Enumerator for ::urEnqueueKernelLaunch
-        # -> 'urEnqueueKernelLaunch'
-        return line.split(self.DEFAULT_UR_API_NAME_COMMENT_PREFIX)[1].strip()
-
-    def __log_or_throw(self, message: str, raise_on_error: bool, warning: bool):
-        if raise_on_error:
-            raise ApiIdRulesViolationError(message)
-        else:
-            print(f"[{'WARNING' if warning else 'ERROR'}] {message}", file=sys.stderr)
-
-    def __load_pti_api_ids(self, pti_include_file: pathlib.Path):
-        """Load PTI API Ids into data structures that can be used for validation."""
-
-        found_api_id_enum = False
-        with pti_include_file.open("r") as include_file:
-            for number, line in enumerate(include_file, 1):
-                if (
-                    not found_api_id_enum
-                    and self.DEFAULT_PTI_SYCL_API_ID_ENUM_START in line
-                ):
-                    found_api_id_enum = True
-                elif found_api_id_enum and "}" in line:
-                    break
-                elif found_api_id_enum and "=" in line:
-                    api_name, api_id_value = extract_c_enum_and_value(line)
-                    if api_id_value not in self.__pti_ur_api_ids_to_api_map:
-                        self.__pti_ur_api_ids_to_api_map[api_id_value] = api_name
-                    else:
-                        raise DuplicatedApiIdError(
-                            f"Duplicated PTI API ID value found: {api_id_value}. Line {number}"
-                        )
-                    if api_name not in self.__pti_ur_api_to_ids_map:
-                        self.__pti_ur_api_to_ids_map[api_name] = api_id_value
-                    else:
-                        raise DuplicatedApiIdError(
-                            f"Duplicated PTI API name found: {api_name}. Line {number}"
-                        )
-
-
-def main():
-    """
-    Entry point to the program.
-
-    Run with --help for detailed usage information
-    """
-
-    parser = argparse.ArgumentParser(description="Utility for SYCL API IDs")
-
-    parser.add_argument(
-        "--pti-include-dir",
-        type=pathlib.Path,
-        help="Path to PTI include directory",
-        required=True,
-    )
-
-    parser.add_argument(
-        "--ur-include-dir",
-        type=pathlib.Path,
-        help="Path to Unified Runtime include directory",
-        required=False,
-        default=None,
-    )
-
-    parser.add_argument(
-        "--validate",
-        action="store_true",
-        help="Validate SYCL API IDs against PTI IDs based on spec rules",
-    )
-
-    args = parser.parse_args()
-
-    pti_include_file = get_public_header_file_path(
-        args.pti_include_dir, DEFAULT_PTI_SYCL_API_ID_PUBLIC_HEADER
-    )
-    validator = PtiApiIdValidator(pti_include_file)
-
-    if args.ur_include_dir:
-        ur_include_file = get_public_header_file_path(
-            args.ur_include_dir, DEFAULT_UNIFIED_RUNTIME_PUBLIC_HEADERS
-        )
-        validator.load_sycl_api_ids(ur_include_file, args.validate)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/sdk/test/view_buffer_test.cc b/sdk/test/view_buffer_test.cc
deleted file mode 100644
index 52d3635b..00000000
--- a/sdk/test/view_buffer_test.cc
+++ /dev/null
@@ -1,230 +0,0 @@
-#include "view_buffer.h"
-
-#include <gtest/gtest.h>
-
-#include <array>
-#include <cstring>
-#include <thread>
-#include <vector>
-
-#include "pti/pti_view.h"
-#include "utils/test_helpers.h"
-#include "view_record_info.h"
-
-namespace {
-
-constexpr auto kNumOfMemRecordsInBuffer = 2;
-constexpr auto kNumOfKernelRecordsInBuffer = 1;
-constexpr auto kNumOfRecordsInBuffer = kNumOfMemRecordsInBuffer + kNumOfKernelRecordsInBuffer;
-constexpr auto kSizeOfTestBuffer = kNumOfRecordsInBuffer * SizeOfLargestViewRecord();
-constexpr auto kDefaultBufferFillValue = 0;
-constexpr const auto* const kDefaultKernelName = "ReallyComplicated_KernelName_SomeOp";
-
-std::size_t FillBuffer(pti::view::utilities::ViewBuffer& a_buffer) {
-  std::size_t bytes_inserted = 0;
-  auto number_of_memory_records_left = kNumOfMemRecordsInBuffer;
-  auto number_of_kernel_records_left = kNumOfKernelRecordsInBuffer;
-  auto keep_inserting = true;
-  for (auto i = 0; i < kNumOfRecordsInBuffer && keep_inserting; i++) {
-    using pti::test::utils::CreateRecord;
-    if (number_of_memory_records_left) {
-      EXPECT_EQ(keep_inserting, true);
-      a_buffer.Insert(CreateRecord<pti_view_record_memory_copy_type>());
-      // check if we can insert a kernel record after
-      keep_inserting = !a_buffer.BufferFull<pti_view_record_kernel_type>();
-      bytes_inserted += sizeof(pti_view_record_memory_copy_type);
-      number_of_memory_records_left--;
-    }
-    if (number_of_kernel_records_left) {
-      EXPECT_EQ(keep_inserting, true);
-      auto record = CreateRecord<pti_view_record_kernel_type>();
-      record._name = kDefaultKernelName;
-      a_buffer.Insert(record);
-      // check if we can insert a memory record after
-      keep_inserting = !a_buffer.BufferFull<pti_view_record_memory_copy_type>();
-      bytes_inserted += sizeof(pti_view_record_kernel_type);
-      number_of_kernel_records_left--;
-    }
-  }
-  return bytes_inserted;
-}
-
-}  // namespace
-
-class ViewBufferFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    standard_buffer_.Refresh(underlying_buffer_.data(), underlying_buffer_.size());
-
-    bytes_inserted_ = FillBuffer(standard_buffer_);
-  }
-
-  void TearDown() override {
-    std::fill(underlying_buffer_.begin(), underlying_buffer_.end(), kDefaultBufferFillValue);
-    bytes_inserted_ = 0;
-  }
-  std::vector<unsigned char> underlying_buffer_ =
-      std::vector<unsigned char>(kSizeOfTestBuffer, kDefaultBufferFillValue);
-  pti::view::utilities::ViewBuffer standard_buffer_ = {};
-  std::size_t bytes_inserted_ = 0;
-};
-
-TEST_F(ViewBufferFixtureTest, MoveConstructor) {
-  EXPECT_EQ(standard_buffer_.IsNull(), false);
-  EXPECT_EQ(standard_buffer_.GetValidBytes(), bytes_inserted_);
-  auto destination_buffer{std::move(standard_buffer_)};
-  EXPECT_EQ(destination_buffer.IsNull(), false);
-  EXPECT_EQ(destination_buffer.GetValidBytes(), bytes_inserted_);
-}
-
-TEST_F(ViewBufferFixtureTest, MoveAssignment) {
-  EXPECT_EQ(standard_buffer_.IsNull(), false);
-  EXPECT_EQ(standard_buffer_.GetValidBytes(), bytes_inserted_);
-  EXPECT_EQ(standard_buffer_.GetBuffer(), underlying_buffer_.data());
-
-  auto plain_buffer = std::vector<unsigned char>(kSizeOfTestBuffer);
-  pti::view::utilities::ViewBuffer destination_buffer{plain_buffer.data(), plain_buffer.size(), 0};
-  auto valid_bytes = FillBuffer(destination_buffer);
-  EXPECT_EQ(destination_buffer.GetValidBytes(), valid_bytes);
-  destination_buffer = std::move(standard_buffer_);
-
-  EXPECT_EQ(destination_buffer.IsNull(), false);
-  EXPECT_EQ(destination_buffer.GetValidBytes(), bytes_inserted_);
-  EXPECT_EQ(destination_buffer.GetBuffer(), underlying_buffer_.data());
-}
-
-TEST_F(ViewBufferFixtureTest, QueuePush) {
-  pti::view::utilities::ViewBufferQueue buf_queue;
-  buf_queue.Push(std::move(standard_buffer_));
-  EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(1));
-}
-
-TEST_F(ViewBufferFixtureTest, QueuePop) {
-  pti::view::utilities::ViewBufferQueue buf_queue;
-  buf_queue.Push(std::move(standard_buffer_));
-  EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(1));
-  auto consume_buffer = buf_queue.Pop();
-  EXPECT_EQ(consume_buffer.IsNull(), false);
-  EXPECT_EQ(consume_buffer.GetValidBytes(), bytes_inserted_);
-  EXPECT_EQ(consume_buffer.GetBuffer(), underlying_buffer_.data());
-}
-
-TEST_F(ViewBufferFixtureTest, QueueMultithreadedPopPush) {
-  pti::view::utilities::ViewBufferQueue buf_queue;
-
-  std::thread pop_thread([this, &buf_queue] {
-    auto consume_buffer = buf_queue.Pop();
-    EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(0));
-    EXPECT_EQ(consume_buffer.IsNull(), false);
-    EXPECT_EQ(consume_buffer.GetValidBytes(), bytes_inserted_);
-    EXPECT_EQ(consume_buffer.GetBuffer(), underlying_buffer_.data());
-  });
-
-  buf_queue.Push(std::move(standard_buffer_));
-  pop_thread.join();
-  EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(0));
-}
-
-TEST_F(ViewBufferFixtureTest, QueueMultithreadedPushPop) {
-  constexpr std::size_t kBufferQueueSize = 3UL;
-  pti::view::utilities::ViewBufferQueue buf_queue(kBufferQueueSize);
-
-  std::thread push_thread([this, &buf_queue, kBufferQueueSize] {
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    buf_queue.Push(std::move(standard_buffer_));
-    EXPECT_LE(buf_queue.Size(), kBufferQueueSize);
-  });
-
-  // Pop the first buffer
-  auto consume_buffer = buf_queue.Pop();
-  EXPECT_EQ(consume_buffer.IsNull(), true);
-  EXPECT_EQ(consume_buffer.GetValidBytes(), static_cast<std::size_t>(0));
-  EXPECT_EQ(consume_buffer.GetBuffer(), nullptr);
-  consume_buffer = buf_queue.Pop();
-  consume_buffer = buf_queue.Pop();
-
-  // Pop the last buffer
-  consume_buffer = buf_queue.Pop();
-  push_thread.join();
-  EXPECT_EQ(consume_buffer.IsNull(), false);
-  EXPECT_EQ(consume_buffer.GetValidBytes(), bytes_inserted_);
-  EXPECT_EQ(consume_buffer.GetBuffer(), underlying_buffer_.data());
-  EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(0));
-}
-
-TEST_F(ViewBufferFixtureTest, QueueMultithreadedWaitUntilEmpty) {
-  pti::view::utilities::ViewBufferQueue buf_queue;
-
-  std::atomic<bool> stop_consumer = false;
-
-  buf_queue.Push(pti::view::utilities::ViewBuffer{});
-  buf_queue.Push(pti::view::utilities::ViewBuffer{});
-
-  std::thread push_thread([this, &buf_queue] {
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    buf_queue.Push(std::move(standard_buffer_));
-  });
-
-  std::thread pop_thread([&buf_queue] {
-    buf_queue.Pop();
-    buf_queue.Pop();
-    buf_queue.Pop();
-    buf_queue.Pop();
-  });
-
-  buf_queue.WaitUntilEmptyOr(stop_consumer);
-  EXPECT_EQ(buf_queue.Size(), static_cast<std::size_t>(0));
-
-  push_thread.join();
-  pop_thread.join();
-}
-
-TEST_F(ViewBufferFixtureTest, QueueMultithreadedWaitUntilEmptyOr) {
-  pti::view::utilities::ViewBufferQueue buf_queue;
-
-  std::atomic<bool> stop_consumer = false;
-
-  buf_queue.Push(pti::view::utilities::ViewBuffer{});
-
-  std::thread push_thread([this, &buf_queue, &stop_consumer] {
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    stop_consumer = true;
-    buf_queue.Push(pti::view::utilities::ViewBuffer{});
-    buf_queue.Push(std::move(standard_buffer_));
-  });
-
-  buf_queue.WaitUntilEmptyOr(stop_consumer);
-  EXPECT_NE(buf_queue.Size(), static_cast<std::size_t>(0));
-
-  push_thread.join();
-}
-
-TEST(GuardedUnorderedMapTest, ForEach) {
-  using pti::view::utilities::GuardedUnorderedMap;
-  GuardedUnorderedMap<int, std::string> table = {};
-  table[100] = "hello";
-  table[101] = ",";
-  table[102] = "world";
-  table.ForEach([&](const auto& key, auto& value) {
-    switch (key) {
-      case 100:
-        value = "world";
-        break;
-      case 101:
-        value = ",";
-        break;
-      case 102:
-        value = "hello";
-        break;
-      default:
-        FAIL();
-        break;
-    }
-  });
-
-  EXPECT_EQ(table[100], "world");
-  ASSERT_EQ(table[101], ",");
-  ASSERT_EQ(table[102], "hello");
-}
diff --git a/sdk/test/view_gpu_local_test.cc b/sdk/test/view_gpu_local_test.cc
deleted file mode 100644
index 06ac67b5..00000000
--- a/sdk/test/view_gpu_local_test.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <iostream>
-
-#include "pti/pti_view.h"
-#include "utils/test_helpers.h"
-
-class ViewGPULocalFixtureTest : public ::testing::Test {
- protected:
-  void SetUp() override {}
-  void TearDown() override {}
-};
-
-// at the moment at least execute this API
-// TODO: more tests to be added;
-// the will respect the version of L0 installed to the system
-TEST_F(ViewGPULocalFixtureTest, CheckGPULocalViewAvailable) {
-  pti_result result = ptiViewGPULocalAvailable();
-  EXPECT_TRUE(result == pti_result::PTI_SUCCESS ||
-              result == pti_result::PTI_ERROR_L0_LOCAL_PROFILING_NOT_SUPPORTED);
-
-  std::cout << "result: " << result << std::endl;
-
-  // just exercising two times and verifying the answer is the same
-  pti_result result2 = ptiViewGPULocalAvailable();
-  EXPECT_TRUE(result2 == result);
-}
diff --git a/sdk/test/xpti_interop_test.py b/sdk/test/xpti_interop_test.py
deleted file mode 100644
index e9b59ef6..00000000
--- a/sdk/test/xpti_interop_test.py
+++ /dev/null
@@ -1,504 +0,0 @@
-#!/usr/bin/env python3
-
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-import subprocess
-import tempfile
-from pathlib import Path
-
-# Test configuration constants
-REPETITIONS = 5  # Number of repetitions for the test workload (-r parameter)
-TARGET_EXECUTABLE = "dpc_gemm_threaded_prof_print"  # The specific executable, instrumented with XPTI, to use in the test
-
-
-def check_environment_preconditions():
-    """
-    Check that the environment is properly configured for the XPTI interoperability test.
-
-    Returns:
-        bool: True if environment is clean, False if preconditions are not met
-    """
-    if "XPTI_SUBSCRIBERS" in os.environ:
-        print("ERROR: XPTI_SUBSCRIBERS environment variable is already set!")
-        print(f"   Current value: {os.environ['XPTI_SUBSCRIBERS']}")
-        print("   This will interfere with the test. Please unset it and run again.")
-        print("   Use: unset XPTI_SUBSCRIBERS")
-        return False
-
-    return True
-
-
-def run_executable_with_env(executable_path, env_vars=None, timeout=60):
-    """
-    Run an executable with specific environment variables and capture output.
-
-    Args:
-        executable_path: Path to the executable
-        env_vars: Dictionary of environment variables to set
-        timeout: Timeout in seconds
-
-    Returns:
-        tuple: (return_code, stdout, stderr)
-    """
-    # Start with current environment
-    env = os.environ.copy()
-
-    # Add/override with provided environment variables
-    if env_vars:
-        env.update(env_vars)
-
-    # Construct command with specific arguments: 1 thread, size 64, configurable repetitions
-    command = [
-        executable_path,
-        "-t",
-        "1",
-        "-s",
-        "64",
-        "-r",
-        str(REPETITIONS),
-        "-c",
-        "gpu",
-        "-c",
-        "-sycl",
-    ]
-
-    print(f"Running: {' '.join(command)}")
-    if env_vars:
-        print(f"Environment: {env_vars}")
-
-    try:
-        result = subprocess.run(
-            command, env=env, capture_output=True, text=True, timeout=timeout
-        )
-        return result.returncode, result.stdout, result.stderr
-    except subprocess.TimeoutExpired:
-        print(f"ERROR: Executable timed out after {timeout} seconds")
-        return -1, "", "Timeout"
-    except Exception as e:
-        print(f"ERROR: Failed to run executable: {e}")
-        return -1, "", str(e)
-
-
-def analyze_output_differences(output1, output2, label1, label2):
-    """
-    Analyze differences between two outputs.
-
-    Args:
-        output1: First output string
-        output2: Second output string
-        label1: Label for first output
-        label2: Label for second output
-
-    Returns:
-        dict: Analysis results
-    """
-    lines1 = output1.strip().split("\n") if output1 else []
-    lines2 = output2.strip().split("\n") if output2 else []
-
-    analysis = {
-        "line_count_1": len(lines1),
-        "line_count_2": len(lines2),
-        "identical": output1 == output2,
-        "empty_1": len(output1.strip()) == 0,
-        "empty_2": len(output2.strip()) == 0,
-        "differences": [],
-    }
-
-    # Check for XPTI subscriber messages
-    xpti_patterns = ["XPTI", "subscriber", "unitrace"]
-    analysis["xpti_found_1"] = any(pattern in output1 for pattern in xpti_patterns)
-    analysis["xpti_found_2"] = any(pattern in output2 for pattern in xpti_patterns)
-
-    # Check for warning messages
-    analysis["warning_found_1"] = "warning" in output1.lower()
-    analysis["warning_found_2"] = "warning" in output2.lower()
-
-    # Check specifically for Sycl Runtime Records
-    sycl_runtime_pattern = "Found Sycl Runtime Record"
-    analysis["sycl_runtime_found_1"] = sycl_runtime_pattern in output1
-    analysis["sycl_runtime_found_2"] = sycl_runtime_pattern in output2
-
-    # Count different record types in both outputs
-    record_types = [
-        "Found Sycl Runtime Record",
-        "Found Kernel Record",
-        "Found Memory Record",
-        "Found Invalid Record",
-    ]
-
-    analysis["record_counts_1"] = {}
-    analysis["record_counts_2"] = {}
-
-    for record_type in record_types:
-        analysis["record_counts_1"][record_type] = output1.count(record_type)
-        analysis["record_counts_2"][record_type] = output2.count(record_type)
-
-    if not analysis["identical"]:
-        # Find line differences
-        max_lines = max(len(lines1), len(lines2))
-        for i in range(max_lines):
-            line1 = lines1[i] if i < len(lines1) else ""
-            line2 = lines2[i] if i < len(lines2) else ""
-            if line1 != line2:
-                analysis["differences"].append(
-                    {"line": i + 1, label1: line1, label2: line2}
-                )
-
-    return analysis
-
-
-def run_test_scenarios(executable_path):
-    """
-    Execute both test scenarios: clean run and foreign subscriber run.
-
-    Args:
-        executable_path: Path to the executable to test
-
-    Returns:
-        tuple: (ret1, stdout1, stderr1, ret2, stdout2, stderr2)
-    """
-    # Test 1: Run without any XPTI_SUBSCRIBERS (clean PTI run)
-    print("\n1. Running without XPTI_SUBSCRIBERS (clean PTI run)...")
-    ret1, stdout1, stderr1 = run_executable_with_env(executable_path)
-
-    # Test 2: Run with XPTI_SUBSCRIBERS=fake_subscr (foreign subscriber)
-    print("\n2. Running with XPTI_SUBSCRIBERS=fake_subscr (foreign subscriber)...")
-    env_vars = {"XPTI_SUBSCRIBERS": "fake_subscr"}
-    ret2, stdout2, stderr2 = run_executable_with_env(executable_path, env_vars)
-
-    return ret1, stdout1, stderr1, ret2, stdout2, stderr2
-
-
-def analyze_outputs_and_report_statistics(
-    ret1, stdout1, stderr1, ret2, stdout2, stderr2
-):
-    """
-    Analyze outputs and generate detailed reports.
-
-    Args:
-        ret1, stdout1, stderr1: Results from clean run
-        ret2, stdout2, stderr2: Results from foreign subscriber run
-
-    Returns:
-        tuple: (stdout_analysis, stderr_analysis)
-    """
-    print("\n" + "=" * 60)
-    print("RESULTS ANALYSIS")
-    print("=" * 60)
-
-    # Analyze return codes
-    print(f"\nReturn codes:")
-    print(f"  Clean run: {ret1}")
-    print(f"  With foreign subscriber: {ret2}")
-
-    # Analyze stdout
-    print(f"\nSTDOUT Analysis:")
-    stdout_analysis = analyze_output_differences(
-        stdout1, stdout2, "clean", "foreign_subscriber"
-    )
-    print(f"  Clean run output length: {stdout_analysis['line_count_1']} lines")
-    print(
-        f"  Foreign subscriber output length: {stdout_analysis['line_count_2']} lines"
-    )
-    print(f"  Outputs identical: {stdout_analysis['identical']}")
-    print(
-        f"  Sycl Runtime Records found (clean): {stdout_analysis['sycl_runtime_found_1']}"
-    )
-    print(
-        f"  Sycl Runtime Records found (foreign): {stdout_analysis['sycl_runtime_found_2']}"
-    )
-    print(f"  Warning found (clean): {stdout_analysis['warning_found_1']}")
-    print(f"  Warning found (foreign): {stdout_analysis['warning_found_2']}")
-
-    # Print record counts for detailed analysis
-    print(f"\nRecord Type Counts:")
-    for record_type in stdout_analysis["record_counts_1"].keys():
-        count1 = stdout_analysis["record_counts_1"][record_type]
-        count2 = stdout_analysis["record_counts_2"][record_type]
-        print(f"  {record_type}: Clean={count1}, Foreign={count2}")
-
-    # Analyze stderr
-    print(f"\nSTDERR Analysis:")
-    stderr_analysis = analyze_output_differences(
-        stderr1, stderr2, "clean", "foreign_subscriber"
-    )
-    print(f"  Clean run stderr length: {stderr_analysis['line_count_1']} lines")
-    print(
-        f"  Foreign subscriber stderr length: {stderr_analysis['line_count_2']} lines"
-    )
-    print(f"  Stderr identical: {stderr_analysis['identical']}")
-
-    return stdout_analysis, stderr_analysis
-
-
-def perform_behavioral_checks(ret1, ret2, stdout_analysis, stderr_analysis):
-    """
-    Perform all behavioral validation checks.
-
-    Args:
-        ret1, ret2: Return codes from both runs
-        stdout_analysis: Analysis results from stdout comparison
-        stderr_analysis: Analysis results from stderr comparison
-
-    Returns:
-        bool: True if all checks pass
-    """
-    print(f"\n" + "=" * 60)
-    print("EXPECTED BEHAVIOR VERIFICATION")
-    print("=" * 60)
-
-    test_passed = True
-
-    # Check 1: Both runs should succeed
-    if ret1 != 0 or ret2 != 0:
-        print("FAIL: One or both runs failed")
-        test_passed = False
-    else:
-        print("PASS: Both runs completed successfully")
-
-    # Check 2: Clean run should have Sycl Runtime Records
-    if stdout_analysis["sycl_runtime_found_1"]:
-        print("PASS: Found Sycl Runtime Record found in clean run")
-    else:
-        print("FAIL: No Found Sycl Runtime Record found in clean run")
-        test_passed = False
-
-    # Check 3: Foreign subscriber run should have zero Sycl Runtime Records
-    sycl_count_clean = stdout_analysis["record_counts_1"]["Found Sycl Runtime Record"]
-    sycl_count_foreign = stdout_analysis["record_counts_2"]["Found Sycl Runtime Record"]
-    kernel_count_foreign = stdout_analysis["record_counts_2"]["Found Kernel Record"]
-
-    if sycl_count_foreign == 0 and sycl_count_clean > 0:
-        print(
-            f"PASS: No SYCL Runtime Records in foreign run as expected (Clean:{sycl_count_clean}, Foreign:{sycl_count_foreign})"
-        )
-    else:
-        print(
-            f"FAIL: Expected zero SYCL Runtime Records in foreign run - Clean:{sycl_count_clean}, Foreign:{sycl_count_foreign}"
-        )
-        test_passed = False
-
-    # Check 4: Foreign subscriber run should still have kernel records
-    if kernel_count_foreign > 0:
-        print(
-            f"PASS: Kernel records still captured in foreign run ({kernel_count_foreign})"
-        )
-    else:
-        print(f"FAIL: No kernel records found in foreign run (expected > 0)")
-        test_passed = False
-
-    # Check 5: All other record types should be identical
-    other_records_identical = True
-    for record_type in stdout_analysis["record_counts_1"].keys():
-        if record_type not in [
-            "Found Sycl Runtime Record"
-        ]:  # Don't check Sycl Runtime Records as we expect them to differ
-            count1 = stdout_analysis["record_counts_1"][record_type]
-            count2 = stdout_analysis["record_counts_2"][record_type]
-            if count1 != count2:
-                print(
-                    f"FAIL: {record_type} counts differ - Clean:{count1}, Foreign:{count2}"
-                )
-                other_records_identical = False
-                test_passed = False
-
-    if other_records_identical:
-        print("PASS: All non-Sycl Runtime Record types have identical counts")
-
-    # Check 6: Both runs should have kernel records equal to repetitions
-    kernel_count_clean = stdout_analysis["record_counts_1"]["Found Kernel Record"]
-    kernel_count_foreign = stdout_analysis["record_counts_2"]["Found Kernel Record"]
-
-    REAL_REPETITIONS = (
-        REPETITIONS + 1
-    )  # Number of actual kernel launches expected, additional run is always added - it is warmup
-    if kernel_count_clean == REAL_REPETITIONS:
-        print(
-            f"PASS: Clean run has correct number of kernel records ({kernel_count_clean} == {REAL_REPETITIONS})"
-        )
-    else:
-        print(
-            f"FAIL: Clean run kernel records mismatch - Expected:{REAL_REPETITIONS}, Got:{kernel_count_clean}"
-        )
-        test_passed = False
-
-    if kernel_count_foreign == REAL_REPETITIONS:
-        print(
-            f"PASS: Foreign run has correct number of kernel records ({kernel_count_foreign} == {REAL_REPETITIONS})"
-        )
-    else:
-        print(
-            f"FAIL: Foreign run kernel records mismatch - Expected:{REAL_REPETITIONS}, Got:{kernel_count_foreign}"
-        )
-        test_passed = False
-
-    # Check 7: Foreign subscriber run should have a warning message
-    if stdout_analysis["warning_found_2"]:
-        print("PASS: Warning message found in foreign subscriber run")
-    else:
-        print("FAIL: No warning message found in foreign subscriber run")
-        test_passed = False
-
-    # Check 8: Summary of expected behavior
-    if sycl_count_clean > 0 and sycl_count_foreign == 0 and kernel_count_foreign > 0:
-        print(
-            f"PASS: PTI correctly detected foreign subscriber - disabled SYCL runtime tracing (Clean:{sycl_count_clean} -> Foreign:{sycl_count_foreign}), kernel tracing still works"
-        )
-    else:
-        print(f"FAIL: Unexpected interoperability behavior pattern")
-        test_passed = False
-
-    # Show detailed differences if requested
-    if stdout_analysis["differences"]:
-        print(f"\nFirst 5 STDOUT differences:")
-        for i, diff in enumerate(stdout_analysis["differences"][:5]):
-            print(f"  Line {diff['line']}:")
-            print(f"    Clean: '{diff['clean']}'")
-            print(f"    Foreign: '{diff['foreign_subscriber']}'")
-
-    if stderr_analysis["differences"]:
-        print(f"\nFirst 5 STDERR differences:")
-        for i, diff in enumerate(stderr_analysis["differences"][:5]):
-            print(f"  Line {diff['line']}:")
-            print(f"    Clean: '{diff['clean']}'")
-            print(f"    Foreign: '{diff['foreign_subscriber']}'")
-
-    return test_passed
-
-
-def save_detailed_outputs(stdout1, stdout2, stderr1, stderr2):
-    """
-    Save detailed outputs to temporary files for further analysis.
-
-    Args:
-        stdout1: Clean run stdout
-        stdout2: Foreign subscriber stdout
-        stderr1: Clean run stderr
-        stderr2: Foreign subscriber stderr
-    """
-    # Save detailed stdout for further analysis
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix="_clean_stdout.txt", delete=False
-    ) as f:
-        f.write(stdout1)
-        print(f"\nDetailed clean run stdout saved to: {f.name}")
-
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix="_foreign_stdout.txt", delete=False
-    ) as f:
-        f.write(stdout2)
-        print(f"Detailed foreign subscriber stdout saved to: {f.name}")
-
-    # Save detailed stderr for further analysis
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix="_clean_stderr.txt", delete=False
-    ) as f:
-        f.write(stderr1)
-        print(f"Detailed clean run stderr saved to: {f.name}")
-
-    with tempfile.NamedTemporaryFile(
-        mode="w", suffix="_foreign_stderr.txt", delete=False
-    ) as f:
-        f.write(stderr2)
-        print(f"Detailed foreign subscriber stderr saved to: {f.name}")
-
-
-def validate_test_results(ret1, stdout1, stderr1, ret2, stdout2, stderr2):
-    """
-    Validate the test results and perform all behavioral checks.
-
-    Args:
-        ret1, stdout1, stderr1: Results from clean run
-        ret2, stdout2, stderr2: Results from foreign subscriber run
-
-    Returns:
-        bool: True if all validations pass
-    """
-    # Analyze and report outputs
-    stdout_analysis, stderr_analysis = analyze_outputs_and_report_statistics(
-        ret1, stdout1, stderr1, ret2, stdout2, stderr2
-    )
-
-    # Perform behavioral validation checks
-    test_passed = perform_behavioral_checks(
-        ret1, ret2, stdout_analysis, stderr_analysis
-    )
-
-    # Save detailed outputs for further analysis
-    save_detailed_outputs(stdout1, stdout2, stderr1, stderr2)
-
-    return test_passed
-
-
-def test_xpti_interoperability(executable_dir):
-    """
-    Test PTI XPTI interoperability with XPTI subscribers.
-
-    Args:
-        executable_dir: Directory containing the dpc_gemm_threaded_prof_print executable
-
-    Returns:
-        bool: Test passed
-    """
-    executable_path = Path(executable_dir) / TARGET_EXECUTABLE
-    executable_name = executable_path.name
-    print("=" * 60)
-    print(f"PTI XPTI INTEROPERABILITY TEST: {executable_name}")
-    print(f"Executable: {executable_path}")
-    print("=" * 60)
-
-    # Check environment preconditions
-    if not check_environment_preconditions():
-        print("=" * 60)
-        return False
-
-    # Execute test scenarios
-    ret1, stdout1, stderr1, ret2, stdout2, stderr2 = run_test_scenarios(
-        str(executable_path)
-    )
-
-    # Validate results
-    test_passed = validate_test_results(ret1, stdout1, stderr1, ret2, stdout2, stderr2)
-
-    print(f"\n" + "=" * 60)
-    print(f"FINAL RESULT: {'PASS' if test_passed else 'FAIL'}")
-    print("=" * 60)
-
-    return test_passed
-
-
-def main():
-    if len(sys.argv) != 2:
-        print(f"Usage: interop_test.py <executable_directory>")
-        print(f"Example: interop_test.py /path/to/build/tests")
-        print(
-            f"  The test will look for '{TARGET_EXECUTABLE}' in the provided directory."
-        )
-        return 1
-
-    executable_dir = Path(sys.argv[1])
-
-    if not executable_dir.exists():
-        print(f"ERROR: Directory not found: {executable_dir}")
-        return 1
-
-    if not executable_dir.is_dir():
-        print(f"ERROR: Path is not a directory: {executable_dir}")
-        return 1
-
-    try:
-        success = test_xpti_interoperability(str(executable_dir))
-        return 0 if success else 1
-    except Exception as e:
-        print(f"ERROR: Test failed with exception: {e}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/sdk/test/ze_event_manager_tests.cc b/sdk/test/ze_event_manager_tests.cc
deleted file mode 100644
index 4af298c6..00000000
--- a/sdk/test/ze_event_manager_tests.cc
+++ /dev/null
@@ -1,602 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <fmt/format.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <tuple>
-#include <vector>
-
-#include "utils.h"
-#include "ze_event_managers.h"
-#include "ze_utils.h"
-
-namespace {
-constexpr size_t kPtiDeviceId = 0;  // run on first device
-}  // namespace
-
-class ZeEventPoolTestSuite : public testing::Test {
- protected:
-  ZeEventPoolTestSuite() = default;
-
-  void SetUp() override {
-    auto status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-    drv_ = utils::ze::GetGpuDriver(kPtiDeviceId);
-    dev_ = utils::ze::GetGpuDevice(kPtiDeviceId);
-    ASSERT_NE(drv_, nullptr);
-    ctx_ = utils::ze::GetContext(drv_);
-    ASSERT_NE(ctx_, nullptr);
-  }
-
-  void TearDown() override {
-    if (ctx_ != nullptr) {
-      EXPECT_EQ(zeContextDestroy(ctx_), ZE_RESULT_SUCCESS);
-    }
-  }
-
-  ze_driver_handle_t drv_ = nullptr;
-  ze_device_handle_t dev_ = nullptr;
-  ze_context_handle_t ctx_ = nullptr;
-};
-
-class ZeEventPoolManagerTestSuite
-    : public ZeEventPoolTestSuite,
-      public testing::WithParamInterface<std::tuple<uint32_t, uint32_t>> {
- protected:
-  void SetUp() override {
-    ZeEventPoolTestSuite::SetUp();
-    auto [num_contexts, num_events] = GetParam();
-    for (uint32_t i = 0; i < num_contexts; ++i) {
-      ze_context_handle_t ctx = utils::ze::GetContext(drv_);
-      ASSERT_NE(ctx, nullptr);
-      ctx_list_.push_back(ctx);
-    }
-  }
-  void TearDown() override {
-    ZeEventPoolTestSuite::TearDown();
-    for (auto* ctx : ctx_list_) {
-      if (ctx) {
-        EXPECT_EQ(zeContextDestroy(ctx), ZE_RESULT_SUCCESS);
-      }
-    }
-  }
-
-  std::vector<ze_context_handle_t> ctx_list_;
-};
-
-TEST_F(ZeEventPoolTestSuite, TestConstructionWithOneEvent) { ZeEventPool event_pool(ctx_, 1U); }
-
-TEST_F(ZeEventPoolTestSuite, TestConstructionWithManyEvents) {
-  constexpr uint32_t kManyEventCount = 1024;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAOneEventEventPoolHasEventsLeftWithoutAcquiringTheEvent) {
-  ZeEventPool event_pool(ctx_, 1U);
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestCheckingIfAOneEventPoolHasEventsLeftWithAcquiringTheEvent) {
-  ZeEventPool event_pool(ctx_, 1U);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_TRUE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAManyEventEventPoolHasEventsLeftWithoutAcquiringAnyEvents) {
-  constexpr uint32_t kManyEventCount = 1024;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAManyEventEventPoolHasEventsLeftWithAfterAcquiringOneEventButNotAllOfThem) {
-  constexpr uint32_t kManyEventCount = 1024;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAManyEventEventPoolHasEventsLeftWithAfterAcquiringManyEventsButNotAllOfThem) {
-  constexpr uint32_t kManyEventCount = 1024;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  auto my_event1 = event_pool.AcquireEvent();
-  auto my_event2 = event_pool.AcquireEvent();
-  auto my_event3 = event_pool.AcquireEvent();
-  auto my_event4 = event_pool.AcquireEvent();
-  auto my_event5 = event_pool.AcquireEvent();
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestCheckingIfAManyEventEventPoolHasEventsLeftAfterAcquireAllOfThem) {
-  constexpr uint32_t kManyEventCount = 5;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  auto my_event1 = event_pool.AcquireEvent();
-  auto my_event2 = event_pool.AcquireEvent();
-  auto my_event3 = event_pool.AcquireEvent();
-  auto my_event4 = event_pool.AcquireEvent();
-  auto my_event5 = event_pool.AcquireEvent();
-  EXPECT_TRUE(event_pool.IsExhausted());
-}
-
-TEST_F(
-    ZeEventPoolTestSuite,
-    TestCheckingIfAManyEventEventPoolHasEventsLeftAfterAcquireAllOfThemHoweverLetThemGoOutOfScope) {
-  constexpr uint32_t kManyEventCount = 5;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  for (uint32_t i = 0; i < kManyEventCount; ++i) {
-    auto my_event = event_pool.AcquireEvent();
-  }
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(
-    ZeEventPoolTestSuite,
-    TestCheckingIfAManyEventEventPoolHasEventsLeftAfterAcquireAllOfThemHoweverLetThemGoOutOfScopeMultipleTimes) {
-  constexpr uint32_t kManyEventCount = 5;
-  constexpr uint32_t kWrapArounds = 2;
-
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  for (uint32_t i = 0; i < kManyEventCount * kWrapArounds; ++i) {
-    auto my_event = event_pool.AcquireEvent();
-  }
-
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAnEventAcquiredFromTheEventPoolIsNotNullIfPoolHasManyEvents) {
-  constexpr uint32_t kManyEventCount = 5;
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_NE(my_event.Get(), nullptr);
-}
-
-TEST_F(ZeEventPoolTestSuite, TestCheckingIfAnEventAcquiredFromTheEventPoolIsNullIfPoolHasOneEvent) {
-  ZeEventPool event_pool(ctx_, 1U);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_NE(my_event.Get(), nullptr);
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfMultipleEventAcquiredFromTheEventPoolAreNullIfPoolHasNotEnoughEvents) {
-  ZeEventPool event_pool(ctx_, 1U);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_NE(my_event.Get(), nullptr);
-  auto my_event1 = event_pool.AcquireEvent();
-  EXPECT_EQ(my_event1.Get(), nullptr);
-}
-
-TEST_F(ZeEventPoolTestSuite, TestCheckingIfAnEventAcquiredFromAnUnusedEventPoolIsNotReady) {
-  ZeEventPool event_pool(ctx_, 1U);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_FALSE(my_event.Ready());
-}
-
-TEST_F(ZeEventPoolTestSuite,
-       TestCheckingIfAnEventAcquiredFromAnUnusedEventPoolIsReadyAfterHostSignal) {
-  ZeEventPool event_pool(ctx_, 1U);
-  auto my_event = event_pool.AcquireEvent();
-  ASSERT_EQ(zeEventHostSignal(my_event.Get()), ZE_RESULT_SUCCESS);
-  EXPECT_TRUE(my_event.Ready());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestCheckingIfEventsAcquiredFromAnUnusedEventPoolAreNotReady) {
-  constexpr uint32_t kManyEventCount = 2;
-  constexpr uint32_t kWrapArounds = 10;
-
-  ZeEventPool event_pool(ctx_, kManyEventCount);
-  for (uint32_t i = 0; i < kManyEventCount * kWrapArounds; ++i) {
-    auto my_event = event_pool.AcquireEvent();
-    EXPECT_FALSE(my_event.Ready());
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestConstructingSingleEventUnmanagedByAnEventPool) {
-  ZeEventPool event_pool(ctx_, 1U);
-  ZeEventView<ZeEventPool> my_event(event_pool.AcquireEvent());
-  EXPECT_FALSE(my_event.Empty());
-}
-
-TEST_P(ZeEventPoolManagerTestSuite, TestCheckingIfEventsAcquiredFromUnusedEventManagerAreNotReady) {
-  auto [num_ctx, num_events] = GetParam();
-  ZeEventPoolManager event_manager;
-  for (auto* ctx : ctx_list_) {
-    for (uint32_t i = 0; i < num_events; ++i) {
-      auto my_event = event_manager.AcquireEvent(ctx);
-      EXPECT_FALSE(my_event.Ready());
-    }
-    event_manager.Clear(ctx);
-  }
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    ZeEventPoolManagerTests, ZeEventPoolManagerTestSuite,
-    ::testing::Combine(::testing::Values(1, 4, 8, 256), ::testing::Values(1, 16, 32, 1024)),
-    [](const testing::TestParamInfo<ZeEventPoolManagerTestSuite::ParamType>& info) {
-      return fmt::format("Ctx_{}_Events_{}", std::get<0>(info.param), std::get<1>(info.param));
-    });
-
-// Tests for pool reuse functionality
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableOnNewPool) {
-  ZeEventPool event_pool(ctx_, 5U);
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableAfterAcquiringOneEvent) {
-  ZeEventPool event_pool(ctx_, 5U);
-  auto my_event = event_pool.AcquireEvent();
-  EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestAssignmentResourceManagement) {
-  ZeEventPool event_pool(ctx_, 5U);
-  {
-    auto my_event = event_pool.AcquireEvent();
-    auto my_event2 = event_pool.AcquireEvent();
-    my_event2 = std::move(my_event);
-  }
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableAfterAcquiringAndReturningOneEvent) {
-  ZeEventPool event_pool(ctx_, 5U);
-  {
-    auto my_event = event_pool.AcquireEvent();
-    EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-  }  // Event goes out of scope, gets returned via destructor
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableAfterAcquiringAllEvents) {
-  constexpr uint32_t kPoolSize = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-  std::vector<ZeEventView<ZeEventPool>> events;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    events.push_back(event_pool.AcquireEvent());
-  }
-  EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableAfterAcquiringAndReturningAllEvents) {
-  constexpr uint32_t kPoolSize = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-  {
-    std::vector<ZeEventView<ZeEventPool>> events;
-    for (uint32_t i = 0; i < kPoolSize; ++i) {
-      events.push_back(event_pool.AcquireEvent());
-    }
-    EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-  }  // All events go out of scope
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestIsCompletelyAvailableAfterPartialReturn) {
-  constexpr uint32_t kPoolSize = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-  std::vector<ZeEventView<ZeEventPool>> events;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    events.push_back(event_pool.AcquireEvent());
-  }
-
-  // Return some but not all events
-  events.pop_back();
-  events.pop_back();
-  EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestPoolReuseAfterAllEventsReturned) {
-  constexpr uint32_t kPoolSize = 3;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  // First round: acquire all events
-  {
-    std::vector<ZeEventView<ZeEventPool>> events;
-    for (uint32_t i = 0; i < kPoolSize; ++i) {
-      events.push_back(event_pool.AcquireEvent());
-    }
-    EXPECT_TRUE(event_pool.IsExhausted());
-  }  // All events returned
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-  EXPECT_FALSE(event_pool.IsExhausted());
-
-  // Second round: should be able to acquire events again
-  std::vector<ZeEventView<ZeEventPool>> new_events;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    new_events.push_back(event_pool.AcquireEvent());
-    EXPECT_NE(new_events.back().Get(), nullptr);
-  }
-  EXPECT_TRUE(event_pool.IsExhausted());
-  EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestPoolReuseMultipleCycles) {
-  constexpr uint32_t kPoolSize = 3;
-  constexpr uint32_t kCycles = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  for (uint32_t cycle = 0; cycle < kCycles; ++cycle) {
-    EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-    {
-      std::vector<ZeEventView<ZeEventPool>> events;
-      for (uint32_t i = 0; i < kPoolSize; ++i) {
-        events.push_back(event_pool.AcquireEvent());
-        EXPECT_NE(events.back().Get(), nullptr);
-      }
-      EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-    }
-    EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestManagerReusesPoolsAcrossCycles) {
-  constexpr uint32_t kPoolSize = ZeEventPoolManager::kDefaultPoolSize;
-  ZeEventPoolManager manager;
-
-  // First cycle: acquire all events from first pool
-  {
-    std::vector<ZeEventView<ZeEventPool>> events;
-    for (uint32_t i = 0; i < kPoolSize; ++i) {
-      events.push_back(manager.AcquireEvent(ctx_));
-      EXPECT_NE(events.back().Get(), nullptr);
-    }
-  }  // All events returned
-
-  // Second cycle: should reuse the same pool instead of creating a new one
-  // We can verify this indirectly by checking that events are acquired successfully
-  std::vector<ZeEventView<ZeEventPool>> new_events;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    new_events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(new_events.back().Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestManagerCreatesSecondPoolWhenFirstIsExhausted) {
-  constexpr uint32_t kPoolSize = ZeEventPoolManager::kDefaultPoolSize;
-  ZeEventPoolManager manager;
-
-  // Acquire more than one pool's worth of events
-  std::vector<ZeEventView<ZeEventPool>> events;
-  for (uint32_t i = 0; i < kPoolSize + 10; ++i) {
-    events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(events.back().Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestManagerReusesPoolAfterPartialUsage) {
-  constexpr uint32_t kAcquireCount = 10;
-  ZeEventPoolManager manager;
-
-  // Acquire some events and let them return
-  {
-    std::vector<ZeEventView<ZeEventPool>> events;
-    for (uint32_t i = 0; i < kAcquireCount; ++i) {
-      events.push_back(manager.AcquireEvent(ctx_));
-    }
-  }  // Events returned
-
-  // Acquire more events - should reuse the same pool
-  std::vector<ZeEventView<ZeEventPool>> new_events;
-  for (uint32_t i = 0; i < kAcquireCount; ++i) {
-    new_events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(new_events.back().Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestManagerReusesPoolAfterMultiplePoolsCreated) {
-  constexpr uint32_t kAcquireCount = (ZeEventPoolManager::kDefaultPoolSize * 2) + 10;
-  ZeEventPoolManager manager;
-
-  std::vector<ZeEventView<ZeEventPool>> events;
-  events.reserve(kAcquireCount);
-  for (uint32_t i = 0; i < kAcquireCount; ++i) {
-    events.push_back(manager.AcquireEvent(ctx_));
-  }
-
-  for (uint32_t i = 0; i < ZeEventPoolManager::kDefaultPoolSize; ++i) {
-    events.at(i) = ZeEventView<ZeEventPool>(nullptr);  // Release a pool
-  }
-
-  // Acquire more events - should reuse the first pool
-  std::vector<ZeEventView<ZeEventPool>> new_events;
-  for (uint32_t i = 0; i < kAcquireCount; ++i) {
-    new_events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(new_events.back().Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestEventsReturnedOutOfOrderReverse) {
-  constexpr uint32_t kPoolSize = 3;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  auto event0 = event_pool.AcquireEvent();
-  auto event1 = event_pool.AcquireEvent();
-  auto event2 = event_pool.AcquireEvent();
-
-  EXPECT_NE(event0.Get(), nullptr);
-  EXPECT_NE(event1.Get(), nullptr);
-  EXPECT_NE(event2.Get(), nullptr);
-
-  event2 = ZeEventView<ZeEventPool>(nullptr);
-  event1 = ZeEventView<ZeEventPool>(nullptr);
-  event0 = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-  EXPECT_FALSE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestEventsReturnedOutOfOrderMiddleFirst) {
-  constexpr uint32_t kPoolSize = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  // Acquire all events
-  auto event0 = event_pool.AcquireEvent();
-  auto event1 = event_pool.AcquireEvent();
-  auto middle_event2 = event_pool.AcquireEvent();
-  auto event3 = event_pool.AcquireEvent();
-  auto event4 = event_pool.AcquireEvent();
-
-  EXPECT_TRUE(event_pool.IsExhausted());
-
-  middle_event2 = ZeEventView<ZeEventPool>(nullptr);
-  EXPECT_FALSE(event_pool.IsCompletelyAvailable());
-
-  event4 = ZeEventView<ZeEventPool>(nullptr);
-  event0 = ZeEventView<ZeEventPool>(nullptr);
-  event3 = ZeEventView<ZeEventPool>(nullptr);
-  event1 = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestEventsReturnedOutOfOrderThenReacquiredWithSameIndices) {
-  constexpr uint32_t kPoolSize = 4;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  auto event0 = event_pool.AcquireEvent();
-  auto event1 = event_pool.AcquireEvent();
-  auto event2 = event_pool.AcquireEvent();
-  auto event3 = event_pool.AcquireEvent();
-
-  auto idx0 = event0.Idx();
-  auto idx1 = event1.Idx();
-  auto idx2 = event2.Idx();
-  auto idx3 = event3.Idx();
-
-  EXPECT_TRUE(event_pool.IsExhausted());
-
-  event3 = ZeEventView<ZeEventPool>(nullptr);
-  event1 = ZeEventView<ZeEventPool>(nullptr);
-  event0 = ZeEventView<ZeEventPool>(nullptr);
-  event2 = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-
-  auto new_event0 = event_pool.AcquireEvent();
-  auto new_event1 = event_pool.AcquireEvent();
-  auto new_event2 = event_pool.AcquireEvent();
-  auto new_event3 = event_pool.AcquireEvent();
-
-  // Events should be acquired in the same order.
-  EXPECT_EQ(new_event0.Idx(), idx0);
-  EXPECT_EQ(new_event1.Idx(), idx1);
-  EXPECT_EQ(new_event2.Idx(), idx2);
-  EXPECT_EQ(new_event3.Idx(), idx3);
-
-  EXPECT_TRUE(event_pool.IsExhausted());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestPartialOutOfOrderReturnAllowsPartialReacquire) {
-  constexpr uint32_t kPoolSize = 5;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  auto event0 = event_pool.AcquireEvent();
-  auto middle_event1 = event_pool.AcquireEvent();
-  auto middle_event2 = event_pool.AcquireEvent();
-
-  middle_event1 = ZeEventView<ZeEventPool>(nullptr);
-  middle_event2 = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_FALSE(event_pool.IsExhausted());
-
-  auto event3 = event_pool.AcquireEvent();
-  auto event4 = event_pool.AcquireEvent();
-
-  // 1 and 2 are available. However, next 'free' event is calculated on the next acquired event.
-  EXPECT_TRUE(event_pool.IsExhausted());
-
-  event0 = ZeEventView<ZeEventPool>(nullptr);
-  event3 = ZeEventView<ZeEventPool>(nullptr);
-  event4 = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestOutOfOrderReturnWithWrapAround) {
-  constexpr uint32_t kPoolSize = 3;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  std::vector<ZeEventView<ZeEventPool>> first_round;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    first_round.push_back(event_pool.AcquireEvent());
-  }
-  EXPECT_TRUE(event_pool.IsExhausted());
-
-  for (uint32_t i = kPoolSize; i > 0; --i) {
-    first_round.at(i - 1) = ZeEventView<ZeEventPool>(nullptr);
-  }
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-
-  std::vector<ZeEventView<ZeEventPool>> second_round;
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    second_round.push_back(event_pool.AcquireEvent());
-    EXPECT_NE(second_round.back().Get(), nullptr);
-  }
-  EXPECT_TRUE(event_pool.IsExhausted());
-
-  second_round.at(1) = ZeEventView<ZeEventPool>(nullptr);
-  second_round.at(0) = ZeEventView<ZeEventPool>(nullptr);
-  second_round.at(2) = ZeEventView<ZeEventPool>(nullptr);
-
-  EXPECT_TRUE(event_pool.IsCompletelyAvailable());
-
-  for (uint32_t i = 0; i < kPoolSize; ++i) {
-    auto event = event_pool.AcquireEvent();
-    EXPECT_NE(event.Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestManagerHandlesOutOfOrderReturnsAcrossMultiplePools) {
-  constexpr uint32_t kPoolSize = ZeEventPoolManager::kDefaultPoolSize;
-  constexpr uint32_t kOverflowSize = kPoolSize + 10;
-  ZeEventPoolManager manager;
-
-  std::vector<ZeEventView<ZeEventPool>> events;
-  for (uint32_t i = 0; i < kOverflowSize; ++i) {
-    events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(events.back().Get(), nullptr);
-  }
-
-  // Return events out of order:
-  // (1) Return events from latter pool(s). Based on overflow.
-  // (2) Return events from first pool.
-  for (uint32_t i = kPoolSize; i < kOverflowSize; ++i) {
-    events.at(i) = ZeEventView<ZeEventPool>(nullptr);
-  }
-
-  for (uint32_t i = kPoolSize; i > 0; --i) {
-    events.at(i - 1) = ZeEventView<ZeEventPool>(nullptr);
-  }
-
-  std::vector<ZeEventView<ZeEventPool>> new_events;
-  for (uint32_t i = 0; i < kOverflowSize; ++i) {
-    new_events.push_back(manager.AcquireEvent(ctx_));
-    EXPECT_NE(new_events.back().Get(), nullptr);
-  }
-}
-
-TEST_F(ZeEventPoolTestSuite, TestNonOwningSoftEventNullReset) {
-  ZeEventView<ZeEventPool> empty_event_view{nullptr};
-  EXPECT_TRUE(empty_event_view.Empty());
-  // ignore resets on empty events because we are no longer using it.
-  EXPECT_TRUE(empty_event_view.ResetSignal());
-}
-
-TEST_F(ZeEventPoolTestSuite, TestNonOwningSoftEventReset) {
-  constexpr uint32_t kPoolSize = 1;
-  ZeEventPool event_pool(ctx_, kPoolSize);
-
-  auto event0 = event_pool.AcquireEvent();
-  auto* event0_handle = event0.Get();
-  EXPECT_TRUE(event0.ResetSignal());
-  EXPECT_EQ(event0.Get(), event0_handle);
-}
diff --git a/sdk/test/ze_events_pools_observer_test.cc b/sdk/test/ze_events_pools_observer_test.cc
deleted file mode 100644
index a5e1d97d..00000000
--- a/sdk/test/ze_events_pools_observer_test.cc
+++ /dev/null
@@ -1,498 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <fmt/format.h>
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <atomic>
-#include <shared_mutex>
-#include <thread>
-#include <vector>
-
-#include "levelzero/ze_events_and_pools_observer.h"
-#include "utils/ze_config_info.h"
-#include "ze_utils.h"
-
-namespace {
-constexpr size_t kPtiDeviceId = 0;  // run on first device
-constexpr int kNumThreads = 8;
-constexpr int kPoolsPerThread = 10;
-constexpr uint32_t kEventsPerPool = 5;
-}  // namespace
-
-class ZeEventPoolsObserverTest : public testing::Test {
- protected:
-  void SetUp() override {
-    // Initialize Level Zero
-    auto status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    ASSERT_EQ(status, ZE_RESULT_SUCCESS);
-
-    drv_ = utils::ze::GetGpuDriver(kPtiDeviceId);
-    ASSERT_NE(drv_, nullptr);
-
-    dev_ = utils::ze::GetGpuDevice(kPtiDeviceId);
-    ASSERT_NE(dev_, nullptr);
-
-    ctx1_ = utils::ze::GetContext(drv_);
-    ASSERT_NE(ctx1_, nullptr);
-
-    ctx2_ = utils::ze::GetContext(drv_);
-    ASSERT_NE(ctx2_, nullptr);
-  }
-
-  void TearDown() override {
-    // Destroy all events first (must destroy before their pools)
-    for (auto event : events_) {
-      if (event) {
-        zeEventDestroy(event);
-      }
-    }
-    events_.clear();
-
-    // Destroy all event pools
-    for (auto pool : event_pools_) {
-      if (pool) {
-        zeEventPoolDestroy(pool);
-      }
-    }
-    event_pools_.clear();
-
-    if (ctx1_) {
-      zeContextDestroy(ctx1_);
-    }
-    if (ctx2_) {
-      zeContextDestroy(ctx2_);
-    }
-  }
-
-  ze_event_pool_handle_t CreateEventPool(ze_context_handle_t context, ze_event_pool_flags_t flags,
-                                         uint32_t count = 5,
-                                         EventPoolType type = EventPoolType::kRegular) {
-    ze_event_pool_desc_t pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr, flags, count};
-
-    // If counter-based, add the experimental descriptor
-    ze_event_pool_counter_based_exp_desc_t counter_desc = {};
-    if (type == EventPoolType::kCounterBased) {
-      counter_desc.stype = ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC;
-      counter_desc.pNext = nullptr;
-      counter_desc.flags = ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE;
-      pool_desc.pNext = &counter_desc;
-    }
-
-    ze_event_pool_handle_t pool = nullptr;
-    auto status = zeEventPoolCreate(context, &pool_desc, 1, &dev_, &pool);
-    EXPECT_EQ(status, ZE_RESULT_SUCCESS);
-
-    if (pool) {
-      event_pools_.push_back(pool);
-    }
-    return pool;
-  }
-
-  ze_event_handle_t CreateEvent(ze_event_pool_handle_t pool, uint32_t index = 0) {
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, index,
-                                  ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-
-    ze_event_handle_t event = nullptr;
-    auto status = zeEventCreate(pool, &event_desc, &event);
-    EXPECT_EQ(status, ZE_RESULT_SUCCESS);
-
-    if (event) {
-      events_.push_back(event);
-    }
-    return event;
-  }
-
-  ze_driver_handle_t drv_ = nullptr;
-  ze_device_handle_t dev_ = nullptr;
-  ze_context_handle_t ctx1_ = nullptr;
-  ze_context_handle_t ctx2_ = nullptr;
-  std::vector<ze_event_pool_handle_t> event_pools_;
-  std::vector<ze_event_handle_t> events_;
-};
-
-// ============================================================================
-// Tests for basic pool operations
-// ============================================================================
-TEST_F(ZeEventPoolsObserverTest, PoolsBasicTest) {
-  Level0Wrapper l0_wrapper;
-  ZeEventPoolsObserver observer(l0_wrapper);
-
-  //
-  // Add regular and mocked counter-based pools
-  // add them to Observer and check the returned properties
-  //
-  auto pool1 = CreateEventPool(ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  ASSERT_NE(pool1, nullptr);
-
-  auto added1 =
-      observer.Add(pool1, ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kRegular);
-  EXPECT_TRUE(added1) << "First add should return true";
-
-  ze_event_pool_flags_t flags =
-      ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
-  auto pool2 = CreateEventPool(ctx1_, flags, kEventsPerPool, EventPoolType::kCounterBased);
-  ASSERT_NE(pool2, nullptr);
-
-  auto added2 = observer.Add(pool2, ctx1_, flags, EventPoolType::kCounterBased);
-  EXPECT_TRUE(added2) << "First add should return true";
-
-  // Query and verify properties
-  auto props = observer.GetPoolProperties(pool1);
-  ASSERT_TRUE(props.has_value()) << "Should find existing pool";
-  EXPECT_EQ(props->type, EventPoolType::kRegular) << "Pool should be regular (not counter-based)";
-  EXPECT_TRUE(props->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP)
-      << "Pool should have timestamp flag";
-  EXPECT_FALSE(props->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE)
-      << "Pool should not have host visible flag";
-
-  auto props2 = observer.GetPoolProperties(pool2);
-  ASSERT_TRUE(props2.has_value());
-  EXPECT_EQ(props2->type, EventPoolType::kCounterBased) << "Pool should be counter-based";
-  EXPECT_TRUE(props2->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  EXPECT_TRUE(props2->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE);
-
-  // Create event from counter-based pool
-  auto counter_event = CreateEvent(pool2);
-  ASSERT_NE(counter_event, nullptr);
-
-  // Verify event inherits counter-based property
-  auto event_props = observer.GetEventProperties(counter_event);
-  ASSERT_TRUE(event_props.has_value());
-  EXPECT_EQ(event_props->type, EventPoolType::kCounterBased)
-      << "Event from counter-based pool should be counter-based";
-
-  //
-  // Add Existing Pool
-  //
-  auto added2_again =
-      observer.Add(pool2, ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kRegular);
-  EXPECT_FALSE(added2_again) << "Second add should return false";
-
-  // Verify that properties stay as when added first time
-  auto props3 = observer.GetPoolProperties(pool2);
-  EXPECT_TRUE(props3.has_value());
-  EXPECT_EQ(props3->type, props2->type);
-  EXPECT_EQ(props3->flags, props2->flags);
-
-  //
-  // Query Non-Existent Pool
-  //
-  // Create a pool but don't add it to observer
-  auto untracked_pool = CreateEventPool(ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  ASSERT_NE(untracked_pool, nullptr);
-
-  //  Query event from untracked pool
-  auto untracked_event = CreateEvent(untracked_pool);
-  ASSERT_NE(untracked_event, nullptr);
-  auto untracked_event_props = observer.GetEventProperties(untracked_event);
-  EXPECT_FALSE(untracked_event_props.has_value()) << "Event's pool not in cache";
-
-  //
-  // ClearPool
-  //
-  // Add some pools
-  auto pool_cleanup1 = CreateEventPool(ctx1_, 0);
-  auto pool_cleanup2 = CreateEventPool(ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  observer.Add(pool_cleanup1, ctx1_, 0, EventPoolType::kRegular);
-  observer.Add(pool_cleanup2, ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kRegular);
-
-  // Verify they exist and information stored
-  auto cleanup_props1 = observer.GetPoolProperties(pool_cleanup1);
-  auto cleanup_props2 = observer.GetPoolProperties(pool_cleanup2);
-  EXPECT_TRUE(cleanup_props1.has_value());
-  EXPECT_TRUE(cleanup_props2.has_value());
-  EXPECT_FALSE(cleanup_props1->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  EXPECT_TRUE(cleanup_props2->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  EXPECT_TRUE(cleanup_props1->type == EventPoolType::kRegular);
-  EXPECT_TRUE(cleanup_props2->type == EventPoolType::kRegular);
-
-  // Clean Pool in Observer
-  observer.ClearPool(pool_cleanup2);
-
-  // pool_cleanup2 is gone from observer, it does not know its types
-  auto after_cleanup1 = observer.GetPoolProperties(pool_cleanup1);
-  auto after_cleanup2 = observer.GetPoolProperties(pool_cleanup2);
-  EXPECT_TRUE(after_cleanup1.has_value());
-  EXPECT_FALSE(after_cleanup2.has_value());
-  EXPECT_FALSE(after_cleanup1->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-  EXPECT_TRUE(after_cleanup1->type == EventPoolType::kRegular);
-}
-
-// ============================================================================
-// Event-based queries and CleanContext
-// ============================================================================
-TEST_F(ZeEventPoolsObserverTest, EventsTest) {
-  Level0Wrapper l0_wrapper;
-  ZeEventPoolsObserver observer(l0_wrapper);
-
-  // Regular and counter-based event pool and events
-  auto regular_pool =
-      CreateEventPool(ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                      5, EventPoolType::kRegular);
-  ASSERT_NE(regular_pool, nullptr);
-
-  observer.Add(regular_pool, ctx1_,
-               ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-               EventPoolType::kRegular);
-
-  auto counter_pool = CreateEventPool(ctx2_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, 5,
-                                      EventPoolType::kCounterBased);  // true = counter-based
-  ASSERT_NE(counter_pool, nullptr);
-
-  observer.Add(counter_pool, ctx2_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP,
-               EventPoolType::kCounterBased);
-
-  auto regular_event = CreateEvent(regular_pool);
-  ASSERT_NE(regular_event, nullptr);
-  auto counter_event = CreateEvent(counter_pool);
-  ASSERT_NE(counter_event, nullptr);
-
-  // Query event properties
-  auto regular_event_props = observer.GetEventProperties(regular_event);
-  ASSERT_TRUE(regular_event_props.has_value());
-  EXPECT_EQ(regular_event_props->type, EventPoolType::kRegular)
-      << "Regular event should NOT be counter-based";
-  EXPECT_TRUE(regular_event_props->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP)
-      << "Regular event should inherit pool's timestamp flag";
-  EXPECT_TRUE(regular_event_props->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE)
-      << "Regular event should inherit pool's host-visible flag";
-
-  observer.ClearContext(ctx1_);
-  // After clearing context, regular event's pool should be gone,
-  // but counter-based still available
-
-  auto counter_event_props = observer.GetEventProperties(counter_event);
-  ASSERT_TRUE(counter_event_props.has_value());
-  EXPECT_EQ(counter_event_props->type, EventPoolType::kCounterBased)
-      << "Event from counter-based pool should be counter-based";
-  EXPECT_TRUE(counter_event_props->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP)
-      << "Counter event should inherit pool's timestamp flag";
-  EXPECT_FALSE(counter_event_props->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE)
-      << "Counter event pool didn't have host-visible flag";
-
-  regular_event_props = observer.GetEventProperties(regular_event);
-  ASSERT_FALSE(regular_event_props.has_value());
-}
-
-// ============================================================================
-// Parameterized test for multiple flag combinations
-// ============================================================================
-struct FlagTestCase {
-  ze_event_pool_flags_t flags;
-  EventPoolType type;
-  bool expect_timestamp;
-  bool expect_host_visible;
-};
-
-class FlagCombinationPoolsObserverTest : public ZeEventPoolsObserverTest,
-                                         public testing::WithParamInterface<FlagTestCase> {};
-
-TEST_P(FlagCombinationPoolsObserverTest, FlagCombinations) {
-  Level0Wrapper l0_wrapper;
-  ZeEventPoolsObserver observer(l0_wrapper);
-
-  const auto& tc = GetParam();
-
-  auto pool = CreateEventPool(ctx1_, tc.flags, kEventsPerPool, tc.type);
-  ASSERT_NE(pool, nullptr);
-
-  observer.Add(pool, ctx1_, tc.flags, tc.type);
-
-  auto tc_props = observer.GetPoolProperties(pool);
-  ASSERT_TRUE(tc_props.has_value());
-  EventPoolType expected_type = tc.type;
-  EXPECT_EQ(tc_props->type, expected_type);
-  EXPECT_EQ(static_cast<bool>(tc_props->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP),
-            tc.expect_timestamp);
-  EXPECT_EQ(static_cast<bool>(tc_props->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE),
-            tc.expect_host_visible);
-
-  // Test event from this pool
-  auto event = CreateEvent(pool);
-  ASSERT_NE(event, nullptr);
-
-  auto tc_event_props = observer.GetEventProperties(event);
-  ASSERT_TRUE(tc_event_props.has_value());
-  EXPECT_EQ(tc_event_props->type, expected_type)
-      << "Event should inherit pool's counter-based property";
-  EXPECT_EQ(static_cast<bool>(tc_event_props->flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP),
-            tc.expect_timestamp)
-      << "Event should inherit pool's timestamp flag";
-  EXPECT_EQ(static_cast<bool>(tc_event_props->flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE),
-            tc.expect_host_visible)
-      << "Event should inherit pool's host-visible flag";
-}
-
-INSTANTIATE_TEST_SUITE_P(
-    FlagCombinations, FlagCombinationPoolsObserverTest,
-    ::testing::Values(
-        // Regular pools
-        FlagTestCase{0, EventPoolType::kRegular, false, false},
-        FlagTestCase{ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kRegular, true, false},
-        FlagTestCase{ZE_EVENT_POOL_FLAG_HOST_VISIBLE, EventPoolType::kRegular, false, true},
-        FlagTestCase{ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                     EventPoolType::kRegular, true, true},
-        // Counter-based pools
-        FlagTestCase{ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kCounterBased, true,
-                     false},
-        FlagTestCase{ZE_EVENT_POOL_FLAG_HOST_VISIBLE, EventPoolType::kCounterBased, false, true},
-        FlagTestCase{ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                     EventPoolType::kCounterBased, true, true}),
-
-    [](const testing::TestParamInfo<FlagCombinationPoolsObserverTest::ParamType>& info) {
-      std::string name = "Flags";
-      if (info.param.flags & ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP) {
-        name += "_Timestamp";
-      }
-      if (info.param.flags & ZE_EVENT_POOL_FLAG_HOST_VISIBLE) {
-        name += "_HostVisible";
-      }
-      if (info.param.type == EventPoolType::kCounterBased) {
-        name += "_CounterBased";
-      } else {
-        name += "_Regular";
-      }
-      return name;
-    });
-
-// ============================================================================
-// Tests for thread safety
-// ============================================================================
-TEST_F(ZeEventPoolsObserverTest, PoolMultithreadedTest) {
-  Level0Wrapper l0_wrapper;
-  ZeEventPoolsObserver observer(l0_wrapper);
-
-  std::atomic<int> ready{0};
-  std::vector<std::thread> threads;
-  std::vector<std::vector<ze_event_pool_handle_t>> event_pools_per_thread(kNumThreads);
-
-  for (int t = 0; t < kNumThreads; ++t) {
-    threads.emplace_back([&, t]() {
-      ready++;
-      while (ready.load() < kNumThreads) {
-      }  // Synchronize start
-
-      for (int i = 0; i < kPoolsPerThread; ++i) {
-        ze_event_pool_flags_t flags = (i % 2 == 0) ? ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP : 0;
-        bool is_counter = (i % 3 == 0);
-
-        ze_event_pool_desc_t pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr, flags, 10};
-
-        ze_event_pool_handle_t pool = nullptr;
-        auto status = zeEventPoolCreate(ctx1_, &pool_desc, 1, &dev_, &pool);
-        if (status == ZE_RESULT_SUCCESS && pool) {
-          event_pools_per_thread[t].push_back(pool);
-          observer.Add(pool, ctx1_, flags,
-                       (is_counter ? EventPoolType::kCounterBased : EventPoolType::kRegular));
-        }
-      }
-    });
-  }
-
-  for (auto& th : threads) {
-    if (th.joinable()) {
-      th.join();
-    }
-  }
-
-  // Verify all pools were added correctly
-  for (int t = 0; t < kNumThreads; ++t) {
-    for (size_t i = 0; i < event_pools_per_thread[t].size(); ++i) {
-      auto pool = event_pools_per_thread[t][i];
-      auto pool_props = observer.GetPoolProperties(pool);
-      ASSERT_TRUE(pool_props.has_value()) << "Pool should exist after concurrent adds";
-      EventPoolType expected_pool_type =
-          (i % 3 == 0) ? EventPoolType::kCounterBased : EventPoolType::kRegular;
-      EXPECT_EQ(pool_props->type, expected_pool_type);
-      ze_event_pool_flags_t expected_pool_flags =
-          (i % 2 == 0) ? ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP : 0;
-      EXPECT_EQ(pool_props->flags, expected_pool_flags);
-    }
-
-    // Clean up pools
-    for (auto pool : event_pools_per_thread[t]) {
-      zeEventPoolDestroy(pool);
-    }
-  }
-
-  observer.ClearAll();
-  ready.store(0);
-  threads.clear();
-
-  // Concurrent Reads and Writes
-  constexpr int kNumReaderThreads = 4;
-  constexpr int kNumWriterThreads = 4;
-  constexpr int kOperationsPerThread = 500;
-  constexpr int kNumPools = 20;
-
-  std::vector<ze_event_pool_handle_t> shared_pools;
-  for (int i = 0; i < kNumPools; ++i) {
-    ze_context_handle_t context = (i % 2 == 0) ? ctx1_ : ctx2_;
-    auto pool = CreateEventPool(context, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP);
-    if (pool) {
-      shared_pools.push_back(pool);
-      observer.Add(pool, context, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP, EventPoolType::kRegular);
-    }
-  }
-
-  ASSERT_EQ(shared_pools.size(), kNumPools) << "Failed to create all pools for concurrent test";
-
-  // Writer threads
-  for (int t = 0; t < kNumWriterThreads; ++t) {
-    threads.emplace_back([&]() {
-      ready++;
-      while (ready.load() < (kNumReaderThreads + kNumWriterThreads)) {
-      }
-
-      for (int i = 0; i < kOperationsPerThread; ++i) {
-        auto pool = shared_pools[i % shared_pools.size()];
-        if (i % 2) {
-          auto res = observer.Add(pool, ctx1_, ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-                                  EventPoolType::kCounterBased);
-          EXPECT_FALSE(res);
-        } else {
-          auto res = observer.Add(pool, ctx1_, ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP,
-                                  EventPoolType::kRegular);
-          EXPECT_FALSE(res);
-        }
-      }
-    });
-  }
-
-  // Reader threads
-  for (int t = 0; t < kNumReaderThreads; ++t) {
-    threads.emplace_back([&]() {
-      ready++;
-      while (ready.load() < (kNumReaderThreads + kNumWriterThreads)) {
-      }
-
-      for (int i = 0; i < kOperationsPerThread; ++i) {
-        auto pool = shared_pools[i % shared_pools.size()];
-
-        // Query properties - should not crash even under contention
-        auto read_props = observer.GetPoolProperties(pool);
-
-        // Should always find it since it was pre-populated
-        EXPECT_TRUE(read_props.has_value());
-
-        // Verify invariants based on what writers set
-        if (read_props.has_value()) {
-          EXPECT_EQ(read_props->type, EventPoolType::kRegular)
-              << "Pool type should stay to regular";
-        }
-      }
-    });
-  }
-
-  for (auto& th : threads) {
-    if (th.joinable()) {
-      th.join();
-    }
-  }
-
-}  // namespace
diff --git a/sdk/test/ze_kernel_name_cache_test.cc b/sdk/test/ze_kernel_name_cache_test.cc
deleted file mode 100644
index 7399e115..00000000
--- a/sdk/test/ze_kernel_name_cache_test.cc
+++ /dev/null
@@ -1,441 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "ze_kernel_name_cache.h"
-
-#include <gtest/gtest.h>
-#include <level_zero/ze_api.h>
-
-#include <atomic>
-#include <string>
-#include <thread>
-#include <vector>
-
-namespace {
-
-// Mock kernel name fetcher for testing
-// Tracks call count to verify cache hits vs misses
-struct CountingFetcher {
-  mutable std::atomic<int> call_count{0};
-
-  std::string operator()(ze_kernel_handle_t kernel, bool demangle) const {
-    ++call_count;
-    // Generate predictable names based on kernel handle and demangle flag
-    std::string base_name = "TestKernel_" + std::to_string(reinterpret_cast<uintptr_t>(kernel));
-    return demangle ? ("demangled_" + base_name) : base_name;
-  }
-};
-
-}  // namespace
-
-class ZeKernelNameCacheTest : public ::testing::Test {
- protected:
-  // Helper to create fake kernel handles for testing
-  static ze_kernel_handle_t MakeKernel(uintptr_t id) {
-    return reinterpret_cast<ze_kernel_handle_t>(id);
-  }
-};
-
-// =============================================================================
-// Basic Functionality Tests
-// =============================================================================
-
-TEST_F(ZeKernelNameCacheTest, CacheHitForSameKernel) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // First call - cache miss
-  std::string name1 = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 1);
-
-  // Second call - cache hit (no new fetch)
-  std::string name2 = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 1);  // Still 1!
-
-  EXPECT_EQ(name1, name2);
-  EXPECT_EQ(name1, "TestKernel_256");  // 0x100 = 256
-}
-
-TEST_F(ZeKernelNameCacheTest, CacheMissForDifferentKernels) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel1 = MakeKernel(0x100);
-  auto kernel2 = MakeKernel(0x200);
-  auto kernel3 = MakeKernel(0x300);
-
-  // Each kernel causes a cache miss
-  cache.GetKernelName(kernel1, false);
-  EXPECT_EQ(fetcher.call_count, 1);
-
-  cache.GetKernelName(kernel2, false);
-  EXPECT_EQ(fetcher.call_count, 2);
-
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 3);
-
-  // Accessing them again should hit the cache
-  cache.GetKernelName(kernel1, false);
-  cache.GetKernelName(kernel2, false);
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 3);  // Still 3!
-}
-
-TEST_F(ZeKernelNameCacheTest, MangledAndDemangledCachedSeparately) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Fetch mangled version
-  std::string mangled = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 1);
-  EXPECT_EQ(mangled, "TestKernel_256");
-
-  // Fetch demangled version - separate cache entry, causes new fetch
-  std::string demangled = cache.GetKernelName(kernel, true);
-  EXPECT_EQ(fetcher.call_count, 2);
-  EXPECT_EQ(demangled, "demangled_TestKernel_256");
-
-  // Fetch mangled again - cached
-  std::string mangled2 = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 2);  // Still 2
-  EXPECT_EQ(mangled2, mangled);
-
-  // Fetch demangled again - cached
-  std::string demangled2 = cache.GetKernelName(kernel, true);
-  EXPECT_EQ(fetcher.call_count, 2);  // Still 2
-  EXPECT_EQ(demangled2, demangled);
-}
-
-TEST_F(ZeKernelNameCacheTest, RepeatedAccessesSameResult) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Call multiple times
-  std::string name1 = cache.GetKernelName(kernel, false);
-  std::string name2 = cache.GetKernelName(kernel, false);
-  std::string name3 = cache.GetKernelName(kernel, false);
-  std::string name4 = cache.GetKernelName(kernel, false);
-  std::string name5 = cache.GetKernelName(kernel, false);
-
-  // All should be identical
-  EXPECT_EQ(name1, name2);
-  EXPECT_EQ(name2, name3);
-  EXPECT_EQ(name3, name4);
-  EXPECT_EQ(name4, name5);
-
-  // Only one fetch should have occurred
-  EXPECT_EQ(fetcher.call_count, 1);
-}
-
-// =============================================================================
-// Lifecycle Management Tests
-// =============================================================================
-
-TEST_F(ZeKernelNameCacheTest, RemoveKernelInvalidatesEntry) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Populate cache
-  cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 1);
-
-  // Remove from cache
-  cache.RemoveKernel(kernel);
-
-  // Next access causes re-fetch
-  cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 2);
-}
-
-TEST_F(ZeKernelNameCacheTest, RemoveNonExistentKernelDoesNotCrash) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Remove kernel that was never added - should not crash
-  EXPECT_NO_THROW(cache.RemoveKernel(kernel));
-}
-
-TEST_F(ZeKernelNameCacheTest, ClearRemovesAllEntries) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel1 = MakeKernel(0x100);
-  auto kernel2 = MakeKernel(0x200);
-  auto kernel3 = MakeKernel(0x300);
-
-  // Populate cache
-  cache.GetKernelName(kernel1, false);
-  cache.GetKernelName(kernel2, false);
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 3);
-
-  // Clear cache
-  cache.Clear();
-
-  // All accesses cause re-fetch
-  cache.GetKernelName(kernel1, false);
-  EXPECT_EQ(fetcher.call_count, 4);
-
-  cache.GetKernelName(kernel2, false);
-  EXPECT_EQ(fetcher.call_count, 5);
-
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 6);
-}
-
-TEST_F(ZeKernelNameCacheTest, MultipleKernelsIndependentLifecycles) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel1 = MakeKernel(0x100);
-  auto kernel2 = MakeKernel(0x200);
-  auto kernel3 = MakeKernel(0x300);
-
-  // Populate cache
-  cache.GetKernelName(kernel1, false);
-  cache.GetKernelName(kernel2, false);
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 3);
-
-  // Remove only kernel2
-  cache.RemoveKernel(kernel2);
-
-  // kernel1 and kernel3 should still be cached
-  cache.GetKernelName(kernel1, false);
-  EXPECT_EQ(fetcher.call_count, 3);  // No new fetch
-
-  cache.GetKernelName(kernel3, false);
-  EXPECT_EQ(fetcher.call_count, 3);  // No new fetch
-
-  // kernel2 should cause re-fetch
-  cache.GetKernelName(kernel2, false);
-  EXPECT_EQ(fetcher.call_count, 4);
-}
-
-// =============================================================================
-// Thread Safety Tests
-// =============================================================================
-
-TEST_F(ZeKernelNameCacheTest, ConcurrentReadsSameKernel) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  constexpr int kNumThreads = 10;
-  std::vector<std::thread> threads;
-  std::atomic<int> success_count{0};
-  std::vector<std::string> results(kNumThreads);
-
-  // Launch threads that all try to read the same kernel
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i]() {
-      results[i] = cache.GetKernelName(kernel, false);
-      if (results[i] == "TestKernel_256") {
-        ++success_count;
-      }
-    });
-  }
-
-  // Wait for all threads
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // All threads should succeed
-  EXPECT_EQ(success_count, kNumThreads);
-
-  // All results should be identical
-  for (int i = 1; i < kNumThreads; ++i) {
-    EXPECT_EQ(results[i], results[0]);
-  }
-  // Only one fetch should have occurred
-  EXPECT_LE(fetcher.call_count, 1);
-}
-
-TEST_F(ZeKernelNameCacheTest, ConcurrentWritesDifferentKernels) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  constexpr int kNumThreads = 10;
-  std::vector<std::thread> threads;
-
-  // Each thread accesses a different kernel
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i]() {
-      auto kernel = MakeKernel(0x100 + i);
-      std::string name = cache.GetKernelName(kernel, false);
-      EXPECT_FALSE(name.empty());
-    });
-  }
-
-  // Wait for all threads
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Each kernel should have been fetched exactly once
-  EXPECT_EQ(fetcher.call_count, kNumThreads);
-
-  // Accessing all kernels again should hit cache
-  int initial_count = fetcher.call_count;
-  for (int i = 0; i < kNumThreads; ++i) {
-    auto kernel = MakeKernel(0x100 + i);
-    cache.GetKernelName(kernel, false);
-  }
-  EXPECT_EQ(fetcher.call_count, initial_count);  // No new fetches
-}
-
-TEST_F(ZeKernelNameCacheTest, ConcurrentMixedOperations) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  constexpr int kNumThreads = 12;
-  std::vector<std::thread> threads;
-  std::atomic<bool> start{false};
-
-  auto kernel1 = MakeKernel(0x100);
-  auto kernel2 = MakeKernel(0x200);
-  auto kernel3 = MakeKernel(0x300);
-
-  // Mix of operations: read, write, remove
-  for (int i = 0; i < kNumThreads; ++i) {
-    threads.emplace_back([&, i]() {
-      // Wait for all threads to be ready
-      while (!start.load()) {
-        std::this_thread::yield();
-      }
-
-      if (i % 3 == 0) {
-        // Read kernel1
-        cache.GetKernelName(kernel1, false);
-      } else if (i % 3 == 1) {
-        // Read kernel2
-        cache.GetKernelName(kernel2, false);
-      } else {
-        // Read kernel3
-        cache.GetKernelName(kernel3, false);
-      }
-    });
-  }
-
-  // Start all threads simultaneously
-  start = true;
-
-  // Wait for completion
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Cache should still be consistent
-  EXPECT_NO_THROW(cache.GetKernelName(kernel1, false));
-  EXPECT_NO_THROW(cache.GetKernelName(kernel2, false));
-  EXPECT_NO_THROW(cache.GetKernelName(kernel3, false));
-}
-
-TEST_F(ZeKernelNameCacheTest, StressTestManyKernels) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  constexpr int kNumKernels = 1000;
-  constexpr int kNumThreads = 8;
-  std::vector<std::thread> threads;
-
-  // Each thread accesses a different range of kernels
-  for (int t = 0; t < kNumThreads; ++t) {
-    threads.emplace_back([&, t]() {
-      int start = t * (kNumKernels / kNumThreads);
-      int end = (t + 1) * (kNumKernels / kNumThreads);
-
-      for (int i = start; i < end; ++i) {
-        auto kernel = MakeKernel(0x1000 + i);
-        std::string name = cache.GetKernelName(kernel, false);
-        EXPECT_FALSE(name.empty());
-      }
-    });
-  }
-
-  // Wait for all threads
-  for (auto& t : threads) {
-    t.join();
-  }
-
-  // Each kernel should have been fetched exactly once
-  EXPECT_EQ(fetcher.call_count, kNumKernels);
-
-  // Test cache hit for random kernels
-  int initial_count = fetcher.call_count;
-  cache.GetKernelName(MakeKernel(0x1000), false);
-  cache.GetKernelName(MakeKernel(0x1100), false);
-  cache.GetKernelName(MakeKernel(0x1200), false);
-  EXPECT_EQ(fetcher.call_count, initial_count);  // All cached
-}
-
-// =============================================================================
-// Edge Cases
-// =============================================================================
-
-TEST_F(ZeKernelNameCacheTest, EmptyCacheOperations) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Clear on empty cache should not crash
-  EXPECT_NO_THROW(cache.Clear());
-
-  // Remove on empty cache should not crash
-  EXPECT_NO_THROW(cache.RemoveKernel(kernel));
-}
-
-TEST_F(ZeKernelNameCacheTest, SameKernelMangledThenDemangled) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  // Access in different order
-  std::string mangled = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 1);
-
-  std::string demangled = cache.GetKernelName(kernel, true);
-  EXPECT_EQ(fetcher.call_count, 2);
-
-  // Both should remain cached
-  std::string mangled2 = cache.GetKernelName(kernel, false);
-  EXPECT_EQ(fetcher.call_count, 2);
-  EXPECT_EQ(mangled2, mangled);
-
-  std::string demangled2 = cache.GetKernelName(kernel, true);
-  EXPECT_EQ(fetcher.call_count, 2);
-  EXPECT_EQ(demangled2, demangled);
-}
-
-TEST_F(ZeKernelNameCacheTest, RapidAddRemoveCycles) {
-  CountingFetcher fetcher;
-  ZeKernelNameCache<CountingFetcher&> cache(fetcher);
-
-  auto kernel = MakeKernel(0x100);
-
-  constexpr int kCycles = 100;
-  for (int i = 0; i < kCycles; ++i) {
-    cache.GetKernelName(kernel, false);
-    cache.RemoveKernel(kernel);
-  }
-
-  // Should have fetched kCycles times (once per cycle)
-  EXPECT_EQ(fetcher.call_count, kCycles);
-}
diff --git a/sdk/third-party/.clang-format b/sdk/third-party/.clang-format
deleted file mode 100644
index e3845288..00000000
--- a/sdk/third-party/.clang-format
+++ /dev/null
@@ -1 +0,0 @@
-DisableFormat: true
diff --git a/sdk/third-party/README.md b/sdk/third-party/README.md
deleted file mode 100644
index 1742f801..00000000
--- a/sdk/third-party/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Third Party Projects
-
-## File structure
-
-```
-third-party/
-├── compute-runtime/
-│   └── third-party.txt
-├── ../
-│   └── third-party.txt
-└── some-3rd-party-project/
-    └── third-party.txt
-```
-
-## Info
-
-Contains vendored third party projects used by Intel(R) PTI that are not
-practical to be used by CMake's `FetchContent`. `FetchContent` is typically the
-preferred way to consume third party projects.
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/CMakeLists.txt b/sdk/third-party/compute-runtime/level_zero/include/level_zero/CMakeLists.txt
deleted file mode 100644
index e4183356..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/CMakeLists.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Copyright (C) 2024-2025 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-set(L0_API_INCLUDE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/ze_intel_gpu.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/ze_intel_results.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/ze_stypes.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zet_intel_gpu_debug.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zes_intel_gpu_sysman.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zet_intel_gpu_metric.h
-)
-
-target_sources(${L0_STATIC_LIB_NAME}
-               PRIVATE
-               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-               ${L0_API_INCLUDE_FILES}
-               ${CMAKE_CURRENT_SOURCE_DIR}/zet_intel_gpu_metric_export.h
-)
-
-if(UNIX)
-  install(FILES
-          ${L0_API_INCLUDE_FILES}
-          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/level_zero
-          PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  )
-endif()
-
-add_subdirectories()
-
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/CMakeLists.txt b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/CMakeLists.txt
deleted file mode 100644
index 142320d0..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/CMakeLists.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-#
-# Copyright (C) 2024-2026 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-set(L0_API_DRIVER_EXPERIMENTAL_INCLUDE_FILES
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_api.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_cmdlist.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_common.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_context.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_driver.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_event.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_graph.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_memory.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_module.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/zex_visit.h
-)
-
-target_sources(${L0_STATIC_LIB_NAME}
-               PRIVATE
-               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-               ${L0_API_DRIVER_EXPERIMENTAL_INCLUDE_FILES}
-)
-
-if(UNIX)
-  install(FILES
-          ${L0_API_DRIVER_EXPERIMENTAL_INCLUDE_FILES}
-          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/level_zero/driver_experimental
-          PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  )
-endif()
-
-add_subdirectories()
\ No newline at end of file
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/CMakeLists.txt b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/CMakeLists.txt
deleted file mode 100644
index 1307c8cd..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/CMakeLists.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-#
-# Copyright (C) 2025 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-target_sources(${L0_STATIC_LIB_NAME}
-               PRIVATE
-               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-               ${CMAKE_CURRENT_SOURCE_DIR}/ze_mutable_command_list_exp.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_control_flow_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_dispatch_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_serialization_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_temp_mem_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_variable_ext.h
-               ${CMAKE_CURRENT_SOURCE_DIR}/zex_mutable_cmdlist_variable_info_ext.h
-)
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/ze_mutable_command_list_exp.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/ze_mutable_command_list_exp.h
deleted file mode 100644
index 7c616101..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/ze_mutable_command_list_exp.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include <level_zero/ze_api.h>
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListGetNextCommandIdExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const ze_mutable_command_id_exp_desc_t *desc,
-    uint64_t *pCommandId);
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListUpdateMutableCommandsExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const ze_mutable_commands_exp_desc_t *desc);
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    uint64_t commandId,
-    ze_event_handle_t hSignalEvent);
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    uint64_t commandId,
-    uint32_t numWaitEvents,
-    ze_event_handle_t *phWaitEvents);
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const ze_mutable_command_id_exp_desc_t *desc,
-    uint32_t numKernels,
-    ze_kernel_handle_t *phKernels,
-    uint64_t *pCommandId);
-
-typedef ze_result_t(ZE_APICALL *ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    uint32_t numKernels,
-    uint64_t *pCommandId,
-    ze_kernel_handle_t *phKernels);
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_control_flow_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_control_flow_ext.h
deleted file mode 100644
index 03fa9007..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_control_flow_ext.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Label handle.
-typedef struct _zex_label_handle_t *zex_label_handle_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Label descriptor.
-typedef struct _zex_label_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure ZEX_STRUCTURE_TYPE_LABEL_DESCRIPTOR
-    const void *pNext;             ///< [in][optional] pointer to extension-specific structure
-    const char *name;              ///< [in][optional] null-terminated name of the label
-    uint32_t alignment;            ///< [in][optional] minimum alignment of the label
-} zex_label_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Operand flags
-typedef uint32_t zex_operand_flags_t;
-typedef enum _zex_operand_flag_t {
-    ZEX_OPERAND_FLAG_USES_VARIABLE = ZE_BIT(0), // variable is being used - passed via memory
-    ZEX_OPERAND_FLAG_JUMP_ON_CLEAR = ZE_BIT(1)  // jump on '0', instead of default '1'
-} zex_operand_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Operand descriptor.
-typedef struct _zex_operand_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure ZEX_STRUCTURE_TYPE_OPERAND_DESCRIPTOR
-    const void *pNext;             ///< [in][optional] pointer to extension-specific structure
-    void *memory;                  ///< [in] if memory is NULL then offset is interpreted as MMIO
-                                   ///< if flag ZEX_OPERAND_FLAG_USES_VARIABLE is set memory is interpreted as variable
-    size_t offset;                 ///< [in] offset within memory or register MMIO
-    uint32_t size;                 ///< [in] operand size - dword
-    zex_operand_flags_t flags;     ///< [in] flags
-} zex_operand_desc_t;
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Creates/returns label based on name provided in
-///        label descriptor.
-///
-/// @details
-///     - When label with the name provided in label descriptor does not
-///       exist new label is created.
-///     - If label with provided name exists it's returned.
-///     - Label at creation is undefined (points to nothing).
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hCommandList
-///         + nullptr == pLabelDesc
-///         + nullptr == phLabel
-///         + pLabelDesc->alignment & (pLabelDesc->alignment - 1) != 0
-///     - ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///         + bad_alloc
-ze_result_t ZE_APICALL
-zexCommandListGetLabel(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of command list
-    const zex_label_desc_t *pLabelDesc,    ///< [in] pointer to label descriptor
-    zex_label_handle_t *phLabel            ///< [out] pointer to handle of label
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets label to point to current location in command list.
-///
-/// @details
-///     - Sets label address to current location.
-///     - All previous jumps to this label are patched with label's address.
-///     - Future jumps to this label will be patched with label's address.
-///     - Label can be set only once.
-///     - Label must be located in the same command list, as it was created
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hCommandList
-///         + nullptr == hLabel
-///     - ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///         + variable already set
-///     - ZE_RESULT_ERROR_UNSUPPORTED_ALIGNMENT
-///         + label's address is not aligned to it's alignment
-ze_result_t ZE_APICALL
-zexCommandListSetLabel(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of command list
-    zex_label_handle_t hLabel              ///< [in] handle of label
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends jump to label predicated by condition.
-///
-/// @details
-///     If condition is present:
-///        If condition->memory is present:
-///            If ZEX_OPERAND_FLAG_USES_VARIABLE flag is set:
-///              - Append MI_LOAD_REGISTER_MEM
-///                 reg = PREDICATE_RESULT_2
-///                 memAddr = gpu address of buffer variable
-///            Else:
-///              - Append MI_LOAD_REGISTER_MEM
-///                reg = PREDICATE_RESULT_2
-///                memAddr = pCondition->memory + pCondition->offset
-///        Else:
-///          - Append MI_LOAD_REGISTER_REG
-///            regDst = PREDICATE_RESULT_2
-///            regSrc = pCondition->offset (need to pass MMIO)
-///
-///        If ZEX_OPERAND_FLAG_JUMP_ON_CLEAR flag is set: //  jumps when '0'
-///          - Append MI_SET_PREDICATE(ENABLE_ON_SET)
-///        Else:                                          //  jumps when '1'
-///          - Append MI_SET_PREDICATE(ENABLE_ON_CLEAR)
-///
-///     - Append MI_BATCH_BUFFER_START
-///       predicationEnabled = condition is present
-///       jumpAddress = label's address
-///     - Append MI_SET_PREDICATE(DISABLE) - after BB_START
-///     - Append MI_SET_PREDICATE(DISABLE) - at label's address
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hCommandList
-///         + nullptr == hLabel
-ze_result_t ZE_APICALL
-zexCommandListAppendJump(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of command list
-    zex_label_handle_t hLabel,             ///< [in] handle of label
-    zex_operand_desc_t *pCondition         ///< [in][opt] pointer to operand
-);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListGetLabelCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const zex_label_desc_t *pLabelDesc,
-    zex_label_handle_t *phLabel);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListSetLabelCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_label_handle_t hLabel);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendJumpCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_label_handle_t hLabel,
-    zex_operand_desc_t *pCondition);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_dispatch_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_dispatch_ext.h
deleted file mode 100644
index 805f3ce0..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_dispatch_ext.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h"
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets kernel group size to provided variable.
-ze_result_t ZE_APICALL
-zexKernelSetVariableGroupSize(
-    ze_kernel_handle_t hKernel,              ///< [in] handle of kernel
-    zex_variable_handle_t hGroupSizeVariable ///< [in] handle of variable
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends kernel launch to command list with variable group size.
-ze_result_t ZE_APICALL
-zexCommandListAppendVariableLaunchKernel(
-    ze_command_list_handle_t hCommandList,     ///< [in] hnadle of mutable command list
-    ze_kernel_handle_t hKernel,                ///< [in] handle of kernel
-    zex_variable_handle_t hGroupCountVariable, ///< [in] handle of variable
-    ze_event_handle_t hSignalEvent,            ///< [in] handle to signal event
-    uint32_t numWaitEvents,                    ///< [in] num events to wait for
-    ze_event_handle_t *phWaitEvents);          ///< [in] array of events to wait for
-
-typedef ze_result_t(ZE_APICALL *zex_pfnKernelSetVariableGroupSizeCb_t)(
-    ze_kernel_handle_t hKernel,
-    zex_variable_handle_t hGroupSizeVariable);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendVariableLaunchKernelCb_t)(
-    ze_command_list_handle_t hCommandList,
-    ze_kernel_handle_t hKernel,
-    zex_variable_handle_t hGroupCountVariable,
-    ze_event_handle_t hSignalEvent,
-    uint32_t numWaitEvents,
-    ze_event_handle_t *phWaitEvents);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_ext.h
deleted file mode 100644
index 4392452e..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_ext.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "level_zero/driver_experimental/mcl_ext/ze_mutable_command_list_exp.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_control_flow_ext.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_dispatch_ext.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_serialization_ext.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_temp_mem_ext.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h"
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_info_ext.h"
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_serialization_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_serialization_ext.h
deleted file mode 100644
index 9e8d3466..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_serialization_ext.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Retrieve native MCL binary from cmdlist.
-ze_result_t ZE_APICALL
-zexCommandListGetNativeBinary(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    void *pBinary,                         ///< [in,out][optional] byte pointer to native MCL binary
-    size_t *pBinarySize,                   ///< [in,out] size of native MCL binary in bytes
-    const void *pModule,                   ///< [in] byte pointer to module containing kernels' used in cmdlist
-    size_t moduleSize                      ///< [in] size in bytes of module containing kernels's used in cmdlist
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Load command list from native MCL binary.
-ze_result_t ZE_APICALL
-zexCommandListLoadNativeBinary(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    const void *pBinary,                   ///< [in] byte pointer to native MCL binary
-    size_t binarySize                      ///< [in] size of native MCL binary in bytes
-);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListGetNativeBinaryCb_t)(
-    ze_command_list_handle_t hCommandList,
-    void *pBinary,
-    size_t *pBinarySize,
-    const void *pModule,
-    size_t moduleSize);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListLoadNativeBinaryCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const void *pBinary,
-    size_t binarySize);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_temp_mem_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_temp_mem_ext.h
deleted file mode 100644
index 7318f737..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_temp_mem_ext.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h"
-#include "level_zero/ze_stypes.h"
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Temporary variable flags
-typedef uint32_t zex_temp_variable_flags_t;
-typedef enum _zex_temp_variable_flag_t {
-    ZEX_TEMP_VARIABLE_FLAGS_IS_CONST_SIZE = ZE_BIT(0), ///< temp variable has constant size
-    ZEX_TEMP_VARIABLE_FLAGS_IS_SCALABLE = ZE_BIT(1)    ///< temp variable scales with num elements
-} zex_temp_variable_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Temporary variable type
-typedef enum _zex_temp_variable_type_t {
-    ZEX_TEMP_VARIABLE_TYPE_CONST_SIZE = 0, ///< temp variable has constant size
-    ZEX_TEMP_VARIABLE_TYPE_SCALABLE = 1    ///< temp variable scales with num elements
-} zex_temp_variable_type_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Temporary variable descriptor
-typedef struct _zex_temp_variable_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure ZEX_STRUCTURE_TYPE_TEMP_VARIABLE_DESCRIPTOR
-    const void *pNext;             ///< [in][optional] pointer to extension-specific structure
-    zex_temp_variable_flags_t flags;
-    size_t size;
-} zex_temp_variable_desc_t;
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets number of elements used by scalable temporary variables.
-ze_result_t ZE_APICALL
-zexCommandListTempMemSetEleCount(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    size_t eleCount);                      ///< [in] number of elements
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Returns size of the buffer required for all temporary variables.
-ze_result_t ZE_APICALL
-zexCommandListTempMemGetSize(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    size_t *pTempMemSize);                 ///< [in,out] size of temporary memory buffer
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets buffer used by temporary variables.
-ze_result_t ZE_APICALL
-zexCommandListTempMemSet(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    const void *pTempMem);                 ///< [in] ptr to temporary memory buffer
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListTempMemSetEleCountCb_t)(
-    ze_command_list_handle_t hCommandList,
-    size_t eleCount);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListTempMemGetSizeCb_t)(
-    ze_command_list_handle_t hCommandList,
-    size_t *pTempMemSize);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListTempMemSetCb_t)(
-    ze_command_list_handle_t hCommandList,
-    const void *pTempMem);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h
deleted file mode 100644
index 28fc7c6b..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h
+++ /dev/null
@@ -1,307 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable handle
-typedef struct _zex_variable_handle_t *zex_variable_handle_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable descriptor
-typedef struct _zex_variable_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure ZEX_STRUCTURE_TYPE_VARIABLE_DESCRIPTOR
-    const void *pNext;             ///< [in][optional] pointer to extension-specific structure
-    const char *name;              ///< [in][optional] null-terminated name of the variable
-} zex_variable_desc_t;
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Creates/returns variable based on name provided in
-///        variable descriptor.
-///
-/// @details
-///     - When variable with the name provided in variable descriptor does not
-///       exist new variable is created.
-///     - Variable at creation has no type attached to it (can be set to buffer, image, etc).
-///     - If variable with provided name exists it's returned.
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///         + bad_alloc
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hCmdList
-///         + nullptr == pVariableDescriptor
-///         + nullptr == phVariable
-ze_result_t ZE_APICALL
-zexCommandListGetVariable(
-    ze_command_list_handle_t hCmdList,              ///< [in] handle of mutable command list
-    const zex_variable_desc_t *pVariableDescriptor, ///< [in] pointer to variable descriptor
-    zex_variable_handle_t *phVariable               ///< [in,out] pointer to handle of variable
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets kernel argument to be a variable.
-///
-/// @details
-///     - Variable will be used as kernel argument at argIndex.
-///     - If variable is used for first time sets it's type accordingly,
-///       else checks if type is right.
-///     - On zeCommandListAppendLaunchKernel, variable will be notified of it's
-///       usage in kernel.
-///     - On zexVariableSetValue all usages will be patched - kernel argument will be set.
-///     - If kernel has not yet been appended using zeCommandListAppendLaunchKernel
-///       it can be overridden with zeKernelSetArgumentValue(). Argument stops being a variable.
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hKernel
-///         + nullptr == hVariable
-///         + kernelArgType != variable->type
-ze_result_t ZE_APICALL
-zexKernelSetArgumentVariable(
-    ze_kernel_handle_t hKernel,     ///< [in] handle of kernel
-    uint32_t argIndex,              ///< [in] argument index in kernel
-    zex_variable_handle_t hVariable ///< [in] handle of variable
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Sets variable's value.
-///
-/// @details
-///     - Sets variable's value based on variable's type.
-///     - Patches all variable's usages with it's value.
-///     - Can be called multiple times to override previous value.
-///     - If variable is a buffer:
-///       - Adds buffer to residency container
-///       - If variable already set remove buffer form residency container
-///
-/// @returns
-///     - ZE_RESULT_SUCCESS
-///     - ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + nullptr == hVariable
-///         + nullptr == pValue
-///         + variable->size != valueSize
-///     - ZE_RESULT_UNSUPPORTED_FEATURE
-///         + variable->type != Type::Buffer ;for now only works with buffers
-ze_result_t ZE_APICALL
-zexVariableSetValue(
-    zex_variable_handle_t hVariable, ///< [in] handle of variable
-    uint32_t flags,                  ///< [in] flags
-    size_t valueSize,                ///< [in] size of value
-    const void *pValue               ///< [in] pointer to value
-);
-
-typedef enum _zex_mcl_alu_reg_t {
-    ZE_MCL_ALU_REG_GPR0 = 0,
-    ZE_MCL_ALU_REG_GPR0_1 = 1,
-    ZE_MCL_ALU_REG_GPR1 = 2,
-    ZE_MCL_ALU_REG_GPR1_1 = 3,
-    ZE_MCL_ALU_REG_GPR2 = 4,
-    ZE_MCL_ALU_REG_GPR2_1 = 5,
-    ZE_MCL_ALU_REG_GPR3 = 6,
-    ZE_MCL_ALU_REG_GPR3_1 = 7,
-    ZE_MCL_ALU_REG_GPR4 = 8,
-    ZE_MCL_ALU_REG_GPR4_1 = 9,
-    ZE_MCL_ALU_REG_GPR5 = 10,
-    ZE_MCL_ALU_REG_GPR5_1 = 11,
-    ZE_MCL_ALU_REG_GPR6 = 12,
-    ZE_MCL_ALU_REG_GPR6_1 = 13,
-    ZE_MCL_ALU_REG_GPR7 = 14,
-    ZE_MCL_ALU_REG_GPR7_1 = 15,
-    ZE_MCL_ALU_REG_GPR8 = 16,
-    ZE_MCL_ALU_REG_GPR8_1 = 17,
-    ZE_MCL_ALU_REG_GPR9 = 18,
-    ZE_MCL_ALU_REG_GPR9_1 = 19,
-    ZE_MCL_ALU_REG_GPR10 = 20,
-    ZE_MCL_ALU_REG_GPR10_1 = 21,
-    ZE_MCL_ALU_REG_GPR11 = 22,
-    ZE_MCL_ALU_REG_GPR11_1 = 23,
-    ZE_MCL_ALU_REG_GPR12 = 24,
-    ZE_MCL_ALU_REG_GPR12_1 = 25,
-    ZE_MCL_ALU_REG_GPR13 = 26,
-    ZE_MCL_ALU_REG_GPR13_1 = 27,
-    ZE_MCL_ALU_REG_GPR14 = 28,
-    ZE_MCL_ALU_REG_GPR14_1 = 29,
-    ZE_MCL_ALU_REG_GPR15 = 30,
-    ZE_MCL_ALU_REG_GPR15_1 = 31,
-    ZE_MCL_ALU_REG_GPR_MAX = 32,
-    ZE_MCL_ALU_REG_PREDICATE1 = 33,
-    ZE_MCL_ALU_REG_REG_MAX = 36,
-    ZE_MCL_ALU_REG_CONST0 = 37,
-    ZE_MCL_ALU_REG_CONST1 = 38,
-    ZE_MCL_ALU_REG_NONE = 39,
-    ZE_MCL_ALU_REG_PREDICATE2 = 40,
-    ZE_MCL_ALU_REG_PREDICATE_RESULT = 41,
-    ZE_MCL_ALU_REG_MAX = 42
-} zex_mcl_alu_reg_t;
-
-typedef enum _zex_mcl_alu_op_type_t {
-    ZE_MCL_ALU_OP_ADD = 0x100,
-    ZE_MCL_ALU_OP_SUB = 0x101,
-    ZE_MCL_ALU_OP_AND = 0x102,
-    ZE_MCL_ALU_OP_OR = 0x103,
-    ZE_MCL_ALU_OP_XOR = 0x104,
-    ZE_MCL_ALU_OP_STORE = 0x180,
-    ZE_MCL_ALU_OP_STOREINV = 0x580,
-    ZE_MCL_ALU_OP_LOAD = 0x080,
-    ZE_MCL_ALU_OP_LOAD0 = 0x081,
-    ZE_MCL_ALU_OP_LOAD1 = 0x481,
-    ZE_MCL_ALU_OP_LOADINV = 0x480,
-    ZE_MCL_ALU_OP_NOOP = 0x0,
-    ZE_MCL_ALU_OP_MAX
-} zex_mcl_alu_op_type_t;
-
-typedef enum _zex_mcl_alu_flag_t {
-    ZE_MCL_ALU_FLAG_ACC = 0x31,
-    ZE_MCL_ALU_FLAG_ZF = 0x32,
-    ZE_MCL_ALU_FLAG_CF = 0x33,
-    ZE_MCL_ALU_FLAG_NACC = ZE_MCL_ALU_FLAG_ACC + 0x100,
-    ZE_MCL_ALU_FLAG_NZF = ZE_MCL_ALU_FLAG_ZF + 0x100,
-    ZE_MCL_ALU_FLAG_NCF = ZE_MCL_ALU_FLAG_CF + 0x100,
-    ZE_MCL_ALU_FLAG_MAX
-} zex_mcl_alu_flag_t;
-
-typedef struct _zex_mcl_alu_operation_t {
-    zex_mcl_alu_op_type_t opType;
-    zex_mcl_alu_reg_t regDest;
-    zex_mcl_alu_reg_t regSource1;
-    zex_mcl_alu_reg_t regSource2;
-    zex_mcl_alu_flag_t flag;
-} zex_mcl_alu_operation_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command loading value (DWORD) to GPR register from
-///        variable's buffer.
-ze_result_t ZE_APICALL
-zexCommandListAppendLoadRegVariable(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t reg,                 ///< [in] GPR register destination
-    zex_variable_handle_t hVariable);      ///< [in] handle of variable
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command storing value (DWORD) from GPR register to
-///        variable's buffer.
-ze_result_t ZE_APICALL
-zexCommandListAppendStoreRegVariable(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t reg,                 ///< [in] GPR register source
-    zex_variable_handle_t hVariable);      ///< [in] handle of variable
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command to load a value from source register to destination register.
-///
-/// @details
-///     - Performs a register-to-register copy operation.
-ze_result_t ZE_APICALL
-zexCommandListAppendMILoadRegReg(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t destination,         ///< [in] destination register
-    zex_mcl_alu_reg_t source);             ///< [in] source register
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command to load a value from memory address to register.
-///
-/// @details
-///     - Loads a DWORD from the specified memory address into the register.
-ze_result_t ZE_APICALL
-zexCommandListAppendMILoadRegMem(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t reg,                 ///< [in] destination register
-    uint64_t address);                     ///< [in] source memory address
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command to load an immediate value into a register.
-///
-/// @details
-///     - Loads the provided immediate 32-bit value into the destination register.
-ze_result_t ZE_APICALL
-zexCommandListAppendMILoadRegImm(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t destination,         ///< [in] destination register
-    uint32_t val);                         ///< [in] immediate value to load
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends command to store a value from register to memory.
-///
-/// @details
-///     - Stores a DWORD from the register to the specified memory address.
-ze_result_t ZE_APICALL
-zexCommandListAppendMIStoreRegMem(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_reg_t reg,                 ///< [in] source register
-    uint64_t address);                     ///< [in] destination memory address
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Appends commands to perform ALU operations.
-///
-/// @details
-///     - Executes an array of ALU operations in sequence.
-///     - Operations can include arithmetic, logical, and register transfer commands.
-ze_result_t ZE_APICALL
-zexCommandListAppendMIMath(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of mutable command list
-    zex_mcl_alu_operation_t *opArray,      ///< [in] array of ALU operations to perform
-    size_t noOperations);                  ///< [in] number of operations in the array
-
-typedef ze_result_t(ZE_APICALL *zex_pfnKernelSetArgumentVariableCb_t)(
-    ze_kernel_handle_t hKernel,
-    uint32_t argIndex,
-    zex_variable_handle_t hVariable);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnVariableSetValueCb_t)(
-    zex_variable_handle_t hVariable,
-    uint32_t flags,
-    size_t valueSize,
-    const void *pValue);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendLoadRegVariableCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t reg,
-    zex_variable_handle_t hVariable);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendStoreRegVariableCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t reg,
-    zex_variable_handle_t hVariable);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegRegCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t destination,
-    zex_mcl_alu_reg_t source);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegMemCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t reg,
-    uint64_t address);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMILoadRegImmCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t destination,
-    uint32_t val);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMIStoreRegMemCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_reg_t reg,
-    uint64_t address);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListAppendMIMathCb_t)(
-    ze_command_list_handle_t hCommandList,
-    zex_mcl_alu_operation_t *opArray,
-    size_t noOperations);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_info_ext.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_info_ext.h
deleted file mode 100644
index b0f70325..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_info_ext.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-#include "level_zero/driver_experimental/mcl_ext/zex_mutable_cmdlist_variable_ext.h"
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief State of the variable object
-typedef enum _zex_variable_state_t {
-    ZEX_VARIABLE_STATE_DECLARED,   ///< not associated to any operation
-    ZEX_VARIABLE_STATE_DEFINED,    ///< associated to an operation, but value not set
-    ZEX_VARIABLE_STATE_INITIALIZED ///< value is set
-} zex_variable_state_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable object flags
-typedef uint32_t zex_variable_flags_t;
-typedef enum _zex_variable_flag_t {
-    ZEX_VARIABLE_FLAGS_NONE = 0,
-    ZEX_VARIABLE_FLAGS_INPUT = ZE_BIT(0),     ///< used as input
-    ZEX_VARIABLE_FLAGS_OUTPUT = ZE_BIT(1),    ///< used as output
-    ZEX_VARIABLE_FLAGS_TEMPORARY = ZE_BIT(2), ///< used as temporary (not visible to host) object
-    ZEX_VARIABLE_FLAGS_SCALABLE = ZE_BIT(3),  ///< variable is scalable
-} zex_variable_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable object value type
-typedef enum _zex_variable_type_t {
-    ZEX_VARIABLE_TYPE_NONE,          ///< ZEX_VARIABLE_STATE_DECLARED
-    ZEX_VARIABLE_TYPE_IMAGE,         ///< variable represents an image
-    ZEX_VARIABLE_TYPE_VALUE,         ///< variable represents a value
-    ZEX_VARIABLE_TYPE_BUFFER,        ///< variable represents a buffer
-    ZEX_VARIABLE_TYPE_SAMPLER,       ///< variable represents a sampler
-    ZEX_VARIABLE_TYPE_EVENT,         ///< variable represents an event
-    ZEX_VARIABLE_TYPE_PARAM,         ///< variable represents host param
-    ZEX_VARIABLE_TYPE_GROUP_SIZE,    ///< variable represents group size
-    ZEX_VARIABLE_TYPE_GROUP_COUNT,   ///< variable represents group count
-    ZEX_VARIABLE_TYPE_GLOBAL_OFFSET, ///< variable represents global offset
-    ZEX_VARIABLE_TYPE_SIGNAL_EVENT,  ///< variable represents signal event
-    ZEX_VARIABLE_TYPE_WAIT_EVENT,    ///< variable represents wait events
-    ZEX_VARIABLE_TYPE_SLM_BUFFER,    ///< variable represents slm buffer
-} zex_variable_type_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable information
-typedef struct _zex_variable_info_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure ZEX_STRUCTURE_TYPE_VARIABLE_INFO
-    const void *pNext;             ///< [in][optional] pointer to extension-specific structure
-    zex_variable_handle_t handle;  ///< [out] handle to the variable
-    const char *name;              ///< [out] name of the variable
-    size_t size;                   ///< [out] size of the variable
-    zex_variable_state_t state;    ///< [out] current state of the variable
-    zex_variable_flags_t flags;    ///< [out] flags providing additional metadata about the variable
-    zex_variable_type_t type;      ///< [out] type of value represented by this variable
-} zex_variable_info_t;
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Variable information
-///
-/// @details
-///     - Variable information represents set of metadata describing a variable
-///     - Retrieved zex_variable_info_t lifetime is bound to lifetime of the commandlist (zex_variable_info_t is not being copied into caller memory)
-ze_result_t ZE_APICALL zexVariableGetInfo(
-    zex_variable_handle_t hVariable,      // [in] handle to the variable
-    const zex_variable_info_t **pTypeInfo // [in] pointer where pointer to requested variable info should be copied to
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Retrieve list of all variables tied to a command list
-///
-/// @details
-///     - pVariables should be big enough to hold pointers to variables information representing all variables in the command list
-///     - it's expected that user first calls zexCommandListGetVariablesList with pVariables==nullptr to query total number of variables in the command list.
-///       Next, user should allocate big enough array and use it with second call to zexCommandListGetVariablesList
-///     - lifetime of zex_variable_info_t pointed to by pointers in pVariables is tied to lifetime of the command list (similarly to zexVariableGetInfo)
-ze_result_t ZE_APICALL zexCommandListGetVariablesList(
-    ze_command_list_handle_t hCommandList,      // [in] handle to the command list object
-    uint32_t *pVariablesCount,                  // [in,out] number of variables defined in the command list
-    const zex_variable_info_t **pVariablesInfos // [in,out][optional] array to which pointers to variables information should be copied to
-);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListGetVariableCb_t)(
-    ze_command_list_handle_t hCmdList,
-    const zex_variable_desc_t *pVariableDescriptor,
-    zex_variable_handle_t *phVariable);
-
-typedef ze_result_t(ZE_APICALL *zex_pfnCommandListGetVariablesListCb_t)(
-    ze_command_list_handle_t hCommandList,
-    uint32_t *pVariablesCount,
-    const zex_variable_info_t **pVariablesInfos);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_api.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_api.h
deleted file mode 100644
index 7645c75b..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_api.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (C) 2022-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_API_H
-#define _ZEX_API_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-// 'core' API headers
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-// 'sysman' API headers
-#include <level_zero/zes_api.h>
-
-// driver experimental API headers
-#include "zex_cmdlist.h"
-#include "zex_context.h"
-#include "zex_driver.h"
-#include "zex_event.h"
-#include "zex_graph.h"
-#include "zex_memory.h"
-#include "zex_module.h"
-#include "zex_visit.h"
-
-#endif // _ZEX_API_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_cmdlist.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_cmdlist.h
deleted file mode 100644
index 2f5d50b2..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_cmdlist.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2022-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_CMDLIST_H
-#define _ZEX_CMDLIST_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#if defined(_WIN32)
-#if !defined(ZE_CALLBACK)
-#define ZE_CALLBACK __stdcall
-#endif
-#else
-#if !defined(ZE_CALLBACK)
-#define ZE_CALLBACK
-#endif
-#endif
-
-ze_result_t ZE_APICALL
-zexCommandListAppendWaitOnMemory(
-    zex_command_list_handle_t hCommandList,
-    zex_wait_on_mem_desc_t *desc,
-    void *ptr,
-    uint32_t data,
-    zex_event_handle_t hSignalEvent);
-
-ze_result_t ZE_APICALL
-zexCommandListAppendWaitOnMemory64(
-    zex_command_list_handle_t hCommandList,
-    zex_wait_on_mem_desc_t *desc,
-    void *ptr,
-    uint64_t data,
-    zex_event_handle_t hSignalEvent);
-
-ze_result_t ZE_APICALL
-zexCommandListAppendWriteToMemory(
-    zex_command_list_handle_t hCommandList,
-    zex_write_to_mem_desc_t *desc,
-    void *ptr,
-    uint64_t data);
-
-typedef void(ZE_CALLBACK *ze_host_function_callback_t)(void *pUserData);
-
-ze_result_t ZE_APICALL
-zeCommandListAppendHostFunction(
-    ze_command_list_handle_t hCommandList,     ///< [in] handle of the command list
-    ze_host_function_callback_t pHostFunction, ///< [in] host function to call
-    void *pUserData,                           ///< [in] user specific data that would be passed to function
-    void *pNext,                               ///< [in][optional] extensions
-    ze_event_handle_t hSignalEvent,            ///< [in][optional] handle of the event to signal on completion
-    uint32_t numWaitEvents,                    ///< [in][optional] number of events to wait on before launching
-    ze_event_handle_t *phWaitEvents);          ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching
-
-ze_result_t ZE_APICALL
-zexCommandListAppendMemoryCopyWithParameters(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of the command list
-    void *dstptr,                          ///< [in] destination pointer
-    const void *srcptr,                    ///< [in] source pointer
-    size_t size,                           ///< [in] size in bytes to copy
-    const void *pNext,                     ///< [in][optional] additional copy parameters
-    uint32_t numWaitEvents,                ///< [in][optional] number of events to wait on before launching
-    ze_event_handle_t *phWaitEvents,       ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching
-    ze_event_handle_t hSignalEvent);       ///< [in][optional] handle of the event to signal on completion
-
-ze_result_t ZE_APICALL
-zexCommandListAppendMemoryFillWithParameters(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of the command list
-    void *ptr,                             ///< [in] pointer to memory to initialize
-    const void *pattern,                   ///< [in] pointer to value to initialize memory to
-    size_t patternSize,                    ///< [in] size in bytes of the value to initialize memory to
-    size_t size,                           ///< [in] size in bytes to initialize
-    const void *pNext,                     ///< [in][optional] additional copy parameters
-    ze_event_handle_t hEvent,              ///< [in][optional] handle of the event to signal on completion
-    uint32_t numWaitEvents,                ///< [in][optional] number of events to wait on before launching
-    ze_event_handle_t *phWaitEvents);      ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching
-
-ze_result_t ZE_APICALL
-zexCommandListAppendCustomOperation(
-    ze_command_list_handle_t hCommandList, ///< [in] handle of the command list
-    const void *pNext,                     ///< [in] operation parameters, there may be only a single operation defined
-    ze_event_handle_t hEvent,              ///< [in][optional] handle of the event to signal on completion
-    uint32_t numWaitEvents,                ///< [in][optional] number of events to wait on before launching
-    ze_event_handle_t *phWaitEvents);      ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching
-
-typedef void (*zex_command_list_cleanup_callback_fn_t)(void *pUserData);
-
-ze_result_t ZE_APICALL
-zexCommandListSetCleanupCallback(
-    ze_command_list_handle_t hCommandList,              ///< [in] handle of the command list
-    zex_command_list_cleanup_callback_fn_t pfnCallback, ///< [in] host function to call
-    void *pUserData,                                    ///< [in] user specific data that would be passed to function
-    const void *pNext);                                 ///< [in][optional] must be null or a pointer to an extension-specific structure
-
-ze_result_t ZE_APICALL
-zexCommandListVerifyMemory(
-    ze_command_list_handle_t hCommandList,
-    const void *allocationPtr,
-    const void *expectedData,
-    size_t sizeOfComparison,
-    zex_verify_memory_compare_type_t comparisonMode);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_CMDLIST_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_common.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_common.h
deleted file mode 100644
index 159f2b8e..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_common.h
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright (C) 2022-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_COMMON_H
-#define _ZEX_COMMON_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#if defined(_WIN32)
-#if !defined(ZE_CALLBACK)
-#define ZE_CALLBACK __stdcall
-#endif
-#else
-#if !defined(ZE_CALLBACK)
-#define ZE_CALLBACK
-#endif
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Handle of command list object
-typedef ze_command_list_handle_t zex_command_list_handle_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Handle of event object
-typedef ze_event_handle_t zex_event_handle_t;
-
-#define ZEX_BIT(_i) (1 << _i)
-
-#if defined(__cplusplus)
-#define EXTENDED_ENUM(ENUM_T, VALUE) static_cast<ENUM_T>(VALUE) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
-#else
-#define EXTENDED_ENUM(ENUM_T, VALUE) ((ENUM_T)VALUE)
-#endif
-
-typedef uint32_t zex_mem_action_scope_flags_t;
-typedef enum _zex_mem_action_scope_flag_t {
-    ZEX_MEM_ACTION_SCOPE_FLAG_SUBDEVICE = ZEX_BIT(0),
-    ZEX_MEM_ACTION_SCOPE_FLAG_DEVICE = ZEX_BIT(1),
-    ZEX_MEM_ACTION_SCOPE_FLAG_HOST = ZEX_BIT(2),
-    ZEX_MEM_ACTION_SCOPE_FLAG_FORCE_UINT32 = 0x7fffffff
-} zex_mem_action_scope_flag_t;
-
-typedef uint32_t zex_wait_on_mem_action_flags_t;
-typedef enum _zex_wait_on_mem_action_flag_t {
-    ZEX_WAIT_ON_MEMORY_FLAG_EQUAL = ZEX_BIT(0),
-    ZEX_WAIT_ON_MEMORY_FLAG_NOT_EQUAL = ZEX_BIT(1),
-    ZEX_WAIT_ON_MEMORY_FLAG_GREATER_THAN = ZEX_BIT(2),
-    ZEX_WAIT_ON_MEMORY_FLAG_GREATER_THAN_EQUAL = ZEX_BIT(3),
-    ZEX_WAIT_ON_MEMORY_FLAG_LESSER_THAN = ZEX_BIT(4),
-    ZEX_WAIT_ON_MEMORY_FLAG_LESSER_THAN_EQUAL = ZEX_BIT(5),
-    ZEX_WAIT_ON_MEMORY_FLAG_FORCE_UINT32 = 0x7fffffff
-} zex_wait_on_mem_action_flag_t;
-
-typedef struct _zex_wait_on_mem_desc_t {
-    zex_wait_on_mem_action_flags_t actionFlag;
-    zex_mem_action_scope_flags_t waitScope;
-} zex_wait_on_mem_desc_t;
-
-typedef struct _zex_write_to_mem_desc_t {
-    zex_mem_action_scope_flags_t writeScope;
-} zex_write_to_mem_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZE_SYNCHRONIZED_DISPATCH_EXP_NAME
-/// @brief Synchronized Dispatch extension name
-#define ZE_SYNCHRONIZED_DISPATCH_EXP_NAME "ZE_experimental_synchronized_dispatch"
-#endif // ZE_SYNCHRONIZED_DISPATCH_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Synchronized Dispatch extension version(s)
-typedef enum _ze_synchronized_dispatch_exp_version_t {
-    ZE_SYNCHRONIZED_DISPATCH_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_SYNCHRONIZED_DISPATCH_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_SYNCHRONIZED_DISPATCH_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} ze_synchronized_dispatch_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported synchronized dispatch flags
-typedef uint32_t ze_synchronized_dispatch_exp_flags_t;
-typedef enum _ze_synchronized_dispatch_exp_flag_t {
-    ZE_SYNCHRONIZED_DISPATCH_DISABLED_EXP_FLAG = ZE_BIT(0), ///< Non-synchronized dispatch. Must synchronize only with other synchronized dispatches
-    ZE_SYNCHRONIZED_DISPATCH_ENABLED_EXP_FLAG = ZE_BIT(1),  ///< Synchronized dispatch. Must synchronize with all synchronized and non-synchronized dispatches
-    ZE_SYNCHRONIZED_DISPATCH_EXP_FLAG_FORCE_UINT32 = 0x7fffffff
-
-} ze_synchronized_dispatch_exp_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Forward-declare ze_synchronized_dispatch_exp_desc_t
-typedef struct _ze_synchronized_dispatch_exp_desc_t ze_synchronized_dispatch_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Command queue or command list descriptor for synchronized dispatch. This structure may be
-///        passed as pNext member of ::ze_command_queue_desc_t. or ::ze_command_list_desc_t.
-typedef struct _ze_synchronized_dispatch_exp_desc_t {
-    ze_structure_type_ext_t stype;              ///< [in] type of this structure
-    const void *pNext;                          ///< [in][optional] must be null or a pointer to an extension-specific
-                                                ///< structure (i.e. contains stype and pNext).
-    ze_synchronized_dispatch_exp_flags_t flags; ///< [in] mode flags.
-                                                ///< must be valid value of ::ze_synchronized_dispatch_exp_flag_t
-
-} ze_synchronized_dispatch_exp_desc_t;
-
-#ifndef ZEX_COUNTER_BASED_EVENT_EXT_NAME
-/// @brief Counter Based Event Extension Name
-#define ZEX_COUNTER_BASED_EVENT_EXT_NAME "ZEX_counter_based_event"
-#endif // ZEX_COUNTER_BASED_EVENT_EXT_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Counter Based Event Extension Version(s)
-typedef enum _zex_counter_based_event_version_t {
-    ZEX_COUNTER_BASED_EVENT_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_COUNTER_BASED_EVENT_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_COUNTER_BASED_EVENT_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} zex_counter_based_event_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief IPC handle to counter based event
-typedef struct _zex_ipc_counter_based_event_handle_t {
-    char data[ZE_MAX_IPC_HANDLE_SIZE]; ///< [out] Opaque data representing an IPC handle
-} zex_ipc_counter_based_event_handle_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported event flags for defining counter-based event
-typedef uint32_t zex_counter_based_event_exp_flags_t;
-typedef enum _zex_counter_based_event_exp_flag_t {
-    ZEX_COUNTER_BASED_EVENT_FLAG_IMMEDIATE = ZE_BIT(0),               ///< Counter-based event is used for immediate command lists (default)
-    ZEX_COUNTER_BASED_EVENT_FLAG_NON_IMMEDIATE = ZE_BIT(1),           ///< Counter-based event is used for non-immediate command lists
-    ZEX_COUNTER_BASED_EVENT_FLAG_HOST_VISIBLE = ZE_BIT(2),            ///< Signals and waits are also visible to host
-    ZEX_COUNTER_BASED_EVENT_FLAG_IPC = ZE_BIT(3),                     ///< Event can be shared across processes for waiting
-    ZEX_COUNTER_BASED_EVENT_FLAG_KERNEL_TIMESTAMP = ZE_BIT(4),        ///< Event contains kernel timestamps
-    ZEX_COUNTER_BASED_EVENT_FLAG_KERNEL_MAPPED_TIMESTAMP = ZE_BIT(5), ///< Event contains kernel timestamps synchronized to host time domain.
-                                                                      ///< Cannot be combined with::ZEX_COUNTER_BASED_EVENT_FLAG_KERNEL_TIMESTAMP
-    ZEX_COUNTER_BASED_EVENT_FLAG_EXTERNAL = ZE_BIT(6),                ///< Events with this flag, when used in graph record and replay or
-                                                                      ///< in a cloned command list, can also be used for external synchronization,
-                                                                      ///< for example, as a wait event outside of a graph or for a host synchronization.
-    ZEX_COUNTER_BASED_EVENT_FLAG_FORCE_UINT32 = 0x7fffffff
-
-} zex_counter_based_event_exp_flag_t;
-
-typedef struct _zex_counter_based_event_desc_t {
-    ze_structure_type_ext_t stype;             ///< [in] type of this structure
-    const void *pNext;                         ///< [in][optional] must be null or a pointer to an extension-specific
-    zex_counter_based_event_exp_flags_t flags; ///< [in] counter based event flags.
-                                               ///< Must be 0 (default) or a valid combination of ::zex_counter_based_event_exp_flag_t
-    ze_event_scope_flags_t signalScope;        ///< [in] defines the scope of relevant cache hierarchies to flush on a
-                                               ///< signal action before the event is triggered.
-                                               ///< must be 0 (default) or a valid combination of ::ze_event_scope_flag_t;
-                                               ///< default behavior is synchronization within the command list only, no
-                                               ///< additional cache hierarchies are flushed.
-    ze_event_scope_flags_t waitScope;          ///< [in] defines the scope of relevant cache hierarchies to invalidate on
-                                               ///< a wait action after the event is complete.
-                                               ///< must be 0 (default) or a valid combination of ::ze_event_scope_flag_t;
-                                               ///< default behavior is synchronization within the command list only, no
-                                               ///< additional cache hierarchies are invalidated.
-} zex_counter_based_event_desc_t;
-
-static const zex_counter_based_event_desc_t defaultZexIntelCounterBasedEventDesc = {
-    ZEX_STRUCTURE_COUNTER_BASED_EVENT_DESC, // stype
-    nullptr,                                // pNext
-    ZEX_COUNTER_BASED_EVENT_FLAG_IMMEDIATE |
-        ZEX_COUNTER_BASED_EVENT_FLAG_NON_IMMEDIATE |
-        ZEX_COUNTER_BASED_EVENT_FLAG_HOST_VISIBLE, // flags
-    ZE_EVENT_SCOPE_FLAG_HOST,                      // signalScope
-    ZE_EVENT_SCOPE_FLAG_DEVICE                     // waitScope
-};
-
-static const ze_event_counter_based_desc_t defaultIntelCounterBasedEventDesc = {
-    ZE_STRUCTURE_TYPE_EVENT_COUNTER_BASED_DESC, // stype
-    nullptr,                                    // pNext
-    ZE_EVENT_COUNTER_BASED_FLAG_IMMEDIATE |
-        ZE_EVENT_COUNTER_BASED_FLAG_NON_IMMEDIATE |
-        ZE_EVENT_COUNTER_BASED_FLAG_HOST_VISIBLE, // flags
-    ZE_EVENT_SCOPE_FLAG_HOST,                     // signalScope
-    ZE_EVENT_SCOPE_FLAG_DEVICE                    // waitScope
-};
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Initial Counter Based Event synchronization parameters. This structure may be
-///        passed as pNext member of ::zex_counter_based_event_desc_t.
-typedef struct _zex_counter_based_event_external_sync_alloc_properties_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;             ///< [in][optional] must be null or a pointer to an extension-specific
-    uint64_t *deviceAddress;       ///< [in] device address for external synchronization allocation
-    uint64_t *hostAddress;         ///< [in] host address for external synchronization allocation
-    uint64_t completionValue;      ///< [in] completion value for external synchronization allocation
-} zex_counter_based_event_external_sync_alloc_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Initial Counter Based Event synchronization parameters. This structure may be
-///        passed as pNext member of ::zex_counter_based_event_desc_t.
-typedef struct _zex_counter_based_event_external_storage_properties_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                   ///< [in][optional] must be null or a pointer to an extension-specific
-    uint64_t *deviceAddress;       ///< [in] device address that would be updated with atomic_add upon signaling of this event, must be device USM memory
-    uint64_t incrementValue;       ///< [in] value which would by atomically added upon each completion
-    uint64_t completionValue;      ///< [in] final completion value, when value under deviceAddress is equal or greater then this value then event is considered as completed
-} zex_counter_based_event_external_storage_properties_t;
-
-typedef enum _zex_verify_memory_compare_type_t {
-    ZEX_VERIFY_MEMORY_COMPARE_EQUAL = 0,                // compare memory for equality
-    ZEX_VERIFY_MEMORY_COMPARE_NOT_EQUAL = 1,            // compare memory for inequality
-    ZEX_VERIFY_MEMORY_COMPARE_FORCE_UINT32 = 0x7fffffff ///< Value marking end of ZEX_VERIFY_MEMORY_COMPARE* ENUMs
-} zex_verify_memory_compare_type_t;
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_COMMON_EXTENDED_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_context.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_context.h
deleted file mode 100644
index 47f9c75a..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_context.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2024-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_CONTEXT_H
-#define _ZEX_CONTEXT_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include "level_zero/ze_intel_gpu.h"
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_CONTEXT_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_driver.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_driver.h
deleted file mode 100644
index 50e93bdc..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_driver.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2020-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_DRIVER_H
-#define _ZEX_DRIVER_H
-
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#ifndef ZEX_DRIVER_IMPORT_HOST_POINTER_NAME
-/// @brief Queue copy operations offload hint extension name
-#define ZEX_DRIVER_IMPORT_HOST_POINTER_NAME "ZEX_driver_import_host_pointer"
-#endif // ZEX_DRIVER_IMPORT_HOST_POINTER_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Queue copy operations offload hint extension version(s)
-typedef enum _zex_driver_import_host_pointer_version_t {
-    ZEX_DRIVER_IMPORT_HOST_POINTER_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_DRIVER_IMPORT_HOST_POINTER_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_DRIVER_IMPORT_HOST_POINTER_VERSION_FORCE_UINT32 = 0x7fffffff
-} zex_driver_import_host_pointer_version_t;
-
-ze_result_t ZE_APICALL
-zexDriverImportExternalPointer(
-    ze_driver_handle_t hDriver, ///< [in] handle of the driver
-    void *ptr,                  ///< [in] pointer to be imported to the driver
-    size_t size                 ///< [in] size to be imported
-);
-
-ze_result_t ZE_APICALL
-zexDriverReleaseImportedPointer(
-    ze_driver_handle_t hDriver, ///< [in] handle of the driver
-    void *ptr                   ///< [in] pointer to be released from the driver
-);
-
-ze_result_t ZE_APICALL
-zexDriverGetHostPointerBaseAddress(
-    ze_driver_handle_t hDriver, ///< [in] handle of the driver
-    void *ptr,                  ///< [in] pointer to be checked if imported to the driver
-    void **baseAddress          ///< [out] if not null, returns address of the base pointer of the imported pointer
-);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_DRIVER_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_event.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_event.h
deleted file mode 100644
index ddedb44c..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_event.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2023-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_EVENT_H
-#define _ZEX_EVENT_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-ze_result_t ZE_APICALL
-zexEventGetDeviceAddress(
-    ze_event_handle_t event,
-    uint64_t *completionValue,
-    uint64_t *address);
-
-// deprecated
-ze_result_t ZE_APICALL
-zexCounterBasedEventCreate(
-    ze_context_handle_t hContext,
-    ze_device_handle_t hDevice,
-    uint64_t *deviceAddress,
-    uint64_t *hostAddress,
-    uint64_t completionValue,
-    const ze_event_desc_t *desc,
-    ze_event_handle_t *phEvent);
-
-ze_result_t ZE_APICALL zexIntelAllocateNetworkInterrupt(ze_context_handle_t hContext, uint32_t &networkInterruptId);
-
-ze_result_t ZE_APICALL zexIntelReleaseNetworkInterrupt(ze_context_handle_t hContext, uint32_t networkInterruptId);
-
-ze_result_t ZE_APICALL zexCounterBasedEventCreate2(ze_context_handle_t hContext, ze_device_handle_t hDevice, const zex_counter_based_event_desc_t *desc, ze_event_handle_t *phEvent);
-
-ze_result_t ZE_APICALL zexCounterBasedEventGetIpcHandle(ze_event_handle_t hEvent, zex_ipc_counter_based_event_handle_t *phIpc);
-
-ze_result_t ZE_APICALL zexCounterBasedEventOpenIpcHandle(ze_context_handle_t hContext, zex_ipc_counter_based_event_handle_t hIpc, ze_event_handle_t *phEvent);
-
-ze_result_t ZE_APICALL zexCounterBasedEventCloseIpcHandle(ze_event_handle_t hEvent);
-
-ze_result_t ZE_APICALL zexDeviceGetAggregatedCopyOffloadIncrementValue(ze_device_handle_t hDevice, uint32_t *incrementValue);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_EVENT_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_graph.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_graph.h
deleted file mode 100644
index 892d0fb2..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_graph.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2025-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_GRAPH_H
-#define _ZEX_GRAPH_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-#ifndef ZE_RECORD_REPLAY_GRAPH_EXP_NAME
-/// @brief Record and Replay Graph Extension Name
-#define ZE_RECORD_REPLAY_GRAPH_EXP_NAME "ZE_experimental_record_replay_graph"
-
-typedef enum _ze_record_replay_graph_exp_version_t {
-    ZE_RECORD_REPLAY_GRAPH_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_RECORD_REPLAY_GRAPH_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_RECORD_REPLAY_GRAPH_EXP_VERSION_FORCE_UINT32 = 0x7fffffff,       ///< Value marking end of ZE_RECORD_REPLAY_GRAPH_EXP_VERSION_* ENUMs
-} ze_record_replay_graph_exp_version_t;
-
-typedef uint32_t ze_record_replay_graph_exp_flags_t;
-typedef enum _ze_record_replay_graph_exp_flag_t {
-    ZE_RECORD_REPLAY_GRAPH_EXP_FLAG_IMMUTABLE_GRAPH = ZE_BIT(0), ///< immutable
-    ZE_RECORD_REPLAY_GRAPH_EXP_FLAG_MUTABLE_GRAPH = ZE_BIT(1),   ///< mutable
-    ZE_RECORD_REPLAY_GRAPH_EXP_FLAG_FORCE_UINT32 = 0x7fffffff,   ///< Value marking end of ZE_RECORD_REPLAY_EXP_FLAG_* ENUMs
-} ze_record_replay_graph_exp_flag_t;
-
-typedef struct _ze_record_replay_graph_exp_properties_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                   ///< [in,out][optional] must be null or a pointer to an extension-specific
-    ///< structure (i.e. contains stype and pNext).
-    ze_record_replay_graph_exp_flags_t graphFlags; ///< [out] record replay flags
-} ze_record_replay_graph_exp_properties_t;
-
-typedef struct _ze_graph_handle_t *ze_graph_handle_t;
-typedef struct _ze_executable_graph_handle_t *ze_executable_graph_handle_t;
-
-typedef enum _ze_record_replay_graph_exp_dump_mode_t {
-    ZE_RECORD_REPLAY_GRAPH_EXP_DUMP_MODE_DETAILED = 0x0,            ///< detailed mode (default)
-    ZE_RECORD_REPLAY_GRAPH_EXP_DUMP_MODE_SIMPLE = 0x1,              ///< simple mode
-    ZE_RECORD_REPLAY_GRAPH_EXP_DUMP_MODE_FORCE_UINT32 = 0x7fffffff, ///< Value marking end of ZE_RECORD_REPLAY_GRAPH_EXP_DUMP_MODE_* ENUMs
-} ze_record_replay_graph_exp_dump_mode_t;
-
-typedef struct _ze_record_replay_graph_exp_dump_desc_t {
-    ze_structure_type_ext_t stype;               ///< [in] type of this structure
-    const void *pNext;                           ///< [in][optional] must be null or a pointer to an extension-specific
-                                                 ///< structure (i.e. contains stype and pNext).
-    ze_record_replay_graph_exp_dump_mode_t mode; ///< [in] graph dump mode
-} ze_record_replay_graph_exp_dump_desc_t;
-
-#define ZE_RESULT_QUERY_TRUE EXTENDED_ENUM(ze_result_t, 0x7fff0000)
-#define ZE_RESULT_QUERY_FALSE EXTENDED_ENUM(ze_result_t, 0x7fff0001)
-#define ZE_RESULT_ERROR_INVALID_GRAPH EXTENDED_ENUM(ze_result_t, 0x7fff0002)
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-typedef void(ZE_CALLBACK *zex_mem_graph_free_callback_fn_t)(void *pUserData);
-
-ze_result_t ZE_APICALL zeGraphCreateExp(ze_context_handle_t hContext, ze_graph_handle_t *phGraph, void *pNext);
-ze_result_t ZE_APICALL zeCommandListBeginGraphCaptureExp(ze_command_list_handle_t hCommandList, void *pNext);
-ze_result_t ZE_APICALL zeCommandListBeginCaptureIntoGraphExp(ze_command_list_handle_t hCommandList, ze_graph_handle_t hGraph, void *pNext);
-ze_result_t ZE_APICALL zeCommandListEndGraphCaptureExp(ze_command_list_handle_t hCommandList, ze_graph_handle_t *phGraph, void *pNext);
-ze_result_t ZE_APICALL zeCommandListInstantiateGraphExp(ze_graph_handle_t hGraph, ze_executable_graph_handle_t *phExecutableGraph, void *pNext);
-ze_result_t ZE_APICALL zeCommandListAppendGraphExp(ze_command_list_handle_t hCommandList, ze_executable_graph_handle_t hGraph, void *pNext,
-                                                   ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents);
-ze_result_t ZE_APICALL zeGraphDestroyExp(ze_graph_handle_t hGraph);
-ze_result_t ZE_APICALL zeExecutableGraphDestroyExp(ze_executable_graph_handle_t hGraph);
-ze_result_t ZE_APICALL zeCommandListIsGraphCaptureEnabledExp(ze_command_list_handle_t hCommandList);
-ze_result_t ZE_APICALL zeGraphIsEmptyExp(ze_graph_handle_t hGraph);
-ze_result_t ZE_APICALL zeGraphDumpContentsExp(ze_graph_handle_t hGraph, const char *filePath, void *pNext);
-ze_result_t ZE_APICALL zeCommandListGetGraphExp(ze_command_list_handle_t hCommandList, ze_graph_handle_t *phGraph);
-ze_result_t ZE_APICALL zeGraphSetDestructionCallbackExp(ze_graph_handle_t hGraph, zex_mem_graph_free_callback_fn_t pfnCallback, void *pUserData, void *pNext);
-ze_result_t ZE_APICALL zeExecutableGraphGetSourceGraphExt(ze_executable_graph_handle_t hGraph, ze_graph_handle_t *phSourceGraph);
-ze_result_t ZE_APICALL zeGraphGetPrimaryCommandListExt(ze_graph_handle_t hGraph, ze_command_list_handle_t *phCommandList);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // ZE_RECORD_REPLAY_GRAPH_EXP_NAME
-#endif // _ZEX_GRAPH_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_memory.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_memory.h
deleted file mode 100644
index 4bbccb72..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_memory.h
+++ /dev/null
@@ -1,127 +0,0 @@
-/*
- * Copyright (C) 2020-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_MEMORY_H
-#define _ZEX_MEMORY_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-///////////////////////////////////////////////////////////////////////////////
-// It indicates that the application wants the L0 driver implementation to use
-// memory referenced by **ptr passed in `zeMemAllocHost` or `zeMemAllocShared`.
-// Can be set in `ze_host_mem_alloc_flags_t`.
-constexpr uint32_t ZEX_HOST_MEM_ALLOC_FLAG_USE_HOST_PTR = ZE_BIT(30);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZEX_MEM_IPC_HANDLES_NAME
-/// @brief Multiple IPC handles driver extension name
-#define ZEX_MEM_IPC_HANDLES_NAME "ZEX_mem_ipc_handles"
-#endif // ZEX_MEM_IPC_HANDLES_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Multiple IPC handles driver extension Version(s)
-typedef enum _zex_mem_ipc_handles_version_t {
-    ZEX_MEM_IPC_HANDLES_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_MEM_IPC_HANDLES_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_MEM_IPC_HANDLES_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} zex_mem_ipc_handles_version_t;
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Returns an array IPC memory handles for the specified allocation
-///
-/// @details
-///     - Takes a pointer to a device memory allocation and returns an array of
-//        IPC memory handle for exporting it for use in another process.
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function must be thread-safe.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + `ptr` not known
-ze_result_t ZE_APICALL
-zexMemGetIpcHandles(
-    ze_context_handle_t hContext,    ///< [in] handle of the context object
-    const void *ptr,                 ///< [in] pointer to the device memory allocation
-    uint32_t *numIpcHandles,         ///< [in,out] number of IPC handles associated with the allocation
-                                     ///< if numIpcHandles is zero, then the driver shall update the value with the
-                                     ///< total number of IPC handles associated with the allocation.
-    ze_ipc_mem_handle_t *pIpcHandles ///< [in,out][optional][range(0, *numIpcHandles)] returned array of IPC memory handles
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Creates an allocation associated with an array of IPC memory handles
-///        imported from another process.
-///
-/// @details
-///     - Takes an array of IPC memory handles from a remote process and associates it
-///       with a device pointer usable in this process.
-///     - The device pointer in this process should not be freed with
-///       ::zeMemFree, but rather with ::zeMemCloseIpcHandle.
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function must be thread-safe.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + handles not known
-ze_result_t ZE_APICALL
-zexMemOpenIpcHandles(
-    ze_context_handle_t hContext,     ///< [in] handle of the context object
-    ze_device_handle_t hDevice,       ///< [in] handle of the device to associate with the IPC memory handle
-    uint32_t numIpcHandles,           ///< [in] number of IPC handles associated with the allocation
-    ze_ipc_mem_handle_t *pIpcHandles, ///< [in][range(0, *numIpcHandles)] array of IPC memory handles
-    ze_ipc_memory_flags_t flags,      ///< [in] flags controlling the operation.
-                                      ///< must be 0 (default) or a valid combination of ::ze_ipc_memory_flag_t.
-    void **pptr                       ///< [out] pointer to device allocation in this process
-);
-
-#define ZE_RESULT_ERROR_INCOMPATIBLE_RESOURCE EXTENDED_ENUM(ze_result_t, 0x7fff0003)
-
-/// @brief Map device memory allocation to host address space
-///
-/// @details
-///    - The application may call this function from simultaneous threads.
-///    - The implementation of this function should be lock-free.
-///    - Host address is only valid on the host, using it on device is invalid.
-///    - Freeing the memory will unmap the host memory mapping.
-///    - The application must only use the memory allocation for the context
-///       which was provided during allocation.
-///    - The application is responsible for properly flushing/sequencing host
-///       writes towards the device memory.
-///    - To potentially solve ZE_RESULT_ERROR_INCOMPATIBLE_RESOURCE the user may
-///       need to allocate using sharing flags by using $x_external_memory_export_desc_t.
-///    - pNext points to extensible list of extensions that may be added in future (none defined yet).
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_INCOMPATIBLE_RESOURCE
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-ze_result_t ZE_APICALL
-zeIntelMemMapDeviceMemToHost(
-    ze_context_handle_t hContext, ///< [in] handle of the context
-    const void *ptr,              ///< [in] pointer to the device memory to be mapped
-    void **pptr,                  ///< [out] pointer to the host mapped memory
-    void *pNext                   ///< [in][optional] must be null or a pointer to an extension-specific structure
-);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZEX_MEMORY_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_module.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_module.h
deleted file mode 100644
index 89ef0729..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_module.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2020-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_MODULE_H
-#define _ZEX_MODULE_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include "level_zero/ze_stypes.h"
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-ze_result_t ZE_APICALL
-zexKernelGetBaseAddress(
-    ze_kernel_handle_t hKernel,
-    uint64_t *baseAddress);
-
-ze_result_t ZE_APICALL
-zexKernelGetArgumentSize(
-    ze_kernel_handle_t hKernel,
-    uint32_t argIndex,
-    uint32_t *pArgSize);
-
-ze_result_t ZE_APICALL
-zexKernelGetArgumentType(
-    ze_kernel_handle_t hKernel,
-    uint32_t argIndex,
-    uint32_t *pSize,
-    char *pString);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief General Register File descriptor.
-/// Must be passed to zeDeviceGetModuleProperties via pNext member of ze_device_module_properties_t.
-typedef struct _zex_device_module_register_file_exp_t {
-    ze_structure_type_ext_t stype;   ///< [in] type of this structure
-    const void *pNext;               ///< [in, out][optional] pointer to extension-specific structure
-    uint32_t registerFileSizesCount; ///< [out] Size of array of supported GRF sizes
-    uint32_t *registerFileSizes;     ///< [in, out][optional] Array of supported GRF sizes
-} zex_device_module_register_file_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Kernel register file size information
-/// Must be passed to zeKernelGetProperties via pNext member of ze_kernel_properties_t
-typedef struct _zex_kernel_register_file_size_exp_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;             ///< [in, out][optional] pointer to extension-specific structure
-    uint32_t registerFileSize;     ///< [out] Register file size used in kernel
-} zex_kernel_register_file_size_exp_t;
-
-#endif // _ZEX_MODULE_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_visit.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_visit.h
deleted file mode 100644
index 1daf4f2f..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/driver_experimental/zex_visit.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZEX_VISIT_H
-#define _ZEX_VISIT_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#include <level_zero/ze_api.h>
-
-#include "zex_common.h"
-
-#ifndef ZE_COMMAND_VISIT_EXT_NAME
-/// @brief Command List Visit Extension Name
-#define ZE_COMMAND_VISIT_EXT_NAME "ZE_extension_command_visit"
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Command List Visit Extension version(s)
-typedef enum _ze_command_visit_ext_version_t {
-    ZE_COMMAND_VISIT_EXT_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_COMMAND_VISIT_EXT_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_COMMAND_VISIT_EXT_VERSION_FORCE_UINT32 = 0x7fffffff,       ///< Value marking end of ZE_COMMAND_VISIT_EXT_VERSION_* ENUMs
-} ze_command_visit_ext_version_t;
-
-#define ZE_COMMAND_LIST_FLAG_ENABLE_CMD_VISITING (static_cast<uint32_t>(ZE_BIT(6)))
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#ifdef _WIN32
-#define VISITOR_CCONV __cdecl
-#else
-#define VISITOR_CCONV
-#endif
-
-typedef void(VISITOR_CCONV *ze_visit_ext_default_op_callback_t)(const char *fname, void *userData, uint32_t *numWaitEvents, ze_event_handle_t **phWaitEvents, ze_event_handle_t *hSignalEvent);
-typedef struct _ze_graph_handle_t *ze_graph_handle_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Defines specialized behavior of zeCommandListVisitExt visit operation for given L0 API function
-///        One or more instances of this structure can be chained in pNext of ze_visit_ext_desc_t to define behavior for multiple L0 API functions
-typedef struct _ze_concrete_visitor_ext_desc_t {
-    ze_structure_type_ext_t stype;
-    const void *pNext;
-
-    const char *fname; ///< [in] L0 API function name for which the behavior is defined, for example "zeCommandListAppendMemoryCopyWithParameters"
-    void *callback;    ///< [in] The implementation of the behavior, the type of the function pointer must match the signature of the L0 API function for which the behavior is defined with one extra parameter at the end - void*
-                       ///       Note : calling convention must match VISITOR_CCONV
-} ze_concrete_visitor_ext_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Defines default operation for visit call
-typedef enum _ze_visit_ext_default_op_t {
-    ZE_VISIT_EXT_DEFAULT_OP_IGNORE = 0,   // if concrete visitor callback is not provided, ignore the command
-    ZE_VISIT_EXT_DEFAULT_OP_REAPPEND = 1, // if concrete visitor callback is not provided, reappend the command
-} ze_visit_ext_default_op_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Defines behavior of visit operations
-typedef struct _ze_visit_ext_desc_t {
-    ze_structure_type_ext_t stype;
-    const void *pNext;
-
-    void *userData; // optional user data to be passed to callbacks
-
-    ze_command_list_handle_t hReappendTargetCmdList; ///< [in][optional]  target commandlist for ZE_VISIT_EXT_DEFAULT_OP_REAPPEND
-                                                     ///                  if visiting a graph, then hReappendTargetCmdList will be used only for root level recording (i.e. not used in forks)
-                                                     ///                  If hReappendTargetCmdList is not set then reappends the command to the same commandlist as originally recorded.
-
-    ze_visit_ext_default_op_callback_t beforeDefaultOpClb; ///< [in][optional] callback to be called before executing default operation, can be null if no action is needed before default operation
-    ze_visit_ext_default_op_t defaultOp;                   ///< [in]           default operation to be taken if concrete visitor callback is not provided
-    ze_visit_ext_default_op_callback_t afterDefaultOpClb;  ///< [in][optional] callback to be called after executing default operation, can be null if no action is needed after default operation
-} ze_visit_ext_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Visits all commands in a commandlist in order of recording operations
-ze_result_t ZE_APICALL zeCommandListVisitExt(ze_command_list_handle_t cmdlist,
-                                             const ze_visit_ext_desc_t *desc);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Visits all commands in a graph in order of recording operations
-ze_result_t ZE_APICALL zeGraphVisitExt(ze_graph_handle_t graph,
-                                       const ze_visit_ext_desc_t *desc);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // ZE_COMMAND_VISIT_EXT_NAME
-#endif // _ZEX_VISIT_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_gpu.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_gpu.h
deleted file mode 100644
index c364e0c4..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_gpu.h
+++ /dev/null
@@ -1,662 +0,0 @@
-/*
- * Copyright (C) 2020-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZE_INTEL_GPU_H
-#define _ZE_INTEL_GPU_H
-
-#include <level_zero/ze_api.h>
-
-#include "ze_stypes.h"
-
-#if defined(__cplusplus)
-#pragma once
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-#define ZE_INTEL_GPU_VERSION_MAJOR 0
-#define ZE_INTEL_GPU_VERSION_MINOR 1
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME
-/// @brief Module DP properties driver extension name
-#define ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME "ZE_intel_experimental_device_module_dp_properties"
-#endif // ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Module DP properties driver extension Version(s)
-typedef enum _ze_intel_device_module_dp_properties_exp_version_t {
-    ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_device_module_dp_properties_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported Dot Product flags
-typedef uint32_t ze_intel_device_module_dp_exp_flags_t;
-typedef enum _ze_intel_device_module_dp_exp_flag_t {
-    ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DP4A = ZE_BIT(0), ///< Supports DP4A operation
-    ZE_INTEL_DEVICE_MODULE_EXP_FLAG_DPAS = ZE_BIT(1), ///< Supports DPAS operation
-    ZE_INTEL_DEVICE_MODULE_EXP_FLAG_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_device_module_dp_exp_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device Module dot product properties queried using
-///        ::zeDeviceGetModuleProperties
-///
-/// @details
-///     - This structure may be passed to ::zeDeviceGetModuleProperties, via
-///       `pNext` member of ::ze_device_module_properties_t.
-/// @brief Device module dot product properties
-typedef struct _ze_intel_device_module_dp_exp_properties_t {
-    ze_structure_type_ext_t stype;               ///< [in] type of this structure
-    void *pNext;                                 ///< [in,out][optional] must be null or a pointer to an extension-specific
-                                                 ///< structure (i.e. contains sType and pNext).
-    ze_intel_device_module_dp_exp_flags_t flags; ///< [out] 0 (none) or a valid combination of ::ze_intel_device_module_dp_flag_t
-} ze_intel_device_module_dp_exp_properties_t;
-
-#ifndef ZE_INTEL_COMMAND_LIST_MEMORY_SYNC
-/// @brief Cmd List memory sync extension name
-#define ZE_INTEL_COMMAND_LIST_MEMORY_SYNC "ZE_intel_experimental_command_list_memory_sync"
-#endif // ZE_INTEL_COMMAND_LIST_MEMORY_SYNC
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Cmd List memory sync extension Version(s)
-typedef enum _ze_intel_command_list_memory_sync_exp_version_t {
-    ZE_INTEL_COMMAND_LIST_MEMORY_SYNC_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_COMMAND_LIST_MEMORY_SYNC_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_COMMAND_LIST_MEMORY_SYNC_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} ze_intel_command_list_memory_sync_exp_version_t;
-
-#ifndef ZE_INTEL_STRUCTURE_TYPE_DEVICE_COMMAND_LIST_WAIT_ON_MEMORY_DATA_SIZE_EXP_DESC
-/// @brief stype for _ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Extended descriptor for cmd list memory sync
-///
-/// @details
-///     - Implementation must support ::ZE_intel_experimental_command_list_memory_sync extension
-///     - May be passed to ze_device_properties_t through pNext.
-typedef struct _ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t {
-    ze_structure_type_ext_t stype;               ///< [in] type of this structure
-    const void *pNext;                           ///< [in][optional] must be null or a pointer to an extension-specific
-                                                 ///< structure (i.e. contains stype and pNext).
-    uint32_t cmdListWaitOnMemoryDataSizeInBytes; /// <out> Defines supported data size for zexCommandListAppendWaitOnMemory[64] API
-} ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t;
-
-#ifndef ZEX_INTEL_EVENT_SYNC_MODE_EXP_NAME
-/// @brief Event sync mode extension name
-#define ZEX_INTEL_EVENT_SYNC_MODE_EXP_NAME "ZEX_intel_experimental_event_sync_mode"
-#endif // ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Event sync mode extension Version(s)
-typedef enum _zex_intel_event_sync_mode_exp_version_t {
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zex_intel_event_sync_mode_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported event sync mode flags
-typedef uint32_t zex_intel_event_sync_mode_exp_flags_t;
-typedef enum _zex_intel_event_sync_mode_exp_flag_t {
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT = ZE_BIT(0),          ///< Low power host synchronization mode, for better CPU utilization
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT = ZE_BIT(1),        ///< Generate interrupt when Event is signalled on Device
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_EXTERNAL_INTERRUPT_WAIT = ZE_BIT(2), ///< Host synchronization APIs wait for external interrupt. Can be used only for Events created via zexCounterBasedEventCreate
-    ZEX_INTEL_EVENT_SYNC_MODE_EXP_EXP_FLAG_FORCE_UINT32 = 0x7fffffff
-
-} zex_intel_event_sync_mode_exp_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Extended descriptor for event sync mode
-///
-/// @details
-///     - Implementation must support ::ZEX_intel_experimental_event_sync_mode extension
-///     - May be passed to ze_event_desc_t through pNext.
-typedef struct _zex_intel_event_sync_mode_exp_desc_t {
-    ze_structure_type_ext_t stype;                       ///< [in] type of this structure
-    const void *pNext;                                   ///< [in][optional] must be null or a pointer to an extension-specific
-                                                         ///< structure (i.e. contains stype and pNext).
-    zex_intel_event_sync_mode_exp_flags_t syncModeFlags; /// <in> valid combination of ::ze_intel_event_sync_mode_exp_flag_t
-    uint32_t externalInterruptId;                        /// <in> External interrupt id. Used only when ZEX_INTEL_EVENT_SYNC_MODE_EXP_FLAG_EXTERNAL_INTERRUPT_WAIT flag is set
-} zex_intel_event_sync_mode_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Forward-declare zex_intel_queue_allocate_msix_hint_exp_desc_t
-typedef struct _zex_intel_queue_allocate_msix_hint_exp_desc_t zex_intel_queue_allocate_msix_hint_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Command queue descriptor for allocating unique msix. This structure may be
-/// passed as pNext member of ::ze_command_queue_desc_t.
-
-typedef struct _zex_intel_queue_allocate_msix_hint_exp_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;             ///< [in][optional] must be null or a pointer to an extension-specific
-                                   ///< structure (i.e. contains stype and pNext).
-    ze_bool_t uniqueMsix;          ///< [in] If set, try to allocate unique msix for command queue.
-                                   ///< If not set, driver will follow default behaviour. It may share msix for signaling completion with other queues.
-                                   ///< Number of unique msixes may be limited. On unsuccessful allocation, queue or immediate cmd list creation API fallbacks to default behaviour.
-
-} zex_intel_queue_allocate_msix_hint_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Command queue descriptor for enabling copy operations offload. This structure may be
-/// passed as pNext member of ::ze_command_queue_desc_t.
-
-typedef struct _zex_intel_queue_copy_operations_offload_hint_exp_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;             ///< [in][optional] must be null or a pointer to an extension-specific
-                                   ///< structure (i.e. contains stype and pNext).
-    ze_bool_t copyOffloadEnabled;  ///< [in] If set, try to offload copy operations to different engines. Applicable only for compute queues.
-                                   ///< This is only a hint. Driver may ignore it per append call, based on platform capabilities or internal heuristics.
-                                   ///< If not set, driver will follow default behaviour. Copy operations will be submitted to same engine as compute operations.
-
-} zex_intel_queue_copy_operations_offload_hint_exp_desc_t;
-
-#ifndef ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_NAME
-/// @brief Queue copy operations offload hint extension name
-#define ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_NAME "ZEX_intel_experimental_queue_copy_operations_offload_hint"
-#endif // ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Queue copy operations offload hint extension version(s)
-typedef enum _zex_intel_queue_copy_operations_offload_hint_exp_version_t {
-    ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_INTEL_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zex_intel_queue_copy_operations_offload_hint_exp_version_t;
-
-#ifndef ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_NAME
-/// @brief Extension name for query to read the Intel Level Zero Driver Version String
-#define ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_NAME "ZE_intel_get_driver_version_string"
-#endif // ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query to read the Intel Level Zero Driver Version String extension version(s)
-typedef enum _ze_intel_get_driver_version_string_exp_version_t {
-    ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_GET_DRIVER_VERSION_STRING_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} ze_intel_get_driver_version_string_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported 2D Block Array flags
-typedef uint32_t ze_intel_device_block_array_exp_flags_t;
-typedef enum _ze_intel_device_block_array_exp_flag_t {
-    ZE_INTEL_DEVICE_EXP_FLAG_2D_BLOCK_STORE = ZE_BIT(0), ///< Supports store operation
-    ZE_INTEL_DEVICE_EXP_FLAG_2D_BLOCK_LOAD = ZE_BIT(1),  ///< Supports load operation
-    ZE_INTEL_DEVICE_EXP_FLAG_2D_BLOCK_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_device_block_array_exp_flag_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_NAME
-/// @brief Device 2D block array properties driver extension name
-#define ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_NAME "ZE_intel_experimental_device_block_array_properties"
-#endif // ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_NAME
-
-/// @brief Device 2D block array properties queried using
-///        ::zeDeviceGetProperties
-///
-/// @details
-///     - This structure may be passed to ::zeDeviceGetProperties, via
-///       `pNext` member of ::ze_device_properties_t.
-/// @brief Device 2D block array properties
-
-typedef struct _ze_intel_device_block_array_exp_properties_t {
-    ze_structure_type_ext_t stype;                 ///< [in] type of this structure
-    void *pNext;                                   ///< [in,out][optional] must be null or a pointer to an extension-specific
-                                                   ///< structure (i.e. contains sType and pNext).
-    ze_intel_device_block_array_exp_flags_t flags; ///< [out] 0 (none) or a valid combination of ::ze_intel_device_block_array_exp_flag_t
-} ze_intel_device_block_array_exp_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device 2D block array properties driver extension versions
-typedef enum _ze_intel_device_block_array_exp_properties_version_t {
-    ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_PROPERTIES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0), ///< version 1.0
-    ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_PROPERTIES_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_PROPERTIES_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_device_block_array_exp_properties_version_t;
-
-/// @brief Query to read the Intel Level Zero Driver Version String
-///
-/// @details
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function should be lock-free.
-///     - The Driver Version String will be in the format:
-///     - Major.Minor.Patch+Optional per semver guidelines https://semver.org/#spec-item-10
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-ze_result_t ZE_APICALL
-zeIntelGetDriverVersionString(
-    ze_driver_handle_t hDriver, ///< [in] Driver handle whose version is being read.
-    char *pDriverVersion,       ///< [in,out] pointer to driver version string.
-    size_t *pVersionSize);      ///< [in,out] pointer to the size of the driver version string.
-                                ///< if size is zero, then the size of the version string is returned.
-
-/// @brief Get Kernel Program Binary
-///
-/// @details
-///     - A valid kernel handle must be created with zeKernelCreate.
-///     - Returns Intel Graphics Assembly (GEN ISA) format binary program data for kernel handle.
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function should be lock-free.
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZEX_MEMORY_FREE_CALLBACK_EXT_NAME
-/// @brief Memory Free Callback Extension Name
-#define ZEX_MEMORY_FREE_CALLBACK_EXT_NAME "ZEX_extension_memory_free_callback"
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory Free Callback Extension Version(s)
-typedef enum _zex_memory_free_callback_ext_version_t {
-    ZEX_MEMORY_FREE_CALLBACK_EXT_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZEX_MEMORY_FREE_CALLBACK_EXT_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZEX_MEMORY_FREE_CALLBACK_EXT_VERSION_FORCE_UINT32 = 0x7fffffff        ///< Value marking end of ZEX_MEMORY_FREE_CALLBACK_EXT_VERSION_* ENUMs
-
-} zex_memory_free_callback_ext_version_t;
-
-#ifndef ZEX_STRUCTURE_TYPE_MEMORY_FREE_CALLBACK_EXT_DESC
-/// @brief stype for _zex_memory_free_callback_ext_desc_t
-#endif
-
-/**
- * @brief Callback function type for memory free events.
- *
- * This function is called when a memory free operation occurs.
- *
- * @param pUserData Pointer to user-defined data passed to the callback.
- */
-typedef void (*zex_mem_free_callback_fn_t)(void *pUserData);
-
-/**
- * @brief Descriptor for a memory free callback extension.
- *
- * This structure is used to specify a callback function that will be invoked when memory is freed.
- *
- * Members:
- * - stype: Specifies the type of this structure.
- * - pNext: Optional pointer to an extension-specific structure; must be null or point to a structure containing stype and pNext.
- * - pfnCallback: Callback function to be called when memory is freed.
- * - pUserData: Optional user data to be passed to the callback function.
- */
-typedef struct _zex_memory_free_callback_ext_desc_t {
-    ze_structure_type_ext_t stype;          ///< [in] type of this structure
-    const void *pNext;                      ///< [in][optional] must be null or a pointer to an extension-specific
-                                            ///< structure (i.e. contains stype and pNext).
-    zex_mem_free_callback_fn_t pfnCallback; // [in] callback function to be called on memory free
-    void *pUserData;                        // [in][optional] user data passed to callback
-} zex_memory_free_callback_ext_desc_t;
-
-/**
- * @brief Registers a callback to be invoked when memory is freed.
- *
- * This function allows the user to register a callback that will be called
- * whenever the specified memory is freed within the given context.
- *
- * @param hContext
- *        [in] Handle to the context in which the memory was allocated.
- * @param hFreeCallbackDesc
- *        [in] Pointer to a descriptor specifying the callback function and its parameters.
- * @param ptr
- *        [in] Pointer to the memory for which the free callback is to be registered.
- *
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + `nullptr == hFreeCallbackDesc`
-///         + `nullptr == ptr`
- *
- * @note The callback will be invoked when the specified memory is freed.
- */
-ze_result_t ZE_APICALL zexMemFreeRegisterCallbackExt(ze_context_handle_t hContext, zex_memory_free_callback_ext_desc_t *hFreeCallbackDesc, void *ptr);
-#endif // ZEX_MEMORY_FREE_CALLBACK_EXT_NAME
-
-#ifndef ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_NAME
-/// @brief Get Kernel Program Binary experimental name
-#define ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_NAME "ZE_intel_experimental_kernel_get_program_binary"
-#endif // ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Intel Kernel Get Binary Extension Version(s)
-typedef enum _ze_intel_kernel_get_binary_exp_version_t {
-    ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_KERNEL_GET_PROGRAM_BINARY_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_kernel_get_binary_exp_version_t;
-
-ze_result_t ZE_APICALL
-zeIntelKernelGetBinaryExp(
-    ze_kernel_handle_t hKernel, ///< [in] Kernel handle
-    size_t *pSize,              ///< [in, out] pointer to variable with size of GEN ISA binary
-    char *pKernelBinary         ///< [in,out] pointer to storage area for GEN ISA binary function
-);
-
-#ifndef ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_NAME
-/// @brief DRM format modifier extension name
-#define ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_NAME "ZE_intel_experimental_drm_format_modifier"
-#endif // ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief DRM format modifier extension Version(s)
-typedef enum _ze_intel_drm_format_modifier_exp_version_t {
-    ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_DRM_FORMAT_MODIFIER_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} ze_intel_drm_format_modifier_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Image DRM format modifier properties
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_image_desc_t,
-///       when using a DRM format modifier.
-///     - Properties struct for providing user with the selected drm format modifier for the image
-///     - This is useful if the application wants to export the image to another API that requires the DRM format modifier
-///     - The application can query the chosen DRM format modifier for the image.
-///     - The application can use this information to choose a DRM format modifier for the image during creation
-typedef struct _ze_intel_image_selected_format_modifier_exp_properties_t {
-    ze_structure_type_t stype;  ///< [in] type of this structure
-    void *pNext;                ///< [in][optional] must be null or a pointer to an extension-specific
-                                ///< structure (i.e. contains stype and pNext).
-    uint64_t drmFormatModifier; ///< [out] DRM format modifier
-} ze_intel_image_selected_format_modifier_exp_properties_t;
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Image DRM format modifier create list
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_image_desc_t,
-///       when providing a list of DRM format modifiers to choose from during image creation.
-///     - This is a descriptor for creating image with the specified list of drm format modifier
-///     - If the user passes a list struct, then implementation chooses one from the list of drm modifiers as it sees fit.
-///     - If user wants to pass a single drm modifier then they can set the drmFormatModifierCount to 1 and pass the single drm modifier in pDrmFormatModifiers
-typedef struct _ze_intel_image_format_modifier_create_list_exp_desc_t {
-    ze_structure_type_t stype;       ///< [in] type of this structure
-    const void *pNext;               ///< [in][optional] must be null or a pointer to an extension-specific
-                                     ///< structure (i.e. contains stype and pNext).
-    uint32_t drmFormatModifierCount; ///< [in] number of DRM format modifiers in the list
-    uint64_t *pDrmFormatModifiers;   ///< [in][range(0, drmFormatModifierCount)] array of DRM format modifiers
-} ze_intel_image_format_modifier_create_list_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Image DRM format modifier import descriptor
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_image_desc_t,
-///       when importing an image with a specific DRM format modifier.
-///     - The pNext chain is setup accordingly in ze_image_desc_t prior to calling zeImageCreate API
-typedef struct _ze_intel_image_format_modifier_import_exp_desc_t {
-    ze_structure_type_t stype;  ///< [in] type of this structure
-    const void *pNext;          ///< [in][optional] must be null or a pointer to an extension-specific
-                                ///< structure (i.e. contains stype and pNext).
-    uint64_t drmFormatModifier; ///< [in] DRM format modifier to use for the image
-} ze_intel_image_format_modifier_import_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Buffer DRM format modifier create list
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_device_mem_alloc_desc_t,
-///       when providing a list of DRM format modifiers to choose from during buffer creation.
-///     - This is a descriptor for creating buffer with the specified list of drm format modifier
-///     - If the user passes a list struct, then implementation chooses one from the list of drm modifiers as it sees fit.
-///     - If user wants to pass a single drm modifier then they can set the drmFormatModifierCount to 1 and pass the single drm modifier in pDrmFormatModifiers
-///     - The pNext chain is setup accordingly in ze_device_mem_alloc_desc_t prior to calling zeMemAllocDevice API
-typedef struct _ze_intel_mem_format_modifier_create_list_exp_desc_t {
-    ze_structure_type_t stype;       ///< [in] type of this structure
-    const void *pNext;               ///< [in][optional] must be null or a pointer to an extension-specific
-                                     ///< structure (i.e. contains stype and pNext).
-    uint32_t drmFormatModifierCount; ///< [in] number of DRM format modifiers in the list
-    uint64_t *pDrmFormatModifiers;   ///< [in][range(0, drmFormatModifierCount)] array of DRM format modifiers
-} ze_intel_mem_format_modifier_create_list_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Buffer DRM format modifier import descriptor
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_device_mem_alloc_desc_t,
-///       when importing a buffer with a specific DRM format modifier.
-///     - This descriptor must be used in conjunction with ze_external_memory_import_fd_t. If not, implementation will return an error.
-///     - The pNext chain is setup accordingly in ze_device_mem_alloc_desc_t prior to calling zeMemAllocDevice API
-typedef struct _ze_intel_mem_format_modifier_import_exp_desc_t {
-    ze_structure_type_t stype;  ///< [in] type of this structure
-    const void *pNext;          ///< [in][optional] must be null or a pointer to an extension-specific
-                                ///< structure (i.e. contains stype and pNext).
-    uint64_t drmFormatModifier; ///< [in] DRM format modifier to use for the buffer
-} ze_intel_mem_format_modifier_import_exp_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Buffer DRM format modifier properties
-///
-/// @details
-///     - This structure may be passed as pNext member of ::ze_memory_allocation_properties_t,
-///       when querying the DRM format modifier of a buffer.
-///     - Properties struct for providing user with the selected drm format modifier for the buffer
-///     - This is useful if the application wants to export the buffer to another API that requires the DRM format modifier
-///     - The application can query the chosen DRM format modifier for the buffer via zeMemGetAllocProperties API
-typedef struct _ze_intel_mem_selected_format_modifier_exp_properties_t {
-    ze_structure_type_t stype;  ///< [in] type of this structure
-    void *pNext;                ///< [in][optional] must be null or a pointer to an extension-specific
-                                ///< structure (i.e. contains stype and pNext).
-    uint64_t drmFormatModifier; ///< [out] DRM format modifier
-} ze_intel_mem_selected_format_modifier_exp_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query for supported DRM format modifiers for a given image descriptor
-///
-/// @details
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function should be lock-free.
-///     - This function can be used to query supported DRM format modifiers for a specific image description.
-///     - User can use this API in two ways:
-///         1. Set pCount to the address of a uint32_t with value 0 and pDrmFormatModifiers to nullptr
-///            to query just the number of supported DRM format modifiers.
-///         2. Set pCount to the address of a uint32_t with the number of elements in the pDrmFormatModifiers
-///            array to retrieve the list of supported DRM format modifiers.
-///     - The application can use the returned DRM format modifiers to:
-///         1. Create L0 images with supported DRM format modifiers.
-///         2. Compare with DRM format modifiers from other APIs (like Vulkan) to find common
-///            modifiers that work for interop scenarios.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hDevice`
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
-///         + `nullptr == pCount`
-///     - ::ZE_RESULT_ERROR_INVALID_IMAGE_DESC
-///         + The image description doesn't match the device capabilities
-ze_result_t ZE_APICALL
-zeIntelImageGetFormatModifiersSupportedExp(
-    ze_device_handle_t hDevice,        ///< [in] handle of the device
-    const ze_image_desc_t *pImageDesc, ///< [in] pointer to image descriptor
-    uint32_t *pCount,                  ///< [in,out] pointer to the number of DRM format modifiers.
-                                       ///< if count is zero, then the driver shall update the value with the
-                                       ///< total number of supported DRM format modifiers for the image format.
-                                       ///< if count is greater than the number of supported DRM format modifiers,
-                                       ///< then the driver shall update the value with the correct number of supported DRM format modifiers.
-    uint64_t *pDrmFormatModifiers      ///< [in,out][optional][range(0, *pCount)] array of supported DRM format modifiers
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query for supported DRM format modifiers for a memory allocation descriptor
-///
-/// @details
-///     - The application may call this function from simultaneous threads.
-///     - The implementation of this function should be lock-free.
-///     - This function can be used to query supported DRM format modifiers for a specific memory allocation description.
-///     - User can use this API in two ways:
-///         1. Set pCount to the address of a uint32_t with value 0 and pDrmFormatModifiers to nullptr
-///            to query just the number of supported DRM format modifiers.
-///         2. Set pCount to the address of a uint32_t with the number of elements in the pDrmFormatModifiers
-///            array to retrieve the list of supported DRM format modifiers.
-///     - The application can use the returned DRM format modifiers to:
-///         1. Create L0 memory allocations with supported DRM format modifiers.
-///         2. Compare with DRM format modifiers from other APIs (like Vulkan) to find common
-///            modifiers that work for interop scenarios.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hContext`
-ze_result_t ZE_APICALL
-zeIntelMemGetFormatModifiersSupportedExp(
-    ze_context_handle_t hContext,                  ///< [in] handle of the context
-    const ze_device_mem_alloc_desc_t *pDeviceDesc, ///< [in] pointer to device memory allocation descriptor
-    size_t size,                                   ///< [in] size in bytes to allocate
-    size_t alignment,                              ///< [in] minimum alignment in bytes for the allocation
-    ze_device_handle_t hDevice,                    ///< [in] handle of the device
-    uint32_t *pCount,                              ///< [in,out] pointer to the number of DRM format modifiers.
-                                                   ///< if count is zero, then the driver shall update the value with the
-                                                   ///< total number of supported DRM format modifiers for the memory allocation.
-                                                   ///< if count is greater than the number of supported DRM format modifiers,
-                                                   ///< then the driver shall update the value with the correct number of supported DRM format modifiers.
-    uint64_t *pDrmFormatModifiers                  ///< [in,out][optional][range(0, *pCount)] array of supported DRM format modifiers
-);
-
-/// @brief Get priority levels
-///
-/// @details
-///    - The application may call this function from simultaneous threads.
-///    - The implementation of this function should be lock-free.
-///    - Returns priority levels supported by the device
-///    - lowestPriority reports the numerical value that corresponds to lowest queue priority
-///    - highesPriority reports the numerical value that corresponds to highest queue priority
-///    - Lower numbers indicate greater priorities
-///    - The range of meaningful queue properties is represented by [*highestPriority, *lowestPriority]
-///    - Priority passed upon queue creation would automatically clamp down or up to the nearest supported value
-///    - 0 means default priority
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
-ze_result_t ZE_APICALL zeDeviceGetPriorityLevels(
-    ze_device_handle_t hDevice,
-    int32_t *lowestPriority,
-    int32_t *highestPriority);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Descriptor used for setting priority on command queues and immediate command lists.
-/// This structure may be passed as pNext member of ::ze_command_queue_desc_t.
-typedef struct _ze_queue_priority_desc_t {
-    ze_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;             ///< [in][optional] must be null or a pointer to an extension-specific structure
-    int priority;                  ///< [in] priority of the queue
-} ze_queue_priority_desc_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZE_INTEL_XE_DEVICE_PROPERTIES_EXP_NAME
-/// @brief Intel Xe device properties driver extension name
-#define ZE_INTEL_XE_DEVICE_PROPERTIES_EXP_NAME "ZE_intel_experimental_xe_device_properties"
-#endif // ZE_INTEL_XE_DEVICE_PROPERTIES_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Intel Xe device compute unit properties extension Version(s)
-typedef enum _ze_intel_xe_device_exp_properties_version_t {
-    ZE_INTEL_XE_DEVICE_EXP_PROPERTIES_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZE_INTEL_XE_DEVICE_EXP_PROPERTIES_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZE_INTEL_XE_DEVICE_EXP_PROPERTIES_VERSION_FORCE_UINT32 = 0x7fffffff
-
-} ze_intel_xe_device_exp_properties_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Intel Xe device compute unit properties
-///
-/// @details
-///     - This structure should be passed to ::zeDeviceGetProperties, via the `pNext` member of ::ze_device_properties_t
-
-typedef struct _ze_intel_xe_device_exp_properties_t {
-    ze_structure_type_ext_t stype;              ///< [in] type of this structure
-    void *pNext;                                ///< [in][optional] must be null or a pointer to extension-specific structure
-    uint32_t numXeStacks;                       ///< [out] number of Stacks (Tiles)
-    uint32_t numXeRegionsPerStack;              ///< [out] number of Regions per stack
-    uint32_t numXeClustersPerRegion;            ///< [out] number of Clusters (Slices) per Region
-    uint32_t numXeCorePerCluster;               ///< [out] number of XE Cores per Cluster
-    uint32_t numExecutionEnginesPerXeCore;      ///< [out] number of Execution Engines (EUs) per XE Core
-    uint32_t maxNumHwThreadsPerExecutionEngine; ///< [out] maximal number of HW threads per Execution Engine
-    uint32_t maxNumLanesPerHwThread;            ///< [out] maximal number of lanes (virtual SIMD size) per HW thread
-} ze_intel_xe_device_exp_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device brain floating-point atomic capabilities
-/// Must be passed to zeDeviceGetModuleProperties via pNext member of ze_device_module_properties_t
-typedef struct _zex_bfloat16_atomic_ext_properties_t {
-    ze_structure_type_ext_t stype;                 ///< [in] type of this structure
-    void *pNext;                                   ///< [in, out][optional] pointer to extension-specific structure
-    ze_device_fp_atomic_ext_flags_t bfloat16Flags; ///< [out] Capabilities for brain floating-point atomic operations
-} zex_bfloat16_atomic_ext_properties_t;
-
-#if ZE_API_VERSION_CURRENT_M <= ZE_MAKE_VERSION(1, 15)
-#define ZE_HOST_MEM_ALLOC_FLAG_MEM_READ_ONLY ZE_BIT(4)
-#endif
-
-#if ZE_API_VERSION_CURRENT_M <= ZE_MAKE_VERSION(1, 16)
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListGetFlags(
-    ze_command_list_handle_t hCommandList,
-    ze_command_list_flags_t *pFlags);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListImmediateGetFlags(
-    ze_command_list_handle_t hCommandListImmediate,
-    ze_command_queue_flags_t *pFlags);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListImmediateGetMode(
-    ze_command_list_handle_t hCommandListImmediate,
-    ze_command_queue_mode_t *pMode);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListImmediateGetPriority(
-    ze_command_list_handle_t hCommandListImmediate,
-    ze_command_queue_priority_t *pPriority);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandQueueGetFlags(
-    ze_command_queue_handle_t hCommandQueue,
-    ze_command_queue_flags_t *pFlags);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandQueueGetMode(
-    ze_command_queue_handle_t hCommandQueue,
-    ze_command_queue_mode_t *pMode);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandQueueGetPriority(
-    ze_command_queue_handle_t hCommandQueue,
-    ze_command_queue_priority_t *pPriority);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeCommandListIsMutableExp(
-    ze_command_list_handle_t hCommandList,
-    ze_bool_t *pIsMutable);
-
-ZE_APIEXPORT ze_result_t ZE_APICALL zeEventGetCounterBasedFlags(
-    ze_event_handle_t hEvent,              ///< [in] handle of the event
-    ze_event_counter_based_flags_t *pFlags ///< [out] pointer to value indicating the flags of the counter based event
-);
-#endif
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_results.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_results.h
deleted file mode 100644
index b4c6a81d..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_intel_results.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2025 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#ifndef _ZE_INTEL_RESULTS_H
-#define _ZE_INTEL_RESULTS_H
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <level_zero/zet_api.h>
-
-#include <cstdint>
-
-// Metrics experimental return codes
-#define ZE_INTEL_RESULT_WARNING_TIME_PARAMS_IGNORED_EXP static_cast<ze_result_t>(0x40000000) // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
-
-#endif // _ZE_INTEL_RESULTS_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_stypes.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_stypes.h
deleted file mode 100644
index fde8422a..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/ze_stypes.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (C) 2024-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#ifndef _ZE_STYPES_H
-#define _ZE_STYPES_H
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <level_zero/zet_api.h>
-
-#include <cstdint>
-using ze_structure_type_ext_t = uint32_t;
-using zet_structure_type_ext_t = uint32_t;
-using zes_structure_type_ext_t = uint32_t;
-
-#define ZE_STRUCTURE_TYPE_SYNCHRONIZED_DISPATCH_EXP_DESC static_cast<ze_structure_type_ext_t>(0x00020020)
-#define ZEX_STRUCTURE_TYPE_LABEL_DESCRIPTOR static_cast<ze_structure_type_ext_t>(0x00030002)
-#define ZEX_STRUCTURE_TYPE_OPERAND_DESCRIPTOR static_cast<ze_structure_type_ext_t>(0x00030003)
-#define ZEX_STRUCTURE_TYPE_VARIABLE_DESCRIPTOR static_cast<ze_structure_type_ext_t>(0x00030004)
-#define ZEX_STRUCTURE_TYPE_TEMP_VARIABLE_DESCRIPTOR static_cast<ze_structure_type_ext_t>(0x00030005)
-#define ZEX_STRUCTURE_TYPE_VARIABLE_INFO static_cast<ze_structure_type_ext_t>(0x00030006)
-#define ZE_INTEL_DEVICE_BLOCK_ARRAY_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030007)
-#define ZEX_STRUCTURE_DEVICE_MODULE_REGISTER_FILE_EXP static_cast<ze_structure_type_ext_t>(0x00030010)
-#define ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP static_cast<ze_structure_type_ext_t>(0x00030012)
-#define ZE_STRUCTURE_INTEL_DEVICE_MODULE_DP_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030013)
-#define ZEX_INTEL_STRUCTURE_TYPE_EVENT_SYNC_MODE_EXP_DESC static_cast<ze_structure_type_ext_t>(0x00030016)
-#define ZE_INTEL_STRUCTURE_TYPE_DEVICE_COMMAND_LIST_WAIT_ON_MEMORY_DATA_SIZE_EXP_DESC static_cast<ze_structure_type_ext_t>(0x00030017)
-#define ZEX_INTEL_STRUCTURE_TYPE_QUEUE_ALLOCATE_MSIX_HINT_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030018)
-#define ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x0003001B)
-#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_DESC static_cast<ze_structure_type_ext_t>(0x0003001C)
-#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_EXTERNAL_SYNC_ALLOC_PROPERTIES static_cast<ze_structure_type_ext_t>(0x0003001D)
-#define ZEX_STRUCTURE_TYPE_BFLOAT16_ATOMIC_EXT_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030020)
-#define ZE_STRUCTURE_TYPE_INTEL_XE_DEVICE_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030021)
-#define ZEX_STRUCTURE_COUNTER_BASED_EVENT_EXTERNAL_STORAGE_ALLOC_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030027)
-#define ZE_STRUCTURE_TYPE_QUEUE_PRIORITY_DESC static_cast<ze_structure_type_ext_t>(0x00030028)
-#ifndef ZE_RECORD_REPLAY_GRAPH_EXP_NAME
-#define ZE_STRUCTURE_TYPE_RECORD_REPLAY_GRAPH_EXP_PROPERTIES static_cast<ze_structure_type_ext_t>(0x00030029)
-#define ZE_STRUCTURE_TYPE_RECORD_REPLAY_GRAPH_EXP_DUMP_DESC static_cast<ze_structure_type_ext_t>(0x00030031)
-#endif // ZE_RECORD_REPLAY_GRAPH_EXP_NAME
-#define ZEX_STRUCTURE_TYPE_MEMORY_FREE_CALLBACK_EXT_DESC static_cast<ze_structure_type_ext_t>(0x00030030)
-
-#define ZEX_STRUCTURE_TYPE_CONCRETE_VISITOR_EXT_DESC static_cast<ze_structure_type_ext_t>(0x00030031)
-#define ZEX_STRUCTURE_TYPE_COMMAND_VISIT_EXT_DESC static_cast<ze_structure_type_ext_t>(0x00030032)
-
-// Metric structure types
-#define ZET_STRUCTURE_TYPE_INTEL_METRIC_SCOPE_PROPERTIES_EXP static_cast<zet_structure_type_ext_t>(0x00010006)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_HW_BUFFER_SIZE_EXP_DESC static_cast<zet_structure_type_ext_t>(0x00010007)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_GROUP_CALCULATION_EXP_PROPERTIES static_cast<zet_structure_type_ext_t>(0x00010008)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULATION_DESC_EXP static_cast<zet_structure_type_ext_t>(0x00010009)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_SOURCE_ID_EXP static_cast<zet_structure_type_ext_t>(0x0001000a)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_DECODED_BUFFER_PROPERTIES_EXP static_cast<zet_structure_type_ext_t>(0x0001000b)
-#define ZET_INTEL_STRUCTURE_TYPE_METRIC_CALCULABLE_PROPERTIES_EXP static_cast<zet_structure_type_ext_t>(0x0001000c)
-
-// Sysman structure types
-#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE static_cast<zes_structure_type_ext_t>(0x00040001)
-#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES static_cast<zes_structure_type_ext_t>(0x00040002)
-#define ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES static_cast<zes_structure_type_ext_t>(0x00040003)
-#define ZES_INTEL_STRUCTURE_TYPE_FREQUENCY_THROTTLE_DETAILED_REASON_EXP static_cast<zes_structure_type_ext_t>(0x00040004)
-#define ZES_INTEL_STRUCTURE_TYPE_RAS_CONFIG_EXP static_cast<zes_structure_type_ext_t>(0x00040005)
-#define ZES_INTEL_STRUCTURE_TYPE_RAS_STATE_EXP static_cast<zes_structure_type_ext_t>(0x00040006)
-#define ZES_INTEL_STRUCTURE_TYPE_MEMORY_PAGE_INFO_EXP static_cast<zes_structure_type_ext_t>(0x00040007)
-#define ZES_INTEL_STRUCTURE_TYPE_MEMORY_PAGE_OFFLINE_PROPERTIES_EXP static_cast<zes_structure_type_ext_t>(0x00040008)
-#define ZES_INTEL_STRUCTURE_TYPE_DEVICE_STATE_PENDING_ACTION_EXP static_cast<zes_structure_type_ext_t>(0x00040009)
-#define ZES_INTEL_STRUCTURE_TYPE_DEVICE_STATE_EXP static_cast<zes_structure_type_ext_t>(0x0004000A)
-#define ZES_INTEL_STRUCTURE_TYPE_RAS_STATE_EXP2 static_cast<zes_structure_type_ext_t>(0x0004000B)
-
-#endif
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zes_intel_gpu_sysman.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/zes_intel_gpu_sysman.h
deleted file mode 100644
index cf7b6e75..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zes_intel_gpu_sysman.h
+++ /dev/null
@@ -1,684 +0,0 @@
-/*
- * Copyright (C) 2025-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZES_INTEL_GPU_SYSMAN_H
-#define _ZES_INTEL_GPU_SYSMAN_H
-
-#include "level_zero/ze_stypes.h"
-#include <level_zero/zes_api.h>
-
-#if defined(__cplusplus)
-#pragma once
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-#define ZES_INTEL_GPU_SYSMAN_VERSION_MAJOR 0
-#define ZES_INTEL_GPU_SYSMAN_VERSION_MINOR 1
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
-/// @brief PCI link speed downgrade state extension name
-#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME "ZES_intel_experimental_pci_link_speed_downgrade_state"
-#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query pcie downgrade status extension Version(s)
-typedef enum _zes_intel_pci_link_speed_downgrade_exp_state_version_t {
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_pci_link_speed_downgrade_exp_state_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query pcie downgrade status.
-/// This structure can be passed in the 'pNext' of zes_pci_state_t
-typedef struct _zes_intel_pci_link_speed_downgrade_exp_state_t {
-    zes_structure_type_ext_t stype;        ///< [in] type of this structure
-    void *pNext;                           ///< [in][optional] must be null or a pointer to an extension-specific
-                                           ///< structure (i.e. contains stype and pNext).
-    ze_bool_t pciLinkSpeedDowngradeStatus; ///< [out] Returns the current PCIe downgrade status .
-} zes_intel_pci_link_speed_downgrade_exp_state_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
-/// @brief PCI link speed downgrade property extension name
-#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME "ZES_intel_experimental_pci_link_speed_downgrade_property"
-#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query pcie downgrade capability extension Version(s)
-typedef enum _zes_intel_pci_link_speed_downgrade_exp_properties_version_t {
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_pci_link_speed_downgrade_exp_properties_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query pcie downgrade capability.
-/// This structure can be passed in the 'pNext' of zes_pci_properties_t
-typedef struct _zes_intel_pci_link_speed_downgrade_exp_properties_t {
-    zes_structure_type_ext_t stype;      ///< [in] type of this structure
-    void *pNext;                         ///< [in][optional] must be null or a pointer to an extension-specific
-                                         ///< structure (i.e. contains stype and pNext).
-    ze_bool_t pciLinkSpeedUpdateCapable; ///< [out] Returns if PCIe downgrade capability is available.
-    int32_t maxPciGenSupported;          ///< [out] Returns the max supported PCIe generation of the device. -1 indicated the information is not available
-} zes_intel_pci_link_speed_downgrade_exp_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_NAME
-/// @brief PCI link speed update extension name
-#define ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_NAME "ZES_intel_experimental_pci_link_speed_update"
-#endif // ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief PCI link speed update extension Version(s)
-typedef enum _zes_intel_pci_link_speed_update_exp_version_t {
-    ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_PCI_LINK_SPEED_UPDATE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_pci_link_speed_update_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Update PCIe Link Speed
-///
-/// @details
-///     - This function allows updating the PCIe link speed by downgrading or upgrading.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
-///     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
-///     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
-///     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
-///     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
-///     - ::ZE_RESULT_ERROR_UNKNOWN
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hDevice`
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
-///         + `nullptr == pendingAction`
-ze_result_t ZE_APICALL zesIntelDevicePciLinkSpeedUpdateExp(
-    zes_device_handle_t hDevice,       ///< [in] handle of the device
-    ze_bool_t downgradeUpgrade,        ///< [in] boolean value to decide whether to perform PCIe downgrade(true) or upgrade(false)
-    zes_device_action_t *pendingAction ///< [out] Pending action
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
-/// @brief Driver name property extension name
-#define ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME "ZES_intel_experimental_driver_name_property"
-#endif // ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query driver name extension Version(s)
-typedef enum _zes_intel_driver_name_exp_properties_version_t {
-    ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_driver_name_exp_properties_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query driver name.
-/// This structure can be passed in the 'pNext' of zes_device_properties_t
-typedef struct _zes_intel_driver_name_exp_properties_t {
-    zes_structure_type_ext_t stype;            ///< [in] type of this structure
-    void *pNext;                               ///< [in][optional] must be null or a pointer to an extension-specific
-                                               ///< structure (i.e. contains stype and pNext).
-    char driverName[ZES_STRING_PROPERTY_SIZE]; ///< [out] Installed driver name (NULL terminated string value). Will be
-                                               ///< set to the string "unknown" if this cannot be determined for the
-                                               ///< device.
-} zes_intel_driver_name_exp_properties_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_FREQ_THROTTLE_REASON_EXP_NAME
-/// @brief Frequency throttle reason extension name
-#define ZES_INTEL_FREQ_THROTTLE_REASON_EXP_NAME "ZES_intel_experimental_frequency_throttle_reason"
-#endif // ZES_INTEL_FREQ_THROTTLE_REASON_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Frequency throttle reason extension Version(s)
-typedef enum _zes_intel_freq_throttle_reason_exp_version_t {
-    ZES_INTEL_FREQ_THROTTLE_REASON_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_FREQ_THROTTLE_REASON_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_FREQ_THROTTLE_REASON_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_freq_throttle_reason_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Frequency Detailed Throttle Reasons Extension Version(s)
-typedef enum _zes_intel_freq_throttle_detailed_reason_exp_version_t {
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_freq_throttle_detailed_reason_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Frequency Detailed Throttle Reasons
-typedef uint64_t zes_intel_freq_throttle_detailed_reason_exp_flags_t;
-typedef enum _zes_intel_freq_throttle_detailed_reason_exp_flag_t {
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_CARD_PL1 = ZE_BIT(0),    ///< frequency throttled due to CARD PL1 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_CARD_PL2 = ZE_BIT(1),    ///< frequency throttled due to CARD PL2 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_CARD_PL4 = ZE_BIT(2),    ///< frequency throttled due to CARD PL4 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_PACKAGE_PL1 = ZE_BIT(3), ///< frequency throttled due to PACKAGE PL1 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_PACKAGE_PL2 = ZE_BIT(4), ///< frequency throttled due to PACKAGE PL2 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_PACKAGE_PL4 = ZE_BIT(5), ///< frequency throttled due to PACKAGE PL4 power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_ICCMAX = ZE_BIT(6),      ///< frequency throttled due to ICC max power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_POWER_FAST_VMODE = ZE_BIT(7),  ///< frequency throttled due to fast Vmode power
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_MEMORY = ZE_BIT(8),    ///< frequency throttled due to memory thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_PROCHOT = ZE_BIT(9),   ///< frequency throttled due to Prochot thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_RATL = ZE_BIT(10),     ///< frequency throttled due to RATL thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_SOC = ZE_BIT(11),      ///< frequency throttled due to SoC thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_SOC_AVG = ZE_BIT(12),  ///< frequency throttled due to SoC average thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_THERMAL_VR = ZE_BIT(13),       ///< frequency throttled due to VR thermal
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_VOLTAGE_P0_FREQ = ZE_BIT(14),  ///< frequency throttled due to P0 frequency
-    ZES_INTEL_FREQ_THROTTLE_DETAILED_REASON_EXP_FLAG_FORCE_UINT32 = 0x7fffffff      ///< Value marking end of ZES_INTEL_FREQ_THROTTLE_REASON_DETAILED_FLAG_* ENUMs
-} zes_intel_freq_throttle_detailed_reason_exp_flag_t;
-
-#define ZES_INTEL_FREQ_THROTTLE_REASON_EXP_FLAG_UTILIZATION_LIMITED ZE_BIT(10) // Frequency utilization limit reason flag used when no specific detailed reason is available
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Detailed Frequency Throttle Reasons.
-/// This structure can be passed in the 'pNext' of zes_intel_freq_state_t
-typedef struct _zes_intel_freq_throttle_detailed_reason_exp_t {
-    zes_structure_type_ext_t stype;                                      ///< [in] type of this structure
-    void *pNext;                                                         ///< [in][optional] must be null or a pointer to an extension-specific
-                                                                         ///< structure (i.e. contains stype and pNext).
-    zes_intel_freq_throttle_detailed_reason_exp_flags_t detailedReasons; ///< [out] Returns the detailed frequency throttle reasons.
-} zes_intel_freq_throttle_detailed_reason_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS Error Categories
-typedef enum _zes_intel_ras_error_category_exp_t {
-    ZES_INTEL_RAS_ERROR_CATEGORY_EXP_PCIE_ERRORS = 10,         ///< The number of errors that have occurred in the PCIe subsystem
-    ZES_INTEL_RAS_ERROR_CATEGORY_EXP_FABRIC_ERRORS = 11,       ///< The number of errors that have occurred in the Fabric interconnect in the SOC
-    ZES_INTEL_RAS_ERROR_CATEGORY_EXP_SOC_INTERNAL_ERRORS = 12, ///< The number of errors that have occurred in the SOC internal components
-    ZES_INTEL_RAS_ERROR_CATEGORY_EXP_FORCE_UINT32 = 0x7fffffff ///< Value marking end of ZES_INTEL_RAS_ERROR_CATEGORY_EXP_* ENUMs
-} zes_intel_ras_error_category_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_RAS_ERROR_THRESHOLD_MANAGEMENT_EXTENSION_NAME
-/// @brief RAS Error Threshold Management Extension Name
-#define ZES_INTEL_RAS_ERROR_THRESHOLD_MANAGEMENT_EXTENSION_NAME "ZES_intel_experimental_ras_error_threshold_management"
-#endif // ZES_INTEL_RAS_ERROR_THRESHOLD_MANAGEMENT_EXTENSION_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Ras Config Driver Experimental Extension Version(s)
-typedef enum _zes_intel_ras_config_exp_version_t {
-    ZES_INTEL_RAS_CONFIG_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_CONFIG_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_CONFIG_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_config_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Ras Config Driver Experimental Extension Structure
-typedef struct _zes_intel_ras_config_exp_t {
-    zes_structure_type_ext_t stype;        ///< [in] type of this structure
-    void *pNext;                           ///< [in][optional] must be null or a pointer to an extension-specific
-                                           ///< structure (i.e. contains stype and pNext).
-    zes_ras_error_category_exp_t category; ///< [in] RAS error category
-    uint64_t threshold;                    ///< [in][out] Error count threshold to trigger RAS action
-                                           ///< [in] when calling zesIntelRasSetConfigExp
-                                           ///< [out] when calling zesIntelRasGetConfigExp
-} zes_intel_ras_config_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Ras State Driver Experimental Extension Version
-typedef enum _zes_intel_ras_state_exp_version_t {
-    ZES_INTEL_RAS_STATE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_STATE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_STATE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_state_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Ras State Driver Experimental Extension Structure
-typedef struct _zes_intel_ras_state_exp_t {
-    zes_structure_type_ext_t stype;        ///< [in] type of this structure
-    void *pNext;                           ///< [in][optional] must be null or a pointer to an extension-specific
-                                           ///< structure (i.e. contains stype and pNext).
-    zes_ras_error_category_exp_t category; ///< [in] Error category.
-    uint64_t errorCounter;                 ///< [out] Current value of RAS counter for specific error category.
-} zes_intel_ras_state_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_NAME
-/// @brief RAS get supported categories extension name
-#define ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_NAME "ZES_intel_experimental_ras_get_supported_categories"
-#endif // ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS get supported categories extension Version(s)
-typedef enum _zes_intel_ras_get_supported_categories_exp_version_t {
-    ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_GET_SUPPORTED_CATEGORIES_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_get_supported_categories_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS Get Supported Driver Experimental Extension Error Categories
-///
-/// @details
-///     - This function retrieves the supported RAS error categories.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hRas`
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
-///         + `nullptr == pCount`
-ze_result_t ZE_APICALL zesIntelRasGetSupportedCategoriesExp(
-    zes_ras_handle_t hRas,                    ///< [in] Handle for the RAS module.
-    uint32_t *pCount,                         ///< [in,out] pointer to the number of categories.
-                                              ///< if count is zero, then the driver shall update the value with the
-                                              ///< total number of categories supported.
-                                              ///< if count is non-zero, then driver shall only retrieve that number
-                                              ///< of categories.
-    zes_ras_error_category_exp_t *pCategories ///< [in][out][optional] array of category types.
-                                              ///< if count is less than the number of categories supported, then
-                                              ///< driver shall only retrieve that number of categories.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_RAS_GET_CONFIG_EXP_NAME
-/// @brief RAS get config extension name
-#define ZES_INTEL_RAS_GET_CONFIG_EXP_NAME "ZES_intel_experimental_ras_get_config"
-#endif // ZES_INTEL_RAS_GET_CONFIG_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS get config extension Version(s)
-typedef enum _zes_intel_ras_get_config_exp_version_t {
-    ZES_INTEL_RAS_GET_CONFIG_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_GET_CONFIG_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_GET_CONFIG_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_get_config_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS Get Driver Experimental Extension Config
-///
-/// @details
-///     - This function retrieves the RAS error thresholds for the given RAS error categories.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hRas`
-ze_result_t ZE_APICALL zesIntelRasGetConfigExp(
-    zes_ras_handle_t hRas,              ///< [in] Handle for the RAS module.
-    const uint32_t count,               ///< [in] Number of elements in the pConfig array.
-    zes_intel_ras_config_exp_t *pConfig ///< [in][out] Array of RAS configurations to get.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_RAS_SET_CONFIG_EXP_NAME
-/// @brief RAS set config extension name
-#define ZES_INTEL_RAS_SET_CONFIG_EXP_NAME "ZES_intel_experimental_ras_set_config"
-#endif // ZES_INTEL_RAS_SET_CONFIG_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS set config extension Version(s)
-typedef enum _zes_intel_ras_set_config_exp_version_t {
-    ZES_INTEL_RAS_SET_CONFIG_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_SET_CONFIG_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_SET_CONFIG_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_set_config_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS Set Driver Experimental Extension Config
-///
-/// @details
-///     - This function sets the RAS error thresholds for the given RAS error categories.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hRas`
-ze_result_t ZE_APICALL zesIntelRasSetConfigExp(
-    zes_ras_handle_t hRas,                    ///< [in] Handle for the RAS module.
-    const uint32_t count,                     ///< [in] Number of elements in the pConfig array.
-    const zes_intel_ras_config_exp_t *pConfig ///< [in] Array of RAS configurations to set.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_RAS_GET_STATE_EXP2_NAME
-/// @brief RAS get state (v2) extension name
-#define ZES_INTEL_RAS_GET_STATE_EXP2_NAME "ZES_intel_experimental_ras_get_state2"
-#endif // ZES_INTEL_RAS_GET_STATE_EXP2_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS get state (v2) extension Version(s)
-typedef enum _zes_intel_ras_get_state_exp2_version_t {
-    ZES_INTEL_RAS_GET_STATE_EXP2_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_RAS_GET_STATE_EXP2_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_RAS_GET_STATE_EXP2_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_ras_get_state_exp2_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS State (v2) structure - one entry per queried category.
-typedef struct _zes_intel_ras_state_exp2_t {
-    zes_structure_type_ext_t stype; ///< [in] must be ZES_INTEL_STRUCTURE_TYPE_RAS_STATE_EXP2
-    void *pNext;                    ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    uint64_t errorCounter;          ///< [out] Current value of RAS counter for the corresponding input category.
-} zes_intel_ras_state_exp2_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief RAS Get Driver Experimental Extension State (v2)
-///
-/// @details
-///     - This function retrieves error counters for a caller-specified set of
-///       RAS error categories.
-///     - The caller provides an input array of error categories and an output
-///       array of zes_intel_ras_state_exp2_t structures of the same length.
-///       pStates[i].errorCounter is populated for pCategories[i].
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hRas`
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER
-///         + `nullptr == pCategories`
-///         + `nullptr == pStates`
-ze_result_t ZE_APICALL zesIntelRasGetStateExp2(
-    zes_ras_handle_t hRas,                           ///< [in] Handle for the RAS module.
-    const uint32_t categoryCount,                    ///< [in] Number of elements in pCategories and pStates.
-    const zes_ras_error_category_exp_t *pCategories, ///< [in] Array of error categories to query.
-    zes_intel_ras_state_exp2_t *pStates              ///< [in][out] Array of RAS state structures, one per category.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_POWER_LIMITS_EXP_NAME
-/// @brief Power limits extension name
-#define ZES_INTEL_POWER_LIMITS_EXP_NAME "ZES_intel_experimental_power_limits"
-#endif // ZES_INTEL_POWER_LIMITS_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Power limits extension Version(s)
-typedef enum _zes_intel_power_limits_exp_version_t {
-    ZES_INTEL_POWER_LIMITS_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_POWER_LIMITS_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_POWER_LIMITS_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_power_limits_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Get Experimental Power Limits
-///
-/// @details
-///     - This function returns the power limit associated with the supplied power domain.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
-///     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
-///     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
-///     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
-///     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
-///     - ::ZE_RESULT_ERROR_UNKNOWN
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hPower`
-ze_result_t ZE_APICALL zesIntelPowerGetLimitsExp(
-    zes_pwr_handle_t hPower, ///< [in] Power domain handle instance.
-    uint32_t *pLimit         ///< [out] Returns limit value in milliwatts for given power domain.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Set Experimental Power Limits
-///
-/// @details
-///     - This function sets the power limit associated with the supplied power domain.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
-///     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
-///     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
-///     - ::ZE_RESULT_ERROR_UNKNOWN
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hPower`
-///     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
-///         + User does not have permissions to make these modifications.
-///     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
-///         + The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported.
-ze_result_t ZE_APICALL zesIntelPowerSetLimitsExp(
-    zes_pwr_handle_t hPower, ///< [in] Power domain handle instance.
-    const uint32_t limit     ///< [in] Limit value in milliwatts to be set for given power domain.
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_POWER_USAGE_EXP_NAME
-/// @brief Power usage extension name
-#define ZES_INTEL_POWER_USAGE_EXP_NAME "ZES_intel_experimental_power_usage"
-#endif // ZES_INTEL_POWER_USAGE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Power usage extension Version(s)
-typedef enum _zes_intel_power_usage_exp_version_t {
-    ZES_INTEL_POWER_USAGE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_POWER_USAGE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_POWER_USAGE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_power_usage_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Get Experimental Power Usage
-///
-/// @details
-///     - This function returns the different Power usage values associated with the supplied power domain.
-///
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
-///     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
-///     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
-///     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
-///     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
-///     - ::ZE_RESULT_ERROR_UNKNOWN
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hPower`
-ze_result_t ZE_APICALL zesIntelDeviceGetPowerUsageExp(
-    zes_pwr_handle_t hPower, ///< [in] handle of the power domain
-    uint32_t *pInstantPower, ///< [out] Returns the instant power usage in milliwatts
-    uint32_t *pAveragePower  ///< [out] Returns the average power usage in milliwatts
-);
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_NAME
-/// @brief  Memory offline extension name
-#define ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_NAME "ZES_intel_memory_page_offline"
-#endif // ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory offline extension Version(s)
-typedef enum _zes_intel_memory_page_offline_exp_version_t {
-    ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_MEMORY_PAGE_OFFLINE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_memory_page_offline_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory Page status
-typedef enum _zes_intel_mem_page_status_exp_t {
-    ZES_INTEL_MEM_PAGE_STATUS_EXP_OFFLINE = 1,
-    ZES_INTEL_MEM_PAGE_STATUS_EXP_PENDING_OFFLINE = 2,
-    ZES_INTEL_MEM_PAGE_STATUS_EXP_FORCE_UINT32 = 0x7fffffff
-} zes_intel_mem_page_status_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory Page information structure
-typedef struct _zes_intel_mem_page_info_exp_t {
-    zes_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                    ///< [in,out][optional] pointer to extension-specific  structure
-    uint64_t pageAddress;           ///< [out] Physical address of the memory page
-    uint32_t pageSize;              ///< [out] Size of the page in bytes
-} zes_intel_mem_page_info_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Get Memory Page Offline
-///
-/// @details
-///     - This function returns the memory page offline state.
-/// @returns
-///     - ::ZE_RESULT_SUCCESS
-///     - ::ZE_RESULT_ERROR_UNINITIALIZED
-///     - ::ZE_RESULT_ERROR_DEVICE_LOST
-///     - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY
-///     - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///     - ::ZE_RESULT_ERROR_UNSUPPORTED_FEATURE
-///     - ::ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE
-///     - ::ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
-///     - ::ZE_RESULT_ERROR_NOT_AVAILABLE
-///     - ::ZE_RESULT_ERROR_DEVICE_REQUIRES_RESET
-///     - ::ZE_RESULT_ERROR_DEVICE_IN_LOW_POWER_STATE
-///     - ::ZE_RESULT_ERROR_UNKNOWN
-///     - ::ZE_RESULT_ERROR_SURVIVABILITY_MODE_DETECTED
-///     - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE
-///         + `nullptr == hDevice`
-ze_result_t ZE_APICALL zesIntelDeviceMemoryGetPageOfflineStateExp(
-    zes_device_handle_t hDevice,                    ///< [in] handle of the device
-    zes_intel_mem_page_status_exp_t pageStatus,     ///< [in] Status of the Memory Pages to be queried
-    uint32_t *pCount,                               ///< [in,out] pointer to the number of memory pages which are already offlined or pending to be offlined.
-                                                    ///< if count is zero, then the driver shall update the value with the
-                                                    ///< total number of memory pages in the given status.
-                                                    ///< if count is non-zero, then driver shall only retrieve that number
-                                                    ///< of memory pages in the given status.
-    zes_intel_mem_page_info_exp_t *pPageOfflineInfo ///< [in,out][optional] array of memory page information structure.
-                                                    ///< if count is less than the number of memory pages in the given status, then
-                                                    ///< driver shall only retrieve that number of memory pages in the given status.
-);
-#ifndef ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_NAME
-/// @brief Device state extension name
-#define ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_NAME "ZES_intel_device_state_pending_action_exp"
-#endif // ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device state extension Version(s)
-typedef enum _zes_intel_device_state_pending_action_exp_version_t {
-    ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_DEVICE_STATE_PENDING_ACTION_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_device_state_pending_action_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Extension to provide wedged device recovery action
-///
-/// @details
-///     - This structure can be passed in the 'pNext' of zes_device_state_t
-///     - Provides information about pending actions required for device recovery
-typedef struct _zes_intel_device_state_pending_action_exp_t {
-    zes_structure_type_ext_t stype;     ///< [in] type of this structure
-    const void *pNext;                  ///< [in][optional] must be null or a pointer to an extension-specific
-                                        ///< structure (i.e. contains stype and pNext).
-    zes_pending_action_t pendingAction; ///< [out] Indicates the pending action required for device recovery.
-                                        ///< When device is wedged, will be set to ZES_PENDING_ACTION_PENDING_COLD_RESET
-                                        ///< For example, When device is wedged this will be set to ZES_PENDING_ACTION_PENDING_COLD_RESET
-} zes_intel_device_state_pending_action_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_DEVICE_STATE_EXP_NAME
-/// @brief Device state extension name
-#define ZES_INTEL_DEVICE_STATE_EXP_NAME "ZES_intel_device_state_exp"
-#endif // ZES_INTEL_DEVICE_STATE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device state extension Version(s)
-typedef enum _zes_intel_device_state_exp_version_t {
-    ZES_INTEL_DEVICE_STATE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_DEVICE_STATE_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_DEVICE_STATE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_device_state_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Device state flags extension
-typedef uint32_t zes_intel_device_state_flags_exp_t;
-typedef enum _zes_intel_device_state_flag_exp_t {
-    ZES_INTEL_DEVICE_STATE_FLAG_EXP_WEDGED = ZE_BIT(0),         ///< The device is wedged
-    ZES_INTEL_DEVICE_STATE_FLAG_EXP_SURVIVABILITY = ZE_BIT(1),  ///< The device is in survivability mode
-    ZES_INTEL_DEVICE_STATE_FLAG_EXP_FLASH_OVERRIDE = ZE_BIT(2), ///< The device has flash override enabled
-    ZES_INTEL_DEVICE_STATE_FLAG_EXP_FORCE_UINT32 = 0x7fffffff
-} zes_intel_device_state_flag_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Extension to provide device state information
-///
-/// @details
-///     - This structure can be passed in the 'pNext' of zes_device_state_t
-///     - Provides extended device state information
-typedef struct _zes_intel_device_state_exp_t {
-    zes_structure_type_ext_t stype;           ///< [in] type of this structure
-    void *pNext;                              ///< [in][optional] must be null or a pointer to an extension-specific
-                                              ///< structure (i.e. contains stype and pNext).
-    zes_intel_device_state_flags_exp_t flags; ///< [out] Device state flags. Returns 0 (none) or a combination of ::zes_intel_device_state_flag_exp_t
-} zes_intel_device_state_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-#ifndef ZES_INTEL_MEMORY_PAGE_OFFLINE_PROPERTY_EXP_NAME
-/// @brief  Memory Page Offline Property extension name
-#define ZES_INTEL_MEMORY_PAGE_OFFLINE_PROPERTY_EXP_NAME "ZES_intel_memory_page_offline_property"
-#endif // ZES_INTEL_MEMORY_PAGE_OFFLINE_PROPERTY_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory Page Offline Property extension Version(s)
-typedef enum _zes_intel_mem_page_offline_properties_exp_version_t {
-    ZES_INTEL_MEM_PAGE_OFFLINE_PROPERTIES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZES_INTEL_MEM_PAGE_OFFLINE_PROPERTIES_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZES_INTEL_MEM_PAGE_OFFLINE_PROPERTIES_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zes_intel_mem_page_offline_properties_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Memory Page Offline Properties structure
-typedef struct _zes_intel_mem_page_offline_properties_exp_t {
-    zes_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                    ///< [in,out][optional] must be null or a pointer to an extension-specific
-    uint32_t maxOfflinePages;       ///< [out] Maximum number of pages that can be offlined.
-                                    ///< Returns 0 if page offline is not supported.
-} zes_intel_mem_page_offline_properties_exp_t;
-
-#define ZES_INTEL_MEM_TYPE_LPDDR5X 500 ///< LPDDR5X Memory Type
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZES_INTEL_GPU_SYSMAN_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_debug.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_debug.h
deleted file mode 100644
index 7815f49c..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_debug.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2021-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZET_INTEL_GPU_DEBUG_H
-#define _ZET_INTEL_GPU_DEBUG_H
-#if defined(__cplusplus)
-#pragma once
-#endif
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#ifndef ZET_INTEL_GPU_DEBUG_MAJOR
-#define ZET_INTEL_GPU_DEBUG_MAJOR 1
-#endif // !ZET_INTEL_GPU_DEBUG_MAJOR
-
-#ifndef ZET_INTEL_GPU_DEBUG_MINOR
-#define ZET_INTEL_GPU_DEBUG_MINOR 2
-#endif //! ZET_INTEL_GPU_DEBUG_MINOR
-
-#if ZET_INTEL_GPU_DEBUG_MAJOR == 1
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Supported device-specific register set types.
-typedef enum _zet_debug_regset_type_intel_gpu_t {
-#if ZET_INTEL_GPU_DEBUG_MINOR >= 0
-    ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU = 0, ///< An invalid register set
-    ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU = 1,     ///< The general purpose register set
-    ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU = 2,    ///< The address register set
-    ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU = 3,    ///< The flag register set
-    ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU = 4,      ///< The channel enable register set
-    ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU = 5,      ///< The status register set
-    ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU = 6,      ///< The control register set
-    ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU = 7,     ///< The thread dependency register set
-    ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU = 8,     ///< The accumulator register set
-    ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU = 9,     ///< The mme register set
-    ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU = 10,     ///< The stack pointer register set
-    ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU = 11,    ///< The state base address register set
-    ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU = 12,    ///< The debug register set
-    ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU = 13,     ///< The flow control register set
-#if ZET_INTEL_GPU_DEBUG_MINOR >= 1
-    ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU = 14,            ///< The msg register set
-    ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU = 15,     ///< System Routine mode flags register set
-    ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU = 16,  ///< Debug Scratch register set
-    ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU = 17, ///< Thread Scratch register set
-    ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU = 18,         ///< The scalar register set
-#endif                                                   // ZET_INTEL_GPU_DEBUG_MINOR >= 1
-#if ZET_INTEL_GPU_DEBUG_MINOR >= 2
-    ZET_DEBUG_REGSET_TYPE_STATUS_INTEL_GPU = 19,
-    ZET_DEBUG_REGSET_TYPE_RANDOM_INTEL_GPU = 20,
-    ZET_DEBUG_REGSET_TYPE_DIRECT_INTEL_GPU = 21,
-#endif // ZET_INTEL_GPU_DEBUG_MINOR >= 1
-    ZET_DEBUG_REGSET_TYPE_FORCE_UINT32 = 0x7fffffff
-#endif // ZET_INTEL_GPU_DEBUG_MINOR >= 0
-} zet_debug_regset_type_intel_gpu_t;
-
-#if ZET_INTEL_GPU_DEBUG_MINOR >= 1
-////////////////////////////////////////////////////////////////////////////////
-/// @brief ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU flag values
-typedef enum _zet_debug_mode_flags_intel_gpu_t {
-    ZET_DEBUG_MODE_FLAG_HEAPLESS = 1 ///< Bit set indicates heapless mode
-} zet_debug_mode_flags_intel_gpu_t;
-
-////////////////////////////////////////////////////////////////////////////////
-/// @brief ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU register layout
-typedef enum _zet_debug_debug_scratch_intel_gpu_t {
-    ZET_DEBUG_DEBUG_SCRATCH_ADDRESS = 0, ///< VA of scratch area for debugger code injection.
-                                         ///< VA is in default address space of device
-    ZET_DEBUG_DEBUG_SCRATCH_SIZE = 1,    ///< Size of scratch area in bytes
-} zet_debug_debug_scratch_intel_gpu_t;
-#endif // ZET_INTEL_GPU_DEBUG_MINOR >= 1
-////////////////////////////////////////////////////////////////////////////////
-/// @brief SBA register set layout
-typedef enum _zet_debug_sba_intel_gpu_t {
-    ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU = 0,    ///< GeneralStateBaseAddress
-    ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU = 1,    ///< SurfaceStateBaseAddress
-    ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU = 2,    ///< DynamicStateBaseAddress
-    ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU = 3,  ///< IndirectObjectBaseAddress
-    ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU = 4,      ///< InstructionBaseAddress
-    ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU = 5, ///< BindlessSurfaceStateBaseAddress
-    ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU = 6, ///< BindlessSamplerStateBaseAddress
-    ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU = 7,    ///< BindingTableStateBaseAddress
-    ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU = 8,    ///< ScratchSpaceBaseAddress
-    ZET_DEBUG_SBA_COUNT_INTEL_GPU = 9             ///< Number of registers in SBA register set
-} zet_debug_sba_intel_gpu_t;
-#endif // ZET_INTEL_GPU_DEBUG_MAJOR == 1
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZET_INTEL_GPU_DEBUG_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric.h
deleted file mode 100644
index 1ce56362..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric.h
+++ /dev/null
@@ -1,476 +0,0 @@
-/*
- * Copyright (C) 2023-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZET_INTEL_GPU_METRIC_H
-#define _ZET_INTEL_GPU_METRIC_H
-
-#include "level_zero/ze_intel_results.h"
-#include "level_zero/ze_stypes.h"
-#include <level_zero/zet_api.h>
-
-#if defined(__cplusplus)
-#pragma once
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-#define ZET_INTEL_GPU_METRIC_VERSION_MAJOR 0
-#define ZET_INTEL_GPU_METRIC_VERSION_MINOR 2
-#define ZET_INTEL_MAX_METRIC_GROUP_NAME_PREFIX_EXP 64u
-#define ZET_INTEL_METRIC_PROGRAMMABLE_PARAM_TYPE_GENERIC_EXP (0x7ffffffe)
-
-#ifndef ZET_INTEL_METRIC_SOURCE_ID_EXP_NAME
-/// @brief Extension name for query to read the Intel Metric source ID
-#define ZET_INTEL_METRIC_SOURCE_ID_EXP_NAME "ZET_intel_metric_source_id"
-#endif // ZET_INTEL_METRIC_SOURCE_ID_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metric Source Id extension Version(s)
-typedef enum _zet_intel_metric_source_id_exp_version_t {
-    ZET_INTEL_METRIC_SOURCE_ID_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),     ///< version 1.0
-    ZET_INTEL_METRIC_SOURCE_ID_EXP_VERSION_CURRENT = ZE_MAKE_VERSION(1, 0), ///< latest known version
-    ZET_INTEL_METRIC_SOURCE_ID_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_source_id_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query an unique identifier representing the source of a metric group
-/// This structure can be passed in the 'pNext' of zet_metric_group_properties_t
-typedef struct _zet_intel_metric_source_id_exp_t {
-    zet_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;              ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    uint32_t sourceId;              ///< [out] Returns an unique source Id of the metric group
-} zet_intel_metric_source_id_exp_t;
-
-#ifndef ZET_INTEL_METRIC_SCOPES_EXP_NAME
-/// @brief Extension name to query Intel Metric Scopes operations
-#define ZET_INTEL_METRIC_SCOPES_EXP_NAME "ZET_intel_metric_scopes"
-#endif // ZET_INTEL_METRIC_SCOPES_EXP_NAME
-typedef enum _zet_intel_metric_scopes_exp_version_t {
-    ZET_INTEL_METRIC_SCOPES_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                       ///< version 1.0
-    ZET_INTEL_METRIC_SCOPES_EXP_VERSION_1_1 = ZE_MAKE_VERSION(1, 1),                       ///< version 1.1
-    ZET_INTEL_METRIC_SCOPES_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_SCOPES_EXP_VERSION_1_1, ///< latest known version
-    ZET_INTEL_METRIC_SCOPES_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_scopes_exp_version_t;
-
-/// @brief Handle of metric scope
-struct _zet_intel_metric_scope_exp_handle_t {};
-typedef struct _zet_intel_metric_scope_exp_handle_t *zet_intel_metric_scope_exp_handle_t;
-
-#define ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP 64u
-#define ZET_INTEL_MAX_METRIC_SCOPE_DESCRIPTION_EXP 128u
-
-/// @brief Query an metric scope properties
-typedef struct _zet_intel_metric_scope_properties_exp_t {
-    zet_structure_type_ext_t stype;                               ///< [in] type of this structure
-    void *pNext;                                                  ///< [in][optional] must be null or a pointer to an extension-specific
-                                                                  ///< structure (i.e. contains stype and pNext).
-    uint16_t iD;                                                  ///< [out ]ID will be equal to the index of the metric scope in the
-                                                                  ///> array returned by zetIntelMetricScopesGetExp()
-    char name[ZET_INTEL_MAX_METRIC_SCOPE_NAME_EXP];               ///< [out] name of the metric scope.
-                                                                  ///< The name is expected to be a human readable string.
-                                                                  ///< The name can be used to identify the metric scope in the UI.
-    char description[ZET_INTEL_MAX_METRIC_SCOPE_DESCRIPTION_EXP]; ///< [out] description of the metric scope.
-                                                                  ///< The description is expected to be a human readable string.
-} zet_intel_metric_scope_properties_exp_t;
-
-ze_result_t ZE_APICALL zetIntelMetricScopesGetExp(
-    zet_context_handle_t hContext,                        ///< [in] handle of the context object
-    zet_device_handle_t hDevice,                          ///< [in] handle of the device
-    uint32_t *pMetricScopesCount,                         ///< [in,out] pointer to the number of metric scopes available for the device.
-                                                          ///< If set to zero, then the driver shall update the value with the total
-                                                          ///< number of metric scopes available for the device.
-    zet_intel_metric_scope_exp_handle_t *phMetricScopes); ///< [out][optional] [range(0, *pMetricScopesCount)] array of metric scopes handles
-                                                          ///< available for the device. If pMetricScopesCount is greater than zero but
-                                                          ///< less than the total number of metric scopes available for the device,
-                                                          ///< then driver shall only return that number of metric scopes.
-
-ze_result_t ZE_APICALL zetIntelMetricScopeGetPropertiesExp(
-    zet_intel_metric_scope_exp_handle_t hMetricScope,                 ///< [in] handle of the metric scope
-    zet_intel_metric_scope_properties_exp_t *pMetricScopeProperties); ///< [out] pointer to the metric scope properties structure
-
-ze_result_t ZE_APICALL zetIntelMetricSupportedScopesGetExp(
-    zet_metric_handle_t hMetric,                    ///< [in] handle of the metric
-    uint32_t *pCount,                               ///< [in,out] pointer to the number of metric scopes available for the metric.
-                                                    ///< If set to zero, then the driver shall update the value with the total
-                                                    ///< number of metric scopes available for the metric.
-    zet_intel_metric_scope_exp_handle_t *phScopes); ///< [out][optional] [range(0, *pCount)] array of metric scopes handles
-                                                    ///< available for the metric. If pCount is greater than zero but
-                                                    ///< less than the total number of metric scopes available for the metric,
-                                                    ///< then driver shall only return that number of metric scopes.
-
-#ifndef ZET_INTEL_METRIC_CALCULATION_EXP_NAME
-/// @brief Extension name to query Intel Metric Calculation operations
-#define ZET_INTEL_METRIC_CALCULATION_EXP_NAME "ZET_intel_metric_calculation"
-#endif // ZET_INTEL_METRIC_CALCULATION_EXP_NAME
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metric Calculation extension Version(s)
-typedef enum _zet_intel_metric_calculation_exp_version_t {
-    ZET_INTEL_METRIC_CALCULATION_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                            ///< version 1.0
-    ZET_INTEL_METRIC_CALCULATION_EXP_VERSION_1_1 = ZE_MAKE_VERSION(1, 1),                            ///< version 1.1
-    ZET_INTEL_METRIC_CALCULATION_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_CALCULATION_EXP_VERSION_1_1, ///< latest known version
-    ZET_INTEL_METRIC_CALCULATION_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_calculation_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query metric group calculation properties
-/// This structure can be passed in the 'pNext' of zet_metric_group_properties_t
-typedef struct _zet_intel_metric_group_calculation_properties_exp_t {
-    zet_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                    ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    bool isTimeFilterSupported;     ///< [out] Flag to indicate if the metric group supports time filtering for
-                                    ///< metrics calculation.
-} zet_intel_metric_group_calculation_properties_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Query a metric calculable property
-/// This structure can be passed in the 'pNext' of zet_metric_properties_t
-typedef struct _zet_intel_metric_calculable_properties_exp_t {
-    zet_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                    ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    bool isCalculable;              ///< [out] Flag to indicate if the metric supports calculation.
-} zet_intel_metric_calculable_properties_exp_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Handle of metric calculation operation
-struct _zet_intel_metric_calculation_operation_exp_handle_t {};
-typedef struct _zet_intel_metric_calculation_operation_exp_handle_t *zet_intel_metric_calculation_operation_exp_handle_t;
-
-typedef struct _zet_intel_metric_calculation_time_window_exp_t {
-    uint64_t windowStart; ///< [in] starting time in nanoseconds of the raw data to where WindowSize
-                          ///< is selected. If WindowStart + WindowSize is bigger than the total
-                          ///< time of the raw data collected, only a fraction of the window will be used.
-    uint64_t windowSize;  ///< [in] size in nanoseconds of the faction of the raw data used for calculation.
-} zet_intel_metric_calculation_time_window_exp_t;
-
-typedef struct _zet_intel_metric_calculation_exp_desc_t {
-    zet_structure_type_ext_t stype;                                          ///< [in] type of this structure
-    const void *pNext;                                                       ///< [in][optional] must be null or a pointer to an extension-specific
-                                                                             ///< structure (i.e. contains stype and pNext).
-    uint32_t metricGroupCount;                                               ///< [in] [in] count for metric group handles in metric hMetricGroups array.
-                                                                             ///< If set to 0, then phMetricGroups must be null
-    zet_metric_group_handle_t *phMetricGroups;                               ///< [in] [optional][range(0, metricGroupCount)] array of metric group
-                                                                             ///< handles to filter metric groups to be calculated.
-    uint32_t metricCount;                                                    ///< [in] number of metrics handles in the phMetrics array. If set to 0, then
-                                                                             ///< phMetrics must be null.
-    zet_metric_handle_t *phMetrics;                                          ///< [in][optional] [range(0, metricsCount)] array of metrics handles to filter
-                                                                             ///< metrics to be calculated. phMetrics are additionally calculated even if repeated
-                                                                             ///< in phMetricGroups.
-    uint32_t timeWindowsCount;                                               ///< [in-out] number of time windows in pCalculationTimeWindows. Must be 0 if disabled.
-                                                                             ///< If set to 0, then pCalculationTimeWindows must be null. On output, is set to the
-                                                                             ///< number of time windows that the calculation operation will use
-    zet_intel_metric_calculation_time_window_exp_t *pCalculationTimeWindows; ///< [in][optional][range(0,timeWindowsCount)] array containing the list of time windows
-                                                                             ///< to filter metrics data
-                                                                             ///< to be used for metrics calculation. Must be null if disabled.
-    uint64_t timeAggregationWindow;                                          ///< [in-out] size in nanoseconds used to divide the raw data and calculate a result for
-                                                                             ///< each metric. When enabled, the API will return one report per aggregation
-                                                                             ///< window. Must not be 0. When set to uint64_t_MAX will include all rawdata
-                                                                             ///< in a single window. If the timeAggregationWindow is bigger than the total
-                                                                             ///< time of the raw data collected, will be same as uint64_t_MAX. When
-                                                                             ///< timeAggregationWindow is not a perfect divisor of the total time,
-                                                                             ///< the last window is expected to be smaller. When CalculationTimeWindows
-                                                                             ///< are used, the API will limit the maximum timeAggregationWindow to
-                                                                             ///< the size of each CalculationTimeWindow individually. When timeAggregationWindow
-                                                                             ///< is smaller than a given CalculationTimeWindow, the CalculationTimeWindow will
-                                                                             ///< be divided into timeAggregationWindow sections for aggregation, with the
-                                                                             ///< last fraction being smaller when there is no perfect division. On output, is set to the size of
-                                                                             ///< the aggregation window the calculation operation will use.
-    uint32_t metricScopesCount;                                              ///< [in] number of metric scopes in metric scopes handles. Must not be 0, otherwise error is returned.
-    zet_intel_metric_scope_exp_handle_t *phMetricScopes;                     ///< [in][optional] [range (0, metricScopesCount)] array of metric scopes handles to use for calculation.
-                                                                             ///< Duplicated entries will be removed. Metrics not supporting all metric scopes listed will be excluded
-                                                                             ///< from the calculation operation. If no metric supports all metric scopes included, the calculation
-                                                                             ///< operation creation will fail.
-} zet_intel_metric_calculation_exp_desc_t;
-typedef enum _zet_intel_metric_calculation_result_status_exp_t {
-    ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_VALID = 0,
-    ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_INVALID,
-    ZET_INTEL_METRIC_CALCULATION_EXP_RESULT_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_calculation_result_status_exp_t;
-
-typedef struct _zet_intel_metric_result_exp_t {
-    zet_value_t value;                                             ///< [out] metric result calculated metric value
-    zet_intel_metric_calculation_result_status_exp_t resultStatus; ///< [out] type of the result for the filters applied to the calculation.
-} zet_intel_metric_result_exp_t;
-typedef struct _zet_intel_metric_decoded_buffer_exp_properties_t {
-    zet_structure_type_ext_t stype; ///< [in] type of this structure
-    void *pNext;                    ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    uint64_t minTimeStamp;          ///< [out] minimum timestamp contained in the raw data buffer
-    uint64_t maxTimeStamp;          ///< [out] maximum timestamp contained in the raw data buffer
-} zet_intel_metric_decoded_buffer_exp_properties_t;
-
-ze_result_t ZE_APICALL
-zetIntelMetricCalculationOperationCreateExp(
-    zet_context_handle_t hContext,                                                ///< [in] handle of the context object
-    zet_device_handle_t hDevice,                                                  ///< [in] handle of the device
-    zet_intel_metric_calculation_exp_desc_t *pCalculationDesc,                    ///< [in] pointer to structure with filters and operations to perform
-                                                                                  ///< at calculation time.
-    zet_intel_metric_calculation_operation_exp_handle_t *phCalculationOperation); ///< [out] Calculation operation handle
-
-ze_result_t ZE_APICALL
-zetIntelMetricCalculationOperationDestroyExp(
-    zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation); ///< [in] Calculation operation handle
-
-ze_result_t ZE_APICALL zetIntelMetricCalculationOperationGetReportFormatExp(
-    zet_intel_metric_calculation_operation_exp_handle_t phCalculationOperation, ///< [in] Calculation operation handle
-    uint32_t *pCount,                                                           ///< [in,out] pointer to the number of metrics in the output report from
-                                                                                ///< calculation operations. If set to zero, then the driver shall update
-                                                                                ///< the value with the total number of metrics to be included in the
-                                                                                ///< calculation results report. If count is greater than the total number
-                                                                                ///< of metrics to be included in the calculation results report, then the
-                                                                                ///< driver shall update the value with the actual number.  If count is
-                                                                                ///< smaller than the total number of metrics to be included in the
-                                                                                ///< calculation results report, then ZE_RESULT_ERROR_INVALID_ARGUMENT
-                                                                                ///< will be returned since this parameter is not intended for
-                                                                                ///< filtering metrics.
-    zet_metric_handle_t *phMetrics,                                             ///< [out][optional] [range(0, pCount)] array of metrics handles
-                                                                                ///< with the order in which results will be found in output report of
-                                                                                ///< calculation operations
-    zet_intel_metric_scope_exp_handle_t *phMetricScopes);                       ///< [out] [range(0, *pCount)] array of metric scopes handles
-                                                                                ///< corresponding to each metric in phMetrics
-
-ze_result_t ZE_APICALL zetIntelMetricCalculationOperationGetExcludedMetricsExp(
-    zet_intel_metric_calculation_operation_exp_handle_t phCalculationOperation, ///< [in] Calculation operation handle
-    uint32_t *pCount,                                                           ///< [in,out] pointer to the number of metrics excluded from the output report.
-                                                                                ///< If set to zero, then the driver shall update the value with the total number
-                                                                                ///< of metrics excluded. If count is greater than the total number
-                                                                                ///< of metrics excluded, then the driver shall update the value with the
-                                                                                ///< actual number. If count is smaller than the total number of metrics
-                                                                                ///< excluded then ZE_RESULT_ERROR_INVALID_ARGUMENT will be returned
-                                                                                ///< since this parameter is not intended for filtering metrics.
-    zet_metric_handle_t *phMetrics);                                            ///< [out][optional] [range(0, pMetricsCount)] array of metrics handles
-                                                                                ///< excluded from the output report of calculation operations
-ze_result_t ZE_APICALL
-zetIntelMetricTracerDecodeCalculateValuesExp(
-    zet_metric_decoder_exp_handle_t hMetricDecoder,                            ///< [in] handle of the metric decoder object
-    const size_t rawDataSize,                                                  ///< [in] size in bytes of raw data buffer.
-    size_t *usedDataSize,                                                      ///< [out] the number raw bytes processed. User is expected to advance pRawData pointer
-                                                                               ///< by this amount if calling this function subsequently with the same data.
-                                                                               ///< Note that appending new data to existing is allowed.
-    const uint8_t *pRawData,                                                   ///< [in,out][range(0, *rawDataSize)] buffer containing tracer
-                                                                               ///< data in raw format
-    zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation, ///< [in] Calculation operation handle
-    uint32_t *pTotalMetricReportsCount,                                        ///< [in,out] [optional] pointer to the total number of metric reports decoded and
-                                                                               ///< calculated, for all metric sets. If count is zero, then the driver shall update
-                                                                               ///< the value with the total number of metric reports to be decoded and calculated.
-                                                                               ///< If count is greater than zero but less than the total number of reports available
-                                                                               ///< in the raw data, then only that number of reports will be decoded and calculated.
-                                                                               ///< If count is greater than the number of reports available in the raw data buffer,
-                                                                               ///< then the driver shall update the value with the actual number of metric reports
-                                                                               ///< decoded and calculated.
-    zet_intel_metric_result_exp_t *pMetricResults);                            ///< [in,out][optional][range(0, *pTotalMetricResultsCount)] buffer of decoded and
-                                                                               ///< calculated metrics results.
-
-ze_result_t ZE_APICALL
-zetIntelMetricTracerDecodeToBinaryBufferExp(
-    zet_metric_decoder_exp_handle_t hMetricDecoder,                             ///< [in] handle of the metric decoder object
-    size_t *pRawDataSize,                                                       ///< [in,out] size in bytes of raw data buffer. If pDecodedBufferSize is greater
-                                                                                ///< than 0 but smaller than the total number of bytes required for decoding
-                                                                                ///< the entire input raw data, then driver shall update this value with
-                                                                                ///< actual number of raw data bytes processed
-    const uint8_t *pRawData,                                                    ///< [in,out][range(0, *pRawDataSize)] buffer containing tracer
-                                                                                ///< data in raw format
-    zet_intel_metric_calculation_operation_exp_handle_t phCalculationOperation, ///< [in] Calculation operation handle, to filter metrics to decode
-    zet_intel_metric_decoded_buffer_exp_properties_t *pProperties,              ///< [in] Properties of the decoded buffer.
-    size_t *pDecodedBufferSize,                                                 ///< [in] Pointer to the size of the decoded binary buffer. If set to 0,
-                                                                                ///< [in,out] Then driver shall update this value with total size in bytes required
-                                                                                ///< for the decoded binary buffer. If size is greater than 0 but smaller
-                                                                                ///< than the total number of bytes required for decoding entire input
-                                                                                ///< raw data, then driver shall only decode an approximate to that number
-                                                                                ///< of bytes. If size is greater than the total number of bytes required
-                                                                                ///< for decoding entire input raw data, then the driver shall update the
-                                                                                ///< value with the actual number of bytes decoded.
-    uint8_t *pDecodedBuffer);                                                   ///< [in,out][optional] binary buffer containing decoded raw data.
-
-ze_result_t ZE_APICALL
-zetIntelMetricCalculateValuesExp(
-    const size_t rawDataSize,                                                  ///< [in] size in bytes of raw data buffer.
-    const uint8_t *pRawData,                                                   ///< [in,out][range(0, *rawDataSize)] buffer containing tracer
-                                                                               ///< data in raw format
-    zet_intel_metric_calculation_operation_exp_handle_t hCalculationOperation, ///< [in] Calculation operation handle
-    bool lastCall,                                                             ///< [in] flag to indicate the if the current is the last call call for the given data.
-                                                                               ///< If false, the driver may cache data as needed for subsequent calls.
-                                                                               ///< If true, the driver will finalize the calculations using available data and clear caches.
-    size_t *usedDataSize,                                                      ///< [out] The number raw bytes processed. User is expected to advance pRawData
-                                                                               ///< pointer by this amount if calling this function subsequently.
-    uint32_t *pTotalMetricReportCount,                                         ///< [in,out] [optional] pointer to the total number of metric reports calculated,
-                                                                               ///< If count is zero, then the driver shall update the value with the total number of
-                                                                               ///< metric reports to be calculated. If count is greater than zero but less than the
-                                                                               ///< total number of reports available in the raw data, then only that number of
-                                                                               ///< reports will be calculated. If count is greater than the number of reports
-                                                                               ///< available in the raw data buffer, then the driver shall update the value with
-                                                                               ///< the actual number of metric reports calculated.
-    zet_intel_metric_result_exp_t *pMetricResults);                            ///< [in,out][optional][range(0, *pTotalMetricResultsCount)] buffer of calculated
-                                                                               ///< metrics results.
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Decoded metric entry
-typedef struct _zet_metric_entry_exp2_t {
-    zet_value_t value;      ///< [out] value of the decodable metric entry or event. Number is
-                            ///< meaningful based on the metric type.
-    uint64_t timeStamp;     ///< [out] timestamp at which the event happened.
-    uint32_t metricIndex;   ///< [out] index to the decodable metric handle in the input array
-                            ///< (phMetric) in ::zetMetricTracerDecodeExp().
-    uint32_t metricScopeID; ///< [out] ID index of the scope for which the entry is meaningful.
-                            ///< If the array of metrics scopes submitted to ::zetMetricTracerDecode()
-                            ///< is the same as the one returned by zetMetricScopesGet(), then expect
-                            ///< the ID to be equal to the index of the metric scope in the array.
-} zet_metric_entry_exp2_t;
-
-#ifndef ZET_INTEL_METRIC_TRACER_DECODE_EXP2_NAME
-/// @brief Extension name to decode Intel Metric Tracer data with metric scopes
-#define ZET_INTEL_METRIC_TRACER_DECODE_EXP2_NAME "ZET_intel_metric_tracer_decode_exp2"
-#endif // ZET_INTEL_METRIC_TRACER_DECODE_EXP2_NAME
-////////////////////////////////////////////////////////////////////////////////
-/// @brief Metric Tracer Decode extension Version(s)
-typedef enum _zet_intel_metric_tracer_decode_exp2_version_t {
-    ZET_INTEL_METRIC_TRACER_DECODE_EXP2_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                               ///< version 1.0
-    ZET_INTEL_METRIC_TRACER_DECODE_EXP2_VERSION_CURRENT = ZET_INTEL_METRIC_TRACER_DECODE_EXP2_VERSION_1_0, ///< latest known version
-    ZET_INTEL_METRIC_TRACER_DECODE_EXP2_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_tracer_decode_exp2_version_t;
-
-ze_result_t ZE_APICALL
-zetIntelMetricTracerDecodeExp2(
-    zet_metric_decoder_exp_handle_t phMetricDecoder,     ///< [in] handle of the metric decoder object
-    const size_t rawDataSize,                            ///< [in] size in bytes of raw data buffer.
-    const uint8_t *pRawData,                             ///< [in][range(0, *rawDataSize)] buffer containing tracer data in raw format
-    uint32_t metricCount,                                ///< [in] number of decodable metrics in the tracer for which the
-                                                         ///< phMetricDecoder handle was provided. See
-                                                         ///< ::zetMetricDecoderGetDecodableMetricsExp(). If metricCount is greater
-                                                         ///< than zero but less than the number decodable metrics available in the raw data buffer,
-                                                         ///< then driver shall only decode those.
-    zet_metric_handle_t *phMetric,                       ///< [in] [range(0, metricsCount)] array of handles of decodable metrics in
-                                                         ///< the decoder for which the phMetricDecoder handle was
-                                                         ///< provided. Metrics handles are expected to be for decodable metrics,
-                                                         ///< see ::zetMetricDecoderGetDecodableMetricsExp()
-                                                         ///< If a reduced list of decodable metrics is provided, only entries
-                                                         ///< for those decodable metrics will be present in the output.
-    uint32_t metricScopeCount,                           ///< [in] number of metric scopes in metric scopes in phMetricScopes. See ::zetMetricScopesGet()
-    zet_intel_metric_scope_exp_handle_t *phMetricScopes, ///< [in] [range (0, metricScopeCount)] array of metric scopes handles.
-                                                         ///< If a reduced list of metric scopes is provided,
-                                                         ///< only entries for those metrics scopes will be present in the output.
-    size_t *usedDataSize,                                ///< [out] The number raw bytes processed. User is expected to advance pRawData
-                                                         ///< pointer by this amount if calling this function subsequently with the same data.
-                                                         ///< Note that appending new data to existing is allowed.
-    uint32_t *pTotalMetricEntriesCount,                  ///< [in,out]  pointer to the total number of metric entries decoded. If count is zero, then the
-                                                         ///< driver shall update the value with the total number of metric entries to be decoded.
-                                                         ///< If count is greater than zero but less than the total number of metric entries available
-                                                         ///< in the raw data, then only that number of entries will be decoded. If count is greater
-                                                         ///< than the number available in the raw data buffer, then the driver shall update the value
-                                                         ///< with the actual number of decodable metric entries decoded.
-    zet_metric_entry_exp2_t *phMetricEntries);           ///< [in,out][optional][range(0, *pTotalMetricEntriesCount)] buffer containing
-                                                         ///< decoded metric entries
-
-#ifndef ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_NAME
-/// @brief Extension name for enabling and disabling Intel Metrics collection
-#define ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_NAME "ZET_intel_metrics_runtime_enable_disable"
-#endif // ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metrics Runtime Enable Disable extension Version(s)
-typedef enum _zet_intel_metrics_runtime_enable_disable_exp_version_t {
-    ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                                        ///< version 1.0
-    ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_VERSION_CURRENT = ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_VERSION_1_0, ///< latest known version
-    ZET_INTEL_METRICS_RUNTIME_ENABLE_DISABLE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metrics_runtime_enable_disable_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief This API Enables Metric collection for a device if not already enabled.
-/// If device is a root-device, then its sub-devices are also enabled.
-/// This API can be used as runtime alternative to setting ZET_ENABLE_METRICS=1.
-ze_result_t ZE_APICALL zetIntelDeviceEnableMetricsExp(zet_device_handle_t hDevice);
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief This API Disables Metric for a device, if it was previously enabled.
-/// If device is a root-device, then its sub-devices are also disabled.
-/// The application has to ensure that all metric operations are complete and
-/// all metric resources are released before this API is called.
-/// If there are metric operations in progress, then ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE
-/// is returned.
-ze_result_t ZE_APICALL zetIntelDeviceDisableMetricsExp(zet_device_handle_t hDevice);
-
-#ifndef ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_NAME
-/// @brief Extension name for query to read the Intel Level Zero Driver Version String
-#define ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_NAME "ZET_intel_get_hw_buffer_size"
-#endif // ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Maximum Hw Buffer Size extension Version(s)
-typedef enum _zet_intel_metric_hw_buffer_size_exp_version_t {
-    ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                               ///< version 1.0
-    ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_VERSION_1_0, ///< latest known version
-    ZET_INTEL_METRIC_HW_BUFFER_SIZE_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_hw_buffer_size_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metric hardware buffer size descriptor
-/// This descriptor can be used as a "pNext" value to the zet_metric_streamer_desc_t and zet_metric_tracer_exp_desc_t.
-/// This descriptor allow to request and query the allocated HW buffer size in bytes.
-/// The sizeInBytes should not be used to estimate buffer overflow scenario (Use notifyNReports to detect it).
-typedef struct _zet_intel_metric_hw_buffer_size_exp_desc_t {
-    zet_structure_type_ext_t stype; ///< [in] type of this structure
-    const void *pNext;              ///< [in][optional] must be null or a pointer to an extension-specific
-                                    ///< structure (i.e. contains stype and pNext).
-    size_t sizeInBytes;             ///< [in,out] size of the hardware buffer size in bytes.
-                                    ///< If the requested value cannot be supported,
-                                    ///< then the driver may use a value that can be supported and shall update this member.
-                                    ///< When hNotificationEvent is set as input has precedence over hw_buffer_size_exp_desc_t when setting HW buffer size.
-                                    ///< The actual size used by the HW will be updated in "sizeInBytes" member by the implementation.
-} zet_intel_metric_hw_buffer_size_exp_desc_t;
-
-#ifndef ZET_INTEL_METRIC_TRACER_EXPORT_EXP_NAME
-/// @brief Extension name for metric tracer export
-#define ZET_INTEL_METRIC_TRACER_EXPORT_EXP_NAME "ZET_intel_metric_tracer_export"
-#endif // ZET_INTEL_METRIC_TRACER_EXPORT_EXP_NAME
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metric Tracer Export extension Version(s)
-typedef enum _zet_intel_metric_tracer_export_exp_version_t {
-    ZET_INTEL_METRIC_TRACER_EXPORT_EXP_VERSION_1_0 = ZE_MAKE_VERSION(1, 0),                              ///< version 1.0
-    ZET_INTEL_METRIC_TRACER_EXPORT_EXP_VERSION_CURRENT = ZET_INTEL_METRIC_TRACER_EXPORT_EXP_VERSION_1_0, ///< latest known version
-    ZET_INTEL_METRIC_TRACER_EXPORT_EXP_VERSION_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_tracer_export_exp_version_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Metric export format
-typedef enum _zet_intel_metric_export_format_t {
-    ZET_INTEL_METRIC_EXPORT_FORMAT_RAW = 0, ///< Raw binary format
-    ZET_INTEL_METRIC_EXPORT_FORMAT_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_export_format_t;
-
-///////////////////////////////////////////////////////////////////////////////
-/// @brief Export metric tracer data
-///
-/// @details
-///     - All metric groups enabled for the tracer handle will be exported.
-///     - If sizeOfExportInBytes is 0, the API returns the number of bytes necessary
-///       to hold the export data in sizeOfExportInBytes.
-///     - It is an error if the application passes in a value less than what was
-///       returned by the API when querying the size.
-///     - The implementation will write the export data into pExportData buffer.
-///
-/// @returns
-///     - ::ZE_RESULT_ERROR_INVALID_ARGUMENT
-///         + The provided buffer size is less than required
-ze_result_t ZE_APICALL zetIntelMetricTracerExportExp(
-    zet_metric_tracer_exp_handle_t hTracer,        ///< [in] input Tracer handle. All metric groups enabled for this tracer handle will be exported.
-    zet_intel_metric_export_format_t exportFormat, ///< [in] format of the exported data.
-    size_t *pSizeOfExportInBytes,                  ///< [in,out] size of export data in bytes. If 0 is passed in, then the API returns
-                                                   ///< the number of bytes necessary to hold the export data. It is an error if the
-                                                   ///< application passes in a value less than what was returned by zetIntelMetricTracerExportExp API.
-    void *pExportData                              ///< [in,out][optional][range(0, *pSizeOfExportInBytes)] buffer to hold the exported data.
-                                                   ///< Implementation will write the export data into this buffer.
-);
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif //_ZET_INTEL_GPU_METRIC_H
diff --git a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric_export.h b/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric_export.h
deleted file mode 100644
index 083b24a0..00000000
--- a/sdk/third-party/compute-runtime/level_zero/include/level_zero/zet_intel_gpu_metric_export.h
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
- * Copyright (C) 2024-2026 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#ifndef _ZET_INTEL_GPU_METRIC_EXPORT_H
-#define _ZET_INTEL_GPU_METRIC_EXPORT_H
-
-#include <level_zero/ze_api.h>
-
-#if defined(__cplusplus)
-#pragma once
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-#define ZET_INTEL_GPU_METRIC_EXPORT_VERSION_MAJOR 0
-#define ZET_INTEL_GPU_METRIC_EXPORT_VERSION_MINOR 1
-
-#pragma pack(push, 1)
-
-#define ZET_INTEL_GPU_METRIC_INVALID_OFFSET ((ptrdiff_t)0u)
-#define zet_intel_metric_df_gpu_offset_to_ptr(type, offset, base) \
-    type##_to_pointer(offset, base);
-
-typedef ptrdiff_t uint8_offset_t;
-typedef ptrdiff_t cstring_offset_t;
-typedef ptrdiff_t zet_intel_metric_df_gpu_equation_element_0_1_offset_t;
-typedef ptrdiff_t zet_intel_metric_df_gpu_information_params_0_1_offset_t;
-typedef ptrdiff_t zet_intel_metric_df_gpu_metric_params_0_1_offset_t;
-typedef ptrdiff_t zet_intel_metric_df_gpu_global_symbol_0_1_offset_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_apiversion_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_apiversion_0_1_t {
-    uint32_t majorNumber;
-    uint32_t minorNumber;
-    uint32_t buildNumber;
-} zet_intel_metric_df_gpu_apiversion_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_adapter_id_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_adapter_id_type_t {
-    ZET_INTEL_METRIC_DF_ADAPTER_ID_TYPE_UNDEFINED = 0,
-    ZET_INTEL_METRIC_DF_ADAPTER_ID_TYPE_LUID,
-    ZET_INTEL_METRIC_DF_ADAPTER_ID_TYPE_MAJOR_MINOR,
-    ZET_INTEL_METRIC_DF_ADAPTER_ID_TYPE_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_adapter_id_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_adapter_id_luid_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_adapter_id_luid_0_1_t {
-    uint32_t lowPart;
-    int32_t highPart;
-} zet_intel_metric_df_gpu_adapter_id_luid_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_adapter_id_major_minor_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_adapter_id_major_minor_0_1_t {
-    int32_t major;
-    int32_t minor;
-} zet_intel_metric_df_gpu_adapter_id_major_minor_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_adapter_id_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_adapter_id_0_1_t {
-    zet_intel_metric_df_gpu_adapter_id_type_t type;
-    union {
-        zet_intel_metric_df_gpu_adapter_id_luid_0_1_t luid;
-        zet_intel_metric_df_gpu_adapter_id_major_minor_0_1_t majorMinor;
-    };
-} zet_intel_metric_df_gpu_adapter_id_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_adapter_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_adapter_params_0_1_t {
-    zet_intel_metric_df_gpu_adapter_id_0_1_t systemId; // Operating system specific adapter id
-    uint32_t busNumber;
-    uint32_t deviceNumber;
-    uint32_t functionNumber;
-    uint32_t domainNumber;
-} zet_intel_metric_df_gpu_adapter_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metrics_device_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metrics_device_params_0_1_t {
-    // API version
-    zet_intel_metric_df_gpu_apiversion_0_1_t version;
-    uint32_t globalSymbolsCount;
-} zet_intel_metric_df_gpu_metrics_device_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_value_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_value_type_t {
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_UINT32 = 0,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_UINT64,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_FLOAT,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_BOOL,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_CSTRING,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_BYTEARRAY,
-    ZET_INTEL_METRIC_DF_VALUE_TYPE_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_value_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_byte_array_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_byte_array_0_1_t {
-    uint8_offset_t data;
-    uint32_t size;
-} zet_intel_metric_df_gpu_byte_array_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_typed_value_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_typed_value_0_1_t {
-    union {
-        uint32_t valueUInt32;
-        uint64_t valueUInt64;
-        struct {
-            uint32_t low;
-            uint32_t high;
-        } valueUInt64Fields;
-        float valueFloat;
-        bool valueBool;
-        cstring_offset_t valueCString;
-        zet_intel_metric_df_gpu_byte_array_0_1_t valueByteArray;
-    };
-    zet_intel_metric_df_gpu_value_type_t valueType;
-} zet_intel_metric_df_gpu_typed_value_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_global_symbol_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_global_symbol_0_1_t {
-    cstring_offset_t symbolName;
-    zet_intel_metric_df_gpu_typed_value_0_1_t symbolTypedValue;
-} zet_intel_metric_df_gpu_global_symbol_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_equation_element_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_equation_element_type_t {
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_OPERATION = 0,             // See Tequation_operation enumeration
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_BITFIELD,               //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_UINT8,                  //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_UINT16,                 //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_UINT32,                 //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_UINT64,                 //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_FLOAT,                  //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_RD_40BIT_CNTR,             // Assemble 40 bit counter that is in two locations, result in unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_IMM_UINT64,                //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_IMM_FLOAT,                 //
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_SELF_COUNTER_VALUE,        // Defined by $Self token, the UINT64 result of delta_function for IO or QueryReadEquation
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_GLOBAL_SYMBOL,             // Defined by $"SymbolName", available in MetricsDevice SymbolTable
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_LOCAL_COUNTER_SYMBOL,      // Defined by $"SymbolName", refers to counter delta value in the local set
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_OTHER_SET_COUNTER_SYMBOL,  // Defined by concatenated string of $"setSymbolName/SymbolName", refers to counter
-                                                                 // Delta value in the other set
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_LOCAL_METRIC_SYMBOL,       // Defined by $$"SymbolName", refers to metric normalized value in the local set
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_OTHER_SET_METRIC_SYMBOL,   // Defined by concatenated string of $$"setSymbolName/SymbolName", refers to metric
-                                                                 // Normalized value in the other set
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_INFORMATION_SYMBOL,        // Defined by i$"SymbolName", refers to information value type only
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_STD_NORM_GPU_DURATION,     // Action is $Self $GpuCoreClocks FDIV 100 FMUL
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_STD_NORM_EU_AGGR_DURATION, // Action is $Self $GpuCoreClocks $EuCoresTotalCount UMUL FDIV 100 FMUL
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_MASK,
-    ZET_INTEL_METRIC_DF_EQUATION_ELEM_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_equation_element_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_equation_operation_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_equation_operation_t {
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_RSHIFT = 0, // 64b unsigned integer right shift
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_LSHIFT,     // 64b unsigned integer left shift
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_AND,        // Bitwise AND of two unsigned integers, 64b each
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_OR,         // Bitwise OR of two unsigned integers, 64b each
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_XOR,        // Bitwise XOR of two unsigned integers, 64b each
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_XNOR,       // Bitwise XNOR of two unsigned integers, 64b each
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_AND_L,      // Logical AND (C-like "&&") of two unsigned integers, 64b each, result is true(1) if both values are true(greater than 0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_EQUALS,     // Equality (C-like "==") of two unsigned integers, 64b each, result is true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UADD,       // Unsigned integer add, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_USUB,       // Unsigned integer subtract, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UMUL,       // Unsigned integer mul, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UDIV,       // Unsigned integer div, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FADD,       // Floating point add, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FSUB,       // Floating point subtract, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FMUL,       // Floating point multiply, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FDIV,       // Floating point divide, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UGT,        // 64b unsigned integers comparison of is greater than, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_ULT,        // 64b unsigned integers comparison of is less than, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UGTE,       // 64b unsigned integers comparison of is greater than or equal, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_ULTE,       // 64b unsigned integers comparison of is less than or equal, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FGT,        // 32b floating point numbers comparison of is greater than, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FLT,        // 32b floating point numbers comparison of is less than, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FGTE,       // 32b floating point numbers comparison of is greater than or equal, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FLTE,       // 32b floating point numbers comparison of is less than or equal, result is bool true(1) or false(0)
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UMIN,       // Unsigned integer MIN function, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_UMAX,       // Unsigned integer MAX function, arguments are casted to be 64b unsigned integers, result is unsigned integer 64b
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FMIN,       // Floating point MIN function, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FMAX,       // Floating point MAX function, arguments are casted to be 32b floating points, result is a 32b float
-    ZET_INTEL_METRIC_DF_EQUATION_OPER_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_equation_operation_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_read_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_read_params_0_1_t {
-    uint32_t byteOffset;
-    uint32_t bitOffset;
-    uint32_t bitsCount;
-    uint32_t byteOffsetExt;
-} zet_intel_metric_df_gpu_read_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_equation_element_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_equation_element_0_1_t {
-    cstring_offset_t symbolName;
-    union {
-        uint64_t immediateUInt64;
-        float immediateFloat;
-        zet_intel_metric_df_gpu_byte_array_0_1_t mask;
-        zet_intel_metric_df_gpu_equation_operation_t operation;
-        zet_intel_metric_df_gpu_read_params_0_1_t readParams;
-    };
-    zet_intel_metric_df_gpu_equation_element_type_t type;
-} zet_intel_metric_df_gpu_equation_element_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_equation_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_equation_0_1_t {
-    uint32_t elementCount;
-    zet_intel_metric_df_gpu_equation_element_0_1_offset_t elements;
-} zet_intel_metric_df_gpu_equation_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_result_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_metric_result_type_t {
-    ZET_INTEL_METRIC_DF_RESULT_UINT32 = 0,
-    ZET_INTEL_METRIC_DF_RESULT_UINT64,
-    ZET_INTEL_METRIC_DF_RESULT_BOOL,
-    ZET_INTEL_METRIC_DF_RESULT_FLOAT,
-    ZET_INTEL_METRIC_DF_RESULT_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_metric_result_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_delta_function_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_delta_function_type_t {
-    ZET_INTEL_METRIC_DF_DELTA_FUNCTION_NULL = 0,
-    ZET_INTEL_METRIC_DF_DELTA_N_BITS,
-    ZET_INTEL_METRIC_DF_DELTA_BOOL_OR,      // Logic OR - good for exceptions
-    ZET_INTEL_METRIC_DF_DELTA_BOOL_XOR,     // Logic XOR - good to check if bits were changed
-    ZET_INTEL_METRIC_DF_DELTA_GET_PREVIOUS, // Preserve previous value
-    ZET_INTEL_METRIC_DF_DELTA_GET_LAST,     // Preserve last value
-    ZET_INTEL_METRIC_DF_DELTA_NS_TIME,      // Delta for nanosecond timestamps (GPU timestamp wraps at 32 bits but was value multiplied by 80)
-    ZET_INTEL_METRIC_DF_DELTA_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_delta_function_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_metric_type_t {
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_DURATION = 0,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_EVENT,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_EVENT_WITH_RANGE,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_THROUGHPUT,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_TIMESTAMP,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_FLAG,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_RATIO,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_RAW,
-    ZET_INTEL_METRIC_DF_METRIC_TYPE_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_metric_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_delta_function_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_delta_function_0_1_t {
-    zet_intel_metric_df_gpu_delta_function_type_t functionType;
-    union {
-        uint32_t bitsCount; // Used for DELTA_N_BITS to specify bits count
-    };
-} zet_intel_metric_df_gpu_delta_function_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metric_params_0_1_t {
-    cstring_offset_t symbolName;                                // Symbol name, used in equations
-    cstring_offset_t shortName;                                 // Consistent metric name, not changed platform to platform
-    cstring_offset_t groupName;                                 // VertexShader for example
-    cstring_offset_t longName;                                  // Hint about the metric shown to users
-    uint32_t idInSet;                                           // Position in set (may change after SetApiFiltering)
-    uint32_t apiMask;                                           //
-    cstring_offset_t metricResultUnits;                         //
-    zet_intel_metric_df_gpu_metric_type_t metricType;           //
-    zet_intel_metric_df_gpu_equation_0_1_t ioReadEquation;      // Read equation specification for IO stream (accessing raw values potentially spread in report in several locations)
-    zet_intel_metric_df_gpu_equation_0_1_t queryReadEquation;   // Read equation specification for query (accessing calculated delta values)
-    zet_intel_metric_df_gpu_delta_function_0_1_t deltaFunction; //
-    zet_intel_metric_df_gpu_equation_0_1_t normEquation;        // Normalization equation to get normalized value to bytes transferred or to a percentage of utilization
-    zet_intel_metric_df_gpu_equation_0_1_t maxValueEquation;    // To calculate metrics max value as a function of other metrics and device parameters (e.g. 100 for percentage)
-    uint32_t usageFlagsMask;
-    zet_intel_metric_df_gpu_metric_result_type_t resultType;
-} zet_intel_metric_df_gpu_metric_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_information_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_information_type_t {
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_REPORT_REASON = 0,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_VALUE,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_FLAG,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_TIMESTAMP,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_CONTEXT_ID_TAG,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_SAMPLE_PHASE,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_GPU_NODE,
-    ZET_INTEL_METRIC_DF_INFORMATION_TYPE_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_information_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_information_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_information_params_0_1_t {
-    cstring_offset_t symbolName; // Symbol name, used in equations
-    cstring_offset_t shortName;  // Consistent name, not changed platform to platform
-    cstring_offset_t groupName;  // Some more global context of the information
-    cstring_offset_t longName;   // Hint about the information shown to users
-    uint32_t idInSet;
-    uint32_t apiMask;                                              //
-    zet_intel_metric_df_gpu_information_type_t infoType;           //
-    cstring_offset_t infoUnits;                                    //
-    zet_intel_metric_df_gpu_equation_0_1_t ioReadEquation;         // Read equation specification for IO stream (accessing raw values potentially spread in report in several locations)
-    zet_intel_metric_df_gpu_equation_0_1_t queryReadEquation;      // Read equation specification for query (accessing calculated delta values)
-    zet_intel_metric_df_gpu_delta_function_0_1_t overflowFunction; //
-} zet_intel_metric_df_gpu_information_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_set_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metric_set_params_0_1_t {
-    cstring_offset_t symbolName; // For example "Dx11Tessellation"
-    cstring_offset_t shortName;  // For example "DX11 Tessellation Metrics Set"
-    uint32_t apiMask;
-    uint32_t metricsCount;
-    uint32_t informationCount;
-    cstring_offset_t availabilityEquation;
-} zet_intel_metric_df_gpu_metric_set_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_concurrent_group_params_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_concurrent_group_params_0_1_t {
-    cstring_offset_t symbolName;  // For example "OA" or "OAM0" or "PipeStats"
-    cstring_offset_t description; // For example "OA Unit Metrics"
-    uint32_t ioMeasurementInformationCount;
-    uint32_t ioGpuContextInformationCount;
-} zet_intel_metric_df_gpu_concurrent_group_params_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_concurrent_group_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_concurrent_group_0_1_t {
-    zet_intel_metric_df_gpu_concurrent_group_params_0_1_t params;
-    zet_intel_metric_df_gpu_information_params_0_1_offset_t ioMeasurementInformation;
-    zet_intel_metric_df_gpu_information_params_0_1_offset_t ioGpuContextInformation;
-} zet_intel_metric_df_gpu_concurrent_group_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_set_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metric_set_0_1_t {
-    zet_intel_metric_df_gpu_metric_set_params_0_1_t params;
-    zet_intel_metric_df_gpu_information_params_0_1_offset_t informationParams;
-    zet_intel_metric_df_gpu_metric_params_0_1_offset_t metricParams;
-} zet_intel_metric_df_gpu_metric_set_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_oa_calc_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metric_oa_calc_0_1_t {
-    zet_intel_metric_df_gpu_metrics_device_params_0_1_t deviceParams;
-    zet_intel_metric_df_gpu_global_symbol_0_1_offset_t globalSymbols;
-    zet_intel_metric_df_gpu_adapter_params_0_1_t adapterParams;
-    zet_intel_metric_df_gpu_concurrent_group_0_1_t concurrentGroup;
-    zet_intel_metric_df_gpu_metric_set_0_1_t metricSet;
-} zet_intel_metric_df_gpu_metric_oa_calc_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_export_data_format_0_1_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_export_data_format_0_1_t {
-    union {
-        zet_intel_metric_df_gpu_metric_oa_calc_0_1_t oaData;
-    };
-} zet_intel_metric_df_gpu_export_data_format_0_1_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_source_type_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef enum _zet_intel_metric_df_gpu_metric_source_type_t {
-    ZET_INTEL_METRIC_DF_SOURCE_TYPE_OA = 0,
-    ZET_INTEL_METRIC_DF_SOURCE_TYPE_IPSAMPLING,
-    ZET_INTEL_METRIC_DF_SOURCE_TYPE_FORCE_UINT32 = 0x7fffffff
-} zet_intel_metric_df_gpu_metric_source_type_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_metric_version_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_metric_version_t {
-    uint32_t major;
-    uint32_t minor;
-    uint32_t reserved[2];
-} zet_intel_metric_df_gpu_metric_version_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_header_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_header_t {
-    zet_intel_metric_df_gpu_metric_source_type_t type;
-    zet_intel_metric_df_gpu_metric_version_t version;
-    ze_device_type_t deviceType;
-    uint64_t rawDataOffset;
-    uint64_t rawDataSize;
-    uint8_t reserved[256];
-} zet_intel_metric_df_gpu_header_t;
-
-//////////////////////////////////////////////////////////////////////////////////
-// zet_intel_metric_df_gpu_export_data_format_t
-//////////////////////////////////////////////////////////////////////////////////
-typedef struct _zet_intel_metric_df_gpu_export_data_format_t {
-    zet_intel_metric_df_gpu_header_t header;
-    zet_intel_metric_df_gpu_export_data_format_0_1_t format01;
-} zet_intel_metric_df_gpu_export_data_format_t;
-
-#define offset_to_pointer(offset, base) (ZET_INTEL_GPU_METRIC_INVALID_OFFSET == offset ? nullptr : (uint8_t *)base + offset)
-#define uint8_offset_t_to_pointer(offset, base) (uint8_t *)offset_to_pointer(offset, base)
-#define cstring_offset_t_to_pointer(offset, base) (const char *)offset_to_pointer(offset, base)
-#define zet_intel_metric_df_gpu_equation_element_0_1_offset_t_to_pointer(offset, base) (zet_intel_metric_df_gpu_equation_element_0_1_t *)offset_to_pointer(offset, base)
-#define zet_intel_metric_df_gpu_information_params_0_1_offset_t_to_pointer(offset, base) (zet_intel_metric_df_gpu_information_params_0_1_t *)offset_to_pointer(offset, base)
-#define zet_intel_metric_df_gpu_metric_params_0_1_offset_t_to_pointer(offset, base) (zet_intel_metric_df_gpu_metric_params_0_1_t *)offset_to_pointer(offset, base)
-#define zet_intel_metric_df_gpu_global_symbol_0_1_offset_t_to_pointer(offset, base) (zet_intel_metric_df_gpu_global_symbol_0_1_t *)offset_to_pointer(offset, base)
-
-#pragma pack(pop)
-
-#if defined(__cplusplus)
-} // extern "C"
-#endif
-
-#endif // _ZET_INTEL_GPU_METRIC_EXPORT_H
diff --git a/sdk/third-party/compute-runtime/third-party.txt b/sdk/third-party/compute-runtime/third-party.txt
deleted file mode 100644
index 29a27a5d..00000000
--- a/sdk/third-party/compute-runtime/third-party.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-repo: https://github.com/intel/compute-runtime.git
-commit: 555fab6499111abdc712ce423fe9ec2b20ee27db
-reprod:
-  - git clone ${repo}
-  - cd compute-runtime
-  - git checkout ${commit}
-  - cd ..
-  - cp -r compute-runtime/level_zero/include/level_zero/* level_zero/include/level_zero/
diff --git a/tests/run.py b/tests/run.py
index f80cc36f..395706af 100644
--- a/tests/run.py
+++ b/tests/run.py
@@ -1,12 +1,24 @@
 import importlib
+import json
 import os
 import re
 import shutil
 import sys
+import time
 import traceback
+from xml.sax.saxutils import escape, quoteattr
 
 import utils
 
+LOG_FILE = "stderr.log"
+JSON_REPORT = "results.json"
+JUNIT_REPORT = "junit.xml"
+
+PASSED = "PASSED"
+FAILED = "FAILED"
+SKIPPED = "SKIPPED"
+DEFAULT_TIMEOUT = 600 # seconds per test (sample/tool + option), 0 = no limit
+
 samples = [["cl_gemm", "gpu", "cpu"],
            ["cl_gemm_inst", None],
            ["cl_gemm_itt", "gpu", "cpu"],
@@ -27,7 +39,7 @@
            ["ze_metric_streamer", "gpu", "dpc"],
            ["omp_gemm", "gpu", "cpu"],
            ["omp_hot_regions", "gpu", "cpu"],
-           ["dpc_gemm", "gpu", "cpu", "host"],
+           ["dpc_gemm", "gpu", "cpu"],
            ["dpc_info", "-a", "-l"]]
 
 tools = [["instcount", "cl", "ze", "dpc"],
@@ -76,7 +88,7 @@ def remove_python_cache(path):
   if os.path.exists(path):
     shutil.rmtree(path)
 
-def clean():
+def clean(log_dir):
   for sample in samples:
     path = utils.get_sample_build_path(sample[0])
     if os.path.exists(path):
@@ -92,43 +104,127 @@ def clean():
   remove_python_cache(os.path.join(utils.get_script_path(), "samples"))
   remove_python_cache(os.path.join(utils.get_script_path(), "tools"))
 
-  for root, subdirs, files in os.walk(utils.get_root_path()):
-    for file in files:
-      if file.endswith(".log"):
-        os.remove(os.path.join(root, file))
+  # Remove only the files that run.py itself writes: in the current
+  # directory (the default), the repository root and the log directory, if set.
+  log_dirs = [os.getcwd(), utils.get_root_path()]
+  if log_dir:
+    log_dirs.append(log_dir)
+  for path in log_dirs:
+    for name in [LOG_FILE, JSON_REPORT, JUNIT_REPORT]:
+      file_path = os.path.join(path, name)
+      if os.path.isfile(file_path):
+        os.remove(file_path)
+
+def get_test_name(name, option):
+  if option is not None and option != "none":
+    return name + " (" + option + ")"
+  return name
 
-def test(f, name, option, istool = False):
+# Runs one sample/tool option. Returns a result dictionary whose "status" is
+# PASSED, FAILED or SKIPPED, and "reason" holds the failure log or skip reason.
+def run_test(f, name, option, istool = False, timeout = DEFAULT_TIMEOUT):
   if istool:
-    if (option and (option != "none")):
-      sys.stdout.write("Running " + name + " (" + option + ")...")
-    else:
-      sys.stdout.write("Running " + name + "...")
+    sys.stdout.write("Running " + get_test_name(name, option) + "...")
   else:
-    if option:
-      sys.stdout.write("Running sample " + name + " (" + option + ")...")
-    else:
-      sys.stdout.write("Running sample " + name + "...")
+    sys.stdout.write("Running sample " + get_test_name(name, option) + "...")
   sys.stdout.flush()
 
   if istool:
     module = importlib.import_module("tools." + name)
   else:
     module = importlib.import_module("samples." + name)
-  log = module.main(option)
+  status = FAILED
+  label = FAILED
+  timed_out = False
+  start = time.monotonic()
+  utils.set_deadline(timeout)
+  try:
+    log = module.main(option)
+    if log is None:
+      status = label = PASSED
+  except utils.TestTimeout as e:
+    log = "Timeout after " + str(timeout) + " s while running: " + str(e) + "\n"
+    label = "FAILED (timeout)"
+    timed_out = True
+  except utils.TestSkipped as e:
+    log = str(e)
+    status = SKIPPED
+    label = "SKIPPED (" + log + ")"
+  finally:
+    utils.set_deadline(None)
+  elapsed = time.monotonic() - start
 
-  if (log is not None):
+  if status == FAILED:
     sys.stdout.write(log)
-    sys.stdout.write("FAILED\n")
     if (option is not None):
       f.write("======= " + name + " (" + option + ") =======\n")
     else:
       f.write("======= " + name + " =======\n")
     f.write(log)
     f.write("\n")
-    return False
-  else:
-    sys.stdout.write("PASSED\n")
-    return True
+  sys.stdout.write(label + "\n")
+
+  return {"name": name, "option": option,
+          "kind": "tool" if istool else "sample",
+          "status": status, "timeout": timed_out,
+          "time": round(elapsed, 3),
+          "reason": log if status != PASSED else None}
+
+# Kept for callers that only need pass/fail: True if the test passed or was
+# skipped, False if it failed.
+def test(f, name, option, istool = False, timeout = DEFAULT_TIMEOUT):
+  return run_test(f, name, option, istool, timeout)["status"] != FAILED
+
+def write_reports(results, log_dir):
+  path = log_dir if log_dir else "."
+  with open(os.path.join(path, JSON_REPORT), "wt") as f:
+    json.dump({"passed": sum(r["status"] == PASSED for r in results),
+               "failed": sum(r["status"] == FAILED for r in results),
+               "skipped": sum(r["status"] == SKIPPED for r in results),
+               "results": results}, f, indent = 2)
+    f.write("\n")
+
+  with open(os.path.join(path, JUNIT_REPORT), "wt") as f:
+    f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
+    f.write('<testsuite name="pti-gpu" tests="%d" failures="%d" skipped="%d" '
+            'time="%.3f">\n' % (len(results),
+                                sum(r["status"] == FAILED for r in results),
+                                sum(r["status"] == SKIPPED for r in results),
+                                sum(r["time"] for r in results)))
+    for r in results:
+      f.write('  <testcase classname=%s name=%s time="%.3f"' %
+              (quoteattr(r["kind"] + "." + r["name"]),
+               quoteattr(get_test_name(r["name"], r["option"])), r["time"]))
+      if r["status"] == PASSED:
+        f.write('/>\n')
+        continue
+      f.write('>\n')
+      if r["status"] == SKIPPED:
+        f.write('    <skipped message=%s/>\n' % quoteattr(r["reason"]))
+      else:
+        message = "timeout" if r["timeout"] else "failed"
+        f.write('    <failure message="%s">%s</failure>\n' %
+                (message, escape(r["reason"])))
+      f.write('  </testcase>\n')
+    f.write('</testsuite>\n')
+
+def print_summary(results):
+  passed = sum(r["status"] == PASSED for r in results)
+  failed = [r for r in results if r["status"] == FAILED]
+  skipped = [r for r in results if r["status"] == SKIPPED]
+
+  # Keep this line unchanged: CI and scripts look for it.
+  print("PASSED: " + str(passed) + " / FAILED: " + str(len(failed)))
+  print("SKIPPED: " + str(len(skipped)))
+  if failed:
+    print("Failed tests:")
+    for r in failed:
+      print("  " + get_test_name(r["name"], r["option"]) +
+            (" (timeout)" if r["timeout"] else ""))
+  if skipped:
+    print("Skipped tests:")
+    for r in skipped:
+      print("  " + get_test_name(r["name"], r["option"]) + ": " + r["reason"])
 
 def main():
   try:
@@ -137,40 +233,54 @@ def main():
       if sys.argv[i] == "-s":
         tmpl = sys.argv[i + 1]
 
+    # --log-dir <path> (or PTI_TEST_LOG_DIR): where stderr.log is written.
+    # Default: the current directory, as before.
+    log_dir = os.environ.get("PTI_TEST_LOG_DIR")
+    timeout = DEFAULT_TIMEOUT
+    for i in range(1, len(sys.argv) - 1):
+      if sys.argv[i] == "--log-dir":
+        log_dir = sys.argv[i + 1]
+      elif sys.argv[i] == "--timeout":
+        timeout = int(sys.argv[i + 1])
+
     for i in range(1, len(sys.argv)):
       if sys.argv[i] == "-c":
-        clean()
+        clean(log_dir)
         return 0
+      elif sys.argv[i] == "--skip-oa":
+        # Skip every test that opens GPU performance (OA) metric streams.
+        os.environ[utils.SKIP_OA_ENV] = "1"
 
-    f = open("stderr.log", "wt")
+    log_path = LOG_FILE
+    if log_dir:
+      os.makedirs(log_dir, exist_ok = True)
+      log_path = os.path.join(log_dir, LOG_FILE)
+    f = open(log_path, "wt")
 
-    tests_passed = 0
-    tests_failed = 0
+    results = []
 
     for sample in samples:
       name = sample[0]
       if re.search(tmpl, name) == None:
         continue
       for i in range(1, len(sample)):
-        if test(f, name, sample[i]):
-          tests_passed += 1
-        else:
-          tests_failed += 1
+        results.append(run_test(f, name, sample[i], False, timeout))
+        f.flush()
 
     for tool in tools:
       name = tool[0]
       if re.search(tmpl, name) == None:
         continue
       for i in range(1, len(tool)):
-        if test(f, name, tool[i], True):
-          tests_passed += 1
-        else:
-          tests_failed += 1
+        results.append(run_test(f, name, tool[i], True, timeout))
+        f.flush()
 
     f.close()
 
-    print("PASSED: " + str(tests_passed) + " / FAILED: " + str(tests_failed))
+    write_reports(results, log_dir)
+    print_summary(results)
 
+    tests_failed = sum(r["status"] == FAILED for r in results)
     return 0 if tests_failed == 0 else  1
 
   except:
diff --git a/tests/samples/cl_gpu_metrics.py b/tests/samples/cl_gpu_metrics.py
index 424fc881..916e1896 100644
--- a/tests/samples/cl_gpu_metrics.py
+++ b/tests/samples/cl_gpu_metrics.py
@@ -72,6 +72,8 @@ def run(path):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_sample_build_path("cl_gpu_metrics")
   log = cl_gemm.main("gpu")
   if log:
diff --git a/tests/samples/cl_gpu_query.py b/tests/samples/cl_gpu_query.py
index ec657360..13d4ae19 100644
--- a/tests/samples/cl_gpu_query.py
+++ b/tests/samples/cl_gpu_query.py
@@ -72,6 +72,8 @@ def run(path):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_sample_build_path("cl_gpu_query")
   log = cl_gemm.main("gpu")
   if log:
diff --git a/tests/samples/cl_hot_functions.py b/tests/samples/cl_hot_functions.py
index f87e0ba5..65535c1f 100644
--- a/tests/samples/cl_hot_functions.py
+++ b/tests/samples/cl_hot_functions.py
@@ -62,7 +62,7 @@ def run(path, option):
     app_folder = utils.get_sample_executable_path("omp_gemm")
     app_file = os.path.join(app_folder, "omp_gemm" + file_extention)
     option = "gpu"
-    e = utils.add_env(None, "LIBOMPTARGET_PLUGIN", "OPENCL")
+    environ = utils.add_env(None, "LIBOMPTARGET_PLUGIN", "OPENCL")
     command = [file_name_prefix + "cl_hot_functions" + file_extention,\
       app_file, option, "1024", "1"]
   else:
diff --git a/tests/samples/dpc_gemm.py b/tests/samples/dpc_gemm.py
index fe3e7801..a30539ed 100644
--- a/tests/samples/dpc_gemm.py
+++ b/tests/samples/dpc_gemm.py
@@ -45,6 +45,7 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_icpx()
   path = utils.get_sample_build_path("dpc_gemm")
   log = config(path)
   if log:
@@ -60,8 +61,6 @@ def main(option):
   option = "gpu"
   if len(sys.argv) > 1 and sys.argv[1] == "cpu":
     option = "cpu"
-  if len(sys.argv) > 1 and sys.argv[1] == "host":
-    option = "host"
   log = main(option)
   if log:
     print(log)
\ No newline at end of file
diff --git a/tests/samples/dpc_info.py b/tests/samples/dpc_info.py
index ee400917..b806fcda 100644
--- a/tests/samples/dpc_info.py
+++ b/tests/samples/dpc_info.py
@@ -67,6 +67,7 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_icpx()
   path = utils.get_sample_build_path("dpc_info")
   log = config(path)
   if log:
diff --git a/tests/samples/gpu_perfmon_set.py b/tests/samples/gpu_perfmon_set.py
index 182f4684..8970ca19 100644
--- a/tests/samples/gpu_perfmon_set.py
+++ b/tests/samples/gpu_perfmon_set.py
@@ -30,6 +30,7 @@ def run(path):
   return None
 
 def main(option):
+  utils.require_perf_access()
   path = utils.get_sample_build_path("gpu_perfmon_set")
   log = config(path)
   if log:
diff --git a/tests/samples/omp_gemm.py b/tests/samples/omp_gemm.py
index 7de957c5..1f50abbe 100644
--- a/tests/samples/omp_gemm.py
+++ b/tests/samples/omp_gemm.py
@@ -48,6 +48,7 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_icpx()
   path = utils.get_sample_build_path("omp_gemm")
   log = config(path)
   if log:
diff --git a/tests/samples/omp_hot_regions.py b/tests/samples/omp_hot_regions.py
index 5573b188..b902e439 100644
--- a/tests/samples/omp_hot_regions.py
+++ b/tests/samples/omp_hot_regions.py
@@ -67,15 +67,16 @@ def run(path, option):
     return "stderr is empty"
   if stdout.find(" CORRECT") == -1:
     return stdout
-  if stderr == "gpu" and stderr.find("Target") == -1:
+  if option == "gpu" and stderr.find("Target") == -1:
     return stderr
-  if stderr == "cpu" and stderr.find("Parallel") == -1:
+  if option == "cpu" and stderr.find("Parallel") == -1:
     return stderr
   if not parse(stderr):
     return stderr
   return None
 
 def main(option):
+  utils.require_icpx()
   path = utils.get_sample_build_path("omp_hot_regions")
   log = omp_gemm.main(option)
   if log:
diff --git a/tests/samples/ze_metric_info.py b/tests/samples/ze_metric_info.py
index d093b4d4..770dff01 100644
--- a/tests/samples/ze_metric_info.py
+++ b/tests/samples/ze_metric_info.py
@@ -55,6 +55,8 @@ def run(path):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_sample_build_path("ze_metric_info")
   log = config(path)
   if log:
diff --git a/tests/samples/ze_metric_query.py b/tests/samples/ze_metric_query.py
index 6c81c473..ba25a056 100644
--- a/tests/samples/ze_metric_query.py
+++ b/tests/samples/ze_metric_query.py
@@ -65,6 +65,8 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_sample_build_path("ze_metric_query")
   if option == "dpc":
     log = dpc_gemm.main("gpu")
diff --git a/tests/samples/ze_metric_streamer.py b/tests/samples/ze_metric_streamer.py
index 214640d3..a114afc7 100644
--- a/tests/samples/ze_metric_streamer.py
+++ b/tests/samples/ze_metric_streamer.py
@@ -65,6 +65,8 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_sample_build_path("ze_metric_streamer")
   if option == "dpc":
     log = dpc_gemm.main("gpu")
diff --git a/tests/tools/gpuinfo.py b/tests/tools/gpuinfo.py
index 15681ea3..5b23a166 100644
--- a/tests/tools/gpuinfo.py
+++ b/tests/tools/gpuinfo.py
@@ -85,6 +85,8 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  utils.require_perf_access()
   path = utils.get_tool_build_path("gpuinfo")
   log = config(path)
   if log:
diff --git a/tests/tools/instcount.py b/tests/tools/instcount.py
index cfccc765..e82f94b3 100644
--- a/tests/tools/instcount.py
+++ b/tests/tools/instcount.py
@@ -11,6 +11,7 @@ def config(path):
   cmake = ["cmake",\
     "-DCMAKE_BUILD_TYPE=" + utils.get_build_flag(), ".."]
   stdout, stderr = utils.run_process(cmake, path)
+  utils.check_gtpin_config(stderr)
   if stderr and stderr.find("CMake Error") != -1:
     return stderr
   return None
diff --git a/tests/tools/memaccess.py b/tests/tools/memaccess.py
index 453ea786..b711b3c3 100644
--- a/tests/tools/memaccess.py
+++ b/tests/tools/memaccess.py
@@ -12,6 +12,7 @@ def config(path):
   cmake = ["cmake",\
     "-DCMAKE_BUILD_TYPE=" + utils.get_build_flag(), ".."]
   stdout, stderr = utils.run_process(cmake, path)
+  utils.check_gtpin_config(stderr)
   if stderr and stderr.find("CMake Error") != -1:
     return stderr
   return None
diff --git a/tests/tools/oneprof.py b/tests/tools/oneprof.py
index fd7517cc..6f5e8dda 100644
--- a/tests/tools/oneprof.py
+++ b/tests/tools/oneprof.py
@@ -51,6 +51,9 @@ def run(path, option):
   return None
 
 def main(option):
+  utils.require_mdapi()
+  if option != "-i": # -i collects kernel intervals only, no metric stream
+    utils.require_perf_access()
   path = utils.get_tool_build_path("oneprof")
   if option == "cl":
     log = cl_gemm.main("gpu")
diff --git a/tests/utils.py b/tests/utils.py
index 2312ec5d..89049d29 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -1,6 +1,82 @@
 import os
+import signal
 import sys
 import subprocess
+import time
+
+# Per-test deadline (time.monotonic() value) set by run.py; None means no limit.
+_deadline = None
+
+class TestTimeout(Exception):
+  pass
+
+class TestSkipped(Exception):
+  """Raised by a test (or a sample it depends on) that cannot run here."""
+  pass
+
+def skip(reason):
+  raise TestSkipped(reason)
+
+# Files that control access to GPU performance (OA) metric streams.
+PERF_PARANOID_FILES = ["/proc/sys/dev/i915/perf_stream_paranoid",
+                       "/proc/sys/dev/xe/observation_paranoid"]
+
+# Set by run.py --skip-oa, or by the user, to skip every test that uses GPU
+# performance (OA) metrics, e.g. on hosts where OA streams are unstable.
+SKIP_OA_ENV = "PTI_TEST_SKIP_OA"
+
+def check_perf_access():
+  """Returns None if metric streams may be opened, otherwise the reason."""
+  if os.environ.get(SKIP_OA_ENV, "0") not in ("", "0"):
+    return "OA metrics tests disabled (--skip-oa / " + SKIP_OA_ENV + "=1)"
+  if sys.platform == 'win32':
+    return None
+  if os.geteuid() == 0:
+    return None
+  for path in PERF_PARANOID_FILES:
+    if os.path.exists(path):
+      with open(path) as f:
+        value = f.read().strip()
+      if value != "0":
+        return (os.path.basename(path) + "=" + value + ", metrics need 0 " +
+                "or root (echo 0 | sudo tee " + path + ")")
+  return None
+
+def require_perf_access():
+  reason = check_perf_access()
+  if reason:
+    skip(reason)
+
+def require_mdapi():
+  if sys.platform == 'win32':
+    return
+  import ctypes
+  for name in ["libigdmd.so", "libigdmd.so.1"]:
+    try:
+      ctypes.CDLL(name)
+      return
+    except OSError:
+      pass
+  skip("Intel(R) Metrics Discovery API library (libigdmd.so) is not found")
+
+def require_icpx():
+  if sys.platform == 'win32':
+    return
+  import shutil
+  if shutil.which("icpx") is None:
+    skip("icpx (Intel(R) oneAPI DPC++/C++ Compiler) is not found, " +
+         "source <oneapi>/setvars.sh")
+
+def check_gtpin_config(stderr):
+  """Skips if the CMake output shows that GTPin is unavailable."""
+  if stderr and (stderr.find("GTPin package download failed") != -1 or
+                 stderr.find("Some parts of GTPin package not found") != -1):
+    skip("GTPin is not available (download failed or GTPIN_PATH is " +
+         "incomplete), see tools/instcount/README.md")
+
+def set_deadline(seconds):
+  global _deadline
+  _deadline = (time.monotonic() + seconds) if seconds and seconds > 0 else None
 
 def get_script_path():
   path, script = os.path.split(os.path.realpath(__file__))
@@ -55,10 +131,33 @@ def add_env(env, name, val):
   custom_env[name] = val
   return custom_env
 
+def _kill(p):
+  if sys.platform != 'win32':
+    try:
+      os.killpg(p.pid, signal.SIGKILL)
+      return
+    except OSError:
+      pass
+  p.kill()
+
 def run_process(command, path, environ = None):
   shell = True if sys.platform == 'win32' else False
+  timeout = None
+  if _deadline is not None:
+    timeout = _deadline - time.monotonic()
+    if timeout <= 0:
+      raise TestTimeout(" ".join(command))
+  # A new session lets a timeout kill the whole process tree (e.g. make, or a
+  # tool that launches the application), not only the direct child.
+  new_session = (sys.platform != 'win32')
   p = subprocess.Popen(command, cwd = path, shell = shell,\
-    env = environ, stdout = subprocess.PIPE, stderr = subprocess.PIPE, encoding = "latin-1", text = True)
-  stdout, stderr = p.communicate()
+    env = environ, stdout = subprocess.PIPE, stderr = subprocess.PIPE, encoding = "latin-1", text = True,\
+    start_new_session = new_session)
+  try:
+    stdout, stderr = p.communicate(timeout = timeout)
+  except subprocess.TimeoutExpired:
+    _kill(p)
+    p.communicate()
+    raise TestTimeout(" ".join(command))
 
   return stdout, stderr
diff --git a/third-party-programs.txt b/third-party-programs.txt
index 4424fafb..f85947dc 100644
--- a/third-party-programs.txt
+++ b/third-party-programs.txt
@@ -12,74 +12,7 @@ govern your use of the third party programs as set forth in in the
 Third party programs and their corresponding required notices and/or license terms are listed
 below.
 ===============================================================================
-1. basic_collector.cpp
-
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-
-===============================================================================
-2. FMTLIB
-   Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
---- Optional exception to the license ---
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into a machine-executable object form of such
-source code, you may redistribute such embedded portions in such object form
-without including the above copyright and permission notices.
-
-
-===============================================================================
-3. SPDLOG
-   Copyright (c) 2016 Gabi Melman.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
--- NOTE: Third party dependency used by this software --
-This software depends on the fmt lib (MIT License),
-and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
-
-
-
-===============================================================================
-4. CMAKE
+1. CMAKE
 CMake - Cross Platform Makefile Generator
 Copyright 2000-2023 Kitware, Inc. and Contributors
 All rights reserved.
@@ -217,7 +150,3 @@ CMake was initially developed by Kitware with the following sponsorship:
 
  * Kitware, Inc.
 ===============================================================================
-5. UNITRACE
-   Unitrace (tools/unitrace) has its own third-party notices in
-   tools/unitrace/third-party-programs.txt, which is installed with unitrace.
-===============================================================================
diff --git a/tools/cl_tracer/README.md b/tools/cl_tracer/README.md
index 5d70be58..b6a5127c 100644
--- a/tools/cl_tracer/README.md
+++ b/tools/cl_tracer/README.md
@@ -1,9 +1,3 @@
-# ⛔️ DEPRECATED: This project is no longer maintained
-
-> **Warning**: This repository is obsolete. We will not be providing updates or support.
-
-Please use [unitrace](../unitrace) instead. Unitrace has support of all the options. Report in case of any issue found. We will be happy to help.
-
 # OpenCL(TM) Tracer
 ## Overview
 This tool is an analogue of [Intercept Layer for OpenCL(TM) Applications](https://github.com/intel/opencl-intercept-layer) designed based on internal [tracing mechanism](../../chapters/runtime_api_tracing/OpenCL.md) implemented in Intel runtimes for OpenCL(TM).
@@ -143,7 +137,7 @@ All the API calls and kernels, which submission happens while collection disable
 - Windows
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/tools/gpuinfo/README.md b/tools/gpuinfo/README.md
index ff6c219a..5c983ac4 100644
--- a/tools/gpuinfo/README.md
+++ b/tools/gpuinfo/README.md
@@ -73,7 +73,7 @@ Expected output should be the following:
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [Intel(R) Metrics Discovery Application Programming Interface](https://github.com/intel/metrics-discovery)
diff --git a/tools/instcount/CMakeLists.txt b/tools/instcount/CMakeLists.txt
index d1d4994d..7bbdfa2d 100644
--- a/tools/instcount/CMakeLists.txt
+++ b/tools/instcount/CMakeLists.txt
@@ -47,3 +47,4 @@ endif()
 # Installation
 
 install(TARGETS instcount instcount_tool DESTINATION bin)
+InstallGTPinRuntime(instcount_tool instcount)
diff --git a/tools/instcount/README.md b/tools/instcount/README.md
index df5f249d..2c456c57 100644
--- a/tools/instcount/README.md
+++ b/tools/instcount/README.md
@@ -100,7 +100,7 @@ The following capabilities are available:
 
 ## Prerequisites
 
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Graphics Technology Pin (GT Pin)](https://software.intel.com/content/www/us/en/develop/articles/gtpin.html)
 
@@ -108,7 +108,7 @@ The following capabilities are available:
 
 ### Linux
 
-If required, use "-DGTPIN_PATH=<gtpin>/Profilers" cmake config option to point on specific GTPin directory. Or use "-DGTPIN_LINK=" to specify link to GTPin package.
+CMake downloads GT Pin 4.6.4 automatically. If the download fails (for example, behind a proxy), get the package from the [GT Pin 4.6.4 download page](https://www.intel.com/content/www/us/en/download/730596/867025/gtpin.html), unpack it and pass `-DGTPIN_PATH=<gtpin>`, the directory that contains `Lib` and `Include`. Use `-DGTPIN_LINK=<url>` to download another package, and `-DGTPIN_DOWNLOAD_INACTIVITY_TIMEOUT=<seconds>` (default 60) or `-DGTPIN_DOWNLOAD_TIMEOUT=<seconds>` (default 900) to change when a stalled download gives up.
 
 Run the following commands to build the sample:
 
@@ -116,7 +116,7 @@ Run the following commands to build the sample:
 cd <pti>/tools/instcount
 mkdir build
 cd build
-cmake -DCMAKE_BUILD_TYPE=Release [-DGTPIN_PATH=<gtpin>/Profilers] ..
+cmake -DCMAKE_BUILD_TYPE=Release [-DGTPIN_PATH=<gtpin>] ..
 make
 ```
 
diff --git a/tools/memaccess/CMakeLists.txt b/tools/memaccess/CMakeLists.txt
index 5807a312..d089e22d 100644
--- a/tools/memaccess/CMakeLists.txt
+++ b/tools/memaccess/CMakeLists.txt
@@ -47,3 +47,4 @@ endif()
 # Installation
 
 install(TARGETS memaccess memaccess_tool DESTINATION bin)
+InstallGTPinRuntime(memaccess_tool memaccess)
diff --git a/tools/memaccess/README.md b/tools/memaccess/README.md
index 76a2c0ae..61484dcd 100644
--- a/tools/memaccess/README.md
+++ b/tools/memaccess/README.md
@@ -53,7 +53,7 @@ The following capabilities are available:
 
 ## Prerequisites
 
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Graphics Technology Pin (GT Pin)](https://software.intel.com/content/www/us/en/develop/articles/gtpin.html)
 
@@ -61,13 +61,15 @@ The following capabilities are available:
 
 ### Linux
 
+CMake downloads GT Pin 4.6.4 automatically. If the download fails (for example, behind a proxy), get the package from the [GT Pin 4.6.4 download page](https://www.intel.com/content/www/us/en/download/730596/867025/gtpin.html), unpack it and pass `-DGTPIN_PATH=<gtpin>`, the directory that contains `Lib` and `Include`. Use `-DGTPIN_LINK=<url>` to download another package, and `-DGTPIN_DOWNLOAD_INACTIVITY_TIMEOUT=<seconds>` (default 60) or `-DGTPIN_DOWNLOAD_TIMEOUT=<seconds>` (default 900) to change when a stalled download gives up.
+
 Run the following commands to build the sample:
 
 ```sh
 cd <pti>/samples/memaccess
 mkdir build
 cd build
-cmake -DCMAKE_BUILD_TYPE=Release [-DGTPIN_PATH=<gtpin>/Profilers] ..
+cmake -DCMAKE_BUILD_TYPE=Release [-DGTPIN_PATH=<gtpin>] ..
 make
 ```
 
diff --git a/tools/oneprof/README.md b/tools/oneprof/README.md
index 547bf0fe..84f8ec9d 100644
--- a/tools/oneprof/README.md
+++ b/tools/oneprof/README.md
@@ -1,9 +1,3 @@
-# ⛔️ DEPRECATED: This project is no longer maintained
-
-> **Warning**: This repository is obsolete. We will not be providing updates or support.
-
-Please use [unitrace](../unitrace) instead. Unitrace has support of all the options. Report in case of any issue found. We will be happy to help.
-
 # GPU Metrics Collection Tool for Data Parallel C++ (DPC++)
 ## Overview
 This tool provides GPU hardware metrics collection capabilities for the compute applications based on Intel runtimes for OpenCL(TM) and Level Zero, like DPC++, Intel(R) Implicit SPMD Program Compiler (Intel(R) ISPC) and OpenMP* GPU offload programs.
@@ -103,7 +97,7 @@ Group 1: ComputeBasic (Compute Metrics Basic set)
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/tools/oneprof/prof_utils.h b/tools/oneprof/prof_utils.h
index 747142b1..2bd2344e 100644
--- a/tools/oneprof/prof_utils.h
+++ b/tools/oneprof/prof_utils.h
@@ -42,6 +42,41 @@ inline ze_device_handle_t GetZeDevice(uint32_t device_id) {
   return nullptr;
 }
 
+struct ZePciAddress {
+  uint32_t domain;
+  uint32_t bus;
+  uint32_t device;
+  uint32_t function;
+};
+
+// Reads the device PCI address through the core PCI properties extension, so
+// sysman (ZES_ENABLE_SYSMAN or zesInit) does not have to be enabled inside the
+// profiled application. Falls back to sysman if the extension is unavailable;
+// that only works when the application enabled sysman itself.
+inline bool GetZeDevicePciAddress(ze_device_handle_t device,
+                                  ZePciAddress* address) {
+  PTI_ASSERT(device != nullptr);
+  PTI_ASSERT(address != nullptr);
+
+  ze_pci_ext_properties_t pci_ext_props{
+      ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES, };
+  if (zeDevicePciGetPropertiesExt(device, &pci_ext_props) ==
+      ZE_RESULT_SUCCESS) {
+    *address = {pci_ext_props.address.domain, pci_ext_props.address.bus,
+                pci_ext_props.address.device, pci_ext_props.address.function};
+    return true;
+  }
+
+  zes_pci_properties_t pci_props{ZES_STRUCTURE_TYPE_PCI_PROPERTIES, };
+  if (zesDevicePciGetProperties(device, &pci_props) == ZE_RESULT_SUCCESS) {
+    *address = {pci_props.address.domain, pci_props.address.bus,
+                pci_props.address.device, pci_props.address.function};
+    return true;
+  }
+
+  return false;
+}
+
 inline cl_device_pci_bus_info_khr GetDevicePciInfo(cl_device_id device) {
   PTI_ASSERT(device != nullptr);
 
@@ -64,16 +99,17 @@ inline cl_device_id GetClDevice(uint32_t device_id) {
     return nullptr;
   }
 
-  zes_pci_properties_t pci_props{ZES_STRUCTURE_TYPE_PCI_PROPERTIES, };
-  ze_result_t status = zesDevicePciGetProperties(device, &pci_props);
-  PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+  ZePciAddress address{};
+  if (!GetZeDevicePciAddress(device, &address)) {
+    return nullptr;
+  }
 
   for (auto device : utils::cl::GetDeviceList(CL_DEVICE_TYPE_GPU)) {
     cl_device_pci_bus_info_khr pci_info = GetDevicePciInfo(device);
-    if (pci_info.pci_domain == pci_props.address.domain &&
-        pci_info.pci_bus == pci_props.address.bus &&
-        pci_info.pci_device == pci_props.address.device &&
-        pci_info.pci_function == pci_props.address.function) {
+    if (pci_info.pci_domain == address.domain &&
+        pci_info.pci_bus == address.bus &&
+        pci_info.pci_device == address.device &&
+        pci_info.pci_function == address.function) {
       return device;
     }
   }
@@ -89,13 +125,14 @@ inline ze_device_handle_t GetZeDevice(cl_device_id device_id) {
   cl_device_pci_bus_info_khr pci_info = GetDevicePciInfo(device_id);
 
   for (auto device : utils::ze::GetDeviceList()) {
-    zes_pci_properties_t pci_props{ZES_STRUCTURE_TYPE_PCI_PROPERTIES, };
-    ze_result_t status = zesDevicePciGetProperties(device, &pci_props);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
-    if (pci_info.pci_domain == pci_props.address.domain &&
-        pci_info.pci_bus == pci_props.address.bus &&
-        pci_info.pci_device == pci_props.address.device &&
-        pci_info.pci_function == pci_props.address.function) {
+    ZePciAddress address{};
+    if (!GetZeDevicePciAddress(device, &address)) {
+      continue;
+    }
+    if (pci_info.pci_domain == address.domain &&
+        pci_info.pci_bus == address.bus &&
+        pci_info.pci_device == address.device &&
+        pci_info.pci_function == address.function) {
       return device;
     }
   }
@@ -103,7 +140,7 @@ inline ze_device_handle_t GetZeDevice(cl_device_id device_id) {
   return nullptr;
 }
 inline void PrintDeviceList() {
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  ze_result_t status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   std::vector<ze_device_handle_t> device_list = utils::ze::GetDeviceList();
@@ -122,15 +159,17 @@ inline void PrintDeviceList() {
     status = zeDeviceGetProperties(device_list[i], &device_properties);
     PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
-    zes_pci_properties_t pci_props{ZES_STRUCTURE_TYPE_PCI_PROPERTIES, };
-    status = zesDevicePciGetProperties(device_list[i], &pci_props);
-    PTI_ASSERT(status == ZE_RESULT_SUCCESS);
+    ZePciAddress address{};
+    if (!GetZeDevicePciAddress(device_list[i], &address)) {
+      std::cout << "[WARNING] Unable to get PCI address of device #" << i <<
+        std::endl;
+    }
 
     std::cout << "Device #" << i << ": [" << std::hex << std::setfill('0') <<
-      std::setw(4) << pci_props.address.domain << ":" <<
-      std::setw(2) << pci_props.address.bus << ":" <<
-      std::setw(2) << pci_props.address.device << "." <<
-      std::setw(1) << pci_props.address.function << std::dec << "] " <<
+      std::setw(4) << address.domain << ":" <<
+      std::setw(2) << address.bus << ":" <<
+      std::setw(2) << address.device << "." <<
+      std::setw(1) << address.function << std::dec << "] " <<
       device_properties.name << std::endl;
   }
 
@@ -152,7 +191,7 @@ inline std::string GetMetricUnits(const char* units) {
 }
 
 inline void PrintMetricList(uint32_t device_id) {
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  ze_result_t status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
 
   std::vector<ze_device_handle_t> device_list = utils::ze::GetDeviceList();
diff --git a/tools/oneprof/tool.cc b/tools/oneprof/tool.cc
index e14fe4bd..5999b025 100644
--- a/tools/oneprof/tool.cc
+++ b/tools/oneprof/tool.cc
@@ -213,7 +213,6 @@ extern "C" PTI_EXPORT
 void SetToolEnv() {
   utils::SetEnv("ZE_ENABLE_TRACING_LAYER", "1");
   utils::SetEnv("ZET_ENABLE_METRICS", "1");
-  utils::SetEnv("ZES_ENABLE_SYSMAN", "1");
 }
 
 static ProfOptions ReadArgs() {
@@ -299,7 +298,7 @@ static ProfOptions ReadArgs() {
 }
 
 void EnableProfiling() {
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  ze_result_t status = utils::ze::InitGpuDrivers();
   if (status == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE) {
     std::cout <<
       "[WARNING] Unable to initialize Level Zero Metrics API" << std::endl;
@@ -320,7 +319,7 @@ void DisableProfiling() {
 void Finalize() {
   utils::SetEnv("ZET_ENABLE_METRICS", "1");
 
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  ze_result_t status = utils::ze::InitGpuDrivers();
   if (status == ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE) {
     std::cout <<
       "[WARNING] Unable to initialize Level Zero Metrics API" << std::endl;
diff --git a/tools/onetrace/README.md b/tools/onetrace/README.md
index e638c000..3a9d5a9f 100644
--- a/tools/onetrace/README.md
+++ b/tools/onetrace/README.md
@@ -1,9 +1,3 @@
-# ⛔️ DEPRECATED: This project is no longer maintained
-
-> **Warning**: This repository is obsolete. We will not be providing updates or support.
-
-Please use [unitrace](../unitrace) instead. Unitrace has support of all the options. Report in case of any issue found. We will be happy to help.
-
 # Tracing and Profiling Tool for Data Parallel C++ (DPC++)
 ## Overview
 This tool provides basic tracing and profiling capabilities for the compute applications based on Intel runtimes for OpenCL(TM) and Level Zero, like DPC++, Intel(R) Implicit SPMD Program Compiler (Intel(R) ISPC) and OpenMP* GPU offload programs.
@@ -159,7 +153,7 @@ All the API calls and kernels, which submission happens while collection disable
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [OpenCL(TM) ICD Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader)
diff --git a/tools/onetrace/unified_tracer.h b/tools/onetrace/unified_tracer.h
index b50f51c7..a8313377 100644
--- a/tools/onetrace/unified_tracer.h
+++ b/tools/onetrace/unified_tracer.h
@@ -34,7 +34,7 @@ class UnifiedTracer {
     cl_device_id cl_gpu_device = utils::cl::GetIntelDevice(CL_DEVICE_TYPE_GPU);
 
     ze_result_t status = ZE_RESULT_SUCCESS;
-    status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+    status = utils::ze::InitGpuDrivers();
 
     UnifiedTracer* tracer = new UnifiedTracer(options);
     PTI_ASSERT(tracer != nullptr);
diff --git a/tools/sysmon/README.md b/tools/sysmon/README.md
index e9ec9125..1cab8c4d 100644
--- a/tools/sysmon/README.md
+++ b/tools/sysmon/README.md
@@ -75,7 +75,7 @@ Min Core Frequency(MHz),                300
 - Linux
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero) and its development headers
   (`level_zero/ze_api.h`, `level_zero/zes_api.h`; e.g. the `libze-dev` package). Headers or a loader in
   another location can be passed with `-DCMAKE_INCLUDE_PATH=<dir>` and `-DCMAKE_LIBRARY_PATH=<dir>`.
diff --git a/tools/sysmon/cmake/FindLevelZero.cmake b/tools/sysmon/cmake/FindLevelZero.cmake
index cfa93339..cc4343a8 100644
--- a/tools/sysmon/cmake/FindLevelZero.cmake
+++ b/tools/sysmon/cmake/FindLevelZero.cmake
@@ -1,6 +1,6 @@
-# Copy of sdk/cmake/Modules/FindLevelZero.cmake (with the version-regex fix from
-# PR #1286), kept here so that sysmon builds without the PTI SDK sources.
-# Keep the two copies in sync.
+# Originally copied from the upstream PTI SDK's FindLevelZero.cmake (with the
+# version-regex fix from PR #1286). The PTI SDK is not part of this fork, so
+# this is now the only copy.
 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
 # file Copyright.txt or https://cmake.org/licensing for details.
 
diff --git a/tools/unitrace/CMakeLists.txt b/tools/unitrace/CMakeLists.txt
deleted file mode 100644
index fc2d04b4..00000000
--- a/tools/unitrace/CMakeLists.txt
+++ /dev/null
@@ -1,493 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-# Need to check the build type first as project() can have default build type set,
-# which can be different for different platforms.
-if(NOT DEFINED CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-project(PTI_Tools_UniTrace C CXX)
-find_package(Python 3.9 COMPONENTS Interpreter REQUIRED)
-
-list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
-include(HeaderFetch)
-
-# Print the configured build type and target bitness. unitrace only supports
-# 64-bit builds, so a 32-bit toolchain fails the configure step.
-message(STATUS "Build Type: ${CMAKE_BUILD_TYPE}")
-if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(STATUS "Bitness: 64 bits")
-else()
-  message(FATAL_ERROR "32-bit mode is not supported")
-endif()
-
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-
-if(WIN32)
-  #Win_Todo :  Default MPI is disabled on windows.It will be enabled once verified.
-  option(BUILD_WITH_MPI
-  "Build with support for MPI tracing"
-  OFF
-  )
-else()
-  option(BUILD_WITH_MPI
-    "Build with support for MPI tracing"
-    ON
-  )
-endif()
-
-# These flags are forwarded to the compiler as macros, so they must be 0 or 1.
-# 1/ON/TRUE/YES and 0/OFF/FALSE/NO are accepted (case-insensitive).
-macro(normalize_build_flag flag default_value)
-  if (NOT DEFINED ${flag})
-    set(${flag} ${default_value})
-  else()
-    string(TOUPPER "${${flag}}" _flag_value)
-    if (_flag_value MATCHES "^(1|ON|TRUE|YES)$")
-      set(${flag} 1)
-    elseif (_flag_value MATCHES "^(0|OFF|FALSE|NO)$")
-      set(${flag} 0)
-    else()
-      message(FATAL_ERROR "${flag}=${${flag}} is invalid. Use 1/ON or 0/OFF.")
-    endif()
-  endif()
-endmacro()
-
-normalize_build_flag(BUILD_WITH_L0 1)
-normalize_build_flag(BUILD_WITH_ITT 1)
-normalize_build_flag(BUILD_WITH_XPTI 1)
-normalize_build_flag(BUILD_WITH_OPENCL 1)
-normalize_build_flag(BUILD_WITH_OMP 1) # OpenMP tracing
-
-if (BUILD_WITH_MPI AND BUILD_WITH_ITT STREQUAL "0")
-  message(FATAL_ERROR "BUILD_WITH_ITT=0 and BUILD_WITH_MPI=1 is not a valid configuration for unitrace tool.")
-endif()
-
-include(GNUInstallDirs)
-
-add_compile_definitions(BUILD_WITH_ITT=${BUILD_WITH_ITT})
-add_compile_definitions(BUILD_WITH_XPTI=${BUILD_WITH_XPTI})
-add_compile_definitions(BUILD_WITH_OPENCL=${BUILD_WITH_OPENCL})
-add_compile_definitions(BUILD_WITH_L0=${BUILD_WITH_L0})
-add_compile_definitions(BUILD_WITH_OMP=${BUILD_WITH_OMP})
-
-if(WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17 /bigobj ")
-  # Keep <windows.h> from defining min/max macros that break std::min/max.
-  add_compile_definitions(NOMINMAX)
-else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -fvisibility=default")
-endif()
-
-# Tool Library
-macro(FindHeadersPath TARGET L0_GEN_SCRIPT GEN_FILE_NAME custom_target)
-  find_path(L0_INC_PATH
-    NAMES level_zero
-    PATHS ENV CPATH)
-  if (NOT L0_INC_PATH)
-    message(FATAL_ERROR
-      "Level Zero headers path is not found.\n"
-      "You may need to install oneAPI Level Zero Driver to fix this issue.")
-  else()
-    message(STATUS "Level Zero headers are found at ${L0_INC_PATH}")
-  endif()
-
-  set(L0_GEN_INC_PATH "${CMAKE_BINARY_DIR}")
-  set(OCL_DIR_PATH "${CMAKE_BINARY_DIR}/CL")
-  add_custom_target(${custom_target} ALL
-                    DEPENDS ${L0_GEN_INC_PATH}/${GEN_FILE_NAME})
-  add_custom_command(OUTPUT ${L0_GEN_INC_PATH}/${GEN_FILE_NAME}
-                     COMMAND "${Python_EXECUTABLE}" ${L0_GEN_SCRIPT} ${L0_GEN_INC_PATH} "${L0_INC_PATH}/level_zero" "${OCL_DIR_PATH}")
-  target_include_directories(${TARGET}
-    PUBLIC "${L0_GEN_INC_PATH}")
-  add_dependencies(${TARGET}
-    ${custom_target})
-  add_dependencies(${custom_target} unitrace_level_zero_headers) # created by UnitraceGetLevelZeroHeaders
-endmacro()
-
-# Get Git Commit Hash
-macro(GetGitCommitHash TARGET GET_COMMIT_HASH_SCRIPT COMMIT_HASH_FILE_NAME target)
-
-  add_custom_target(${target} ALL DEPENDS ${CMAKE_BINARY_DIR}/${COMMIT_HASH_FILE_NAME})
-  add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/${COMMIT_HASH_FILE_NAME}
-                     COMMAND "${Python_EXECUTABLE}" ${GET_COMMIT_HASH_SCRIPT} ${CMAKE_BINARY_DIR} ${COMMIT_HASH_FILE_NAME})
-  add_dependencies(${TARGET} ${target})
-endmacro()
-
-if (${BUILD_WITH_ITT})
-  # Download itt source from github repo
-  set(ITT_HASH 6ddf03848b46f78a8d2cbe596cbe1b5e2602005c)
-  if (CMAKE_INSTALL_PREFIX AND INSTALL_ITT)
-    set (ITT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX})
-  endif()
-  execute_process(COMMAND "${Python_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/get_itt.py ${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR} ${ITT_HASH} ${ITT_INSTALL_PATH}
-    RESULT_VARIABLE result
-    ERROR_VARIABLE error_msg
-  )
-  if (NOT result EQUAL 0)
-    message(FATAL_ERROR "Error occurred while building ITT component")
-  endif()
-endif()
-
-# Perfetto protobuf trace output (built from source into the build tree.
-# All of the fetch/build/generate logic lives in
-# cmake/Perfetto.cmake; SetupPerfetto() degrades to JSON-only on any failure.
-option(BUILD_WITH_PERFETTO "Build with support for Perfetto protobuf trace output" ON)
-# The fuzz targets (test/fuzz/cpp, clang only) include the unitrace sources, so they build
-# here, against the same include paths and generated headers as unitrace.
-option(UNITRACE_BUILD_FUZZ "Build the libFuzzer targets in test/fuzz/cpp" OFF)
-if (BUILD_WITH_PERFETTO)
-  include(${PROJECT_SOURCE_DIR}/cmake/Perfetto.cmake)
-  SetupPerfetto()  # clears BUILD_WITH_PERFETTO (degrade to JSON-only) on any failure
-endif()
-
-add_compile_definitions(BUILD_WITH_PERFETTO=$<BOOL:${BUILD_WITH_PERFETTO}>)
-
-if (BUILD_WITH_MPI)
-  find_package(MPI REQUIRED)
-  add_library(unitrace_mpi SHARED
-    "${PROJECT_SOURCE_DIR}/src/mpi/mpi.c")
-
-  target_link_libraries(unitrace_mpi
-    PUBLIC MPI::MPI_C
-    PRIVATE ${CMAKE_BINARY_DIR}/libittnotify.a)
-  target_include_directories(unitrace_mpi
-    PRIVATE "${PROJECT_SOURCE_DIR}"
-    PRIVATE "${I_MPI_ROOT}/include"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/itt"
-    PRIVATE "${CMAKE_BINARY_DIR}/ittheaders"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/mpi"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/opencl"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/levelzero")
-  if(CMAKE_INCLUDE_PATH)
-    target_include_directories(unitrace_mpi
-      PUBLIC "${CMAKE_INCLUDE_PATH}")
-  endif()
-endif()
-
-
-add_library(unitrace_tool SHARED
-  "${PROJECT_SOURCE_DIR}/src/tracer.cc"
-  "${PROJECT_SOURCE_DIR}/src/utils/logger_factory.cc"
-)
-link_directories(${ONEAPI_COMPILER_HOME}/lib)
-
-# On Windows the static ittnotify in the profiled application resolves this
-# collector's __itt_* overrides by name via GetProcAddress (ittnotify_static.c:
-# __itt_api_init -> fill_func_ptr_per_lib). DLL symbols are not exported by
-# default on Windows, so without this the lookups return NULL and in-application
-# ITT control (__itt_pause/__itt_resume/__itt_detach) silently no-ops. Export
-# all symbols so the collector entry points are visible. Linux/ELF exports
-# extern symbols by default and is unaffected.
-if (WIN32)
-  set_target_properties(unitrace_tool PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
-endif()
-
-if (BUILD_WITH_XPTI)
-  find_package(Xptifw REQUIRED)
-  if (Xptifw_FOUND)
-    message(STATUS "XPTI found")
-    target_include_directories(unitrace_tool PRIVATE "${Xptifw_INCLUDE_DIR}")
-    target_link_directories(unitrace_tool PRIVATE "${Xptifw_LIBRARY_DIR}")
-    if(WIN32)
-      target_link_libraries(unitrace_tool ${Xptifw_LIBRARY})
-    else()
-      target_link_libraries(unitrace_tool xptifw)
-    endif()
-  endif()
-endif()
-
-target_include_directories(unitrace_tool
-  PRIVATE "${PROJECT_SOURCE_DIR}"
-  PRIVATE "${ONEAPI_COMPILER_HOME}/include"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src/opencl"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src/levelzero")
-
-if (BUILD_WITH_XPTI)
-  target_include_directories(unitrace_tool
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/xpti")
-endif()
-
-if (BUILD_WITH_ITT)
-  target_include_directories(unitrace_tool
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/itt"
-    PRIVATE "${CMAKE_BINARY_DIR}/ittheaders")
-endif()
-
-if(BUILD_WITH_OMP)
-  find_package(OpenMP REQUIRED)
-  target_include_directories(unitrace_tool
-    PRIVATE "$ENV{CMPLR_ROOT}/opt/compiler/include"
-    PRIVATE "${PROJECT_SOURCE_DIR}/src/omp")
-endif()
-
-target_compile_definitions(unitrace_tool PUBLIC PTI_LEVEL_ZERO=1)
-if(CMAKE_INCLUDE_PATH)
-  target_include_directories(unitrace_tool
-    PUBLIC "${CMAKE_INCLUDE_PATH}")
-endif()
-
-# Link libprotobuf + its headers (vars from SetupPerfetto()); SYSTEM mutes
-# protobuf's own warnings.
-if (BUILD_WITH_PERFETTO)
-  # Generated protobuf TU goes in its own STATIC lib, not unitrace_tool directly:
-  # WINDOWS_EXPORT_ALL_SYMBOLS auto-exports the target's own objects, and the huge
-  # perfetto_trace.pb.cc would blow the MSVC 65535-export cap (LNK1189). Symbols
-  # from a linked static lib are not auto-exported, so this keeps exports.def small.
-  add_library(unitrace_perfetto_proto STATIC ${PERFETTO_PROTO_SRCS})
-  target_include_directories(unitrace_perfetto_proto SYSTEM PRIVATE
-    "${PROTOBUF_INCLUDE}" "${PERFETTO_GEN_DIR}")
-  set_target_properties(unitrace_perfetto_proto PROPERTIES POSITION_INDEPENDENT_CODE ON)
-
-  # unitrace_tool sources include perfetto_trace.pb.h (via perfettologger.h).
-  target_include_directories(unitrace_tool SYSTEM PRIVATE
-    "${PROTOBUF_INCLUDE}" "${PERFETTO_GEN_DIR}")
-  target_link_libraries(unitrace_tool unitrace_perfetto_proto ${PROTOBUF_LIB})
-  # Keep the static protobuf's symbols internal: LD_PRELOADed unitrace_tool.so
-  # would otherwise interpose on a target's own protobuf (e.g. PyTorch) and crash
-  # it. --exclude-libs takes the archive basename, not a path.
-  if (UNIX AND NOT APPLE)
-    get_filename_component(_protobuf_lib_name "${PROTOBUF_LIB}" NAME)
-    target_link_options(unitrace_tool PRIVATE
-      "LINKER:--exclude-libs,${_protobuf_lib_name}")
-  endif()
-endif()
-
-if (BUILD_WITH_OPENCL)
-  include(OpenCL)
-  UnitraceFindOpenCLLibrary(unitrace_tool)
-  UnitraceFindOpenCLHeaders(unitrace_tool)
-endif()
-
-# Needed for both OpenCL tracing and the Level Zero driver extension APIs.
-UnitraceGetComputeRuntimeHeaders(unitrace_tool)
-
-# v1.32.0 is the first release with the stable graph API (zeGraphCreateExt and
-# friends), which SYCL uses instead of the Exp one.
-set (LEVEL_ZERO_COMMIT_ID "v1.32.0")
-UnitraceGetLevelZeroHeaders(unitrace_tool ${LEVEL_ZERO_COMMIT_ID})
-
-# Add IGA support for kernel disassembly.
-# Only the IGA C API headers are needed at build time, and only by the unitrace
-# executable: unitrace_tool - the library injected into the traced application -
-# collects the kernel records and module binaries but decodes nothing, so it needs
-# no IGA header, calls no IGA function and loads no iga64. The disassembly runs in
-# unitrace, which resolves iga64 dynamically via LibraryLoader on both Windows and
-# Linux.
-# Unitrace owns its IGA header fetch (see cmake/HeaderFetch.cmake) so it can pin a
-# revision that defines IGA_XE3P_XPC and shield itself from a stale /usr/include/iga.
-# intel-graphics-compiler revision to fetch IGA API headers from. Pinned to a
-# revision that defines IGA_XE3P_XPC (XE_VER(3,3)) so Xe3P/CRI kernels disassemble.
-# Consumed by the UnitraceGetIGAHeaders(unitrace ...) call further down.
-set (IGA_COMMIT_ID "4ba3c2aaab4f189b143ef288bc3e75eb02ad6f82")
-
-FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_tracing_common_header.py" "common_header.gen" gen_common_header)
-FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_tracing_callbacks.py" "tracing.gen" gen_tracing_header)
-FindHeadersPath(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/gen_l0_loader.py" "l0_loader.gen" gen_l0_loader_header)
-
-# gen_l0_loader_header needs extensions from unitrace_compute_runtime_headers
-add_dependencies(gen_l0_loader_header unitrace_compute_runtime_headers)
-# gen_tracing_header needs extensions from unitrace_compute_runtime_headers for extension API tracing
-add_dependencies(gen_tracing_header unitrace_compute_runtime_headers)
-# gen_common_header needs CL tracing headers from unitrace_compute_runtime_headers
-add_dependencies(gen_common_header unitrace_compute_runtime_headers)
-
-target_include_directories(unitrace_tool PRIVATE "${L0_INC_PATH}")
-
-# Loader
-
-add_executable(unitrace
-  "${PROJECT_SOURCE_DIR}/src/unitrace.cc"
-  "${PROJECT_SOURCE_DIR}/src/utils/logger_factory.cc"
-)
-# unitrace to depend on gen_l0_loader_header to ensure that it exists
-add_dependencies(unitrace gen_l0_loader_header)
-
-# unitrace is where the disassembler actually runs, so it needs the full IGA API - and
-# it is the only target that needs it at all. UnitraceGetIGAHeaders adds the fetched
-# build-dir path with BEFORE so it wins over any stale /usr/include/iga (which may
-# predate IGA_XE2), and adds the fetch dependency.
-UnitraceGetIGAHeaders(unitrace ${IGA_COMMIT_ID})
-
-# unitrace_tool to depend on unitrace to build unitrace first and then we can
-# remove l0_loader.gen when unitrace_tool is built
-add_dependencies(unitrace_tool unitrace)
-
-if(UNIX)
-    include(CMakePushCheckState)
-    cmake_push_check_state()
-    cmake_reset_check_state()
-    include(CheckCXXSourceCompiles)
-    set(code
-        "#include <filesystem>
-        int main()
-        {
-            return std::filesystem::exists(std::filesystem::path(\"/tmp\"));
-        }")
-    check_cxx_source_compiles("${code}" FILESYSTEM_JUST_WORKS)
-    if(FILESYSTEM_JUST_WORKS)
-        set(CXX_STD_FILESYSTEM_EXPERIMENTAL 0)
-    else()
-    set(code
-        "#include <experimental/filesystem>
-        int main()
-        {
-            return std::experimental::filesystem::exists(std::experimental::filesystem::path(\"/tmp\"));
-        }")
-        set(saved_libs ${CMAKE_REQUIRED_LIBRARIES})
-        set(CMAKE_REQUIRED_LIBRARIES ${saved_libs} "-lstdc++fs")
-        check_cxx_source_compiles("${code}" FILESYSTEM_NEEDS_LIBSTDCXXFS)
-        if (FILESYSTEM_NEEDS_LIBSTDCXXFS)
-            set(CXX_STD_FILESYSTEM_EXPERIMENTAL 1)
-            target_link_libraries(unitrace stdc++fs)
-        else()
-            set(CMAKE_REQUIRED_LIBRARIES ${saved_libs} "-lc++fs")
-            check_cxx_source_compiles("${code}" FILESYSTEM_NEEDS_LIBCXXFS)
-            if (FILESYSTEM_NEEDS_LIBCXXFS)
-                set(CXX_STD_FILESYSTEM_EXPERIMENTAL 1)
-                target_link_libraries(unitrace c++fs)
-            else()
-                message(FATAL_ERROR "C++17 filesystem support is required")
-            endif()
-        endif()
-    endif()
-    cmake_pop_check_state()
-    target_compile_definitions(unitrace PRIVATE CXX_STD_FILESYSTEM_EXPERIMENTAL=${CXX_STD_FILESYSTEM_EXPERIMENTAL})
-endif()
-
-set(_use_mpi 1)
-
-if (BUILD_WITH_MPI)
-  set(_use_mpi 1)
-else()
-  set(_use_mpi 0)
-endif()
-target_compile_definitions(unitrace PRIVATE BUILD_WITH_MPI=${_use_mpi})
-
-if(CMAKE_INSTALL_LIBDIR)
-  target_compile_definitions(unitrace PRIVATE UNITRACE_INSTALL_LIBDIR="${CMAKE_INSTALL_LIBDIR}")
-endif()
-
-target_include_directories(unitrace
-  PRIVATE "${CMAKE_BINARY_DIR}"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src/levelzero"
-  PRIVATE "${PROJECT_SOURCE_DIR}/src/utils"
-  PRIVATE "${PROJECT_SOURCE_DIR}")
-
-# IGA headers only (needed by kernel_disassembler.h, which unitrace reaches through
-# ze_metrics.h). The iga64 shared library is loaded at runtime, so there is nothing to
-# link: unitrace gets the fetched IGA include path via UnitraceGetIGAHeaders() above,
-# and only the dlopen/pthread/rt libs remain.
-if(UNIX)
-  # ${CMAKE_DL_LIBS} provides dlopen()/dlsym(). unitrace uses it to load iga64;
-  # unitrace_tool needs it for the Level Zero loader regardless (ze_loader.h).
-  target_link_libraries(unitrace pthread ${CMAKE_DL_LIBS} rt)
-  target_link_libraries(unitrace_tool ${CMAKE_DL_LIBS} rt)
-endif()
-
-UnitraceGetLevelZeroHeaders(unitrace ${LEVEL_ZERO_COMMIT_ID})
-GetGitCommitHash(unitrace "${PROJECT_SOURCE_DIR}/scripts/get_commit_hash.py" "unitrace_commit_hash.h" get_git_commit_hash_unitrace)
-GetGitCommitHash(unitrace_tool "${PROJECT_SOURCE_DIR}/scripts/get_commit_hash.py" "unitrace_tool_commit_hash.h" get_git_commit_hash_unitrace_tool)
-
-# The fuzz targets include unitrace.cc and the collectors, so they need the generated
-# headers kept.
-if(UNIX AND NOT UNITRACE_BUILD_FUZZ)
-  add_custom_command(TARGET unitrace POST_BUILD COMMAND "rm" "-rf" "unitrace_commit_hash.h")
-  add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "rm" "-rf" "unitrace_tool_commit_hash.h")
-elseif(NOT UNITRACE_BUILD_FUZZ)
-  add_custom_command(TARGET unitrace POST_BUILD COMMAND "del" "unitrace_commit_hash.h")
-  add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "del" "unitrace_tool_commit_hash.h")
-endif()
-
-# Clearning files only for release build, for any other build types lets skip deletion for better debuggability
-string(TOLOWER "${CMAKE_BUILD_TYPE}" LOWER_CMAKE_BUILD_TYPE)
-if(NOT LOWER_CMAKE_BUILD_TYPE STREQUAL "debug" AND NOT UNITRACE_BUILD_FUZZ)
-  if(UNIX)
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "rm" "-rf" "common_header.gen")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "rm" "-rf" "tracing.gen")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "rm" "-rf" "tracing.gen.types")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "rm" "-rf" "l0_loader.gen")
-  else()
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "del" "common_header.gen")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "del" "tracing.gen")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "del" "tracing.gen.types")
-    add_custom_command(TARGET unitrace_tool POST_BUILD COMMAND "del" "l0_loader.gen")
-  endif()
-endif()
-
-if(UNITRACE_BUILD_FUZZ)
-  add_subdirectory(test/fuzz/cpp)
-endif()
-
-configure_file(${PROJECT_SOURCE_DIR}/scripts/uniview.py ${CMAKE_BINARY_DIR}/scripts/uniview.py COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/tracemerge/mergetrace.py ${CMAKE_BINARY_DIR}/scripts/tracemerge/mergetrace.py COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/analyzeperfmetrics.py ${CMAKE_BINARY_DIR}/scripts/metrics/analyzeperfmetrics.py COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/addrasm.py ${CMAKE_BINARY_DIR}/scripts/metrics/addrasm.py COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/ComputeBasic.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/ComputeBasic.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/GpuOffload.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/GpuOffload.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/MemProfile.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/MemProfile.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/L1ProfileReads.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/L1ProfileReads.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/L1ProfileWrites.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/L1ProfileWrites.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/pvc/L1ProfileSlmBankConflicts.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/pvc/L1ProfileSlmBankConflicts.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/bmg/ComputeBasic.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/bmg/ComputeBasic.txt COPYONLY)
-configure_file(${PROJECT_SOURCE_DIR}/scripts/metrics/config/bmg/MemoryProfile.txt ${CMAKE_BINARY_DIR}/scripts/metrics/config/bmg/MemoryProfile.txt COPYONLY)
-
-# Installation
-# Note: CMake will ignore not relevant DESTINATION (e.g., LIBRARY DESTINATION
-# for unitrace)
-install(TARGETS unitrace unitrace_tool
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                COMPONENT Unitrace_Runtime
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                COMPONENT Unitrace_Runtime
-)
-
-install(PROGRAMS
-        ${PROJECT_SOURCE_DIR}/scripts/uniview.py
-        ${PROJECT_SOURCE_DIR}/scripts/tracemerge/mergetrace.py
-        ${PROJECT_SOURCE_DIR}/scripts/metrics/analyzeperfmetrics.py
-        ${PROJECT_SOURCE_DIR}/scripts/metrics/addrasm.py
-        DESTINATION ${CMAKE_INSTALL_BINDIR}
-        COMPONENT Unitrace_Scripts)
-
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/scripts/metrics/config
-        DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/unitrace/metrics
-        COMPONENT Unitrace_Config)
-
-# TODO: Properly handle the directory inside bin (a little expected on Linux).
-install(DIRECTORY
-        ${PROJECT_SOURCE_DIR}/scripts/summary
-        DESTINATION ${CMAKE_INSTALL_BINDIR}
-        COMPONENT Unitrace_Scripts)
-
-if (BUILD_WITH_MPI)
-  install(TARGETS unitrace_mpi
-          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-                  COMPONENT Unitrace_Runtime
-          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-                  COMPONENT Unitrace_Runtime
-  )
-endif()
-
-# License notices for the third-party code built into unitrace_tool (Perfetto
-# trace protos, protobuf, ITT API, and the Level Zero, compute-runtime, IGA and
-# OpenCL API headers it compiles against): unitrace's own third-party-programs.txt (the
-# PTI SDK ships the repository-root one) and the full license texts with their
-# version records.
-set(UNITRACE_INSTALL_DOCDIR "${CMAKE_INSTALL_DATAROOTDIR}/doc/unitrace")
-install(FILES ${PROJECT_SOURCE_DIR}/third-party-programs.txt
-        DESTINATION ${UNITRACE_INSTALL_DOCDIR}
-        COMPONENT Unitrace_Runtime)
-# unitrace's own (outbound) MIT license, next to the notices as the SWLC notice
-# guidelines require. It lives at the repository root.
-install(FILES ${PROJECT_SOURCE_DIR}/../../LICENSE
-        DESTINATION ${UNITRACE_INSTALL_DOCDIR}
-        COMPONENT Unitrace_Runtime)
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/third_party/
-        DESTINATION ${UNITRACE_INSTALL_DOCDIR}/third_party
-        COMPONENT Unitrace_Runtime)
diff --git a/tools/unitrace/README.md b/tools/unitrace/README.md
deleted file mode 100644
index dd6e1306..00000000
--- a/tools/unitrace/README.md
+++ /dev/null
@@ -1,1453 +0,0 @@
-# Unified Tracing and Profiling Tool
-
-## Introduction
-
-This is a performance tool for Intel(R) oneAPI applications. It traces and profiles host/device activities, interactions, and hardware utilization for
-Intel(R) GPU applications.
-
-## Supported Platforms
-
-- Linux
-- Windows
-- Intel(R) oneAPI Base Toolkits
-- Intel(R) GPUs
-
-## Requirements
-
-- CMake 3.22 or above (CMake versions prior to 3.22 are not fully tested or validated)
-- C++ compiler with C++17 support
-- Intel(R) oneAPI Base Toolkits
-- Python 3.9 or later
-- Matplotlib 3.8 or later (https://matplotlib.org/)
-- Pandas 2.2.1 or later (https://pandas.pydata.org/)
-- Bokeh 3.9 or later (https://bokeh.org/)
-- Intel(R) MPI (optional)
-
-## Build and Install
-
-Unitrace is self-contained: its common headers live in `utils/`, test-only
-helpers in `test/utils/`, and its CMake helpers and header-fetch scripts in
-`cmake/` and `scripts/`. Nothing under `tools/unitrace` depends on the
-repository-level `utils/`, `tools/utils/` or `build_utils/` directories.
-
-```sh
-set up Intel(R) oneAPI environment
-set up Intel(R) MPI Environment (optional)
-```
-
-### Linux
-
-```sh
-cd <....>/tools/unitrace
-mkdir build
-cd build
-cmake -DCMAKE_BUILD_TYPE=Release ..
-make
-or
-cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..
-ninja
-or
-cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_WITH_MPI=<0|1> ..
-make
-or
-cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_WITH_MPI=<0|1> -DCMAKE_INSTALL_PREFIX=<installpath> ..
-make install
-or
-make install
-```
-
-### Windows
-
-```sh
-cd <....>\tools\unitrace
-mkdir build
-cd build
-cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release ..
-nmake
-or
-cmake -GNinja -DCMAKE_BUILD_TYPE=Release ..
-ninja
-or
-cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DBUILD_WITH_MPI=0 ..
-nmake
-or
-cmake -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DBUILD_WITH_MPI=0 -DCMAKE_INSTALL_PREFIX=<installpath> ..
-nmake
-or
-nmake install
-```
-
-The **BUILD_WITH_MPI=<1/0>** setting enables/disables MPI profiling support (enabled for Linux and disabled for Windows by default).
-
-In addition to BUILD_WITH_MPI, one or more of the following settings can also be passed to cmake:\
-**BUILD_WITH_ITT=<1/0>** to enable/disable oneCCL/oneDNN profiling support (enabled by default),\
-**BUILD_WITH_XPTI=<1/0>** to enable/disable SYCL/Unified Runtime profiling support (enabled by default),\
-**BUILD_WITH_OMP=<1/0>** to enable/disable OpenMP profiling support (enabled by default),\
-**BUILD_WITH_OPENCL=<1/0>** to enable/disable OpenCL profiling support (enabled by default),\
-**BUILD_WITH_L0=<1/0>** to enable/disable Level Zero profiling support (enabled by default).
-
-All of these settings also accept ON/OFF (case-insensitive).
-
-Example:
-
-```
-cmake -DBUILD_WITH_ITT=0 -DBUILD_WITH_XPTI=0 -DBUILD_WITH_MPI=0 -DBUILD_WITH_OPENCL=0 ..
-```
-
-## Test
-
-After unitrace is built, run test_unitrace.py from the test folder. When
-unitrace was built outside the standalone tools/unitrace layout (for example
-the repository's top-level build, which places binaries under `<build>/bin`),
-point the harness at it explicitly:
-
-```sh
-python test_unitrace.py --unitrace-exe <build>/bin/unitrace --unitrace-build-dir <build>
-```
-
-For a standalone tools/unitrace build no flags are needed; run it from the
-test folder
-
-```sh
-cd test
-python test_unitrace.py
-```
-
-By default, command **python test_unitrace.py** builds and runs all the tests of the **cpp-test** group, the fuzz tests included. The fuzz tests are the `[fuzz_*]` blocks of **test/tests.txt**: test_unitrace.py builds the fuzz targets in **test/fuzz/** (see [test/fuzz/README.md](/tools/unitrace/test/fuzz/README.md)) with clang into `<unitrace build>/test/fuzz_build`, and each test replays one target's seed corpus and regression inputs. They need no GPU. The C++ targets build with clang from PATH or, when oneAPI is loaded (setvars.sh), the clang oneAPI ships; they are reported as Skipped off Linux or without a clang that links libFuzzer, the Python ones without atheris. **--test-name 'fuzz_*'** runs only the fuzz tests (and builds only the fuzz targets).
-If the tests are already built and rebuilding the tests is not needed, you can use **--run** to skip building the tests:
-
-```sh
-cd test
-python test_unitrace.py --run
-```
-
-The test workloads are built incrementally in **test/cpp_test/build** and then
-installed into the unitrace build directory, so a clean unitrace build does not
-rebuild them. Logs and unitrace output go to the build directory too:
-
-```
-<unitrace build>/test/bin/<workload>/            one directory per workload: binary and .spv kernels
-<unitrace build>/test/output/cpp_test/logs/      one <test>.<scenario>.log per scenario
-<unitrace build>/test/output/cpp_test/results/<test>/  unitrace output files, one directory per test
-<unitrace build>/test/output/python_test/...     the same for --test-group python-test
-```
-
-`<unitrace build>` is `--unitrace-build-dir` when given, otherwise
-**tools/unitrace/build**. `--output-dir <dir>` writes logs and results to
-`<dir>/cpp_test` (or `<dir>/python_test`) instead. On Windows, use it when the
-checkout path is long: unitrace output paths must stay under MAX_PATH (260
-characters).
-
-The test suite is defined in **test/tests.txt**: each test is a block with
-its command line, the platforms it runs on, and the unitrace option scenarios
-it is exercised with (defaulting to the shared `[defaults]` scenario matrix).
-The file's header documents the full format.
-
-To see every test with its resolved scenario matrix on the current platform:
-
-```sh
-cd test
-python test_unitrace.py --list
-```
-
-To add a new test, for example **mytest**: add its workload under
-**test/cpp_test/mytest/** with a `CMakeLists.txt` building and installing it
-(`install(TARGETS mytest RUNTIME DESTINATION bin COMPONENT mytest)`, plus
-`install(FILES ...)` for any file the binary loads from its own directory),
-add an `add_subdirectory(mytest)` line in **test/cpp_test/CMakeLists.txt**,
-and declare it in **test/tests.txt**:
-
-```
-[mytest]
-command  = run_test.py mytest <args>
-```
-
-With no further keys it runs the default scenario matrix on all platforms;
-add `platform`, `scenario`, `skip-scenario` or `options` lines to specialize
-(see the header of tests.txt).
-
-Fuzz harnesses for the inputs unitrace parses are in **test/fuzz/** (see [test/fuzz/README.md](/tools/unitrace/test/fuzz/README.md)).
-
-## Run
-
-```sh
-unitrace [options] <application> [args]
-```
-
-The options can be one or more of the following:
-
-```
---call-logging [-c]                           Trace host API calls
---host-timing  [-h]                           Report host API execution time
---device-timing [-d]                          Report kernel execution time
---ccl-summary-report [-r]                     Report CCL execution time summary
---kernel-submission [-s]                      Report append (queued), submit and execute intervals for kernels
---device-timeline [-t]                        Report device timeline
---opencl                                      Trace OpenCL
---chrome-omp-logging                          Trace OpenMP
---chrome-mpi-logging                          Trace MPI
---chrome-syclrt-logging                       Trace SYCL runtime
---chrome-ur-logging                           Trace Unified Runtime (implementation layer beneath the SYCL runtime)
---chrome-sycl-logging                         Trace SYCL runtime and Unified Runtime (same as --chrome-syclrt-logging --chrome-ur-logging)
---chrome-ccl-logging                          Trace oneCCL
---chrome-dnn-logging                          Trace oneDNN
---chrome-call-logging                         Trace Level Zero and/or OpenCL host calls
---chrome-kernel-logging                       Trace device and host kernel activities
---chrome-device-logging                       Trace device activities
---chrome-itt-logging                          Trace activities in applications instrumented using Intel(R) Instrumentation and Tracing Technology APIs
---chrome-no-thread-on-device                  Trace device activities without per-thread info
-                                              Device activities are traced per thread if this option is not present
---chrome-no-engine-on-device                  Trace device activities without per-Level-Zero-engine-or-OpenCL-queue info.
-                                              Device activities are traced per Level-Zero engine or OpenCL queue if this option is not present
---chrome-event-buffer-size <number-of-events> Size of event buffer on host per host thread (default is -1 or unlimited)
---output-format <format>                      Timeline trace format: "json" (Chrome trace, default) or "protobuf" (Perfetto)
---verbose [-v]                                Enable verbose mode to show kernel shapes
-                                              Kernel shapes are always enabled in timelines for Level Zero backend
---demangle                                    Demangle kernel names. For OpenCL backend only. Kernel names are always demangled for Level Zero backend
---separate-tiles                              Trace each tile separately in case of implicit scaling
---tid                                         Output TID in host API trace
---pid                                         Output PID in host API and device activity trace
---output [-o] <filename>                      Output profiling result to file
---conditional-collection                      Enable conditional collection. This option is deprecated. Use --start-paused instead
---start-paused                                Start the tool with tracing and profiling paused
---output-dir-path <path>                      Output result to a flat directory
---result-dir <path>                           Output result to a hierarchical directory
---metric-query [-q]                           Query hardware metrics for each kernel instance (Level Zero only)
---metric-sampling [-k]                        Sample hardware performance metrics for each kernel instance in time-based mode
---group [-g] <metric-group>                   Hardware metric group (ComputeBasic by default)
---sampling-interval [-i] <interval>           Hardware performance metric sampling interval in us (default is 50 us) in time-based mode
---device-list                                 Print available devices
---metric-list                                 Print available metric groups and metrics
---metric-config <filename>                    Configuration file with metrics to collect
---gen-metric-config <filename>                Generate a metric configuration file template with all supported predefined and programmable metrics
---stall-sampling                              Sample hardware execution unit stalls. Valid for Intel(R) Data Center GPU Max Series and later GPUs
---ranks-to-sample <ranks>                     MPI ranks to sample. The argument <ranks> is a list of comma separated MPI ranks
---devices-to-sample <devices>                 Devices ID to sample. The argument <devices> is a list of comma separated devices as reported
-                                              by --device-list
---follow-child-process <0/1>                  0: Do not follow or profile child processes on Linux
-                                              1: Follow and profile child processes on Linux (default)
---teardown-on-signal <signum>                 Try to gracefully shut down in case the application crashes or is terminated or <signum> is raised
-                                              This option may change the application behavior so please use it carefully
---session <session>                           Name this session <session> for dynamic control. The argument <session> is an alphanumeric string
---pause <session>                             Pause session <session>. The argument <session> must be the same session named with --session option
---resume <session>                            Resume session <session>. The argument <session> must be the same session named with --session option
---stop <session>                              Stop session <session>. The argument <session> must be the same session named with --session option
---chrome-kmd-logging <script>                 Trace OS/KMD activities. The argument <script> file defines the OS kernel or device driver activities to trace
---include-kernels <kernel-filters>            Include kernels with names containing any of the kernel filter strings. The argument <kernel-filters> is a comma-separated list of strings
---include-kernels-file <kernel-filter-file>   Include kernels with names containing any of the kernel filter strings in the <kernel-filter-file>.
---exclude-kernels <kernel-filters>            Exclude kernels with names containing any of the kernel filter strings. The argument <kernel-filters> is a comma-separated list of strings
---exclude-kernels-file <kernel-filter-file>   Exclude kernels with names containing any of the kernel filter strings in the <kernel-filter-file>.
---chrome-kmd-logging <script>                 Trace OS/KMD activities. The argument <script> file defines the OS kernel or device driver activities to trace
---version                                     Print version
---help                                        Show this help message and exit. Please refer to the README.md file for further details.
-```
-
-By default, only Level Zero tracing/profiling is enabled. To enable OpenCL tracing and profiling, please use --opencl option.
-
-## View
-
-If one or more of the **--chrome-** options are used, a .json file, for example, **myapp.json** is generated (or a **.pftrace** file with **--output-format protobuf**; see [Output Format](#output-format)). You can run the **uniview.py** utility to view the data, assuming all required Python packages are installed:
-
-```sh
-python uniview.py -t <myapp.json>
-```
-
-This utility launches the default browser and loads **myapp.json** in **https://ui.perfetto.dev/**.
-
-![Host-Device Timelines!](/tools/unitrace/doc/images/host-device-times.png)
-
-If metric query (**--metric-query [-q]**) or metric sampling (**--metric-sampling [-k]**) or stall sampling (**--stall-sampling**) option is also enabled along with **--chrome-kernel-logging** or **--chrome-device-logging** option, you can view performance metrics of each kernel instance by selecting the kernel instance then following the metrics link in the **Arguments** in the browser.
-
-    ```sh
-     $ unitrace -k --chrome-kernel-logging -o perf.csv ./testapp
-     ... ...
-
-     [INFO] Log is stored in perf.1092793.csv
-     [INFO] Timeline is stored in testapp.1092793.json
-     [INFO] Device metrics are stored in perf.metrics.1092768.csv
-
-     $ python uniview.py -t testapp.1092793.json -m perf.metrics.1092768.csv -f metrics/config/PVC/ComputeBasic.txt
-    ```
-    
-![Performance Metrics Through Event Trace!](/tools/unitrace/doc/images/perfmetricstrace.png)
-    
-Once you click the link next to **metrics:** in the **"Arguments"**, another browser window is opened:
-
-![Performance Metrics Browser Window!](/tools/unitrace/doc/images/perfmetricsbrowser.png)
-
-In case of stall sampling, for example:
-
-    ```sh
-     $ unitrace --stall-sampling --chrome-kernel-logging -o perfstall.csv ./testapp
-    ```
-To view the source stall analysis report, pass the metrics file to **uniview.py**:
-
-    ```sh
-    python uniview.py -t testapp.1092793.json -m ./perfstall.metrics.564289.csv
-    ```
-
-![Stall Statistics!](/tools/unitrace/doc/images/stallstatistics.png)
-
-followed by source stall analysis report:
-
-![Stall Report!](/tools/unitrace/doc/images/stallreport.png)
-
-Please note that **-f <config>** is not needed for viewing stall sampling report.
-
-Only the top 10 most expensive stalls of each type are reported by default. You can change the number of top expensive stalls of each type to report using **-n** option, for example:
-
-    ```sh
-    python uniview.py -t testapp.1092793.json -m ./perfstall.metrics.564289.csv -n 5
-    ```
-
-If you just want to view only the .json trace, alternatively, you can open **https://ui.perfetto.dev/** in either Google Chrome or Microsoft Edge browser and load the .json file manually. **Do NOT use chrome://tracing/**! 
-
-#### Query Trace Events
-
-You can switch to SQL mode by typing ":" in the search box, write your SQL query statement(s) and then navigate to the events of interest from the query result, for example.
-
-![Query Trace Events!](/tools/unitrace/doc/images/event_query.png)
-
-Please refer to https://perfetto.dev/docs/ for more information.
-
-## Usages and Options
-
-### Host Level Zero and/or OpenCL Activities
-
-To trace/profile Level Zero and/or OpenCL host activities, you need one or more of the following options:
-
---call-logging [-c]
---host-timing  [-h]
---chrome-call-logging
-
-The **--call-logging [-c]** option traces Level Zero and/or OpenCL calls on the host:
-![Host Call Logging!](/tools/unitrace/doc/images/call-trace.png)
-
-The **--host-timing  [-h]** option outputs a Level Zero and/or OpenCL host call timing summary:
-![Host Call Timing!](/tools/unitrace/doc/images/host-timing.png)
-
-The **--chrome-call-logging** option generates a Level Zero and/or OpenCL host .json event trace that can be viewed in **https://ui.perfetto.dev/**:
-![Host Event Trace!](/tools/unitrace/doc/images/call-logging.png)
-
-
-### Device and Kernel Activities
-
-To trace/profile device and kernel activities, you need one or more of the following options:
-
---device-timing [-d]
---kernel-submission [-s]
---device-timeline [-t]
---chrome-kernel-logging
---chrome-device-logging
---chrome-no-thread-on-device
---chrome-no-engine-on-device
-
-The **--device-timing [-d]** option outputs a timing summary of kernels and commands executed on the device:
-
-![Device Timing With No Shape!](/tools/unitrace/doc/images/device-timing-with-no-shape.png)
-
-In addition, it also outputs kernel information that helps to identify kernel performance issues that relate to occupancy caused by shared local memory usage and register spilling.
-
-![Kernel Info With No Shape!](/tools/unitrace/doc/images/kernel-info-with-no-shape.png)
-
-Here, the **"SLM Per Work Group"** shows the amount of shared local memory needed for each work group in bytes. This size can potentially affect occupancy.
-
-The **"Private Memory Per Thread"** is the private memory allocated for each thread in bytes. A non-zero value indicates that one or more thread private variables are not in registers.
-
-The **"Spill Memory Per Thread"** is the memory used for register spilled for each thread in bytes. A non-zero value indicates that one or more thread private variables are allocated in registers but are later spilled to memory.
-
-The **"Register File Size Per Thread"** is the number of registers available to each thread. In case the Level Zero runtime is not up-to-date, this column may be shown as **"unknown"**.
-
-In addition, the **"Compiled"** indicates the kernel compilation mode: just-in-time(JIT) or ahead-of-time(AOT).
-
-By default, the kernel timing is summarized regardless of shapes. In case the kernel has different shapes, using **-v** along with **-d** is strongly recommended:
-
-![Device Timing!](/tools/unitrace/doc/images/device-timing.png)
-
-![Kernel Info!](/tools/unitrace/doc/images/kernel-info.png)
-
-The **--kernel-submission [-s]** option outputs a time summary of kernels spent in queuing, submission and execution:
-![Kernel Submissions!](/tools/unitrace/doc/images/kernel-submissions.png)
-
-The **--device-timeline [-t]** option outputs timestamps of each kernel instance queuing, submission and execution start and execution end in text format while the application is running.
-
-![Device Timeline Text!](/tools/unitrace/doc/images/device-timeline-text.png)
-
-Both **--chrome-kernel-logging** and **--chrome-device-logging** create device event trace and store it in a .json file. However, **--chrome-kernel-logging** also traces host-device interactions and dependencies in addition to device events.
-
-Kernel Loggging:
-
-![Kernel Logging!](/tools/unitrace/doc/images/kernel-logging.png)
-
-Device Logging:
-
-![Device Logging!](/tools/unitrace/doc/images/device-logging.png)
-
-In case both **--chrome-kernel-logging** and **--chrome-device-logging** are present, **--chrome-kernel-logging** takes precedence.
-
-### Output Format
-
-By default the timeline trace is written as a Chrome JSON file (**chrome_trace.json** / **\<app\>.\<pid\>.json**). Use **--output-format protobuf** to emit a Perfetto protobuf trace (**.pftrace**) instead:
-
-```
-unitrace --output-format protobuf --chrome-kernel-logging <application>
-```
-
-Both formats load in **https://ui.perfetto.dev/**, and **uniview.py -t \<file\>** works with either extension. To convert a protobuf trace to JSON for tooling that still expects JSON, use Perfetto's **traceconv** (https://perfetto.dev/docs/quickstart/traceconv):
-
-```
-traceconv json <trace>.pftrace <trace>.json
-```
-
-> [!NOTE]
-> **--output-format protobuf** requires unitrace built with Perfetto support (**BUILD_WITH_PERFETTO=ON**, the default). If protobuf support is unavailable, the output falls back to JSON.
-
-### Include and Exclude Kernels
-
-If you care about the performance of just a subset of kernels in an application, for example, kernels you are currently developing or optimizing, you can use the kernel inclusion and/or exclusion options **--include-kernels**, **--exclude-kernels**, **--include-kernels-file** and **--exclude-kernels-file** to instruct unitrace to profile and trace only the kernels of interest, reducing performance overhead and improving analysis efficiency.
-
-**Examples:**
-
-- include only kernels with names containing `matmul` or `conv`:
-  ```
-  --include-kernels matmul,conv
-  ```
-- exclude all kernels with names containing `test` or `debug`:
-  ```
-  --exclude-kernels test,debug
-  ```
-
-If both **--include-kernels** and **--exclude-kernels** are specified, **--include-kernels** takes precedence, in other words, the kernels excluded are excluded from the kernels included.
-
-If a kernel is excluded from tracing, its execution time is not counted in the total device time.
-
-### Specifying Kernel Names Containing Commas
-
-If a kernel name contains a comma, wrap the name in double quotes to prevent the comma from being treated as a separator. This applies to both `--include-kernels` and `--exclude-kernels` options.
-
-**Example:**
-```
---exclude-kernels "foo,\"bar,with,comma\",baz"
-```
-This will exclude kernels with names containing `foo`, `bar,with,comma`, and `baz`.
-
-You can also use this syntax in files passed to `--include-kernels-file` or `--exclude-kernels-file`.
-
-### Toggling Device Thread, Level-Zero Engine and OpenCL Queue Collection On/Off
-
-By default, device activities are profiled per thread, per Level-Zero engine and per OpenCL queue (if OpenCL profiling is enabled):
-
-![Device Activities Per Thread and Per Level-Zero Engine and Per OpenCL Queue!](/tools/unitrace/doc/images/device-per-thread-per-engine.png)
-
-This can potentially take a lot of screen space if a lot of threads use the device and/or multiple Level-Zero engines and/or OpenCL queues are utilized when the trace is viewed in a browser.
-
-You can use **--chrome-no-thread-on-device** to suppress thread data:
-
-![Device Activities Per Level-Zero Engine and Per OpenCL Queue!](/tools/unitrace/doc/images/device-per-engine.png)
-
-or **--chrome-no-engine-on-device** to suppress engine and/or queue data:
-
-![Device Activities Per Thread!](/tools/unitrace/doc/images/device-per-thread.png)
-
-or both to suppress thread and engine and/or queue data at the same time:
-
-![Device Activities!](/tools/unitrace/doc/images/device-no-thread-no-engine.png)
-
-### Tile Activities in Implicit Scaling
-
-In case of implicit scaling, the hardware partitions the load of each kernel and distributes portions to each tile. By default, the tool treats the whole device as a unit. To trace activities on each tile separately, you need to use **--separate-tiles** together with **--chrome-kernel-logging/--chrome-device-logging** options:
-
-![Tile Activities Logging!](/tools/unitrace/doc/images/implicit-per-tile-kernel-logging.png)
-
-or with **--device-timing [-d]** option:
-
-![Tile Activities Timing!](/tools/unitrace/doc/images/implicit-per-tile-timing.png)
-
-### Trace and Profile Layers above Level Zero/OpenCL
-
-The **--chrome-mpi-logging** traces MPI activities
-
-![MPI Logging!](/tools/unitrace/doc/images/mpi-logging.png)
-
-The **--chrome-syclrt-logging** traces SYCL runtime activities.
-
-The **--chrome-ur-logging** traces Unified Runtime (UR) activities. Unified Runtime is the implementation layer beneath the SYCL runtime (the modern successor to the SYCL Plugin Interface), so this option is primarily useful for Intel GPU software stack developers.
-
-The **--chrome-sycl-logging** traces both SYCL runtime and Unified Runtime activities. It is kept for backward compatibility and is equivalent to passing both **--chrome-syclrt-logging** and **--chrome-ur-logging**.
-
-![SYCL Logging!](/tools/unitrace/doc/images/sycl-logging.png)
-
-The **--chrome-ccl-logging** traces CCL runtime activities
-![CCL Logging!](/tools/unitrace/doc/images/ccl_logging.png)
-
-Similarly, one can use **--chrome-dnn-logging** for oneDNN.
-
-The **--chrome-itt-logging** traces activities in applications instrumented using Intel(R) Instrumentation and Tracing Technology APIs
-
-![ITT logging!](/tools/unitrace/doc/images/chrome_itt_logging.png)
-
-The **--ccl-summary-report  [-r]** option outputs CCL call timing summary:
-![CCL Call Timing!](/tools/unitrace/doc/images/ccl_summary_report.png)
-
-If the application is a PyTorch workload, one or more options from **--chrome-mpi-logging**, **--chrome-ccl-logging** and **--chrome-dnn-logging** also enable PyTorch profiling (see [Profile PyTorch](#profile-pytorch) for more information).
-
-### Trace Operating System Kernel and/or Device Driver Activities (Linux)
-
-To trace operating system kernel and/or device driver activities, you must have root access and a [bpftrace](https://bpftrace.org) script as the argument to option **--chrome-kmd-logging**. The [script](/tools/unitrace/examples/kmdprobes/probes.bt) is a simple example.
-
-The trace data for each operating system and/or GPU device driver event or function collected using bpftrace should be in the format of
-
-**tid,event,timestamp,duration[,data]**
-
-The **tid** is the kernel thread identifier; the **event** is the name of the event or function; the **timestamp** is the starting time of the event or function and the **duration** is the time duration of the event or function.
-
-The **data** is optional. If it is present, it will be treated as a string argument of the **event** in the trace file. As an example, the [script](/tools/unitrace/examples/kmdprobes/probes_extra.bt) shows extra timestamp data of a probe.
-
-The trace is stored in file **oskmd.json**.
-
-The **--chrome-kmd-logging** can be used together with other options, for example, **--chrome-kernel-logging**, to trace user space and kernel space events at the same time, for example:
-
-    ```sh
-     $ unitrace --chrome-kmd-logging probes.bt --chrome-kernel-logging ./testapp
-     ... ...
-
-     [INFO] Timeline is stored in testapp.1092793.json
-     [INFO] KMD profiling data are stored in oskmd.json
-    ```
-
-To view events in both the user space and kernel space, you need to merge them into a single trace: 
-
-    ```sh
-     python mergetrace.py -o output.json testapp.1092793.json oskmd.json
-    ```
- 
-![KMD Logging!](/tools/unitrace/doc/images/kmd-logging.png)
-
-### Location of Output
-
-By default, the host and device profile data are printed to the standard output, and if one or more of **--chrome-** options are present, the tracing data is written to a .json file in the current working directory.
-
-Following flags can be used to control output destination:
-
-#### Redirect Standard Output to File (--output or -o)
-You can use the **--output [-o]** option to redirect the profiling data output to a file instead of the standard output, for example:
-```sh
-unitrace -d -o myapp_device_timing myapp
-```
-The device timing summary is written to file **myapp_device_timing.<pid>** instead of the standard output.
-
-#### Output .JSON Tracing Data to A Flat Directory (--output-dir-path)
-You can use the **--output-dir-path** option to specify a directory for the .json output file, for example:
-
-```sh
-unitrace --chrome-kernel-logging --output-dir-path /tmp/unitrace-result myapp
-```
-
-The output .json trace file is written to **/tmp/unitrace-result** instead of the current working directory.
-
-#### Output All Result Data to A Hierarchical Directory (--result-dir)
-The **--result-dir** option creates a new directory if it does not exist and stores all profiling data files in the directory in a hierarchical manner.
-
-> [!NOTE]
-> If the given directory already exists and the directory is not empty, the new output files will be mixed with the existing files. To avoid this, please specify a new directory or make sure the exisitng directory is empty.
-
-The output files are organized in a hierarchical manner with a sub-directory for each unitrace launcher and a sub-directory for each application process. The sub-directory is named with the pattern of **\<appname\>.\<pid\>**. For example, if the application name is **myapp** and the process id is 12345, the sub-directory is **myapp.12345**. This layout ensures that the output files are well organized and not mixed up.
-
-> [!NOTE]
-> The sub-directoy name may have a prefix of "rank_\<rank\>." if the application is an MPI application, where \<rank\> is the MPI rank number. For example, if the process with pid 12345 is rank 0, the sub-directory name is **rank_0.myapp.12345**.
-
-
-Different profiling data is stored in different files. The table below shows the file name corresponding to the command line option(s):
-
-| Options | File Name |
-|---------------------|-----------|
-| --chrome-*-logging (except --chrome-kmd-logging) | chrome_trace.json (or chrome_trace.pftrace with --output-format protobuf) |
-| -h | host_timing.txt |
-| -d | device_timing.txt |
-| -s | device_submission.txt |
-| -c | call_logging.txt |
-| --ccl-summary-report | ccl_summary_report.txt |
-| -t | device_timeline.txt |
-| -k/-q/--stall-sampling | metrics_<device_id>.csv |
-| --chrome-kmd-logging | oskmd.json |
-
-> [!NOTE]
-> Metrics data files are stored under the application's process sub-directoy when query mode metric profiling is used, and under the unitrace launcher sub-directory when time-based or stall sampling mode metric profiling is used.
-
-A metadata file is created under the unitrace launcher sub-directory with the name **run_config.json**, this file contains the configuration of the unitrace run, including the options used and the command line of the application.
-
-> [!NOTE]
-> The **--result-dir** option cannot be used together with **--output-dir-path** or **--output** option.
-
-### Hardware Performance Metrics
-
-Hardware performance metric counter can be profiled at the same time while host/device activities are profiled in the same run or they can be done in separate runs.
-
-Please note that device timing is also enabled if hardware performance metric counter profiling is enabled. The device timing information guides you to the hot kernels so you know which kernel's performance counters are of most interest.
-
-Please also note that FLAT device hierarchy is required for hardware metric profiling.
-
-#### Selecting Metrics to Profile
-The hardware performance metrics to profile can be selected by using the **--group [-g]** option to specify a predefined metric group or by using the **--metric-config** option to specify a custom metric configuration file with the metrics to profile. The predefined metric groups and the metrics in each group can be listed by **--metric-list** option.
-
-See [Metric Config File Format](#metric-config-file-format) for details on how to create a custom metric configuration file.
-When neither **--group [-g]** nor **--metric-config** is specified, the default metric group **ComputeBasic** is used.
-
-#### Query Metrics for Each Kernel Instance
-
-The **--metric-query [-q]** option enables metric query for each kernel instance.
-
-   ```sh
-   unitrace -q -o perfquery.csv myapp
-   ```
-Performance metrics data are stored in **perfquery.\<pid\>.csv** file.
-
-![Metric Query!](/tools/unitrace/doc/images/metric-query.png)
-
-The metrics file holds one section per kernel instance. Each section has two subsections: a subsection of the kernel's name with shape and its global instance id followed by a subsection of the metric data:
-
-```sh
-Kernel, GlobalInstanceId
-"GEMM[SIMD32 {8192; 1; 1} {128; 1; 1}]", 4
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], XVE_ACTIVE[%], XVE_STALL[%]
-41360937, 74196135, 1793, 82.172699, 17.319138
-
-Kernel, GlobalInstanceId
-"GEMM[SIMD32 {8192; 1; 1} {128; 1; 1}]", 5
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], XVE_ACTIVE[%], XVE_STALL[%]
-41425831, 74306291, 1794, 82.201385, 17.290176
-```
-
-The **GlobalInstanceId** uniquely identifies a kernel dispatch on a device in the process.
-
-By default, counters in **ComputeBasic** metric group are profiled. You can use the **--group [-g]** option to specify a different group. All available metric groups can be listed by **--metric-list** option.
-
-#### Sample Metrics in Time-based Mode
-
-Different from the **--metric-query [-q]** option, the **--metric-sampling [-k]** option profiles hardware metrics in time-based sampling mode.
-
-   ```sh
-   unitrace -k -o perfmetrics.csv myapp
-   ```
-Performance metrics data are stored in **perfmetrics.\<pid\>.csv** file.
-
-![Metric Sampling!](/tools/unitrace/doc/images/metric-sampling.png)
-
-The metrics file has the same format as the **--metric-query [-q]** file, one section per kernel instance:
-
-```sh
-Kernel, GlobalInstanceId
-"GEMM[SIMD32 {2; 2048; 1} {1024; 1; 1}]", 1
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], XVE_ACTIVE[%], XVE_STALL[%]
-26666, 31998, 1199, 99.906242, 0.000000
-26666, 31998, 1199, 90.833801, 0.000000
-26666, 31998, 1199, 0.000000, 0.000000
-```
-
-For kernels that take a short time, you may find that the default sampling rate is not high enough and the sampling rate or the sampling interval needs to be adjusted using **--sampling-interval [-i]** option, for example:
-
-   ```sh
-   unitrace -k -i 20 -o perfmetrics.csv myapp
-   ```
-
-By default, counters in **ComputeBasic** metric group are profiled. You can use the **--group [-g]** option to specify a different group. All available metric groups can be listed by **--metric-list** option.
-
-The **--metric-sampling [-k]** option alone samples all devices, but it can be used together with the **--devices-to-sample** option to sample only specific devices. The devices are given in a comma-separated list of integer identifiers as reported by **--device-list**. Those identifiers that do not match actual devices will be ignored. In the event that no valid or existent device is specified, no sampling will be performed at all.
-
-#### Sample Stalls at Instruction Level
-
-The **--stall-sampling** option works on Intel(R) Data Center GPU Max Series and later products.
-
-The metrics file holds one section per kernel. Each section has two subsections: a subsection of the kernel's name, the pid of the process and its kernel id, followed by a subsection of the stall data with one row per sampled instruction:
-
-```sh
-Kernel,Pid,KernelId
-"GEMM",3315113,120
-Source,Offset,Instruction,Dependency,Active[Events],ControlStall[Events],SbidStall[Events]
-"gemm.cl:12",0x00000080,"(W) and (1|M0) r127.0<1>:ud r0.0<0;1,0>:ud 0xFFFFFFC0:ud {$0.src}","NA",0,2,0
-"gemm.cl:17:41",0x000001b8,"(W) macl (1|M0) r22.0<1>:d r3.8<0;1,0>:d r4.4<0;1,0>:d {Compacted}","0x000001a8 (gemm.cl:17:34): (W) mul (1|M0) acc0.0<1>:d r3.8<0;1,0>:d r4.8<0;1,0>:uw {I@1}",4,0,3
-```
-
-| Column | Meaning |
-|--------|---------|
-| Source | Source location of the instruction, as `<file>:<line>[:<column>]`, or `NA` where the module carries no line information |
-| Offset | Offset of the instruction from the start of the kernel's code |
-| Instruction | The instruction the sample landed on, or `unknown` where the kernel could not be disassembled |
-| Dependency | The instructions the stalled instruction depends on, each as `<offset>[ (<source>)][: <instruction>]` and joined by ` \| `, or `NA` where none is known |
-| the rest | One column per stall type, counting the sampled events of that type at this instruction. `Active[Events]` counts executing rather than stalling |
-
-For kernels that take a short time, you may find that the default sampling rate is not high enough and the sampling rate or the sampling interval needs to be adjusted using **--sampling-interval [-i]** option.
-
-#### Sample Metrics of MPI Ranks
-
-If the workload is an MPI application, sampling multiple ranks running on the same node with **-k** or **--stall-sampling** is usually unnecessary. You can use option **--ranks-to-sample** to specify which rank/ranks to sample. If the workload has 8 ranks running on 2 nodes with 4 ranks each, for example, you can sample rank #0 on one node and rank #4 on the other node:
-
-   ```sh
-   mpiexec -n 8 -ppn 4 unitrace -k -o perfmetrics.csv --ranks-to-sample 0,4 <app>
-   ```
-
-#### Metric Config File Format
-
-The file given to **--metric-config** is a plain-text file that selects the hardware metrics to collect. It can select a **predefined** metric group (the same groups as **--group [-g]** and **--metric-list**), or **programmable** metrics, which are created from metric templates with the parameter values you choose. A complete example is in [metric_config.txt](/tools/unitrace/examples/metricconfig/metric_config.txt), and **--gen-metric-config** writes a template with everything your device supports (see [Generate a Metric Config File Template](#generate-a-metric-config-file-template)).
-
-##### Syntax
-
-The file is line-based, with one item per line:
-
-| Line | Meaning |
-| ---- | ------- |
-| `<name>{` | Opens a node named **<name>**. Nodes nest. |
-| `}` | Closes the innermost open node. |
-| `<key>=<value>` | Sets an attribute of the innermost open node. Spaces around **=** are ignored. |
-| `# text` | Comment. Text from **#** to the end of the line is ignored, also after a value. |
-| (empty) | Ignored. |
-
-Names and keys cannot be empty and cannot contain spaces or any of **{ } = # ' [ ]**. A value is one of:
-
-| Value | Example | Notes |
-| ----- | ------- | ----- |
-| Boolean | `true`, `false` | |
-| Unsigned integer | `2` | Decimal digits only. |
-| Decimal number | `0.5` | Any value containing **.** |
-| Range list | `[0,1,2,10:19]`, `[0:16:4]` | Comma-separated items: **v** (one value), **first:last** (every value in between) or **first:last:step**. Items must be ascending and must not overlap. **[0:9:4]** is 0, 4 and 8. |
-
-##### Structure
-
-```txt
-predefined{                      # optional, at most once
-    <group name>{                # a predefined metric group, as listed by --metric-list
-        enable=<true|false>      # optional, false if missing
-    }
-    ...
-}
-programmable{                    # optional, at most once
-    <programmable name>{         # a programmable metric, as listed by --gen-metric-config
-        enable=<true|false>      # optional, false if missing
-        parameters{              # optional; parameters not listed keep their default value
-            <parameter>=<value>
-            ...
-        }
-    }
-    ...
-}
-```
-
-* At least one of **predefined** and **programmable** must be present, and each name can appear only once in its node.
-* Only entries with **enable=true** are collected.
-* Only one metric group can be collected in a run. Enable either exactly one predefined group, or any number of programmable metrics, which are collected together as one group. A group given with **--group [-g]** counts as well, so **-g** is normally not combined with **--metric-config**. Entries a device does not support are skipped (see [Validation](#validation)), so the rule applies to what is left on each device. If the driver cannot fit all enabled programmable metrics into one group, because they need conflicting hardware resources, the run fails as well; enable fewer metrics.
-* A parameter value must match the type of the parameter: an unsigned integer for integer parameters, a decimal number (or an integer) for decimal parameters, and **true**/**false** for boolean parameters.
-* A parameter value must be one of the valid values of the parameter on the device. The template lists them in a **# Valid values:** comment, e.g. **0:11,16:31** means 0 to 11 and 16 to 31. If the device reports no valid values for a parameter, the value is passed to the driver, which checks it.
-* At most one parameter of a programmable metric can be a range list. The metric is created once for every value in the list, so **Disaggregation=[0:3]** creates the metrics of XeCore 0, 1, 2 and 3.
-
-The examples below use the names and valid values of an Intel(R) Arc(TM) B-Series GPU (BMG G31, device ID 0xE221). Other GPUs, and even other boards of the same model (the available XeCores differ), can differ: use **--gen-metric-config** to get the list for your device.
-
-Example selecting a predefined metric group:
-
-```txt
-predefined{
-    ComputeBasic{
-        # Supported sampling types: event_based,time_based
-        enable=true
-    }
-    MemoryProfile{
-        # Supported sampling types: event_based,time_based
-        enable=false
-    }
-}
-```
-
-Only **ComputeBasic** is collected. The **# Supported sampling types** comment written by **--gen-metric-config** tells whether the group can be used with **--metric-query [-q]** (event_based) and/or **--metric-sampling [-k]** (time_based).
-
-Example selecting programmable metrics:
-
-```txt
-programmable{
-    XVE_INST_EXECUTED_SEND_ALL{
-        # Supported sampling types: event_based,time_based
-        enable=true
-        parameters{
-            # Valid values: 0:11,16:31
-            Disaggregation=2
-            # Valid values: 1
-            Normalization_average=1
-        }
-    }
-    XVE_INST_EXECUTED_CONTROL_ALL{
-        # Supported sampling types: event_based,time_based
-        enable=false
-        parameters{
-            # Valid values: 0:11,16:31
-            Disaggregation=[0,1,2,16:19]
-            # Valid values: 1
-            Normalization_average=1
-        }
-    }
-}
-```
-
-The first programmable metric selects normalized average disaggregation for XeCore 2 and produces the metric XVE_INST_EXECUTED_SEND_ALL_XECORE2_AVERAGE.
-The second one is not enabled. If it were, it would select XeCore 0, 1, 2 and 16 to 19, and produce XVE_INST_EXECUTED_CONTROL_ALL_XECORE0_AVERAGE, XVE_INST_EXECUTED_CONTROL_ALL_XECORE1_AVERAGE, XVE_INST_EXECUTED_CONTROL_ALL_XECORE2_AVERAGE, XVE_INST_EXECUTED_CONTROL_ALL_XECORE16_AVERAGE, ..., XVE_INST_EXECUTED_CONTROL_ALL_XECORE19_AVERAGE.
-
-##### Validation
-
-The file is checked before the application starts. If it is invalid, unitrace prints the file name, the line and the reason, and exits with a non-zero status without running the application, for example:
-
-```sh
-$ unitrace -k --metric-config my_metrics.txt ./testapp
-[ERROR] Invalid metric configuration file: my_metrics.txt:7: invalid range list '[0:5,3]' for 'Disaggregation' (expected e.g. [0,2,4:8] or [0:16:4], ascending and not overlapping)
-```
-
-The checks before the application starts cover the syntax and the structure described above: unknown or duplicate nodes, unknown attributes, an **enable** that is not **true**/**false**, unsupported parameter values (strings or negative integers), more than one range list in a metric, and a file in which nothing is enabled (unless a group is given with **--group [-g]**).
-
-When the metric groups are created on each device, unitrace also checks that every parameter exists and that every parameter value is valid on the device, and reports the parameter and the value otherwise. A predefined group or programmable metric that does not exist on a device, or does not support the sampling type of the run, is skipped with a warning, so one file can be used on different devices. Then exactly one metric group must be left: if nothing is left, or more than one group is, unitrace reports an error naming the groups.
-
-##### Generate a Metric Config File Template
-
-Use the **--gen-metric-config <filename>** option to generate a metric configuration file template with all supported predefined and programmable metrics. You can then edit the generated file to enable the desired metrics for collection.
-
-If the device has more than one programmable metric with the same name but different parameters, the template names the additional ones **<name>_<id>**. Such names are valid only for the unitrace build that generated the template.
-
-#### Analyze Performance Metrics
-
-Once you have the hardware performance metrics data collected, you can use **uniview.py** to analyze and view the metrics if **--chrome-kernel-logging** or **--chrome-device-logging** was used (see [View](#view)). Alternatively, you can use the script **scripts/metrics/analyzeperfmetrics.py** to view and analyze the metrics with more flexibility and control. Plus, this script allows you to analyze and view performance metrics in case that **--chrome-kernel-logging** or **--chrome-device-logging** was absent. This section focuses on the usage of this script.
-
-##### List Contents of the Metric Data File
-
-The first step is to inspect the contents of the metric data file using **-l** or **--list** option. 
-
-   ```sh
-   python analyzeperfmetrics.py -l perfmetrics.12345.csv
-   ```
-
-This shows the device, metrics and kernels profiled:
-
-```sh
-Device 0
-    Metric
-        GpuTime[ns]
-        GpuCoreClocks[cycles]
-        AvgGpuCoreFrequencyMHz[MHz]
-        GpuSliceClocksCount[events]
-        AvgGpuSliceFrequencyMHz[MHz]
-        L3_BYTE_READ[bytes]
-        L3_BYTE_WRITE[bytes]
-        GPU_MEMORY_BYTE_READ[bytes]
-        GPU_MEMORY_BYTE_WRITE[bytes]
-        XVE_ACTIVE[%]
-        XVE_STALL[%]
-        XVE_BUSY[events]
-        XVE_THREADS_OCCUPANCY_ALL[%]
-        XVE_COMPUTE_THREAD_COUNT[threads]
-        XVE_ATOMIC_ACCESS_COUNT[messages]
-        XVE_BARRIER_MESSAGE_COUNT[messages]
-        XVE_INST_EXECUTED_ALU0_ALL[events]
-        XVE_INST_EXECUTED_ALU1_ALL[events]
-        XVE_INST_EXECUTED_XMX_ALL[events]
-        XVE_INST_EXECUTED_SEND_ALL[events]
-        XVE_INST_EXECUTED_CONTROL_ALL[events]
-        XVE_PIPE_ALU0_AND_ALU1_ACTIVE[%]
-        XVE_PIPE_ALU0_AND_XMX_ACTIVE[%]
-        XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%]
-        XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%]
-        XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%]
-        XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%]
-        XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]
-        QueryBeginTime[ns]
-        CoreFrequencyMHz[MHz]
-        XveSliceFrequencyMHz[MHz]
-        ReportReason
-        ContextIdValid
-        ContextId
-        SourceId
-        StreamMarker
-    Kernel, Number of Instances
-        "main::{lambda(auto:1)#1}[SIMD32 {8192; 1; 1} {128; 1; 1}]", 1
-        "main::{lambda(auto:1)#2}[SIMD32 {8192; 1; 1} {128; 1; 1}]", 1
-        "main::{lambda(auto:1)#3}[SIMD32 {8192; 1; 1} {128; 1; 1}]", 1
-        "main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]", 5
-        "main::{lambda(auto:1)#5}[SIMD32 {4096; 1; 1} {256; 1; 1}]", 5
-        "main::{lambda(auto:1)#6}[SIMD32 {4096; 1; 1} {256; 1; 1}]", 5
-        "main::{lambda(auto:1)#7}[SIMD32 {2048; 1; 1} {512; 1; 1}]", 5
-```
-
-The **Device** is the device on which the metrics are sampled. In this example output, the device is 0. If multiple devices are used and sampled, multiple sections of **Device** will be present.
-
-The **Metric** section shows the metrics collected on the device, and the **Kernel, Number of Instances** section lists each kernel with its number of sampled instances. An instance is one kernel execution sampled on the device. For example, the kernel "main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]" having 5 instances means the 5 executions of the kernel are sampled. Please note that the number of instances of a kernel here may be less than the total number of executions or submissions of the kernel in the application, especially when the kernel is short and/or sampling interval is large.
-
-The number of instances is not applicable to stall sampling metric data:
-
-```sh
-Device 0
-    Metric
-        Active[Events]
-        ControlStall[Events]
-        PipeStall[Events]
-        SendStall[Events]
-        DistStall[Events]
-        SbidStall[Events]
-        SyncStall[Events]
-        InstrFetchStall[Events]
-        OtherStall[Events]
-    Kernel
-        "main::{lambda(auto:1)#1}"
-        "main::{lambda(auto:1)#2}"
-        "main::{lambda(auto:1)#3}"
-        "main::{lambda(auto:1)#5}"
-        "main::{lambda(auto:1)#6}"
-        "main::{lambda(auto:1)#7}"
-        "main::{lambda(auto:1)#4}"
-```
-
-You can also use the **-o** option to redirect the output to a text file for later reference:
-
-   ```sh
-   python analyzeperfmetrics.py -l -o contents.txt perfmetrics.12345.csv
-   ```
-
-##### Analyze Kernel Performance Metrics
-
-Once you have the knowledge of the device, the metrics and the kernels in the metric data file, you can run the same script to analyze specific performance metrics of a specific instance of a specific kernel, all instances of a specific kernel or all instances of all kernels executed on a specific device. The performance chart will be stored in a PDF file. 
-
-   ```sh
-   python analyzeperfmetrics.py -d 0 -k "main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]" -i 2 -m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "Utilization and Stall (%)" -t "Utilization and Stall" -o perfchart.pdf perfmetrics.12345.csv
-   ```
-
-This command plots a chart of XVE stall and function unit utilizations for the **second** instance of kernel **"main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]"** profiled on device **0** and stores the chart in file **perfchart.pdf**.
-
-![Analyze Kernel Performance Metrics!](/tools/unitrace/doc/images/perfchart.png)
-
-If the instance is 0, all 5 instances of the kernel **"main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]"** are analyzed.
-
-   ```sh
-   python analyzeperfmetrics.py -d 0 -k "main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]" -i 0 -m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "Utilization and Stall (%)" -t "Utilization and Stall" -o perfchart.pdf perfmetrics.12345.csv
-
-   ```
-
-If **-k** option is not present and instance is 0, all instances of all kernels are analyzed.
-
-   ```sh
-   python analyzeperfmetrics.py -d 0 -i 0 -m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "Utilization and Stall (%)" -t "Utilization and Stall" -o perfchart.pdf perfmetrics.12345.csv
-
-   ```
-
-The **-m** option can be repeated multiple times to analyze multiple sets of metrics at the same time, for example:
-
-   ```sh
-   python analyzeperfmetrics.py -d 0 -k "main::{lambda(auto:1)#4}[SIMD32 {4096; 1; 1} {256; 1; 1}]" -i 2 -m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "Utilization and Stall (%)" -m "L3_BYTE_READ[bytes],L3_BYTE_WRITE[bytes]" -y "L3 Cache Read/Write (bytes)" -o perfchart.pdf perfmetrics.12345.csv
-   ```
-
-![Analyze Multiple Performance Metric Sets!](/tools/unitrace/doc/images/perfchart-multi-sets.png)
-
-Instead of typing the command options in every run, you can store the options in a text configuration file and use the **-f** or **--config** option to read the options from the file. For example, the command options above can be stored in a **myconfig.txt**:
-
-   ```sh
-   python analyzeperfmetrics.py -f myconfig.txt -o perfchart.pdf perfmetrics.12345.csv
-   ```
-
-Please note that the input file cannot be present in the command option configuration file.
-
-You can also use the **-b** option together with one or more **-m** options to get throughput data.
-
-![Analyze Multiple Performance Metric Sets and Throughputs!](/tools/unitrace/doc/images/throughput.png)
-
-If the input metric data file has stall sampling events collected using **--stall-sampling** option, the chart generated shows stall events and instruction offsets.
-
-![Analyze Stall Metrics!](/tools/unitrace/doc/images/stallchart.png)
-
-From this chart, we can easily see that the most stalls are **SbidStalls** at instruction **0x000001b8**. To reduce or eliminate the stalls, we need to analyze the stalls at instruction level to find out the cause of the stalls.
-
-###### Use Pre-configured Options #####
-
-A pre-configured option file **metrics/config/ComputeBasic.txt** for **ComputeBasic** (the default metric group) on PVC is provided. You can use it as it is:
-
-   ```sh
-   python analyzeperfmetrics.py -f config/pvc/ComputeBasic.txt -o perfchart.pdf perfmetrics.12345.csv
-   ```
-
-Or you can customize it to create your own recipes. 
-
-You may also want to create configurations for other metric groups and/or devices.
-
-##### Analyze Stalls at Instruction Level
-
-Stalls are pinpointed to exact instructions without any extra setup. If you want to pinpoint to the source lines and source files as well, use the compiler option **-g**, for example:
-
-    ```sh
-    icpx -fsycl -g -O2 -o mytest mytest.cpp
-    ````
-
-Note that specifying **-g** may lower the default optimization level to **-O0**, so also specify the desired optimization level, for example **-O2**.
-
-After you run unitrace using **--stall-sampling**, you can run the same script to analyze stalls:
-
-    ```sh
-     python analyzeperfmetrics.py -k "main::{lambda(auto:1)#3}" -o stallchart.pdf ./stallmetrics.56789.csv
-    ```
-
-In addition to the stall statistics chart, a stall analysis report is also generated. The report shows not only the instruction and the location (instruction offset, and source file and line if available) of each stall, but also the instruction and the location if available that causes the stall.
-
-The stall analysis report can also be stored in a text file if you prefer:
-
-
-    ```sh
-     python analyzeperfmetrics.py -k "main::{lambda(auto:1)#3}" -o stallchart.pdf -r stallreport.txt ./stallmetrics.56789.csv
-    ```
-
-##### View Kernel Performance Metrics in a Browser
-
-If you use **-k** or **-q** or **--stall-sampling** option together with **--chrome-kernel-logging** or **--chrome-device-logging** option, you can use **analyzeperfmetrics.py** to view metrics in a browser.  
-    
-    ```sh
-     $ unitrace -k --chrome-kernel-logging -o perf.csv ./testapp
-     ... ...
-
-     [INFO] Log is stored in perf.1092793.csv
-     [INFO] Timeline is stored in testapp.1092793.json
-     [INFO] Device metrics are stored in perf.metrics.1092768.csv
-    ```
-
-The performance metrics are stored in file **perf.metrics.1092768.csv** and the event trace is stored in the .json file. 
-
-Run **analyzeperfmetrics.py** in a shell window with **-q** option, for example:
-
-    ```sh
-     $ python analyzeperfmetrics.py -q -m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],
-     XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "Stall and Utilizations" -t "Stall and Utilizations" ./perf.metrics.1092768.csv
-    ```
-
-The **-q** option starts a http server.
-
-If you have a .json file that contains https links generated using earlier versions of the tool, please use **-p** instead of **-q**. In this case, if no certificate and private key are provided, a self-signed certificate and private key will be generated and used.
-    
-Now load the event trace .json file into https://ui.perfetto.dev:
-
-![Performance Metrics Through Event Trace!](/tools/unitrace/doc/images/perfmetricstrace.png)
-    
-Once you click the link next to **metrics:** in the **"Arguments"**, another browser window is opened:
-
-![Performance Metrics Browser Window!](/tools/unitrace/doc/images/perfmetricsbrowser.png)
-
-The metrics shown in the browser are the metrics passed to the **-m** option when you start **analyzeperfmetrics.py**. If you stop and restart **analyzeperfmetrics.py** with a different set of metrics passed to **-m** option, for example:
-
-    ```sh
-     $ python analyzeperfmetrics.py -p -m "L3_BYTE_READ[bytes],L3_BYTE_WRITE[bytes]" -y "Bytes" -t "L3 Traffic" ./grfbasic.metrics.1092768.csv
-    ```
-
-Refreshing the same link will show the new metrics:
-
-![Performance Metrics Browser Window #2!](/tools/unitrace/doc/images/perfmetricsbrowser2.png)
-
-In case of stall sampling, for example:
-
-    ```sh
-     $ unitrace --stall-sampling --chrome-kernel-logging -o perfstall.csv ./testapp
-    ```
-
-The **-m** option is not required for **analyzeperfmetrics.py**:
-
-    ```sh
-    python analyzeperfmetrics.py -p ./perfstall.metrics.564289.csv -t "XVE Stall Statistics and Report"
-    ```
-
-Refreshing the same link will show stall statistics by type and instruction address:
-
-![Stall Statistics!](/tools/unitrace/doc/images/stallstatistics.png)
-
-followed by source stall analysis report:
-
-![Stall Report!](/tools/unitrace/doc/images/stallreport.png)
-
-## Activate and Deactivate Tracing and Profiling at Runtime
-
-By default, the application is traced/profiled from the start to the end. In certain cases, however, it is more efficient and desirable to
-dynamically activate and deactivate tracing at runtime. 
-
-There are 2 ways to control tracing/processing at runtime: temporal or out-of-application control and spatial or in-application control. 
-
-If both temporal or out-of-application control and spatial or in-application control are used, temporal or out-of-application control takes precedence.
-
-### Temporal or Out-of-Application Control (Linux Only)
-
-The temporal or out-of-application control runs control commands in a separate process to pause/resume/stop tracing/profiling. It does not require any application code change.
-
-By default, a unitrace session is unnamed. To use temporal or out-of-application control, you have to name the unitrace session using the **--session** option. The name must be an alphanumeric string.
-
-```sh
-unitrace --chrome-call-logging --chrome-kernel-logging --session mysession1 --start-paused <application> [args]
-```
-
-The optional **--start-paused** flag pauses tracing/profiling of the application when it starts. Later, when it is time to trace/profile the execution, you can run the following command in a different terminal:
-
-```sh
-unitrace --resume mysession1
-```
-
-to resume tracing/profiling.
-
-Once you have the execution of interest traced/profiled, you can run
-
-```sh
-unitrace --pause mysession1
-```
-
-to pause tracing/profiling.
-
-You can pause and resume multiple times. When all the executions of interest are traced/profiled, you can run command
-
-```sh
-unitrace --stop mysession1
-```
-
-to stop tracing/profiling. 
-
-Once a session is stopped, it can no longer be resumed or paused.
-
-A session may have more than one process and the pause/resume/stop command simultaneously controls all processes in the same session.
-
-### Spatial or In-Application Control (Linux and Windows)
-
-The spatial or in-application control requies application code changes with pause/resume functions/statements added. Inside the application, you can resume/pause tracing/profiling by setting/unsetting environment variable **"PTI_ENABLE_COLLECTION"**:
-
-```cpp
-// activate tracing
-setenv("PTI_ENABLE_COLLECTION", "1", 1);
-// tracing is now activated
-
-......
-
-// deactivate tracing
-setenv("PTI_ENABLE_COLLECTION", "0", 1);
-// tracing is now deactivated
-```
-
-To use spatial or in-application control, You have to start unitrace with **--start-paused** (or the deprecated **--conditional-collection**), for example:
-
-```sh
-unitrace --chrome-call-logging --chrome-kernel-logging --start-paused <application> [args]
-```
-
-Events in the code region between **setenv("PTI_ENABLE_COLLECTION", "1", 1)** and **setenv("PTI_ENABLE_COLLECTION", "0", 1)** are collected. Any event outside this region is ignored.
-
-You can also use __itt_pause() and __itt_resume() APIs to pause and resume collection:
-
-```cpp
-__itt_pause();
-// tracing is now deactivated
-
-......
-
-__itt_resume();
-// tracing is now activated
-```
-
-If both environment variable **PTI_ENABLE_COLLECTION** and **__itt_pause()/__itt_resume()** are present, **__itt_pause()/__itt_resume()** takes precedence.
-
-Collection is disabled by default when the application is started (you have to use **--start-paused** to enable in-application control). However, you can set **PTI_ENABLE_COLLECTION** to 1 when unitrace is started to enable collection at the beginning, for example:
-
-```sh
-PTI_ENABLE_COLLECTION=1 unitrace --chrome-call-logging --chrome-kernel-logging --start-paused <application> [args]
-```
-
-If **--start-paused** option is not specified, PTI_ENABLE_COLLECTION settings or __itt_pause()/__itt_resume() calls have **no** effect and the application is traced/profiled from the start to the end.
-
-## Profile OpenMP Workloads
-
-### Run Profiling
-
-To profile an OpenMP workload, just enable OpenMP logging as follows:
-
-```sh
-unitrace --chrome-omp-logging <application>
-```
-
-The trace result is written to a JSON file `<application>.<process_id>.json`.
-
-### View Traces
-
-The trace result shows timelines of OpenMP activities or events that each OpenMP
-thread participates. Such activities include `parallel`/`teams` regions, task
-regions, synchronizations, work-sharing loops, etc.
-For example, the following trace collected from an OpenMP matrix multiplication
-application shows the timelines of parallel regions on the primary thread,
-implicit tasks invoked by each thread in the team, and barrier synchronizations
-implied at the end of each parallel region. It also shows each implicit task
-executing loop iterations statically assigned to it.
-
-![OpenMP Logging](/tools/unitrace/doc/images/omp-logging.png)
-
-## Profile MPI Workloads
-
-### Run Profiling
-
-To profile an MPI workload, you need to launch the tool on each rank, for example:
-
-```sh
-mpiexec <options> unitrace ...
-```
-
-You can also do selective rank profiling by launching the tool only on the ranks of interest.
-
-The result .json file has the rank id embedded as **<application>.<pid>.<rank>.json**.
-
-### Extended Support for Intel® MPI
-
-With Intel® MPI version 2021.15 and above, extra information can be profiled that may be critical to performance optimization, for example, the idle time caused by communication or application imbalance:
-
-![MPI Application Imbalance!](/tools/unitrace/doc/images/mpi-imbalance.png)
-
-and the device-initiated communications that are executed on host:
-
-![MPI Device-initiated Communications!](/tools/unitrace/doc/images/mpi-device-initiated.png)
-
-The argument `mpi_counter` in the device-initiated communication event is a non-negative integer. It represents operation sequence number for identifying particular call triggered by a GPU kernel.
-
-![mpi_counter Argument!](/tools/unitrace/doc/images/mpi-counter-parameter.png)
-
-### Merge and View Traces from Multiple MPI Ranks
-
-You can view the result files rank by rank. But often you may want to view the traces from multiple ranks at the same time.
-To view traces from multiple MPI ranks, you can use **scripts/tracemerge/mergetrace.py** script to merge them first and then load the merged trace into
-manually load the merged trace into https://ui.perfetto.dev/ or use **uniview.py**.
-
-```sh
-python mergetrace.py -o <output-trace-file> <input-trace-file-1> <input-trace-file-2> <input-trace-file-3> ...
-```
-![Multiple MPI Ranks Host-Device Timelines!](/tools/unitrace/doc/images/multipl-ranks-timelines.png)
-
-## Profile PyTorch
-
-To profile PyTorch, you need to enclose the code to be profiled with
-
-```sh
-with torch.autograd.profiler.emit_itt():
-    ......
-```
-
-For example:
-
-```sh
-with torch.autograd.profiler.emit_itt(record_shapes=False):
-    for batch_idx, (data, target) in enumerate(train_loader):
-        optimizer.zero_grad()
-        data = data.to("xpu")
-        target = target.to("xpu")
-        with torch.xpu.amp.autocast(enabled=True, dtype=torch.bfloat16):
-            output = model(data)
-            loss = criterion(output, target)
-        loss.backward()
-        optimizer.step()
-```
-
-You also need to use one or more options from **--chrome-mpi-logging**,  **--chrome-ccl-logging** and **--chrome-dnn-logging** to enable PyTorch prifling, for example:
-
-```sh
-unitrace --chrome-ccl-logging python ./rn50.py
-```
-or
-```sh
-unitrace --chrome-dnn-logging python ./rn50.py
-```
-or
-```sh
-unitrace --chrome-mpi-logging --chrome-ccl-logging --chrome-dnn-logging python ./rn50.py
-```
-
-Other options can be used together with one or more of these options, for example:
-
-```sh
-unitrace --chrome-kernel-logging --chrome-mpi-logging --chrome-ccl-logging --chrome-dnn-logging python ./rn50.py
-```
-
-![PyTorch Profiling!](/tools/unitrace/doc/images/pytorch.png)
-
-You can use **PTI_ENABLE_COLLECTION** environment variable to selectively enable/disable profiling.
-
-```sh
-with torch.autograd.profiler.emit_itt(record_shapes=False):
-    os.environ["PTI_ENABLE_COLLECTION"] = "1"
-    for batch_idx, (data, target) in enumerate(train_loader):
-        optimizer.zero_grad()
-        data = data.to("xpu")
-        target = target.to("xpu")
-        with torch.xpu.amp.autocast(enabled=True, dtype=torch.bfloat16):
-            output = model(data)
-            loss = criterion(output, target)
-        loss.backward()
-        optimizer.step()
-        if (batch_idx == 2):
-            os.environ["PTI_ENABLE_COLLECTION"] = "0"
-```
-Alternatively, you can use itt-python to do selective profiling as well. The itt-python can be installed from conda-forge
-
-```sh
-conda install -c conda-forge --override-channels itt-python
-```
-
-```sh
-import itt
-......
-
-with torch.autograd.profiler.emit_itt(record_shapes=False):
-    itt.resume()
-    for batch_idx, (data, target) in enumerate(train_loader):
-        optimizer.zero_grad()
-        data = data.to("xpu")
-        target = target.to("xpu")
-        with torch.xpu.amp.autocast(enabled=True, dtype=torch.bfloat16):
-            output = model(data)
-            loss = criterion(output, target)
-        loss.backward()
-        optimizer.step()
-        if (batch_idx == 2):
-            itt.pause()
-```
-
-```sh
-unitrace --chrome-kernel-logging --chrome-dnn-logging --conditional-collection python ./rn50.py
-```
-
-## Categorize GPU Kernels
-
-In case of a large application, for example, LLaMA, there may be a lot of small kernels with long 
-kernel names in the profiled data. To analyze the data at a high level, you may find the kernel categorizing script are helpful.
-
-The summarizing and categorizing script analyzes unitrace reports and aggregates kernels by categories. The summary is stored in `JSON` format (see example below) for further analysis or as input to other tools.
-
-```json
-{
-  "allreduce_time": 660801949838.875,
-  "allreduce_calls": 6937803.0,
-  "matmul_time": 163155211000.0,
-  "matmul_calls": 11520000.0,
-  "attn_time": 53528349820.0,
-  "attn_calls": 3276800.0,
-  "norm_time": 26989135820.0,
-  "norm_calls": 3379201.0,
-  "mem_op_time": 4660369802.857142,
-  "mem_op_calls": 873879.0,
-}
-```
-
-Before runing the script, all summary outputs from all processes should be packed into a single `tarball`. 
-
-```sh
-unitrace -h -d -r mpirun -np 4 python ...
-tar cfz unitrace_4_mpi_100iter.tgz output.*
-```
-
-The summary script takes the `tarball` and a schema file as inputs and aggregates kernels from all processes before categorizing them.
-
-```sh
-python summary.py --input unitrace_4_mpi_100iter.tgz --schema schemas/LLaMA.json --output summary_4_mpi_100iter.json
-```
-
-The schema defines classes of kernels and how the kerenls should be categorized in INI format:
-
-```ini
-[matmul if equals to]
-gemm_kernel
-
-[matmul if starts with]
-xpu::xetla::hgemm_caller
-xpu::xetla::HgemmQKVKernel
-
-[allreduce if ends with]
-ALLREDUCE_SMALL
-ALLREDUCE_MEDIUM
-ALLREDUCE_LARGE
-```
-
-Each section starts with a category name (matmul, allreduce etc.) and a condition followed by a list of kernel names.
-There are 3 kinds of conditions: equals to, starts with and ends with.
-
-Before it can be used with `summary.py`, a schema needs to be converted to JSON format:
-
-```sh
-python categorize.py --input LLaMA.ini --output LLaMA.json
-```
- 
-## GPU Roofline
-
-It is often desirable to estimate the peak performance of a GPU kernel on a specific device using the roofline model.  This can be done by running the **roofline.py** tool. 
-
-```sh
-$ python roofline.py -h
-options:
-  -h, --help            show this help message and exit
-  --compute COMPUTE     compute metrics collected by unitrace
-  --memory MEMORY       memory metrics collected by unitrace
-  --app APP             application to profile
-  --device DEVICE       device configuration file
-  --output OUTPUT       output file in HTML format
-  --unitrace UNITRACE   path to unitrace executable if not in PATH
-
-```
-You can get the roofline in 2 ways:
-
-1. run unitrace and roofline model at the same time 
-
-```sh
-
-python roofline.py --app <application> --device <device-config> --output <output-file>
-
-```
-
-If the path of **unitrace** is not set in your PATH environment, you need to explicitly specify it using **--unitrace** option:
-
-```sh
-
-python roofline.py --app <application> --device <device-config> --output <output-file> --unitrace <path-to-unitrace>
-
-```
-
-2. run unitrace to profile the application, then run roofline model
-
-This is useful if you want to profile your workload once and later run the roofline model multiple times, or if you profile your workload on one machine, but need to run the roofline model on a different machine.
-
-```sh
-
-python roofline.py  --compute <compute-profile> --memory <memory-profile> --device <device-config> --output <output-file>
-
-```
-The `<compute-profile>` is created by running:
-
-```sh
-
-unitrace --g ComputeBasic -q --chrome-kernel-logging -o <compute-profile> <application>
-
-```
-The `<memory-profile>` is created by running: 
-
-```sh
-
-unitrace --g VectorEngine138 -q --chrome-kernel-logging -o <memory-profile> <application>
-
-```
-The `<device-config>` is required in both usage cases. This file is device specific and can be found in the **device_configs** folder.
-
-The `<output-file>` is in HTML format, drawn with Bokeh. The file is self-contained (the charting code is embedded in it), so it can be loaded and viewed in a browser without network access:
-
-![GPU Roofline and Kernel Summary!](/tools/unitrace/doc/images/roofline.png)
-
-## Recommended Usage
-
-How to make the best use of the tool and to get the most out of it really depends on what you want to do and what part of your code you want to focus on.
-
-If you care about just the host activities, you don't need options for device profiling. If you just want to focus on one specific layer of the software stack, for example, the SYCL runtime, you can use the corresponding layer specific options to enable profiling only the layer of interest, for example, **--chrome-syclrt-logging**. Of course, if you need to see interactions between layers, you need to enable profiling multiple layers at the same time.
-
-Similarly, if you care about just the device activities, you can use the options to turn on device profiling only. By default, device activities are profiled by thread (not GPU thread) and by Level Zero engines and/or OpenCL queues. This gives detailed information of how the device is utilized and if concurrencies between engines/queues match the expectations. In case you don't need the details and care only how the device is utilized in general, you may use **--chrome-no-thread-on-device** and/or **--chrome-no-engine-on-device** to turn one or both off.
-
-Typically, you need options to enable profiling both host activities and device activities to understand how host and device are utilized and interacted. Ideally, you want both the concurrencies or overlappings between host activities and device activities and the concurrencies or overlappings between device engines maximized for best performance. Turning on profiling both host and device will give you the timelines of both and help you identify concurrency issues.
-
-It is also recommended to start with device timing (**-d**) and/or host timing (**-h**) summaries. From the summaries, you can quickly spot the hot spots or the expensive kernels on device or calls on host. From the device summary, you will also learn if each kernel has occupancy and/or register spilling issues. Next, from the detailed timelines you will determine if these expensive device kernels or host calls are indeed performance bottlenecks to the overall performance.
-
-Once a kernel is determined to be a performance bottleneck, it is time to figure out why its performance is not optimal. There can be multiple reasons why the kernel is not performant: cache misses, low occupancy, low ALU utilizations, execution unit stalls, etc. You can get answers from metric profiles using **-k"", **-q** or **--stall-sampling** option. In case of execution unit stall analysis, the **--stall-sampling** will give you instruction offsets, source lines and reasons of stalls.
-
-In an interactive, for example Python, session, the **-t** option can be very useful with the kernel queuing, submission and execution data are output immediately after each kernel completes while your session is active.
-
-## License
-
-Unitrace is distributed under the MIT License; see [LICENSE](../../LICENSE).
-The third-party software built into unitrace and its license terms are listed
-in [third-party-programs.txt](third-party-programs.txt). Both files are installed
-to `share/doc/unitrace`.
diff --git a/tools/unitrace/cmake/FindXptifw.cmake b/tools/unitrace/cmake/FindXptifw.cmake
deleted file mode 100644
index 9dab885e..00000000
--- a/tools/unitrace/cmake/FindXptifw.cmake
+++ /dev/null
@@ -1,36 +0,0 @@
-include(FindPackageHandleStandardArgs)
-find_library(Xptifw_LIBRARY
-    NAMES xptifw
-    HINTS
-        ENV LD_LIBRARY_PATH
-        ENV LIBRARY_PATH
-    )
-find_path(Xptifw_INCLUDE_DIR
-    NAMES xpti/xpti_trace_framework.h
-    PATH_SUFFIXES
-        include
-        ../include
-    )
-
-find_package_handle_standard_args(Xptifw REQUIRED_VARS Xptifw_LIBRARY Xptifw_INCLUDE_DIR)
-
-if (Xptifw_LIBRARY)
-	get_filename_component(Xptifw_LIBRARY_DIR ${Xptifw_LIBRARY} DIRECTORY)
-endif()
-
-if (Xptifw_FOUND)
-    mark_as_advanced(Xptifw_LIBRARY)
-    mark_as_advanced(Xptifw_LIBRARY_DIR)
-    mark_as_advanced(Xptifw_INCLUDE_DIR)
-endif()
-
-if (Xptifw_FOUND AND NOT TARGET Xptifw::Xptifw)
-  add_library(Xptifw::Xptifw SHARED IMPORTED)
-  set_target_properties(
-    Xptifw::Xptifw
-    PROPERTIES IMPORTED_LOCATION "${Xptifw_LIBRARY}"
-               INTERFACE_COMPILE_DEFINITIONS
-               "XPTI_API_EXPORTS;XPTI_CALLBACK_API_EXPORTS"
-               INTERFACE_LINK_DIRECTORIES "${Xptifw_LIBRARY_DIR}"
-               INTERFACE_INCLUDE_DIRECTORIES "${Xptifw_INCLUDE_DIR}")
-endif()
diff --git a/tools/unitrace/cmake/HeaderFetch.cmake b/tools/unitrace/cmake/HeaderFetch.cmake
deleted file mode 100644
index 547ceee8..00000000
--- a/tools/unitrace/cmake/HeaderFetch.cmake
+++ /dev/null
@@ -1,140 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-#
-# Unitrace-owned header fetching.
-#
-# Unitrace builds against pinned upstream headers (Level Zero, compute-runtime,
-# IGA) that it
-# fetches into the build tree itself, instead of relying on whatever a host
-# has installed. Each macro below creates the fetch target once and makes the
-# given target compile against the fetched headers.
-
-# Resolved at include time (CMAKE_CURRENT_LIST_DIR inside a macro would expand
-# relative to the caller), so the macros work from any CMakeLists.txt.
-get_filename_component(UNITRACE_FETCH_SCRIPTS_DIR "${CMAKE_CURRENT_LIST_DIR}/../scripts" ABSOLUTE)
-
-# Fetch the pinned IGA API headers into the build tree and make TARGET compile
-# against them.
-#
-#   UnitraceGetIGAHeaders(<target> <iga_commit>)
-#
-# <iga_commit> is the intel-graphics-compiler revision to fetch (passed through
-# to get_iga_headers.py) so the pinned commit lives in Unitrace's CMake rather
-# than hardcoded in the Python script.
-#
-# Notes:
-#   - We ALWAYS fetch and use our own headers. We deliberately do NOT probe the
-#     system include paths and skip fetching when iga/*.h already exist there:
-#     an installed IGA package may ship older headers under /usr/include/iga
-#     that predate IGA_XE2 (XE_VER(2,0)), and building against those fails with
-#     "IGA_XE2 not defined".
-#   - The include path is added with BEFORE so the fetched headers win over any
-#     stale system copy on the include search order.
-#   - igc/igfxfmid.h (GFXCORE_FAMILY) comes from the same intel-graphics-compiler
-#     revision, so the core families match the IGA architectures.
-#   - Only the C API headers are needed at build time; the iga64 shared library
-#     is loaded at runtime via LibraryLoader (dlopen/LoadLibrary).
-macro(UnitraceGetIGAHeaders TARGET IGA_COMMIT)
-  set(IGA_INC_PATH "${CMAKE_BINARY_DIR}")
-
-  # Create the fetch target once; the macro may be called for several targets.
-  if (NOT TARGET unitrace_iga_headers)
-    add_custom_target(unitrace_iga_headers ALL
-                      DEPENDS ${IGA_INC_PATH}/iga/iga.h
-                              ${IGA_INC_PATH}/iga/iga_types_ext.hpp
-                              ${IGA_INC_PATH}/iga/iga_types_swsb.hpp
-                              ${IGA_INC_PATH}/iga/iga_bxml_ops.hpp
-                              ${IGA_INC_PATH}/iga/iga_bxml_enums.hpp
-                              ${IGA_INC_PATH}/igc/igfxfmid.h)
-    add_custom_command(OUTPUT ${IGA_INC_PATH}/iga/iga.h
-                              ${IGA_INC_PATH}/iga/iga_types_ext.hpp
-                              ${IGA_INC_PATH}/iga/iga_types_swsb.hpp
-                              ${IGA_INC_PATH}/iga/iga_bxml_ops.hpp
-                              ${IGA_INC_PATH}/iga/iga_bxml_enums.hpp
-                              ${IGA_INC_PATH}/igc/igfxfmid.h
-                      COMMAND "${Python_EXECUTABLE}" "${UNITRACE_FETCH_SCRIPTS_DIR}/get_iga_headers.py" ${IGA_INC_PATH} ${CMAKE_BINARY_DIR} ${IGA_COMMIT})
-  endif()
-
-  # BEFORE ensures the fetched headers win over any /usr/include/iga on the path.
-  target_include_directories(${TARGET}
-    BEFORE PUBLIC "${IGA_INC_PATH}")
-  add_dependencies(${TARGET}
-    unitrace_iga_headers)
-endmacro()
-
-# Fetch the pinned Level Zero API headers into the build tree and make TARGET
-# compile against them.
-#
-#   UnitraceGetLevelZeroHeaders(<target> <level_zero_commit>)
-#
-# <level_zero_commit> is the oneapi-src/level-zero tag or revision to fetch
-# (passed through to get_ze_headers.py). The headers are the input of the
-# tracing-callback generator, so the pin is deliberately explicit.
-macro(UnitraceGetLevelZeroHeaders TARGET LEVEL_ZERO_COMMIT)
-  set(L0_INC_PATH "${CMAKE_BINARY_DIR}")
-
-  # Create the fetch target once; the macro may be called for several targets.
-  if (NOT TARGET unitrace_level_zero_headers)
-    set(LEVEL_ZERO_HEADERS
-      "${L0_INC_PATH}/level_zero/ze_api.h"
-      "${L0_INC_PATH}/level_zero/zes_api.h"
-      "${L0_INC_PATH}/level_zero/zet_api.h"
-      "${L0_INC_PATH}/level_zero/zer_api.h"
-      "${L0_INC_PATH}/level_zero/layers/zel_tracing_api.h"
-      "${L0_INC_PATH}/level_zero/layers/zel_tracing_register_cb.h")
-    add_custom_target(unitrace_level_zero_headers ALL DEPENDS ${LEVEL_ZERO_HEADERS})
-    add_custom_command(OUTPUT ${LEVEL_ZERO_HEADERS}
-      COMMAND "${Python_EXECUTABLE}" "${UNITRACE_FETCH_SCRIPTS_DIR}/get_ze_headers.py"
-        "${L0_INC_PATH}" "${CMAKE_BINARY_DIR}" "${LEVEL_ZERO_COMMIT}"
-      DEPENDS "${UNITRACE_FETCH_SCRIPTS_DIR}/get_ze_headers.py"
-        "${UNITRACE_FETCH_SCRIPTS_DIR}/build_utils.py"
-      VERBATIM)
-  endif()
-
-  # BEFORE ensures the fetched headers win over any /usr/include/level_zero.
-  target_include_directories(${TARGET}
-    BEFORE PUBLIC "${L0_INC_PATH}")
-  add_dependencies(${TARGET}
-    unitrace_level_zero_headers)
-endmacro()
-
-# Fetch the compute-runtime (NEO) headers that are not part of any public
-# package into the build tree and make TARGET compile against them: the
-# Level Zero driver extensions (driver_experimental/zex_*.h, ze_intel_gpu.h,
-# ze_stypes.h) and the OpenCL tracing headers. The compute-runtime revision is
-# pinned in get_compute_runtime_headers.py.
-#
-#   UnitraceGetComputeRuntimeHeaders(<target>)
-macro(UnitraceGetComputeRuntimeHeaders TARGET)
-  set(COMPUTE_RUNTIME_INC_PATH "${CMAKE_BINARY_DIR}")
-
-  # Create the fetch target once; the macro may be called for several targets.
-  if (NOT TARGET unitrace_compute_runtime_headers)
-    file(GLOB COMPUTE_RUNTIME_ZEX_HEADERS
-      "${COMPUTE_RUNTIME_INC_PATH}/level_zero/driver_experimental/zex_*.h")
-    set(COMPUTE_RUNTIME_HEADERS
-      "${COMPUTE_RUNTIME_INC_PATH}/CL/tracing_api.h"
-      "${COMPUTE_RUNTIME_INC_PATH}/CL/tracing_types.h"
-      "${COMPUTE_RUNTIME_INC_PATH}/CL/cl_ext_private.h"
-      "${COMPUTE_RUNTIME_INC_PATH}/level_zero/ze_stypes.h"
-      "${COMPUTE_RUNTIME_INC_PATH}/level_zero/ze_intel_gpu.h"
-      "${COMPUTE_RUNTIME_INC_PATH}/level_zero/driver_experimental/zex_graph.h"
-      ${COMPUTE_RUNTIME_ZEX_HEADERS})
-    list(REMOVE_DUPLICATES COMPUTE_RUNTIME_HEADERS)
-    add_custom_target(unitrace_compute_runtime_headers ALL DEPENDS ${COMPUTE_RUNTIME_HEADERS})
-    add_custom_command(OUTPUT ${COMPUTE_RUNTIME_HEADERS}
-      COMMAND "${Python_EXECUTABLE}" "${UNITRACE_FETCH_SCRIPTS_DIR}/get_compute_runtime_headers.py"
-        "${COMPUTE_RUNTIME_INC_PATH}" "${CMAKE_BINARY_DIR}"
-      DEPENDS "${UNITRACE_FETCH_SCRIPTS_DIR}/get_compute_runtime_headers.py"
-        "${UNITRACE_FETCH_SCRIPTS_DIR}/build_utils.py"
-      VERBATIM)
-  endif()
-
-  target_include_directories(${TARGET}
-    PUBLIC "${COMPUTE_RUNTIME_INC_PATH}")
-  add_dependencies(${TARGET}
-    unitrace_compute_runtime_headers)
-endmacro()
diff --git a/tools/unitrace/cmake/LevelZero.cmake b/tools/unitrace/cmake/LevelZero.cmake
deleted file mode 100644
index 1f16077b..00000000
--- a/tools/unitrace/cmake/LevelZero.cmake
+++ /dev/null
@@ -1,54 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-#
-# Unitrace-owned Level Zero loader support for the test workloads on Windows.
-# (unitrace itself loads ze_loader at runtime and never links it; the Level
-# Zero headers come from HeaderFetch.cmake on every platform.)
-#
-#   UnitraceFindL0Library(<target>)  - link TARGET against ze_loader.lib; if
-#                                      only ze_loader.dll is installed, generate
-#                                      an import library from it.
-
-# Resolved at include time so the macro works from any CMakeLists.txt.
-get_filename_component(UNITRACE_LEVELZERO_SCRIPTS_DIR "${CMAKE_CURRENT_LIST_DIR}/../scripts" ABSOLUTE)
-
-macro(UnitraceFindL0Library TARGET)
-  if(NOT WIN32)
-    message(FATAL_ERROR "UnitraceFindL0Library is Windows-only; link ze_loader directly elsewhere")
-  endif()
-  find_library(L0_LIB_PATH NAMES ze_loader PATHS ${CMAKE_LIBRARY_PATH})
-  if(NOT L0_LIB_PATH)
-    set(PATH_LIST $ENV{PATH})
-    foreach(VALUE ${PATH_LIST})
-      if(VALUE MATCHES "[S|s]ystem32*$")
-        set(WIN_SYS_PATH "${VALUE}")
-        break()
-      endif()
-    endforeach()
-    file(GLOB L0_DLL_PATH "${WIN_SYS_PATH}/ze_loader.dll")
-    if(NOT L0_DLL_PATH)
-      message(FATAL_ERROR "Level Zero loader is not found. You may need to install oneAPI Level Zero loader.")
-    endif()
-    message(STATUS "Level Zero Loader is found at ${L0_DLL_PATH}")
-    find_library(L0_LIB_PATH NAMES ze_loader PATHS ${SEARCH_LIB_PATH})
-    if(NOT L0_LIB_PATH)
-      if(NOT TARGET unitrace_level_zero_lib)
-        add_custom_target(unitrace_level_zero_lib ALL DEPENDS "${CMAKE_BINARY_DIR}/ze_loader.lib")
-        add_custom_command(OUTPUT "${CMAKE_BINARY_DIR}/ze_loader.lib"
-          COMMAND "${Python_EXECUTABLE}" "${UNITRACE_LEVELZERO_SCRIPTS_DIR}/convert_dll_to_lib.py"
-            "${CMAKE_BINARY_DIR}" "${L0_DLL_PATH}"
-          DEPENDS "${L0_DLL_PATH}" "${UNITRACE_LEVELZERO_SCRIPTS_DIR}/convert_dll_to_lib.py"
-          VERBATIM)
-      endif()
-      add_dependencies(${TARGET} unitrace_level_zero_lib)
-      target_link_libraries(${TARGET} "${CMAKE_BINARY_DIR}/ze_loader.lib")
-    endif()
-  endif()
-  if(L0_LIB_PATH)
-    message(STATUS "Level Zero loader is found at ${L0_LIB_PATH}")
-    target_link_libraries(${TARGET} "${L0_LIB_PATH}")
-  endif()
-endmacro()
diff --git a/tools/unitrace/cmake/OpenCL.cmake b/tools/unitrace/cmake/OpenCL.cmake
deleted file mode 100644
index 89460a75..00000000
--- a/tools/unitrace/cmake/OpenCL.cmake
+++ /dev/null
@@ -1,86 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-#
-# Unitrace-owned OpenCL build support, used only when BUILD_WITH_OPENCL is on.
-#
-#   UnitraceFindOpenCLLibrary(<target>)  - locate the OpenCL ICD loader and
-#                                          link TARGET against it (fatal if absent)
-#   UnitraceFindOpenCLHeaders(<target>)  - use the installed Khronos headers if
-#                                          they are recent enough, otherwise
-#                                          fetch the pinned ones into the build
-#                                          tree; sets CL_TARGET_OPENCL_VERSION
-
-include(CheckIncludeFileCXX)
-include(CheckTypeSize)
-
-# Resolved at include time so the macros work from any CMakeLists.txt.
-get_filename_component(UNITRACE_OPENCL_SCRIPTS_DIR "${CMAKE_CURRENT_LIST_DIR}/../scripts" ABSOLUTE)
-
-macro(UnitraceFindOpenCLLibrary TARGET)
-  if(WIN32)
-    if(NOT OpenCL_FOUND)
-      find_package(OpenCL 2.1)
-    endif()
-  else()
-    set(SEARCH_LIB_PATH "")
-    if(DEFINED ENV{LD_LIBRARY_PATH} AND NOT "$ENV{LD_LIBRARY_PATH}" STREQUAL "")
-      string(REPLACE ":" ";" SEARCH_LIB_PATH "$ENV{LD_LIBRARY_PATH}")
-    endif()
-    list(APPEND CMAKE_FIND_LIBRARY_SUFFIXES .so.1)
-    find_library(OpenCL_LIBRARY NAMES OpenCL PATHS ${SEARCH_LIB_PATH})
-  endif()
-  if(EXISTS "${OpenCL_LIBRARY}")
-    message(STATUS "OpenCL library is found at ${OpenCL_LIBRARY}")
-    target_link_libraries(${TARGET} ${OpenCL_LIBRARY})
-  else()
-    message(FATAL_ERROR
-      "OpenCL library is not found. You may need to install OpenCL ICD Loader or specify "
-      "the path to the library as -DCMAKE_LIBRARY_PATH=<OpenCL_Library_Path>")
-  endif()
-endmacro()
-
-macro(UnitraceFindOpenCLHeaders TARGET)
-  if(WIN32)
-    if(NOT OpenCL_FOUND)
-      find_package(OpenCL 2.1)
-    endif()
-  else()
-    check_include_file_cxx(CL/cl.h OpenCL_INCLUDE_DIRS)
-    if(OpenCL_INCLUDE_DIRS)
-      set(CMAKE_EXTRA_INCLUDE_FILES "CL/cl.h")
-      check_type_size(cl_kernel_sub_group_info CL_KERNEL_SUB_GROUP_INFO_SIZE LANGUAGE CXX)
-      unset(CMAKE_EXTRA_INCLUDE_FILES)
-      if(NOT CL_KERNEL_SUB_GROUP_INFO_SIZE)
-        set(OpenCL_INCLUDE_DIRS 0)
-      endif()
-    endif()
-  endif()
-
-  if(NOT OpenCL_INCLUDE_DIRS)
-    set(OPENCL_INC_PATH "${CMAKE_BINARY_DIR}")
-    if(NOT TARGET unitrace_cl_headers)
-      message(STATUS "OpenCL headers are not found, will be downloaded automatically")
-      set(OPENCL_HEADERS
-        "${OPENCL_INC_PATH}/CL/cl.h"
-        "${OPENCL_INC_PATH}/CL/cl_gl.h"
-        "${OPENCL_INC_PATH}/CL/cl_version.h"
-        "${OPENCL_INC_PATH}/CL/cl_platform.h"
-        "${OPENCL_INC_PATH}/CL/cl_ext.h")
-      add_custom_target(unitrace_cl_headers ALL DEPENDS ${OPENCL_HEADERS})
-      add_custom_command(OUTPUT ${OPENCL_HEADERS}
-        COMMAND "${Python_EXECUTABLE}" "${UNITRACE_OPENCL_SCRIPTS_DIR}/get_cl_headers.py"
-          "${OPENCL_INC_PATH}" "${CMAKE_BINARY_DIR}"
-        DEPENDS "${UNITRACE_OPENCL_SCRIPTS_DIR}/get_cl_headers.py"
-          "${UNITRACE_OPENCL_SCRIPTS_DIR}/build_utils.py"
-        VERBATIM)
-    endif()
-    target_include_directories(${TARGET} PUBLIC "${OPENCL_INC_PATH}")
-    add_dependencies(${TARGET} unitrace_cl_headers)
-  else()
-    target_include_directories(${TARGET} PUBLIC ${OpenCL_INCLUDE_DIRS})
-  endif()
-  target_compile_options(${TARGET} PRIVATE -DCL_TARGET_OPENCL_VERSION=300)
-endmacro()
diff --git a/tools/unitrace/cmake/Perfetto.cmake b/tools/unitrace/cmake/Perfetto.cmake
deleted file mode 100644
index b11e492a..00000000
--- a/tools/unitrace/cmake/Perfetto.cmake
+++ /dev/null
@@ -1,205 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Perfetto protobuf trace output support for unitrace.
-#
-# Call SetupPerfetto() only when BUILD_WITH_PERFETTO is ON. It fetches the
-# Perfetto trace proto (pinned by sha256), builds protoc + libprotobuf from source
-# into the build tree and generates the C++ bindings. On any failure it degrades to
-# JSON-only by setting BUILD_WITH_PERFETTO OFF
-#
-# On success it sets the following, which the caller wires
-# into its target:
-#   PERFETTO_PROTO_SRCS   - generated .pb.cc to add to the target's sources
-#   PERFETTO_GEN_DIR      - dir of the generated .pb.{h,cc}
-#   PROTOBUF_INCLUDE      - libprotobuf headers
-#   PROTOBUF_LIB          - the static libprotobuf to link
-
-# Tags / pinned hash live next to this file in third_party/perfetto/VERSION.
-set(PERFETTO_TAG "v56.1" CACHE STRING "google/perfetto tag for perfetto_trace.proto")
-set(PERFETTO_SRC_SHA256 "e7b94164193323695a81013ee82e1678bf434fc9fbb79f03b50fe1027bc93b5b"
-    CACHE STRING "sha256 of the google/perfetto source tarball at PERFETTO_TAG")
-set(PERFETTO_PROTO_SHA256 "69515f6fa6c0073de20f08c7ddee1b54befa788847af956ad5f74d113340f4c3"
-    CACHE STRING "Expected sha256 of perfetto_trace.proto")
-set(PROTOBUF_TAG "v3.21.12" CACHE STRING "protobuf tag to build from source")
-
-function(SetupPerfetto)
-  # 1. Fetch the trace proto, pinned by sha256 (cached; re-download skipped on match).
-  set(proto "${PROJECT_BINARY_DIR}/perfetto/perfetto_trace.proto")
-  file(DOWNLOAD
-    "https://raw.githubusercontent.com/google/perfetto/${PERFETTO_TAG}/protos/perfetto/trace/perfetto_trace.proto"
-    "${proto}"
-    EXPECTED_HASH SHA256=${PERFETTO_PROTO_SHA256}
-    STATUS dl_status TLS_VERIFY ON)
-  list(GET dl_status 0 dl_code)
-  if (NOT dl_code EQUAL 0)
-    list(GET dl_status 1 dl_msg)
-    message(WARNING "Perfetto proto fetch failed (${dl_msg}); building JSON-only.")
-    set(BUILD_WITH_PERFETTO OFF PARENT_SCOPE)
-    return()
-  endif()
-
-  # 2. Build protoc + libprotobuf from source (skips if already built). Forward
-  #    our generator and build type so the sub-build matches the parent (keeps
-  #    Ninja and the same MSVC runtime on Windows).
-  execute_process(
-    COMMAND "${Python_EXECUTABLE}" ${PROJECT_SOURCE_DIR}/scripts/get_protobuf.py
-            ${PROJECT_BINARY_DIR} ${PROTOBUF_TAG} "${CMAKE_GENERATOR}" "${CMAKE_MAKE_PROGRAM}"
-            "${CMAKE_BUILD_TYPE}"
-    RESULT_VARIABLE build_result)
-  if (NOT build_result EQUAL 0)
-    message(WARNING "Failed to build protobuf from source; building JSON-only.")
-    set(BUILD_WITH_PERFETTO OFF PARENT_SCOPE)
-    return()
-  endif()
-
-  # 3. Locate the from-source install
-  set(install "${PROJECT_BINARY_DIR}/protobuf-install")
-  set(protoc "${install}/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}")
-  set(lib "${install}/lib/libprotobuf${CMAKE_STATIC_LIBRARY_SUFFIX}")
-  if (NOT EXISTS "${lib}")
-    set(lib "${install}/lib64/libprotobuf${CMAKE_STATIC_LIBRARY_SUFFIX}")  # some distros install to lib64
-  endif()
-  if (NOT EXISTS "${protoc}" OR NOT EXISTS "${lib}")
-    message(WARNING "protobuf install incomplete (protoc or libprotobuf missing); building JSON-only.")
-    set(BUILD_WITH_PERFETTO OFF PARENT_SCOPE)
-    return()
-  endif()
-
-  # 4. Generate C++ from the trace schema, into its own dir so it can be a
-  #    SYSTEM include (silences protobuf's generated-code warnings) without
-  #    affecting unitrace's other generated headers in the binary dir.
-  #    Per source proto when the pinned source tarball is available, else from
-  #    the single amalgamated file (why: third_party/perfetto/VERSION).
-  set(gen_dir "${PROJECT_BINARY_DIR}/perfetto_gen")
-  file(MAKE_DIRECTORY "${gen_dir}")
-
-  set(srcs "")
-  set(tarball "${PROJECT_BINARY_DIR}/perfetto/perfetto-${PERFETTO_TAG}.tar.gz")
-  if (NOT EXISTS "${tarball}")
-    # No EXPECTED_HASH: a mismatch there is a fatal error, and an unavailable
-    # or changed tarball must fall back to the single-file flow instead.
-    file(DOWNLOAD
-      "https://github.com/google/perfetto/archive/refs/tags/${PERFETTO_TAG}.tar.gz"
-      "${tarball}"
-      STATUS src_dl_status TLS_VERIFY ON)
-    list(GET src_dl_status 0 src_dl_code)
-    if (NOT src_dl_code EQUAL 0)
-      file(REMOVE "${tarball}")
-    endif()
-  endif()
-  if (EXISTS "${tarball}")
-    file(SHA256 "${tarball}" _tarball_hash)
-    if (NOT _tarball_hash STREQUAL "${PERFETTO_SRC_SHA256}")
-      message(WARNING "perfetto source tarball hash mismatch "
-                      "(${_tarball_hash}); ignoring it.")
-      file(REMOVE "${tarball}")
-    endif()
-  endif()
-
-  if (EXISTS "${tarball}")
-    # Keyed by the source hash, so a changed pin is extracted afresh rather
-    # than reusing a previous release's protos.
-    string(SUBSTRING "${PERFETTO_SRC_SHA256}" 0 16 _src_key)
-    set(src_root "${PROJECT_BINARY_DIR}/perfetto/src-${_src_key}")
-    if (NOT EXISTS "${src_root}/protos")
-      set(_extract_dir "${PROJECT_BINARY_DIR}/perfetto/extract")
-      file(REMOVE_RECURSE "${_extract_dir}" "${src_root}")
-      file(ARCHIVE_EXTRACT INPUT "${tarball}"
-           DESTINATION "${_extract_dir}"
-           PATTERNS "*/protos/*")
-      file(GLOB _extracted "${_extract_dir}/perfetto-*")
-      list(GET _extracted 0 _extracted_root)
-      file(RENAME "${_extracted_root}" "${src_root}")
-    endif()
-
-    # The amalgamated proto's source list, in its original order.
-    file(STRINGS "${proto}" _markers REGEX "Begin of protos/")
-    set(proto_rel "")
-    set(gen_cc "")
-    foreach(_line IN LISTS _markers)
-      string(REGEX MATCH "protos/[^ ]+\.proto" _rel "${_line}")
-      if (_rel AND EXISTS "${src_root}/${_rel}")
-        list(APPEND proto_rel "${_rel}")
-        string(REGEX REPLACE "\.proto$" ".pb.cc" _cc "${_rel}")
-        list(APPEND gen_cc "${gen_dir}/${_cc}")
-      else()
-        set(proto_rel "")  # any miss: use the single-file fallback
-        break()
-      endif()
-    endforeach()
-
-    if (proto_rel)
-      # Chunked invocations with paths relative to the source root: a single
-      # command listing all 253 files exceeds the Windows command-line limit
-      # (ninja then falls back to a batch file, which cmd.exe cannot run).
-      list(LENGTH proto_rel _n)
-      set(_chunk_size 40)
-      set(_i 0)
-      while(_i LESS _n)
-        math(EXPR _rem "${_n} - ${_i}")
-        if (_rem LESS _chunk_size)
-          set(_len ${_rem})
-        else()
-          set(_len ${_chunk_size})
-        endif()
-        list(SUBLIST proto_rel ${_i} ${_len} _chunk_rel)
-        set(_chunk_out "")
-        set(_chunk_dep "")
-        foreach(_rel IN LISTS _chunk_rel)
-          string(REGEX REPLACE "\.proto$" ".pb.cc" _cc "${_rel}")
-          string(REGEX REPLACE "\.proto$" ".pb.h" _h "${_rel}")
-          list(APPEND _chunk_out "${gen_dir}/${_cc}" "${gen_dir}/${_h}")
-          list(APPEND _chunk_dep "${src_root}/${_rel}")
-        endforeach()
-        add_custom_command(
-          OUTPUT ${_chunk_out}
-          COMMAND "${protoc}" --proto_path=. --cpp_out=${gen_dir} ${_chunk_rel}
-          WORKING_DIRECTORY "${src_root}"
-          DEPENDS ${_chunk_dep} "${proto}"
-          COMMENT "Generating perfetto trace protobuf sources (${_i}/${_n})")
-        math(EXPR _i "${_i} + ${_len}")
-      endwhile()
-      # Sources keep including "perfetto_trace.pb.h"; in the split layout the
-      # messages they use live in these generated headers. Drop a monolithic
-      # .pb.cc left by an earlier single-file configure: beside the shim it
-      # would make a later fallback look up to date and skip regeneration.
-      file(REMOVE "${gen_dir}/perfetto_trace.pb.cc")
-      file(WRITE "${gen_dir}/perfetto_trace.pb.h"
-        "#pragma once\n"
-        "#include \"protos/perfetto/trace/trace.pb.h\"\n"
-        "#include \"protos/perfetto/trace/trace_packet.pb.h\"\n"
-        "#include \"protos/perfetto/trace/track_event/track_event.pb.h\"\n")
-      set(srcs ${gen_cc})
-    endif()
-  endif()
-
-  if (NOT srcs)
-    message(WARNING "perfetto source tarball unavailable; generating the "
-                    "single amalgamated .pb.cc (slower to compile).")
-    set(srcs "${gen_dir}/perfetto_trace.pb.cc")
-    add_custom_command(
-      OUTPUT "${srcs}" "${gen_dir}/perfetto_trace.pb.h"
-      COMMAND "${protoc}" --proto_path=${PROJECT_BINARY_DIR}/perfetto
-              --cpp_out=${gen_dir} ${proto}
-      DEPENDS "${proto}")
-  endif()
-
-  # Silence warnings, and hide visibility: the .pb.cc's protobuf template symbols
-  # must not be exported from the LD_PRELOADed unitrace_tool.so (they'd interpose
-  # on a target's own protobuf). --exclude-libs covers the archive, not these TUs.
-  if (MSVC)
-    set_source_files_properties(${srcs} PROPERTIES COMPILE_OPTIONS "/w")
-  else()
-    set_source_files_properties(${srcs} PROPERTIES COMPILE_OPTIONS
-      "-w;-fvisibility=hidden;-fvisibility-inlines-hidden")
-  endif()
-
-  set(PERFETTO_PROTO_SRCS ${srcs} PARENT_SCOPE)
-  set(PERFETTO_GEN_DIR "${gen_dir}" PARENT_SCOPE)
-  set(PROTOBUF_INCLUDE "${install}/include" PARENT_SCOPE)
-  set(PROTOBUF_LIB "${lib}" PARENT_SCOPE)
-endfunction()
diff --git a/tools/unitrace/doc/images/call-logging.png b/tools/unitrace/doc/images/call-logging.png
deleted file mode 100644
index 831e6a3f..00000000
Binary files a/tools/unitrace/doc/images/call-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/call-trace.png b/tools/unitrace/doc/images/call-trace.png
deleted file mode 100644
index 5ccb9d61..00000000
Binary files a/tools/unitrace/doc/images/call-trace.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/ccl_logging.png b/tools/unitrace/doc/images/ccl_logging.png
deleted file mode 100644
index f422c1fd..00000000
Binary files a/tools/unitrace/doc/images/ccl_logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/ccl_summary_report.png b/tools/unitrace/doc/images/ccl_summary_report.png
deleted file mode 100644
index eccd4b2a..00000000
Binary files a/tools/unitrace/doc/images/ccl_summary_report.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/chrome_itt_logging.png b/tools/unitrace/doc/images/chrome_itt_logging.png
deleted file mode 100644
index 4c34aebd..00000000
Binary files a/tools/unitrace/doc/images/chrome_itt_logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-logging.png b/tools/unitrace/doc/images/device-logging.png
deleted file mode 100644
index 66aff377..00000000
Binary files a/tools/unitrace/doc/images/device-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-no-thread-no-engine.png b/tools/unitrace/doc/images/device-no-thread-no-engine.png
deleted file mode 100644
index c877ef97..00000000
Binary files a/tools/unitrace/doc/images/device-no-thread-no-engine.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-per-engine.png b/tools/unitrace/doc/images/device-per-engine.png
deleted file mode 100644
index 288256e6..00000000
Binary files a/tools/unitrace/doc/images/device-per-engine.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-per-thread-per-engine.png b/tools/unitrace/doc/images/device-per-thread-per-engine.png
deleted file mode 100644
index 07adf441..00000000
Binary files a/tools/unitrace/doc/images/device-per-thread-per-engine.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-per-thread.png b/tools/unitrace/doc/images/device-per-thread.png
deleted file mode 100644
index 144ca731..00000000
Binary files a/tools/unitrace/doc/images/device-per-thread.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-timeline-text.png b/tools/unitrace/doc/images/device-timeline-text.png
deleted file mode 100644
index 1f7f123a..00000000
Binary files a/tools/unitrace/doc/images/device-timeline-text.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-timing-with-no-shape.png b/tools/unitrace/doc/images/device-timing-with-no-shape.png
deleted file mode 100644
index 73da94d8..00000000
Binary files a/tools/unitrace/doc/images/device-timing-with-no-shape.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/device-timing.png b/tools/unitrace/doc/images/device-timing.png
deleted file mode 100644
index e0fbd946..00000000
Binary files a/tools/unitrace/doc/images/device-timing.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/event_query.png b/tools/unitrace/doc/images/event_query.png
deleted file mode 100644
index 145bd004..00000000
Binary files a/tools/unitrace/doc/images/event_query.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/host-device-times.png b/tools/unitrace/doc/images/host-device-times.png
deleted file mode 100644
index a8652ce2..00000000
Binary files a/tools/unitrace/doc/images/host-device-times.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/host-timing.png b/tools/unitrace/doc/images/host-timing.png
deleted file mode 100644
index c1c89331..00000000
Binary files a/tools/unitrace/doc/images/host-timing.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/implicit-per-tile-kernel-logging.png b/tools/unitrace/doc/images/implicit-per-tile-kernel-logging.png
deleted file mode 100644
index 7b56aa69..00000000
Binary files a/tools/unitrace/doc/images/implicit-per-tile-kernel-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/implicit-per-tile-timing.png b/tools/unitrace/doc/images/implicit-per-tile-timing.png
deleted file mode 100644
index 2d56b436..00000000
Binary files a/tools/unitrace/doc/images/implicit-per-tile-timing.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/kernel-info-with-no-shape.png b/tools/unitrace/doc/images/kernel-info-with-no-shape.png
deleted file mode 100644
index 441ba185..00000000
Binary files a/tools/unitrace/doc/images/kernel-info-with-no-shape.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/kernel-info.png b/tools/unitrace/doc/images/kernel-info.png
deleted file mode 100644
index 211bc19d..00000000
Binary files a/tools/unitrace/doc/images/kernel-info.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/kernel-logging.png b/tools/unitrace/doc/images/kernel-logging.png
deleted file mode 100644
index 5516d3a3..00000000
Binary files a/tools/unitrace/doc/images/kernel-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/kernel-submissions.png b/tools/unitrace/doc/images/kernel-submissions.png
deleted file mode 100644
index e4283bb3..00000000
Binary files a/tools/unitrace/doc/images/kernel-submissions.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/kmd-logging.png b/tools/unitrace/doc/images/kmd-logging.png
deleted file mode 100644
index 13ecc5e4..00000000
Binary files a/tools/unitrace/doc/images/kmd-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/metric-query.png b/tools/unitrace/doc/images/metric-query.png
deleted file mode 100644
index ed513186..00000000
Binary files a/tools/unitrace/doc/images/metric-query.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/metric-sampling.png b/tools/unitrace/doc/images/metric-sampling.png
deleted file mode 100644
index 4505cca9..00000000
Binary files a/tools/unitrace/doc/images/metric-sampling.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/mpi-counter-parameter.png b/tools/unitrace/doc/images/mpi-counter-parameter.png
deleted file mode 100644
index 7c1ec907..00000000
Binary files a/tools/unitrace/doc/images/mpi-counter-parameter.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/mpi-device-initiated.png b/tools/unitrace/doc/images/mpi-device-initiated.png
deleted file mode 100644
index f4e2b502..00000000
Binary files a/tools/unitrace/doc/images/mpi-device-initiated.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/mpi-imbalance.png b/tools/unitrace/doc/images/mpi-imbalance.png
deleted file mode 100644
index 13e6fbd2..00000000
Binary files a/tools/unitrace/doc/images/mpi-imbalance.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/mpi-logging.png b/tools/unitrace/doc/images/mpi-logging.png
deleted file mode 100644
index 8cb4c537..00000000
Binary files a/tools/unitrace/doc/images/mpi-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/multipl-ranks-timelines.png b/tools/unitrace/doc/images/multipl-ranks-timelines.png
deleted file mode 100644
index fec63060..00000000
Binary files a/tools/unitrace/doc/images/multipl-ranks-timelines.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/omp-logging.png b/tools/unitrace/doc/images/omp-logging.png
deleted file mode 100644
index fa37fd00..00000000
Binary files a/tools/unitrace/doc/images/omp-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/perfchart-multi-sets.png b/tools/unitrace/doc/images/perfchart-multi-sets.png
deleted file mode 100644
index f48cf4ed..00000000
Binary files a/tools/unitrace/doc/images/perfchart-multi-sets.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/perfchart.png b/tools/unitrace/doc/images/perfchart.png
deleted file mode 100644
index 9751d2da..00000000
Binary files a/tools/unitrace/doc/images/perfchart.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/perfmetricsbrowser.png b/tools/unitrace/doc/images/perfmetricsbrowser.png
deleted file mode 100755
index c421caca..00000000
Binary files a/tools/unitrace/doc/images/perfmetricsbrowser.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/perfmetricsbrowser2.png b/tools/unitrace/doc/images/perfmetricsbrowser2.png
deleted file mode 100755
index 6178c91e..00000000
Binary files a/tools/unitrace/doc/images/perfmetricsbrowser2.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/perfmetricstrace.png b/tools/unitrace/doc/images/perfmetricstrace.png
deleted file mode 100755
index 8fc360eb..00000000
Binary files a/tools/unitrace/doc/images/perfmetricstrace.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/pytorch.png b/tools/unitrace/doc/images/pytorch.png
deleted file mode 100644
index 53d794a3..00000000
Binary files a/tools/unitrace/doc/images/pytorch.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/roofline.png b/tools/unitrace/doc/images/roofline.png
deleted file mode 100755
index 3d47a181..00000000
Binary files a/tools/unitrace/doc/images/roofline.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/stallchart.png b/tools/unitrace/doc/images/stallchart.png
deleted file mode 100644
index 52e0d8fa..00000000
Binary files a/tools/unitrace/doc/images/stallchart.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/stallreport.png b/tools/unitrace/doc/images/stallreport.png
deleted file mode 100755
index 4004e4e3..00000000
Binary files a/tools/unitrace/doc/images/stallreport.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/stallstatistics.png b/tools/unitrace/doc/images/stallstatistics.png
deleted file mode 100755
index 2192d6c4..00000000
Binary files a/tools/unitrace/doc/images/stallstatistics.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/sycl-logging.png b/tools/unitrace/doc/images/sycl-logging.png
deleted file mode 100644
index 2373b283..00000000
Binary files a/tools/unitrace/doc/images/sycl-logging.png and /dev/null differ
diff --git a/tools/unitrace/doc/images/throughput.png b/tools/unitrace/doc/images/throughput.png
deleted file mode 100644
index f707abbb..00000000
Binary files a/tools/unitrace/doc/images/throughput.png and /dev/null differ
diff --git a/tools/unitrace/examples/kmdprobes/probes.bt b/tools/unitrace/examples/kmdprobes/probes.bt
deleted file mode 100644
index 630d299e..00000000
--- a/tools/unitrace/examples/kmdprobes/probes.bt
+++ /dev/null
@@ -1,20 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-kprobe:xe_exec_ioctl {
-    @xe_exec_ioctl_start[tid] = nsecs;
-}
-
-kretprobe:xe_exec_ioctl {
-    $start = @xe_exec_ioctl_start[tid];
-    if ($start) {
-        $dur = nsecs - $start;
-        delete(@xe_exec_ioctl_start[tid]);
-        // output format is
-        // <tid>,<event>,<start-time>,<duration>
-        printf("%d,%s,%llu,%llu\n", tid, "xe_exec_ioctl", $start, $dur);
-    }
-}
diff --git a/tools/unitrace/examples/kmdprobes/probes_extra.bt b/tools/unitrace/examples/kmdprobes/probes_extra.bt
deleted file mode 100644
index e2658e04..00000000
--- a/tools/unitrace/examples/kmdprobes/probes_extra.bt
+++ /dev/null
@@ -1,21 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-kprobe:xe_exec_ioctl {
-    @xe_exec_ioctl_start[tid] = nsecs;
-}
-
-kretprobe:xe_exec_ioctl {
-    $start = @xe_exec_ioctl_start[tid];
-    if ($start) {
-        $dur = nsecs - $start;
-        delete(@xe_exec_ioctl_start[tid]);
-        // output format is
-        // <tid>,<event>,<start-time>,<duration>[,<data>]
-        // the data is "end,<nsecs>" 
-        printf("%d,%s,%llu,%llu,%s,%llu\n", tid, "xe_exec_ioctl", $start, $dur, "end", nsecs);
-    }
-}
diff --git a/tools/unitrace/examples/kmdprobes/probes_faults.bt b/tools/unitrace/examples/kmdprobes/probes_faults.bt
deleted file mode 100644
index 9ba9ba0a..00000000
--- a/tools/unitrace/examples/kmdprobes/probes_faults.bt
+++ /dev/null
@@ -1,33 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-kprobe:xe_svm_handle_pagefault {
-  @start_gpu_page_fault_handler[tid] = nsecs;
-  @addr_gpu_page_fault_handler[tid] = arg3;
-}
-
-kretprobe:xe_svm_handle_pagefault {
-  $start = @start_gpu_page_fault_handler[tid];
-  if ($start) {
-    $dur = nsecs - $start;
-    delete(@start_gpu_page_fault_handler[tid]);
-    printf("%d,GPU_page_fault,%llu,%llu,addr=0x%llx\n", tid, $start, $dur, @addr_gpu_page_fault_handler[tid]);
-    delete(@addr_gpu_page_fault_handler[tid]);
-  }
-}
-
-kprobe:drm_pagemap_migrate_to_ram {
-  @start_cpu_page_fault_handler[tid] = nsecs;
-}
-
-kretprobe:drm_pagemap_migrate_to_ram {
-  $start = @start_cpu_page_fault_handler[tid];
-  if ($start) {
-    $dur = nsecs - $start;
-    delete(@start_cpu_page_fault_handler[tid]);
-    printf("%d,CPU_page_fault,%llu,%llu\n", tid, $start, $dur);
-  }
-}
diff --git a/tools/unitrace/examples/metricconfig/metric_config.txt b/tools/unitrace/examples/metricconfig/metric_config.txt
deleted file mode 100644
index 92e9ed5b..00000000
--- a/tools/unitrace/examples/metricconfig/metric_config.txt
+++ /dev/null
@@ -1,55 +0,0 @@
-# Example metric configuration file for unitrace --metric-config.
-#
-#   unitrace -k --metric-config metric_config.txt <application>
-#   unitrace -q --metric-config metric_config.txt <application>
-#
-# Generate the full list of what your device supports, with the valid parameter
-# values, using:
-#
-#   unitrace --gen-metric-config all_metrics.txt
-#
-# Only one metric group can be collected per run: enable either one predefined
-# group, or any number of programmable metrics (they are collected together).
-# As shipped, this file collects the predefined ComputeBasic group, which every
-# supported GPU has, so it runs as is on any device. The other entries are
-# disabled and show the syntax; disabled entries are not checked against the
-# device. Their names and valid values come from --gen-metric-config on an
-# Intel(R) Arc(TM) B-Series GPU (BMG G31, device ID 0xE221); other GPUs, and
-# even other boards of the same model (the available XeCores differ), can
-# differ. To collect programmable metrics instead, set ComputeBasic to
-# enable=false and enable the programmables, using the names and values that
-# --gen-metric-config reports for your device.
-
-predefined{
-    ComputeBasic{
-        # Supported sampling types: event_based,time_based
-        enable=true
-    }
-    MemoryProfile{
-        # Supported sampling types: event_based,time_based
-        enable=false
-    }
-}
-
-programmable{
-    XVE_INST_EXECUTED_SEND_ALL{
-        # Supported sampling types: event_based,time_based
-        enable=false
-        parameters{
-            # Valid values: 0:11,16:31
-            Disaggregation=2            # XeCore 2 only
-            # Valid values: 1
-            Normalization_average=1
-        }
-    }
-    XVE_INST_EXECUTED_CONTROL_ALL{
-        # Supported sampling types: event_based,time_based
-        enable=false
-        parameters{
-            # Valid values: 0:11,16:31
-            Disaggregation=[0:3,16:19:3]  # one metric per value: 0,1,2,3,16,19
-            # Valid values: 1
-            Normalization_average=1
-        }
-    }
-}
diff --git a/tools/unitrace/requirements.txt b/tools/unitrace/requirements.txt
deleted file mode 100644
index 136a19a0..00000000
--- a/tools/unitrace/requirements.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-# Packages of the Python scripts of unitrace, uniview.py and the scripts of
-# scripts/, installed with: python -m pip install -r requirements.txt
-#
-# Known-good versions: bokeh 3.9.0, pandas 3.0.1, matplotlib 3.10.8.
-pandas >= 2.2.1
-matplotlib >= 3.8.0
-bokeh >= 3.9
diff --git a/tools/unitrace/scripts/build_utils.py b/tools/unitrace/scripts/build_utils.py
deleted file mode 100644
index 7a92bbe3..00000000
--- a/tools/unitrace/scripts/build_utils.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import os
-import shutil
-import subprocess
-
-def clone(url, commit, clone_path):
-  if (not os.path.exists(clone_path)):
-    subprocess.check_call(["git", "clone", url, clone_path])
-    subprocess.check_call(["git", "checkout", commit], cwd = os.path.abspath(clone_path))
-  # Reject incomplete clones or stale checkouts instead of copying unpinned headers.
-  expected = subprocess.check_output(
-    ["git", "rev-parse", "--verify", commit + "^{commit}"],
-    cwd=os.path.abspath(clone_path), text=True).strip()
-  actual = subprocess.check_output(
-    ["git", "rev-parse", "--verify", "HEAD"],
-    cwd=os.path.abspath(clone_path), text=True).strip()
-  if actual != expected:
-    raise RuntimeError(f"{clone_path} is at {actual}, expected {commit} ({expected}); "
-                       "remove the cached clone and retry")
-
-def copy(src_path, dst_path, file_list):
-  for file in file_list:
-    dst_file = os.path.join(dst_path, file)
-    if os.path.isfile(dst_file):
-      os.remove(dst_file)
-
-    src_file = os.path.join(src_path, file)
-    if not os.path.isfile(src_file):
-      raise FileNotFoundError(src_file)
-
-    shutil.copy(src_file, dst_file)
diff --git a/tools/unitrace/scripts/convert_dll_to_lib.py b/tools/unitrace/scripts/convert_dll_to_lib.py
deleted file mode 100644
index b5b2230f..00000000
--- a/tools/unitrace/scripts/convert_dll_to_lib.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import os
-import sys
-import subprocess
-import shutil
-import re
-
-def main():
-  if len(sys.argv) < 3:
-    print("Usage: python convert_dll_to_lib.py <path to the generated .lib file> <.dll file path>")
-    return 1
-
-  if os.environ.get('OS','') != 'Windows_NT':
-    print("This script is only for Windows")
-    return 1
-  else:
-    lib_path = sys.argv[1]
-    dll_file = sys.argv[2]
-
-    dumpbin = shutil.which("dumpbin")
-    librarian = shutil.which("lib")
-    if not dumpbin or not librarian:
-      raise RuntimeError("dumpbin and lib must be available on PATH")
-    if not os.path.isfile(dll_file) or not dll_file.lower().endswith(".dll"):
-      raise FileNotFoundError(dll_file)
-
-    if not os.path.exists(lib_path):
-      os.mkdir(lib_path)
-
-    lib_name = os.path.basename(dll_file)
-    lib_name = os.path.splitext(lib_name)[0]
-
-    def_file = os.path.join(lib_path, lib_name + ".def")
-    lib_file = os.path.join(lib_path, lib_name + ".lib")
-
-    exports = subprocess.check_output([dumpbin, "/exports", dll_file], text=True)
-    symbols = re.findall(r"^\s+\d+\s+[0-9A-Fa-f]+\s+[0-9A-Fa-f]+\s+(\S+)",
-                         exports, re.MULTILINE)
-    if not symbols:
-      raise RuntimeError(f"No exports found in {dll_file}")
-    with open(def_file, "w") as output:
-      output.write("EXPORTS\n" + "\n".join(symbols) + "\n")
-    subprocess.check_call([librarian, "/def:" + def_file, "/out:" + lib_file, "/machine:x64"])
-    if not os.path.isfile(lib_file):
-      raise FileNotFoundError(lib_file)
-
-if __name__ == "__main__":
-  sys.exit(main())
\ No newline at end of file
diff --git a/tools/unitrace/scripts/gen_l0_loader.py b/tools/unitrace/scripts/gen_l0_loader.py
deleted file mode 100644
index 869eb757..00000000
--- a/tools/unitrace/scripts/gen_l0_loader.py
+++ /dev/null
@@ -1,125 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-
-from parse_l0_headers import find_extension_headers, get_extension_function_names
-
-
-def get_func_list(file_path, func_list):
-  f = open(file_path, "rt")
-  for line in f.readlines():
-    if line.find("ZE_APICALL") != -1:
-      items = []
-      is_rt_func = False
-      if line.find("ze_pfn") != -1:
-        items = line.split("ze_pfn")
-      elif line.find("zer_pfn") != -1:
-        is_rt_func = True
-        items = line.split("zer_pfn")
-      if len(items) == 2 and items[1].find("Cb_t") != -1:
-        items = items[1].split("Cb_t")
-        if len(items) == 2:
-          if is_rt_func:
-            func_list.append("zer" + items[0].strip())
-          else:
-            func_list.append("ze" + items[0].strip())
-  f.close()
-
-def get_api_func_list(file_path, func_list):
-  f = open(file_path, "rt")
-  api_line = False
-  for line in f.readlines():
-    if line.find("ZE_APICALL") != -1:
-      # Check if function name is on the same line (format: ZE_APIEXPORT ze_result_t ZE_APICALL funcName(...))
-      parts = line.split("ZE_APICALL")
-      if len(parts) == 2 and "(" in parts[1]:
-        # Function name is on the same line after ZE_APICALL
-        items = parts[1].split("(")
-        if len(items) >= 2:
-          func_list.append(items[0].strip())
-        api_line = False
-      else:
-        # Function name is on the next line
-        api_line = True
-    elif api_line:
-      api_line = False
-      items = line.split("(")
-      assert len(items) == 2
-      func_list.append(items[0].strip())
-  f.close()
-
-def gen_loader(f, register_func_list, api_func_list, ext_func_list):
-  f.write("public:\n")
-  for func in register_func_list:
-    offset = 2
-    if func.find("zer") == 0:
-      offset = 3
-    reg_fname = "zelTracer" + func[offset:] + "RegisterCallback"
-    f.write("  decltype(&" + reg_fname + ") " + reg_fname + "_ = nullptr;\n")
-    f.write("  decltype(&" + func + ") " + func + "_ = nullptr;\n")
-  for func in api_func_list:
-    f.write("  decltype(&" + func + ") " + func + "_ = nullptr;\n")
-
-  # Extension function pointers - these are populated by interception, not from loader
-  f.write("\n  // Extension function pointers (populated via InterceptExtensionApi)\n")
-  for func in ext_func_list:
-    f.write("  decltype(&" + func + ") " + func + "_ = nullptr;\n")
-
-  f.write("private:\n")
-  f.write("  void init() {\n")
-  for func in register_func_list:
-    offset = 2
-    if func.find("zer") == 0:
-      offset = 3
-    reg_fname = "zelTracer" + func[offset:] + "RegisterCallback"
-    f.write("  LEVEL_ZERO_LOADER_GET_SYMBOL(" + reg_fname + ");\n")
-    f.write("  LEVEL_ZERO_LOADER_GET_SYMBOL(" + func + ");\n")
-  for func in api_func_list:
-    f.write("  LEVEL_ZERO_LOADER_GET_SYMBOL(" + func + ");\n")
-  # Note: Extension functions are NOT loaded here - they come via interception
-  f.write("}\n")
-
-def main():
-  if len(sys.argv) < 3:
-    print("Usage: python gen_l0_loader.py <output_include_path> <l0_include_path>")
-    return
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  dst_loader_file_path = os.path.join(dst_path, "l0_loader.gen")
-  if (os.path.isfile(dst_loader_file_path)):
-    os.remove(dst_loader_file_path)
-
-  dst_loader_file = open(dst_loader_file_path, "wt")
-
-  register_func_list = []
-  api_func_list = []
-  ext_func_list = []
-
-  l0_path = sys.argv[2]
-  get_func_list(os.path.join(l0_path, "ze_api.h"), register_func_list)
-  get_func_list(os.path.join(l0_path, "layers", "zel_tracing_register_cb.h"), register_func_list)
-  get_api_func_list(os.path.join(l0_path, "zet_api.h"), api_func_list)
-  get_api_func_list(os.path.join(l0_path, "zes_api.h"), api_func_list)
-  get_api_func_list(os.path.join(l0_path, "layers", "zel_tracing_api.h"), api_func_list)
-
-  # Extension functions go into a separate list - they're not loaded from the library.
-  # Skip the ones that graduated into the core API: they are declared above already.
-  core_func_names = set(register_func_list) | set(api_func_list)
-  for header_path in find_extension_headers(l0_path):
-    ext_func_list.extend(func for func in get_extension_function_names(header_path)
-                         if func not in core_func_names)
-
-  gen_loader(dst_loader_file, register_func_list, api_func_list, ext_func_list)
-
-  dst_loader_file.close()
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/gen_tracing_callbacks.py b/tools/unitrace/scripts/gen_tracing_callbacks.py
deleted file mode 100644
index b64b0821..00000000
--- a/tools/unitrace/scripts/gen_tracing_callbacks.py
+++ /dev/null
@@ -1,1233 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-import re
-from typing import List
-
-from parse_l0_headers import (
-  FunctionDecl,
-  find_extension_headers,
-  get_extension_functions,
-  get_param_struct_name as get_ext_param_struct_name,
-  get_param_struct_field_name,
-)
-
-# Extension APIs to skip due to L0 header uncommon behavior (reference params, struct by value, etc.)
-SKIPPED_EXTENSION_APIS = {
-  'zexIntelAllocateNetworkInterrupt',    # uses C++ reference parameter (uint32_t&)
-  'zexCounterBasedEventOpenIpcHandle',   # uses struct by value (zex_ipc_counter_based_event_handle_t)
-  'zexCounterBasedEventGetIpcHandle',    # uses struct by value (zex_ipc_counter_based_event_handle_t)
-  'zeIntelMediaCommunicationCreate',     # uses struct by value (ze_intel_media_doorbell_handle_desc_t)
-  'zeIntelMediaCommunicationDestroy',    # uses struct by value (ze_intel_media_doorbell_handle_desc_t)
-}
-
-# IPC handles are structs wrapping an opaque byte array: log their 'data' member.
-IPC_HANDLE_TYPES = {
-  'ze_ipc_mem_handle_t',
-  'ze_ipc_event_pool_handle_t',
-  'ze_ipc_event_counter_based_handle_t',
-}
-
-# Parse Level Zero Headers ####################################################
-
-STATE_NORMAL = 0
-STATE_CONDITION = 1
-STATE_SKIP = 2
-
-def get_comma_count(line):
-  count = 0
-  level = 0
-  for symbol in line:
-    if symbol == "(":
-      level += 1
-    elif symbol == ")":
-      assert level > 0
-      level -= 1
-    elif symbol == "," and level == 0:
-      count += 1
-  return count
-
-def remove_comments(line):
-  pos = line.find("//")
-  if pos != -1:
-    line = line[0:pos]
-  return line
-
-def get_func_name(callback_struct_name):
-  assert callback_struct_name.strip().find("ze_pfn") == 0
-  assert callback_struct_name.strip().find("Cb_t") + len("Cb_t") == len(callback_struct_name.strip())
-  body = callback_struct_name.strip()
-  body = body.split("ze_pfn")[1]
-  body = body.split("Cb_t")[0]
-  return "ze" + body
-
-def get_struct_range(lines, struct_name):
-  start = -1
-  for i in range(len(lines)):
-    if lines[i].find(struct_name) != -1:
-      start = i
-      break
-  assert start >= 0
-
-  while lines[start].find("{") == -1:
-    start +=1
-  start += 1
-  assert start < len(lines)
-
-  end = start
-  while lines[end].find("}") == -1:
-    end += 1
-  assert end < len(lines)
-
-  return start, end
-
-def get_callback_struct_map(f, struct_name):
-  f.seek(0)
-  lines = f.readlines()
-
-  start, end = get_struct_range(lines, struct_name)
-
-  struct_map = {}
-  cond = ""
-  state = STATE_NORMAL
-  for i in range(start, end):
-    if lines[i].find("#if") >= 0:
-      items = lines[i].strip().split()
-      assert len(items) == 2
-      state = STATE_CONDITION
-      cond = items[1].strip()
-      continue
-    elif lines[i].find("#else") >= 0:
-      assert state == STATE_CONDITION
-      state = STATE_SKIP
-      continue
-    elif lines[i].find("#endif") >= 0:
-      assert state != STATE_NORMAL
-      state = STATE_NORMAL
-      cond = ""
-      continue
-
-    if state == STATE_SKIP:
-      continue
-
-    items = lines[i].strip().split()
-    assert len(items) == 2
-    type_name = items[0].strip()
-    field_name = items[1].strip().strip(";")
-    assert not (type_name in struct_map)
-    struct_map[type_name] = (field_name, cond)
-
-  return struct_map
-
-def get_params(f, func_name):
-  f.seek(0)
-  params = []
-
-  param_struct_name = get_param_struct_name(func_name)
-  lines = f.readlines()
-  start, end = get_struct_range(lines, param_struct_name)
-
-  for i in range(start, end):
-    items = lines[i].strip().split()
-    assert len(items) >= 2
-
-    type = ""
-    for j in range(len(items) - 1):
-      type += items[j] + " "
-    type = type.strip()
-    assert type[len(type) - 1] == "*"
-    type = type[0:len(type) - 1]
-
-    name = items[len(items) - 1].rstrip(";")
-    assert name[0] == "p"
-    name = name[1:len(name)]
-
-    assert not ((name, type) in params)
-    params.append((name, type))
-
-  return params
-
-def find_enums(f, enum_map):
-  f.seek(0)
-  lines = f.readlines()
-
-  enum_list = []
-  for line in lines:
-    if line.find("typedef enum") != -1:
-      items = line.strip().rstrip("{").split()
-      assert len(items) == 3
-      enum_list.append(items[2].strip().lstrip("_"))
-
-  for enum_name in enum_list:
-    params = {}
-    start, end = get_struct_range(lines, enum_name)
-    default_value = 0
-    has_unresolved_values = False
-    for i in range(start, end):
-      line = remove_comments(lines[i]).strip()
-      if not line:
-        continue
-      # skip lines starting with hash (c preprocessor lines)
-      if line[0] == '#':
-          continue
-      comma_count = get_comma_count(line)
-      assert comma_count == 0 or comma_count == 1
-      if line.find("=") == -1:
-        assert not has_unresolved_values
-        field_name = line.rstrip(",")
-        field_value = str(default_value)
-        default_value += 1
-      else:
-        items = line.split("=")
-        assert len(items) == 2
-        field_name = items[0].strip()
-        field_value = items[1].strip().rstrip(",")
-        if field_value.find("0x") == 0:
-          field_value = str(int(field_value, 16))
-        if all(symbol.isdigit() for symbol in field_value):
-          default_value = int(field_value)
-          default_value += 1
-        else:
-          has_unresolved_values = True
-      assert not (field_name in params)
-      params[field_name] = field_value
-    assert len(params) > 0
-    # The same enum can come from two headers (compute-runtime's ze_stypes.h
-    # backports core ones); keep the first, which is the core declaration.
-    if enum_name not in enum_map:
-      enum_map[enum_name] = params
-    elif enum_map[enum_name] != params:
-      print("[WARNING] " + enum_name + " is declared differently in another header; "
-            "keeping the first declaration", file = sys.stderr)
-
-def get_param_struct_name(func_name):
-  assert func_name[0] == 'z'
-  func_name = 'Z' + func_name[1:]
-  func_name = func_name.replace("CL", "Cl")
-  func_name = func_name.replace("IPC", "Ipc")
-  func_name = func_name.replace("RTAS", "Rtas")
-  items = re.findall('[A-Z][^A-Z]*', func_name)
-  assert len(items) > 1
-  struct_name = ""
-  for item in items:
-    struct_name += item.lower() + "_"
-  struct_name += "params_t"
-  return struct_name
-
-def get_func_dict(f):
-  func_dict = {}
-  f.seek(0)
-  for line in f:
-    if line.find("ZE_APICALL") != -1 :
-      initial = "ze"
-      items = []
-      if line.find("ze_pfn") != -1:
-        items = line.split("ze_pfn")
-      elif line.find("zer_pfn") != -1:
-        initial += 'r'
-        items = line.split("zer_pfn")
-      if len(items) == 2 and items[1].find("Cb_t") != -1:
-        func_dict[initial + items[1].split("Cb_t")[0].strip()] = [next(f).strip(), next(f).strip()]
-  return func_dict
-
-def get_func_list(f, func_list):
-  f.seek(0)
-  for line in f.readlines():
-    if line.find("ZE_APICALL") != -1 and line.find("ze_pfn") != -1:
-      items = line.split("ze_pfn")
-      assert len(items) == 2
-      assert items[1].find("Cb_t") != -1
-      items = items[1].split("Cb_t")
-      assert len(items) == 2
-      func_list.append("ze" + items[0].strip())
-
-def add_param_map(f, func_list, param_map):
-  for func in func_list:
-    assert not (func in param_map)
-    param_map[func] = get_params(f, func)
-
-  return param_map
-
-def get_enum_map(include_path):
-  enum_map = {}
-
-  # ze_api.h first, so that a duplicated enum resolves to the core declaration.
-  file_names = sorted(os.listdir(include_path), key = lambda name: (name != "ze_api.h", name))
-  for file_name in file_names:
-    if file_name.endswith(".h") or file_name.endswith(".hpp"):
-      file_path = os.path.join(include_path, file_name)
-      file = open(file_path, "rt")
-      find_enums(file, enum_map)
-      file.close()
-
-  return enum_map
-
-# Generate Callbacks ##########################################################
-
-def gen_register(f, func_list):
-  for func in func_list:
-    offset = 2
-    if func.startswith("zer") or func.startswith("zex"):
-      offset = 3
-    reg_fname = "ZeLoader::get().zelTracer" + func[offset:] + "RegisterCallback_"
-    f.write("    if (" + reg_fname + " != nullptr) {\n")
-    f.write("      status = " + reg_fname + "(tracer, ZEL_REGISTER_PROLOGUE, " + func + "OnEnter);\n")
-    f.write("      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-    f.write("      status = " + reg_fname + "(tracer, ZEL_REGISTER_EPILOGUE, " + func + "OnExit);\n")
-    f.write("      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-    f.write("    }\n")
-
-def gen_api(f, func_list, kfunc_list):
-  f.write("void EnableTracing(zel_tracer_handle_t tracer) {\n")
-  f.write("  ze_result_t status = ZE_RESULT_SUCCESS;\n")
-  f.write("  if (options_.api_tracing) {\n")
-  gen_register(f, func_list)
-  f.write("  }\n")
-  f.write("  else if (options_.kernel_tracing) {\n")
-  gen_register(f, kfunc_list)
-  f.write("  }\n")
-  f.write("\n")
-  f.write("  status = ZE_FUNC(zelTracerSetEnabled)(tracer, true);\n")
-  f.write("  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);\n")
-  f.write("}\n")
-  
-  f.write("\n")
-
-def gen_structure_type_converter(f, enum_map):
-  struct_type_enum = {}
-  for name in enum_map["ze_structure_type_t"]:
-    struct_type_enum[name] = int(enum_map["ze_structure_type_t"][name])
-  struct_type_enum = sorted(struct_type_enum.items(), key=lambda x:x[1])
-  assert "ze_structure_type_t" in enum_map
-  f.write("static const char* GetStructureTypeString(unsigned structure_type) {\n")
-  f.write("  switch (structure_type) {\n")
-  for name, value in struct_type_enum:
-    f.write("    case " + name + ":\n")
-    f.write("      return \"" + name + "\";\n")
-  f.write("    default:\n")
-  f.write("      break;\n")
-  f.write("  }\n")
-  f.write("  return \"UNKNOWN\";\n")
-  f.write("}\n")
-  f.write("\n")
-
-def gen_result_converter(f, enum_map):
-  result_enum = {}
-  for name in enum_map["ze_result_t"]:
-    result_enum[name] = int(enum_map["ze_result_t"][name])
-  result_enum = sorted(result_enum.items(), key=lambda x:x[1])
-  assert "ze_result_t" in enum_map
-  f.write("static const char* GetResultString(unsigned result) {\n")
-  f.write("  switch (result) {\n")
-  for name, value in result_enum:
-    f.write("    case " + name + ":\n")
-    f.write("      return \"" + name + "\";\n")
-  f.write("    default:\n")
-  f.write("      break;\n")
-  f.write("  }\n")
-  f.write("  return \"UNKNOWN\";\n")
-  f.write("}\n")
-  f.write("\n")
-
-def gen_enum(f, enum_map, enum_name, param_name):
-  assert enum_name in enum_map
-  f.write("    switch (" + param_name + ") {\n")
-  for name, value in enum_map[enum_name].items():
-    f.write("      case " + value + ":\n")
-    f.write("        stream << \"" + name + "\";\n")
-    f.write("        break;\n")
-  f.write("      default:\n")
-  f.write("        stream << \"<UNKNOWN>\";\n")
-  f.write("        break;\n")
-  f.write("    }\n")
-
-def get_kernel_tracing_callback(func):
-  d = os.path.dirname(os.path.abspath(__file__))
-  d = d + "/../src/levelzero/"
-  cb = ""
-  func_ = func + "("
-  with open(os.path.join(d, 'ze_collector.h')) as fp:
-    if func_ in fp.read():
-      cb = func
-    fp.close()
-    return cb
-
-def gen_enter_callback(f, func, synchronize_func_list, params):
-  f.write("  ZeCollector* collector =\n")
-  f.write("    reinterpret_cast<ZeCollector*>(global_user_data);\n")
-
-  if (func in synchronize_func_list):
-    f.write("  std::vector<uint64_t> kids;\n")
-
-  cb = get_kernel_tracing_callback('OnEnter' + func[2:])
-  if (cb != ""):
-    f.write("\n")
-    f.write("  if (collector->options_.kernel_tracing) {\n")
-    if (func in synchronize_func_list):
-      f.write("    " + cb + "(params, global_user_data, instance_user_data, &kids);\n")
-      f.write("    if (kids.size() != 0) {\n")
-      f.write("        ze_instance_data.kid = kids[0];\n") # pass kid to the exit callback
-      f.write("    }\n")
-      f.write("    else {\n")
-      f.write("        ze_instance_data.kid = (uint64_t)(-1);\n")
-      f.write("    }\n")
-    else:
-      f.write("    " + cb + "(params, global_user_data, instance_user_data);\n")
-    f.write("  }\n")
-
-  f.write("\n")
-  f.write("  if (!UniController::IsCollectionEnabled()) {\n")
-  f.write("    ze_instance_data.start_time_host = 0;\n")
-  f.write("    return;\n")
-  f.write("  }\n")
-  f.write("\n")
-  f.write("  if (collector->options_.call_logging) {\n")
-  f.write("    std::string str;\n")
-  f.write("    str += \">>>> [\" + std::to_string(UniTimer::GetHostTimestamp()) + \"] \";\n")
-  f.write("    if (collector->options_.need_pid) {\n")
-  f.write("      str += \"<PID:\" + std::to_string(utils::GetPid()) + \"> \";\n")
-  f.write("    }\n")
-  f.write("    if (collector->options_.need_tid) {\n")
-  f.write("      str += \"<TID:\" + std::to_string((unsigned int)utils::GetTid()) + \"> \";\n")
-  f.write("    }\n")
-  f.write("    str += \"" + func + ":\";\n")
-  for name, type in params:
-    if type in IPC_HANDLE_TYPES:
-      f.write("    str += \" " + name + " = \" ;\n")
-      f.write("    TO_HEX_STRING(str, (params->p" + name + ")->data);\n")
-    else:
-      if type.find("char*") >= 0 and type.find("char*") == len(type) - len("char*"):
-        if func == "zeModuleGetFunctionPointer" or func == "zeModuleGetGlobalPointer" or func == "zeDriverGetExtensionFunctionAddress":
-          f.write("    if (*(params->p" + name + ") == nullptr) {\n")
-          f.write("      str += \" " + name + " = 0\";\n")
-          f.write("    } else if (strlen(*(params->p" + name +")) == 0) {\n")
-          f.write("      str += \" " + name + " = \\\"\\\"\";\n")
-          f.write("    } else {\n")
-          f.write("      str += \" " + name + " = \\\"\" + std::string(*(params->p" + name + ")) + \"\\\"\";\n")
-          f.write("    }\n")
-        else:
-          f.write("    if (*(params->p" + name + ") == nullptr) {\n")
-          f.write("      str += \" " + name + " = 0\";\n")
-          f.write("    } else {\n")
-          f.write("      str += \" " + name + " = \";\n")
-          f.write("      TO_HEX_STRING(str, *(params->p" + name + "));\n")
-          f.write("    }\n")
-      else:
-        f.write("    str += \" " + name + " = \" ;\n")
-        if not (name == "groupCounts" or name == "groupSizes"):
-          f.write("    TO_HEX_STRING(str, *(params->p" + name + "));\n")
-        if name == "pArgValue" and func == "zeKernelSetArgumentValue":
-          f.write("    void* argValuePtr = const_cast<void*>(*(params->ppArgValue));\n")
-          f.write("    if (!argValuePtr) {\n")
-          f.write("      str += \" (NULL)\";\n")
-          f.write("    } else if (*(params->pargSize) == 1) {\n")
-          f.write("      str += \" ArgValue = \";\n")
-          f.write("      TO_HEX_STRING(str, *(reinterpret_cast<uint8_t *>(argValuePtr)));\n")
-          f.write("    } else if (*(params->pargSize) == 2) {\n")
-          f.write("      str += \" ArgValue = \";\n")
-          f.write("      TO_HEX_STRING(str, *(reinterpret_cast<uint16_t *>(argValuePtr)));\n")
-          f.write("    } else if (*(params->pargSize) == 4) {\n")
-          f.write("      str += \" ArgValue = \";\n")
-          f.write("      TO_HEX_STRING(str, *(reinterpret_cast<uint32_t *>(argValuePtr)));\n")
-          f.write("    } else if (*(params->pargSize) == 8) {\n")
-          f.write("      str += \" ArgValue = \";\n")
-          f.write("      TO_HEX_STRING(str, *(reinterpret_cast<uint64_t *>(argValuePtr)));\n")
-          f.write("    } else {\n")
-          f.write("      // do nothing\n")
-          f.write("    }\n")
-        if name.find("Kernel") >= 0 and func in ["zeCommandListAppendLaunchKernel", "zeCommandListAppendLaunchKernelIndirect",
-                                                "zeCommandListAppendLaunchCooperativeKernel", "zeCommandListAppendLaunchKernelWithParameters",
-                                                "zeCommandListAppendLaunchKernelWithArguments"]:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      bool demangle = collector->options_.demangle;\n")
-          f.write("      std::string kernel_name =\n")
-          f.write("        GetKernelName(*(params->p" + name + "), demangle);\n")
-          f.write("      if (!kernel_name.empty()) {\n")
-          f.write("        str += \" (\" + kernel_name + \")\";\n")
-          f.write("      }\n")
-          f.write("    }\n")
-        if name.find("ph") == 0 or name.find("pptr") == 0 or name.find("pCount") == 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          if type.endswith("*") and type[:-1] in IPC_HANDLE_TYPES:
-            f.write("      str += \" (" + name[1:] + " = \" ;\n")
-            f.write("      TO_HEX_STRING(str, (*(params->p" + name + "))->data);\n")
-          elif type == "ze_event_handle_t*" and func != "zeEventCreate":
-            prev_name = ''
-            for n,t in params:
-              if n == name:
-                break
-              prev_name = n
-            if prev_name == "numEvents" or prev_name == "numWaitEvents":
-              f.write("      str += \" (" + name[1:] + " = [\";\n")
-              f.write("      auto phWaitEvents = *(params->p"+ name + ");\n")
-              f.write("      auto numWaitEvents = *(params->p" + prev_name + ");\n")
-              f.write("      while(numWaitEvents > 0) {\n")
-              f.write("        TO_HEX_STRING(str, (*phWaitEvents));\n")
-              f.write("        numWaitEvents--;\n")
-              f.write("        if (numWaitEvents > 0)\n")
-              f.write("          str +=\", \";\n")
-              f.write("        phWaitEvents = phWaitEvents + 1;\n")
-              f.write("      }\n")
-              f.write("      str += \"])\";\n")
-          else:
-            f.write("      str += \" (" + name[1:] + " = \" ;\n")
-            f.write("      TO_HEX_STRING(str, **(params->p" + name + "));\n")
-            f.write("      str += \")\";\n")
-          f.write("    }\n")
-        elif type.find("ze_group_count_t*") >= 0:
-          f.write("    if (*(params->p" + name +") != nullptr) {\n")
-          f.write("      str += \" {\" + std::to_string((*(params->p" + name + "))->groupCountX) + \", \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->groupCountY) + \", \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->groupCountZ) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_group_count_t") >=0:
-          f.write("      str += \" {\" + std::to_string(((params->p" + name + "))->groupCountX) + \", \";\n")
-          f.write("      str += std::to_string(((params->p" + name + "))->groupCountY) + \", \";\n")
-          f.write("      str += std::to_string(((params->p" + name + "))->groupCountZ) + \"}\";\n")
-        elif type.find("ze_group_size_t") >=0:
-          f.write("      str += \" {\" + std::to_string(((params->p" + name + "))->groupSizeX) + \", \";\n")
-          f.write("      str += std::to_string(((params->p" + name + "))->groupSizeY) + \", \";\n")
-          f.write("      str += std::to_string(((params->p" + name + "))->groupSizeZ) + \"}\";\n")
-        elif type.find("ze_event_pool_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->count) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_command_queue_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->ordinal) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->index) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->mode) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->priority) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_kernel_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      if ((*(params->p" + name + "))->pKernelName == nullptr) {\n")
-          f.write("        str += \"0\";\n")
-          f.write("      } else if (strlen((*(params->p" + name + "))->pKernelName) == 0) {\n")
-          f.write("        str += \" " + name + " = \\\"\\\"\";\n")
-          f.write("      } else {\n")
-          f.write("        str += \"\\\"\" + std::string((*(params->p" + name + "))->pKernelName) + \"\\\"\";\n")
-          f.write("        if (collector->options_.demangle) {\n")
-          f.write("          str += \" (\" + utils::Demangle((*(params->p" + name + "))->pKernelName) + \")\";\n")
-          f.write("        }\n")
-          f.write("      str += \"}\";\n")
-          f.write("      }\n")
-          f.write("    }\n")
-        elif type.find("ze_device_mem_alloc_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->ordinal) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_context_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_command_list_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->commandQueueGroupOrdinal) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_event_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->index) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->signal) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->wait) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_fence_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_image_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->type) + \" \";\n")
-          f.write("      str += \"{\" + std::to_string((long long unsigned int)(*(params->p" + name +"))->format.layout) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format.type) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format.x) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format.y) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format.z) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format.w) + \"} \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->width) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->height) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->depth) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->arraylevels) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->miplevels) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_host_mem_alloc_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_external_memory_export_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_module_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->format) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->inputSize) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)static_cast<const void*>((*(params->p" + name + "))->pInputModule)) + \" \";\n")
-          f.write("      if ((*(params->p" + name + ")) -> pBuildFlags != nullptr)\n")
-          f.write("        str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pBuildFlags) + \" \";\n")
-          f.write("      else str += \"0 \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pConstants) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_sampler_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->addressMode) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->filterMode) + \" \";\n")
-          f.write("      str += std::to_string((long long unsigned int)static_cast<const unsigned char>((*(params->p" + name + "))->isNormalized)) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_physical_mem_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->size) + \"}\";\n")
-          f.write("    }\n")
-        elif type.find("ze_raytracing_mem_alloc_ext_desc_t*") >= 0:
-          f.write("    if (*(params->p" + name + ") != nullptr) {\n")
-          f.write("      str += \" {\";\n")
-          f.write("      str += GetStructureTypeString((*(params->p" + name + "))->stype);\n")
-          f.write("      std::stringstream hexstream;")
-          f.write("      hexstream << std::hex << (*(params->p" + name + "))->stype;")
-          f.write("      str += \"(0x\"+ hexstream.str() + \") \";\n")
-          f.write("      str += std::to_string((long long unsigned int)(*(params->p" + name + "))->pNext) + \" \";\n")
-          f.write("      str += std::to_string((*(params->p" + name + "))->flags) + \"}\";\n")
-          f.write("    }\n")
-  f.write("    str += \"\\n\";\n")
-  f.write("    collector->logger_->Log(str);\n")
-  f.write("  }\n")
-  
-  f.write("  uint64_t start_time_host = 0;\n")
-  f.write("  start_time_host = UniTimer::GetHostTimestamp();\n")
-
-  f.write("  ze_instance_data.start_time_host = start_time_host;\n")
-
-def gen_exit_callback(f, func, return_type, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, params, tracing_id=None):
-  func_name_offset = 2
-  if func.startswith("zer") or func.startswith("zex"):
-    func_name_offset = 3
-  # For extension APIs, use the provided tracing_id; for regular APIs, compute from func name
-  if tracing_id is None:
-    tracing_id = func[func_name_offset:] + "TracingId"
-
-  f.write("  uint64_t end_time_host = 0;\n")
-  f.write("  end_time_host = UniTimer::GetHostTimestamp();\n")
-  
-  f.write("  ZeCollector* collector =\n")
-  f.write("    reinterpret_cast<ZeCollector*>(global_user_data);\n")
-
-  cb = get_kernel_tracing_callback('OnExit' + func[func_name_offset:])
-
-  if ((func in submission_func_list) or (func in synchronize_func_list_on_enter) or (func in synchronize_func_list_on_exit)):
-    f.write("  std::vector<uint64_t> kids;\n")
-
-  if (func in synchronize_func_list_on_enter):	# enter callback pass the kids to exit callback
-    f.write("  if (ze_instance_data.kid != (uint64_t)(-1)) {\n")
-    f.write("      kids.push_back(ze_instance_data.kid);\n")
-    f.write("  }\n")
-
-  if (cb != ""):
-    f.write("\n")
-    f.write("  if (collector->options_.kernel_tracing) {\n")
-    if ((func in submission_func_list) or (func in synchronize_func_list_on_exit)):
-      f.write("    " + cb + "(params, result, global_user_data, instance_user_data, &kids);\n")
-    else:
-      f.write("    " + cb + "(params, result, global_user_data, instance_user_data);\n")
-    f.write("  }\n")
-
-  # Intercept extension API function pointers regardless of collection state,
-  # so that extension functions are always intercepted even if collection is
-  # enabled later.
-  if func == "zeDriverGetExtensionFunctionAddress":
-    f.write("\n")
-    f.write("  // Intercept extension API function pointers (graph APIs, etc.)\n")
-    f.write("  if (result == ZE_RESULT_SUCCESS && *(params->pname) != nullptr && *(params->pppFunctionAddress) != nullptr) {\n")
-    f.write("    collector->InterceptExtensionApiInternal(*(params->pname), *(params->pppFunctionAddress));\n")
-    f.write("  }\n")
-
-  f.write("\n")
-  f.write("  if (!UniController::IsCollectionEnabled()) {\n")
-  f.write("      return;\n")
-  f.write("  }\n")
-  f.write("  uint64_t start_time_host = ze_instance_data.start_time_host;\n")
-  f.write("\n")
-  f.write("  if (start_time_host == 0) {\n")
-  f.write("    return;\n")
-  f.write("  }\n")
-  f.write("\n")
-  
-  f.write("  uint64_t time;\n")
-  f.write("  time = end_time_host - start_time_host;\n")
-  f.write("  if (collector->options_.host_timing) {\n")
-  f.write("    collector->CollectHostFunctionTimeStats(" + tracing_id + ", time);\n")
-  f.write("  }\n")
-
-  f.write("  if (collector->options_.call_logging) {\n")
-  f.write("    std::string str;\n")
-  f.write("    str += \"<<<< [\" + std::to_string(end_time_host) + \"] \";\n")
-  f.write("    if (collector->options_.need_pid) {\n")
-  f.write("      str += \"<PID:\" + std::to_string(utils::GetPid()) + \"> \";\n")
-  f.write("    }\n")
-  f.write("    if (collector->options_.need_tid) {\n")
-  f.write("      str += \"<TID:\" + std::to_string((unsigned int)utils::GetTid()) + \"> \";\n")
-  f.write("    }\n")
-  f.write("    str +=\""+ func + "\";\n")
-  f.write("    str += \" [\" + std::to_string(time) + \" ns]\";\n")
-  if return_type.startswith("ze_result_t"):
-    result_block_present = False
-    for name, type in params:
-      if name.find("ph") == 0:
-        if not result_block_present:
-          f.write("    if (result == ZE_RESULT_SUCCESS) {\n")
-          result_block_present = True
-        if func == "zeDeviceGet" or func == "zeDeviceGetSubDevices":
-          f.write("      if (*(params->p" + name + ") != nullptr &&\n")
-          f.write("          *(params->ppCount) != nullptr) {\n")
-          f.write("        for (uint32_t i = 0; i < **(params->ppCount); ++i) {\n")
-          f.write("          str += \" " + name[1:] + "[\";\n")
-          f.write("          str += std::to_string(i);\n")
-          f.write("          str += \"] = \";\n")
-          f.write("          TO_HEX_STRING(str, (*(params->p" + name + "))[i]);\n")
-          f.write("        }\n")
-          f.write("      }\n")
-        else:
-          f.write("      if (*(params->p" + name + ") != nullptr) {\n")
-          if type.endswith("*") and type[:-1] in IPC_HANDLE_TYPES:
-            f.write("        str += \" " + name[1:] + " = \";\n")
-            f.write("        str += (*(params->p" + name + "))->data;\n")
-
-          else:
-            f.write("        str += \" " + name[1:] + " = \";\n")
-            f.write("        TO_HEX_STRING(str, **(params->p" + name + "));\n")
-
-          f.write("      }\n")
-      elif name.find("pptr") == 0 or name == "pCount" or name == "pSize":
-        if not result_block_present:
-          f.write("    if (result == ZE_RESULT_SUCCESS) {\n")
-          result_block_present = True
-        f.write("      if (*(params->p" + name + ") != nullptr) {\n")
-        if type.endswith("*") and type[:-1] in IPC_HANDLE_TYPES:
-          f.write("        str += \" " + name[1:] + " = \";\n")
-          f.write("        TO_HEX_STRING(str, (*(params->p" + name + "))->data);\n")
-
-        else:
-          f.write("        str += \" " + name[1:] + " = \" ;\n")
-          f.write("        TO_HEX_STRING(str, **(params->p" + name + "));\n")
-        f.write("      }\n")
-      elif name.find("groupSize") == 0 and type.find("uint32_t*") == 0:
-        if not result_block_present:
-          f.write("    if (result == ZE_RESULT_SUCCESS) {\n")
-          result_block_present = True
-        f.write("      if (*(params->p" + name + ") != nullptr) {\n")
-        f.write("        str += \" " + name + " = \" ;\n")
-        f.write("        TO_HEX_STRING(str, **(params->p" + name + "));\n")
-        f.write("      }\n")
-      elif name == "pName":
-        if not result_block_present:
-          f.write("    if (result == ZE_RESULT_SUCCESS) {\n")
-          result_block_present = True
-        f.write("      if (*(params->p" + name + ") != nullptr) {\n")
-        f.write("        if (strlen(*(params->p" + name +")) == 0) {\n")
-        f.write("          str += \" " + name[1:] + " = \\\"\\\"\";\n")
-        f.write("        } else {\n")
-        f.write("          str += \" " + name[1:] + " = \\\"\";\n")
-        f.write("          TO_HEX_STRING(str, *(params->p" + name + "));\n")
-        f.write("          str += \"\\\"\";\n")
-        f.write("        }\n")
-        f.write("      }\n")
-    if result_block_present:
-      f.write("    }\n")
-    f.write("    str += \" -> \";\n")
-    f.write("    str +=  GetResultString(result);\n")
-    f.write("    str += \"(0x\" + std::to_string(result) + \")\\n\";\n")
-
-
-  if func == "zeModuleCreate":
-    f.write("    bool aot = (*(params->pdesc))->format;\n")
-    f.write("    unsigned int kcount = 0;\n")
-    f.write("    if (ZE_FUNC(zeModuleGetKernelNames)(**(params->pphModule), &kcount, NULL) == ZE_RESULT_SUCCESS) {\n")
-    f.write("      if (aot) {\n")
-    f.write("        str += \"AOT (AOT_BINARY) \";\n")
-    f.write("      }\n")
-    f.write("      else {\n")
-    f.write("        str += \"JIT (IL_SPIRV) \";\n")
-    f.write("      }\n")
-    f.write("      str += \"kernels in module: \" + std::to_string(kcount) + \"\\n\";\n")
-    f.write("    }\n")
-
-    f.write("    char *p = (char *)malloc(kcount * 1024 + kcount * sizeof(char **));\n")
-    f.write("    const char **knames = (const char **)p;\n")
-    f.write("    char *q = p + kcount * sizeof(char **);\n")
-    f.write("    for (unsigned int i = 0; i < kcount; i++) {\n")
-    f.write("      knames[i] = q;\n")
-    f.write("      q += 1024;\n")
-    f.write("    }\n")
-
-    f.write("    if (ZE_FUNC(zeModuleGetKernelNames)(**(params->pphModule), &kcount, knames) == ZE_RESULT_SUCCESS) {\n")
-    f.write("      for (unsigned int i = 0; i < kcount; i++) {\n")
-    f.write("        str += \"Kernel #\" + std::to_string(i) + \": \" + knames[i] + \"\\n\";\n")
-    f.write("      }\n")
-    f.write("    }\n")
-    f.write("    free(p);\n")
-
-  f.write("    collector->logger_->Log(str);\n")
-  f.write("  }\n")
-  f.write("\n")
-  f.write("  if (collector->fcallback_ != nullptr) {\n")
-  if ((func in submission_func_list) or (func in synchronize_func_list_on_enter) or (func in synchronize_func_list_on_exit)):
-    f.write("    if (kids.size() == 0) {\n")
-    f.write("      collector->fcallback_(\n")
-    f.write("          nullptr, FLOW_NUL,\n")
-    f.write("          "+tracing_id+",\n")
-    f.write("          start_time_host, end_time_host);\n")
-    f.write("    }\n")
-    f.write("    else {\n")
-    if (func in submission_func_list):
-      f.write("      collector->fcallback_(\n")
-      f.write("          &kids, FLOW_H2D,\n")
-      f.write("          "+tracing_id+",\n")
-      f.write("          start_time_host, end_time_host);\n")
-    else:
-      f.write("      collector->fcallback_(\n")
-      f.write("          &kids, FLOW_D2H,\n")
-      f.write("          "+tracing_id+",\n")
-      f.write("          start_time_host, end_time_host);\n")
-    f.write("    }\n")
-  else:
-    f.write("      collector->fcallback_(\n")
-    f.write("          nullptr, FLOW_NUL,\n")
-    f.write("          "+tracing_id+",\n")
-    f.write("          start_time_host, end_time_host);\n")
-  f.write("  }\n")
-
-def gen_callbacks(f, func_dict, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map):
-  for func in func_dict:
-    f.write("static void " + func + "OnEnter(\n")
-    f.write("    [[maybe_unused]] " + func_dict[func][0] + "\n")
-    f.write("    [[maybe_unused]] "+ func_dict[func][1] +"\n")
-    f.write("    void* global_user_data,\n")
-    f.write("    [[maybe_unused]] void** instance_user_data) {\n")
-    # Skip callback if called re-entrantly from an extension API wrapper
-    f.write("  if (s_extension_api_tracing_in_progress_) return;\n")
-    gen_enter_callback(f, func, synchronize_func_list_on_enter, param_map[func])
-    f.write("}\n")
-    f.write("\n")
-    f.write("static void " + func + "OnExit(\n")
-    f.write("    [[maybe_unused]] " + func_dict[func][0] + "\n")
-    f.write("    [[maybe_unused]] " + func_dict[func][1] +"\n")
-    f.write("    void* global_user_data,\n")
-    f.write("    [[maybe_unused]] void** instance_user_data) {\n")
-    # Skip callback if called re-entrantly from an extension API wrapper
-    f.write("  if (s_extension_api_tracing_in_progress_) return;\n")
-    gen_exit_callback(f, func, func_dict[func][1], submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map[func])
-    f.write("}\n")
-    f.write("\n")
-
-def gen_to_hex_string_functions(f):
-    f.write("#include <string>\n")
-    f.write("#include <cstdio>\n")
-    f.write("#include <cstdint>\n")
-    f.write("#include <cstring>\n")  # For strcmp in extension interception
-    f.write("#define TO_HEX_STRING(str, val) \\\n")
-    f.write("    {char buffer[32]; \\\n")
-    if (sys.platform == 'win32'):
-        f.write("    sprintf_s(buffer, sizeof(buffer), \"0x%lx\", (uintptr_t)(val)); \\\n")
-    else:
-        f.write("    std::sprintf(buffer, \"0x%lx\", (uintptr_t)(val)); \\\n")
-    f.write("    str += std::string(buffer); \\\n")
-    f.write("    }\n")
-    f.write("\n")
-
-# Extension API Generation ####################################################
-
-def gen_extension_params_struct(f, func: FunctionDecl):
-  """Generate a params struct for an extension function."""
-  struct_name = get_ext_param_struct_name(func.name)
-  f.write("typedef struct _" + struct_name + " {\n")
-  for param in func.params:
-    ptr_name = get_param_struct_field_name(param)
-    f.write("    " + param.type + "* " + ptr_name + ";\n")
-  f.write("} " + struct_name + ";\n\n")
-
-def gen_extension_callback(f, func: FunctionDecl, submission_func_list):
-  """Generate OnEnter and OnExit callbacks for an extension function."""
-  struct_name = get_ext_param_struct_name(func.name)
-  tracing_id = func.name + "TracingId"
-
-  # Convert FunctionDecl.params to the format expected by gen_enter_callback/gen_exit_callback
-  # Format: list of (name, type) tuples
-  params = [(p.name, p.type) for p in func.params]
-
-  # OnEnter callback
-  f.write("static void " + func.name + "OnEnter(\n")
-  f.write("    [[maybe_unused]] " + struct_name + "* params,\n")
-  f.write("    [[maybe_unused]] ze_result_t result,\n")
-  f.write("    void* global_user_data,\n")
-  f.write("    [[maybe_unused]] void** instance_user_data) {\n")
-  gen_enter_callback(f, func.name, [], params)
-  f.write("}\n\n")
-
-  # OnExit callback. submission_func_list is forwarded so extension APIs that
-  # submit kernels (e.g. zeCommandListAppendGraphExp) emit FLOW_H2D links.
-  f.write("static void " + func.name + "OnExit(\n")
-  f.write("    [[maybe_unused]] " + struct_name + "* params,\n")
-  f.write("    ze_result_t result,\n")
-  f.write("    void* global_user_data,\n")
-  f.write("    [[maybe_unused]] void** instance_user_data) {\n")
-  gen_exit_callback(f, func.name, "ze_result_t", submission_func_list, [], [], params, tracing_id=tracing_id)
-  f.write("}\n\n")
-
-def gen_extension_wrapper(f, func: FunctionDecl):
-  """Generate a wrapper function that calls OnEnter/OnExit with params."""
-  struct_name = get_ext_param_struct_name(func.name)
-
-  # Function signature
-  params_str = ", ".join([p.type + " " + p.name for p in func.params])
-  f.write("static " + func.return_type + " " + func.name + "Wrapper(" + params_str + ") {\n")
-
-  # Populate params struct
-  f.write("  " + struct_name + " params;\n")
-  for param in func.params:
-    ptr_name = get_param_struct_field_name(param)
-    f.write("  params." + ptr_name + " = &" + param.name + ";\n")
-
-  f.write("\n")
-  f.write("  void* instance_data = nullptr;\n")
-  f.write("  ZeCollector* collector = s_global_ze_collector_;\n")
-  # Set recursion guard so that any L0 API calls made from within
-  # our callbacks do not re-enter kernel_tracing callbacks via zelTracer.
-  f.write("  s_extension_api_tracing_in_progress_ = true;\n")
-  f.write("  if (collector != nullptr) {\n")
-  f.write("    " + func.name + "OnEnter(&params, ZE_RESULT_SUCCESS, collector, &instance_data);\n")
-  f.write("  }\n")
-  f.write("\n")
-
-  # Call original function through ZeLoader
-  call_args_list = []
-  for p in func.params:
-    ptr_name = get_param_struct_field_name(p)
-    call_args_list.append("*params." + ptr_name)
-  call_args = ", ".join(call_args_list)
-  f.write("  " + func.return_type + " result = ZE_FUNC(" + func.name + ")(" + call_args + ");\n")
-  f.write("\n")
-
-  f.write("  if (collector != nullptr) {\n")
-  f.write("    " + func.name + "OnExit(&params, result, collector, &instance_data);\n")
-  f.write("  }\n")
-  f.write("  s_extension_api_tracing_in_progress_ = false;\n")
-  f.write("\n")
-  f.write("  return result;\n")
-  f.write("}\n\n")
-
-def gen_extension_interception(f, ext_funcs: List[FunctionDecl]):
-  """Generate the InterceptExtensionApi function."""
-  f.write("// Extension API interception - called from zeDriverGetExtensionFunctionAddress exit callback\n")
-  f.write("inline bool InterceptExtensionApiInternal(const char* name, void** ppFunctionAddress) {\n")
-  f.write("  if (ppFunctionAddress == nullptr || *ppFunctionAddress == nullptr || name == nullptr) {\n")
-  f.write("    return false;\n")
-  f.write("  }\n")
-  f.write("\n")
-
-  for func in ext_funcs:
-    f.write("  if (strcmp(name, \"" + func.name + "\") == 0) {\n")
-    f.write("    ZeLoader::get()." + func.name + "_ = reinterpret_cast<decltype(&" + func.name + ")>(*ppFunctionAddress);\n")
-    f.write("    *ppFunctionAddress = reinterpret_cast<void*>(&" + func.name + "Wrapper);\n")
-    f.write("    return true;\n")
-    f.write("  }\n")
-
-  f.write("\n")
-  f.write("  return false;\n")
-  f.write("}\n\n")
-
-def gen_extension_api_tracing(f, types_f, ext_funcs: List[FunctionDecl], submission_func_list,
-                              core_func_names):
-  """Generate all extension API tracing code."""
-  if not ext_funcs:
-    return
-
-  # Filter out functions with L0 header uncommon behavior (reference params, struct by value, etc.)
-  # and the ones that graduated into the core API, which the core generator covers.
-  filtered_funcs = [func for func in ext_funcs
-                    if func.name not in SKIPPED_EXTENSION_APIS
-                    and func.name not in core_func_names]
-
-  if not filtered_funcs:
-    return
-
-  f.write("\n// ============== Extension API Tracing ==============\n\n")
-
-  # Generate params structs
-  types_f.write("// Extension API parameter structures\n")
-  for func in filtered_funcs:
-    gen_extension_params_struct(types_f, func)
-
-  # Generate OnEnter/OnExit callbacks
-  f.write("// Extension API callbacks\n")
-  for func in filtered_funcs:
-    gen_extension_callback(f, func, submission_func_list)
-
-  # Generate wrapper functions
-  f.write("// Extension API wrappers\n")
-  for func in filtered_funcs:
-    gen_extension_wrapper(f, func)
-
-  # Generate interception function
-  gen_extension_interception(f, filtered_funcs)
-
-def main():
-  if len(sys.argv) < 3:
-    print("Usage: python gen_tracing_header.py <output_include_path> <l0_include_path>")
-    return
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  dst_file_path = os.path.join(dst_path, "tracing.gen")
-  if (os.path.isfile(dst_file_path)):
-    os.remove(dst_file_path)
-
-  dst_file = open(dst_file_path, "wt")
-  gen_to_hex_string_functions(dst_file)
-
-  l0_path = sys.argv[2]
-  l0_file_path = os.path.join(l0_path, "ze_api.h")
-
-  func_list = []
-  param_map = {}
-
-  func_dict = {}
-  l0_file = open(l0_file_path, "rt")
-  func_dict = get_func_dict(l0_file)
-  func_list = list(func_dict.keys())
-  add_param_map(l0_file, func_list, param_map)
-
-  l0_exp_path = os.path.join(l0_path, "layers", "zel_tracing_register_cb.h")
-  l0_exp_file = open(l0_exp_path, "rt")
-  exp_func_list = []
-  exp_func_dict = get_func_dict(l0_exp_file)
-  exp_func_list = list(exp_func_dict.keys())
-  add_param_map(l0_exp_file, exp_func_list, param_map)
-
-  func_dict.update(exp_func_dict)
-  func_list += exp_func_list
-
-  kfunc_list = [
-      "zeEventCreate",
-      "zeEventDestroy",
-      "zeEventHostReset",
-      "zeEventPoolCreate",
-      "zeCommandListAppendEventReset",
-      "zeCommandListAppendLaunchKernel",
-      "zeCommandListAppendLaunchCooperativeKernel",
-      "zeCommandListAppendLaunchKernelIndirect",
-      "zeCommandListAppendLaunchKernelWithArguments",
-      "zeCommandListAppendLaunchKernelWithParameters",
-      "zeCommandListAppendMemoryCopy",
-      "zeCommandListAppendMemoryFill",
-      "zeCommandListAppendBarrier",
-      "zeCommandListAppendMemoryRangesBarrier",
-      "zeCommandListAppendMemoryCopyRegion",
-      "zeCommandListAppendMemoryCopyFromContext",
-      "zeCommandListAppendImageCopy",
-      "zeCommandListAppendImageCopyRegion",
-      "zeCommandListAppendImageCopyToMemory",
-      "zeCommandListAppendImageCopyFromMemory",
-      "zeCommandListAppendSignalEvent",
-      "zeCommandListAppendWaitOnEvents",
-      "zeCommandQueueExecuteCommandLists",
-      "zeCommandListClose",
-      "zeCommandListCreate",
-      "zeCommandListCreateImmediate",
-      "zeCommandListDestroy",
-      "zeCommandListReset",
-      "zeCommandQueueCreate",
-      "zeCommandQueueSynchronize",
-      "zeDeviceSynchronize",
-      "zeCommandQueueDestroy",
-      "zeImageCreate",
-      "zeImageDestroy",
-      "zeModuleCreate",
-      "zeModuleDestroy",
-      "zeKernelCreate",
-      "zeKernelSetGroupSize",
-      "zeKernelDestroy",
-      "zeEventHostSynchronize",
-      "zeCommandListHostSynchronize",
-      "zeEventQueryStatus",
-      "zeFenceHostSynchronize",
-      "zeContextDestroy",
-      "zeCommandListImmediateAppendCommandListsExp",
-      "zeDriverGetExtensionFunctionAddress"]
-
-  # Stable graph APIs. The Exp ones are traced by wrapping the pointers returned
-  # from zeDriverGetExtensionFunctionAddress; these are core, so they need callbacks.
-  kfunc_list += [
-      "zeCommandListBeginGraphCaptureExt",
-      "zeCommandListBeginCaptureIntoGraphExt",
-      "zeCommandListEndGraphCaptureExt",
-      "zeGraphInstantiateExt",
-      "zeCommandListAppendGraphExt",
-      "zeGraphDestroyExt",
-      "zeExecutableGraphDestroyExt"]
-
-  command_list_func_list = [
-      "zeCommandListAppendEventReset",
-      "zeCommandListAppendLaunchKernel",
-      "zeCommandListAppendLaunchCooperativeKernel",
-      "zeCommandListAppendLaunchKernelIndirect",
-      "zeCommandListAppendLaunchKernelWithArguments",
-      "zeCommandListAppendLaunchKernelWithParameters",
-      "zeCommandListAppendMemoryCopy",
-      "zeCommandListAppendMemoryFill",
-      "zeCommandListAppendBarrier",
-      "zeCommandListAppendMemoryRangesBarrier",
-      "zeCommandListAppendMemoryCopyRegion",
-      "zeCommandListAppendMemoryCopyFromContext",
-      "zeCommandListAppendImageCopy",
-      "zeCommandListAppendImageCopyRegion",
-      "zeCommandListAppendImageCopyToMemory",
-      "zeCommandListAppendImageCopyFromMemory",
-      "zeCommandListImmediateAppendCommandListsExp"]
-
-  command_queue_func_list = [
-      "zeCommandQueueExecuteCommandLists"]
-    
-  submission_func_list = command_list_func_list.copy()
-  submission_func_list.append("zeCommandQueueExecuteCommandLists")
-  # AppendGraph replays captured commands; treat as a submission API so
-  # FLOW_H2D links are drawn into the replayed kernel records.
-  submission_func_list.append("zeCommandListAppendGraphExp")
-  submission_func_list.append("zeCommandListAppendGraphExt")
-
-  synchronize_func_list_on_enter = [
-      "zeEventDestroy",
-      "zeEventHostReset"]
-    
-  synchronize_func_list_on_exit = [
-      "zeEventHostSynchronize",
-      "zeEventQueryStatus",
-      "zeFenceHostSynchronize",
-      "zeCommandQueueSynchronize",
-      "zeDeviceSynchronize",
-      "zeCommandListHostSynchronize"]
-
-  enum_map = get_enum_map(l0_path)
-
-  gen_result_converter(dst_file, enum_map)
-  gen_structure_type_converter(dst_file, enum_map)
-  gen_callbacks(dst_file, func_dict, submission_func_list, synchronize_func_list_on_enter, synchronize_func_list_on_exit, param_map)
-  gen_api(dst_file, func_list, kfunc_list)
-
-  # Parse and generate extension API tracing
-  ext_funcs = []
-  for header_path in find_extension_headers(l0_path):
-    ext_funcs.extend(get_extension_functions(header_path))
-
-  types_file_path = os.path.join(dst_path, "tracing.gen.types")
-  if (os.path.isfile(types_file_path)):
-    os.remove(types_file_path)
-
-  types_file = open(types_file_path, "wt")
-  if ext_funcs:
-    gen_extension_api_tracing(dst_file, types_file, ext_funcs, submission_func_list,
-                              set(func_list))
-
-  types_file.close()
-  l0_exp_file.close()
-  l0_file.close()
-  dst_file.close()
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/gen_tracing_common_header.py b/tools/unitrace/scripts/gen_tracing_common_header.py
deleted file mode 100644
index 0fe397fb..00000000
--- a/tools/unitrace/scripts/gen_tracing_common_header.py
+++ /dev/null
@@ -1,227 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-import re
-
-from parse_l0_headers import find_extension_headers, get_extension_function_names
-
-# Function scans ze_api.h file from given path (l0_path) and 
-# generates list of l0 API of interest
-def get_func_list(file_list):
-  l0_func_list = []
-  l0_rt_func_list = []
-  for f in file_list:
-    for line in f.readlines():
-      if line.find("ZE_APICALL") != -1:
-        items = []
-        is_rt_func = False
-        if line.find("ze_pfn") != -1:
-          items = line.split("ze_pfn")
-        elif line.find("zer_pfn") != -1:
-          items = line.split("zer_pfn")
-          is_rt_func = True
-        if len(items) == 2 and items[1].find("Cb_t") != -1:
-          items = items[1].split("Cb_t")
-          if len(items) == 2:
-            if is_rt_func:
-              l0_rt_func_list.append(items[0].strip())
-            else:
-              l0_func_list.append(items[0].strip())
-  return l0_func_list, l0_rt_func_list
-
-def get_l0_api_list(l0_path):
-  file_list = []
-  l0_file_path = os.path.join(l0_path, "ze_api.h")
-  l0_exp_path = os.path.join(l0_path, "layers", "zel_tracing_register_cb.h")
-  try:
-    l0_file = open(l0_file_path, "rt")
-    file_list.append(l0_file)
-    l0_exp_file = open(l0_exp_path, "rt")
-    file_list.append(l0_exp_file)
-    l0_func_list = []
-    l0_rt_func_list = []
-    l0_func_list, l0_rt_func_list = get_func_list(file_list)
-  finally:
-    l0_file.close()
-    l0_exp_file.close()
-  return l0_func_list, l0_rt_func_list
-
-def get_extension_api_list(l0_path):
-  func_list = []
-  for header_path in find_extension_headers(l0_path):
-    func_list.extend(get_extension_function_names(header_path))
-  return func_list
-
-def get_ocl_api_list(ocl_path):
-  if (not os.path.exists(ocl_path)):
-    return []
-
-  ocl_file_path = os.path.join(ocl_path, "tracing_types.h")
-  ocl_file = open(ocl_file_path, "rt")
-  func_list = []
-  cl_function_id_found = False
-  for line in ocl_file.readlines():
-    line = line.strip()
-    if cl_function_id_found == True and line.find("CL_FUNCTION_COUNT") == -1:
-      if line.startswith("CL_FUNCTION_"):
-        api_name = line[len("CL_FUNCTION_"):line.find("=",len("CL_FUNCTION_"))]
-        func_list.append(api_name.strip())
-    elif line.find("ClFunctionId") != -1 or line.find("_cl_function_id") != -1:
-      cl_function_id_found = True
-  return func_list
-# =================== generate common header =======================
-
-# Func generates l0 enums from the list
-def gen_l0_enums(out_file, l0_func_list):
-  out_file.write("  L0StartTracingId,\n")
-  for func in l0_func_list:
-    out_file.write('  ' +func+'TracingId,\n')
-  out_file.write("  L0EndTracingId,\n")
-
-def gen_extension_enums(out_file, ext_func_list):
-  out_file.write("  ExtStartTracingId,\n")
-  for func in ext_func_list:
-    out_file.write('  ' +func+'TracingId,\n')
-  out_file.write("  ExtEndTracingId,\n")
-
-def get_ocl_enums(out_file, ocl_func_list):
-  out_file.write("  OCLStartTracingId,\n")
-  if len(ocl_func_list) > 0:
-    # first entry needs special care
-    out_file.write('  ' +ocl_func_list[0]+'TracingId = OCLStartTracingId,\n')
-    index = 1
-    while index < len(ocl_func_list):
-      out_file.write('  ' +ocl_func_list[index]+'TracingId,\n')
-      index = index + 1
-  out_file.write("  OCLEndTracingId,\n")
-
-# generate enums
-def gen_enums(out_file, l0_func_list, ext_func_list, ocl_func_list):
-  # header
-  out_file.write("typedef enum {\n")
-  # common enums
-  out_file.write("  UnknownTracingId,\n")
-  out_file.write("  DummyTracingId,\n")
-  out_file.write("  ZeKernelTracingId,\n")
-
-  #l0 enums
-  gen_l0_enums(out_file, l0_func_list)
-
-  #extension enums (graph APIs, etc.)
-  gen_extension_enums(out_file, ext_func_list)
-
-  #opencl enum
-  get_ocl_enums(out_file, ocl_func_list)
-  out_file.write("  ClKernelTracingId,\n")
-  out_file.write("  OpenClTracingId,\n")
-
-  #xpti api id
-  out_file.write("  XptiTracingId,\n")
-
-  #itt api id
-  out_file.write("  IttTracingId,\n")
-
-  #omp api id
-  out_file.write("  OmpTracingId,\n")
-
-  #footer
-  out_file.write("} API_TRACING_ID;\n")
-
-# Generates list of supported API names
-def gen_api_name_list(out_file, l0_func_list, l0_rt_func_list, ext_func_list, ocl_func_list):
-  #header
-  out_file.write("\n\n static std::string tracing_api_name [ ] = {\n")
-  
-  #generate l0 names first
-  for func in l0_func_list:
-    out_file.write("  \"ze"+func+"\",\n")
-
-  #generate l0 runtime names
-  for func in l0_rt_func_list:
-    out_file.write("  \"zer"+func+"\",\n")
-
-  #generate extension api names
-  for func in ext_func_list:
-    out_file.write("  \""+func+"\",\n")
-
-  #generate ocl names
-  for func in ocl_func_list:
-    out_file.write("  \""+func+"\",\n")  
-  
-  #footer
-  out_file.write("};\n")
-
-
-def gen_symbol_func(file_handle):
-  file_handle.write("\n#include \"cl_intel_ext.h\"\n")
-  # The id is an API_TRACING_ID or, for the OpenCL Intel extensions, a
-  # cl_ext_api_id (ClExtApiStart and up), so it is taken as a plain int. Each
-  # range maps to its own slice of tracing_api_name, which holds API names only
-  # (no marker or reserved ids), so ids cannot be bounded by its size.
-  file_handle.write("\n\nstatic std::string get_symbol(int id){\n")
-  file_handle.write("    constexpr int l0_count = L0EndTracingId - L0StartTracingId - 1;\n")
-  file_handle.write("    constexpr int ext_count = ExtEndTracingId - ExtStartTracingId - 1;\n")
-  file_handle.write("    constexpr int tracing_api_name_size = static_cast<int>(sizeof(tracing_api_name) / sizeof(tracing_api_name[0]));\n")
-  file_handle.write("    int index;\n")
-  file_handle.write("    if ((id > L0StartTracingId) && (id < L0EndTracingId)) {\n")
-  file_handle.write("      // L0+RT APIs: array starts at index 0\n")
-  file_handle.write("      index = id - L0StartTracingId - 1;\n")
-  file_handle.write("    } else if ((id > ExtStartTracingId) && (id < ExtEndTracingId)) {\n")
-  file_handle.write("      // Extension APIs: array starts after L0+RT APIs\n")
-  file_handle.write("      index = l0_count + (id - ExtStartTracingId - 1);\n")
-  file_handle.write("    } else if ((id >= OCLStartTracingId) && (id < OCLEndTracingId)) {\n")
-  file_handle.write("      // OCL APIs: array starts after L0+RT and Extension APIs\n")
-  file_handle.write("      index = l0_count + ext_count + (id - OCLStartTracingId);\n")
-  file_handle.write("    } else if ((id >= ClExtApiStart) && (id < ClExtApiEnd)) {\n")
-  file_handle.write("      return cl_ext_api[id - ClExtApiStart];\n")
-  file_handle.write("    } else {\n")
-  file_handle.write("      return \"UnknownAPIName\";\n")
-  file_handle.write("    }\n")
-  file_handle.write("    return (index < tracing_api_name_size) ? tracing_api_name[index] : \"UnknownAPIName\";\n")
-  file_handle.write("  }\n")
-
-def main():
-  if len(sys.argv) < 4:
-    print("Usage: python gen_tracing_common_header.py <output_include_path> <include_path> <ocl_path>")
-    sys.exit(1) # Non-zero indicates error
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  dst_file_path = os.path.join(dst_path, "common_header.gen")
-  if (os.path.isfile(dst_file_path)):
-    os.remove(dst_file_path)
-
-  dst_file = open(dst_file_path, "wt")
-
-  l0_path = sys.argv[2]
-  if not os.path.exists(l0_path):
-    print(f"Error: Level Zero include path does not exist: {l0_path}")
-    sys.exit(1)
-  l0_api_list, rt_l0_api_list = get_l0_api_list(l0_path)
-  ext_api_list = get_extension_api_list(l0_path)
-
-  ocl_path = sys.argv[3]
-  if ocl_path and not os.path.exists(ocl_path):
-    print(f"Warning: OpenCL include path does not exist: {ocl_path}")
-    sys.exit(1)
-  ocl_api_list = get_ocl_api_list(ocl_path)
-
-  dst_file.write("#ifndef PTI_TOOLS_COMMON_H_\n")
-  dst_file.write("#define PTI_TOOLS_COMMON_H_\n\n")
-
-  gen_enums(dst_file, l0_api_list + rt_l0_api_list, ext_api_list, ocl_api_list)
-  gen_api_name_list(dst_file, l0_api_list, rt_l0_api_list, ext_api_list, ocl_api_list)
-  gen_symbol_func(dst_file)
-
-  dst_file.write("#endif //PTI_TOOLS_COMMON_H_\n")
-  dst_file.close()
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/get_cl_headers.py b/tools/unitrace/scripts/get_cl_headers.py
deleted file mode 100644
index 1be0eadb..00000000
--- a/tools/unitrace/scripts/get_cl_headers.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import sys
-import os
-
-import build_utils
-
-url = "https://github.com/KhronosGroup/OpenCL-Headers.git"
-commit = "dcd5bede6859d26833cd85f0d6bbcee7382dc9b3"
-
-def main():
-  if len(sys.argv) < 3:
-    print("Usage: python get_cl_headers.py <include_path> <build_path>")
-    return 1
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.makedirs(dst_path, exist_ok=True)
-  dst_path = os.path.join(dst_path, "CL")
-  if (not os.path.exists(dst_path)):
-    os.makedirs(dst_path, exist_ok=True)
-
-  clone_path = sys.argv[2]
-  clone_path = os.path.join(clone_path, "OpenCL-Headers")
-  build_utils.clone(url, commit, clone_path)
-
-  src_path = os.path.join(clone_path, "CL")
-  build_utils.copy(src_path, dst_path, ["cl.h", "cl_gl.h", "cl_version.h", "cl_platform.h", "cl_ext.h"])
-
-if __name__ == "__main__":
-  sys.exit(main())
diff --git a/tools/unitrace/scripts/get_commit_hash.py b/tools/unitrace/scripts/get_commit_hash.py
deleted file mode 100644
index 459766b0..00000000
--- a/tools/unitrace/scripts/get_commit_hash.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import subprocess
-import sys
-import re
-
-def main():
-  if len(sys.argv) < 3:
-    print("Usage: python get_commit_hash.py <directory> <file_name>")
-    return
-
-  dir_path = sys.argv[1]
-  if (not os.path.exists(dir_path)):
-    os.mkdir(dir_path)
-
-  file_path = os.path.join(dir_path, sys.argv[2])
-  if (os.path.isfile(file_path)):
-    os.remove(file_path)
-
-  of = open(file_path, "wt")
-
-  of.write("#ifndef PTI_TOOLS_UNITRACE_COMMIT_HASH_H_\n")
-  of.write("#define PTI_TOOLS_UNITRACE_COMMIT_HASH_H_\n\n")
-
-  result = subprocess.run(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE, universal_newlines=True)
-  of.write("#define COMMIT_HASH \"")
-  of.write(result.stdout[0:len(result.stdout) - 1])
-  of.write("\"\n\n")
-
-  of.write("#endif /* PTI_TOOLS_UNITRACE_COMMIT_HASH_ */\n")
-  of.close()
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/get_compute_runtime_headers.py b/tools/unitrace/scripts/get_compute_runtime_headers.py
deleted file mode 100644
index 1098fc02..00000000
--- a/tools/unitrace/scripts/get_compute_runtime_headers.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import sys
-import os
-import subprocess
-
-import build_utils
-
-url = "https://github.com/intel/compute-runtime.git"
-commit = "050536ff3b6f830199ec99cff8ffcac3d804c40a"  # release 26.31.39395.14
-
-def postprocess(file_path):
-    """Post-process header file: remove non-local tracing header includes.
-
-    The compute-runtime repository uses internal include paths that need
-    to be adjusted for external inclusion.
-    """
-    try:
-        with open(file_path, "rt") as input_file:
-            lines = input_file.readlines()
-
-        with open(file_path + ".bk", "wt") as output_file:
-            for line in lines:
-                if line.find("#include \"opencl/source/tracing/tracing_types.h\"") >= 0:
-                    items = line.split("opencl/source/tracing/")
-                    if len(items) == 2:
-                        line = items[0] + items[1]
-                output_file.write(line)
-
-        # Replace original with processed version
-        os.remove(file_path)
-        os.rename(file_path + ".bk", file_path)
-    except IOError as e:
-        raise IOError(f"Failed to post-process {file_path}: {e}")
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python get_compute_runtime_headers.py <include_path> <build_path>")
-        return 1
-
-    dst_path = sys.argv[1]
-    if not os.path.exists(dst_path):
-        try:
-            os.makedirs(dst_path)
-        except OSError as e:
-            print(f"ERROR: Failed to create destination directory {dst_path}: {e}")
-            return 1
-
-    build_path = sys.argv[2]
-
-    try:
-        # Clone compute-runtime
-        clone_path = os.path.join(build_path, "compute-runtime")
-        print(f"Cloning compute-runtime to {clone_path}...")
-        build_utils.clone(url, commit, clone_path)
-
-        # Copy OpenCL tracing headers
-        cl_dst_path = os.path.join(dst_path, "CL")
-        if not os.path.exists(cl_dst_path):
-            os.makedirs(cl_dst_path)
-
-        src_path = os.path.join(clone_path, "opencl", "source", "tracing")
-        print(f"Copying OpenCL tracing headers from {src_path}...")
-        build_utils.copy(src_path, cl_dst_path, ["tracing_api.h", "tracing_types.h"])
-
-        postprocess(os.path.join(cl_dst_path, "tracing_api.h"))
-
-        src_path = os.path.join(clone_path, "opencl", "extensions", "public")
-        print(f"Copying OpenCL extension headers from {src_path}...")
-        build_utils.copy(src_path, cl_dst_path, ["cl_ext_private.h"])
-
-        # Copy Level Zero driver_experimental headers (zex_graph.h)
-        l0_dst_path = os.path.join(dst_path, "level_zero")
-        if not os.path.exists(l0_dst_path):
-            os.makedirs(l0_dst_path)
-
-        # Copy ze_stypes.h and ze_intel_gpu.h (required by extension headers)
-        src_path = os.path.join(clone_path, "level_zero", "include", "level_zero")
-        print(f"Copying Level Zero headers from {src_path}...")
-        build_utils.copy(src_path, l0_dst_path, ["ze_stypes.h", "ze_intel_gpu.h"])
-
-        l0_exp_dst_path = os.path.join(l0_dst_path, "driver_experimental")
-        if not os.path.exists(l0_exp_dst_path):
-            os.makedirs(l0_exp_dst_path)
-
-        src_path = os.path.join(clone_path, "level_zero", "include", "level_zero", "driver_experimental")
-        print(f"Copying Level Zero driver_experimental headers from {src_path}...")
-        # Copy all zex_*.h headers from driver_experimental
-        zex_headers = [f for f in os.listdir(src_path) if f.startswith("zex_") and f.endswith(".h")]
-        if "zex_graph.h" not in zex_headers:
-            raise FileNotFoundError(os.path.join(src_path, "zex_graph.h"))
-        build_utils.copy(src_path, l0_exp_dst_path, zex_headers)
-
-        print(f"SUCCESS: All headers copied to {dst_path}")
-        return 0
-
-    except (OSError, RuntimeError, subprocess.CalledProcessError) as e:
-        print(f"ERROR: Failed to extract headers: {e}")
-        return 1
-
-if __name__ == "__main__":
-  # Fail the build when the headers could not be fetched.
-  sys.exit(main())
diff --git a/tools/unitrace/scripts/get_iga_headers.py b/tools/unitrace/scripts/get_iga_headers.py
deleted file mode 100644
index 0908e13a..00000000
--- a/tools/unitrace/scripts/get_iga_headers.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import sys
-import os
-
-import build_utils
-
-url = "https://github.com/intel/intel-graphics-compiler.git"
-
-def main():
-  # Usage: python get_iga_headers.py <include_path> <build_path> <iga_commit>
-  # The IGA commit is passed in (from Unitrace's CMake) rather than hardcoded, so
-  # the pinned revision lives in one place: tools/unitrace/CMakeLists.txt.
-  if len(sys.argv) < 4:
-    print("Usage: python get_iga_headers.py <include_path> <build_path> <iga_commit>")
-    return
-
-  include_path = sys.argv[1]
-  if (not os.path.exists(include_path)):
-    os.mkdir(include_path)
-  dst_path = os.path.join(include_path, "iga")
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  clone_path = sys.argv[2]
-  clone_path = os.path.join(clone_path, "intel-graphics-compiler")
-
-  commit = sys.argv[3]
-  build_utils.clone(url, commit, clone_path)
-
-  src_path = os.path.join(clone_path, "visa")
-  src_path = os.path.join(src_path, "iga")
-  src_path = os.path.join(src_path, "IGALibrary")
-  src_path = os.path.join(src_path, "api")
-
-  # Only the C API headers reachable from iga.h.
-  build_utils.copy(src_path, dst_path,
-    ["iga.h",
-     "iga_types_ext.hpp",
-     "iga_types_swsb.hpp",
-     "iga_bxml_ops.hpp",
-     "iga_bxml_enums.hpp"])
-
-  # GFXCORE_FAMILY and PRODUCT_FAMILY, the values IGC records in a binary's notes.
-  igc_dst_path = os.path.join(include_path, "igc")
-  if (not os.path.exists(igc_dst_path)):
-    os.mkdir(igc_dst_path)
-  igc_src_path = os.path.join(clone_path, "inc", "common")
-  build_utils.copy(igc_src_path, igc_dst_path, ["igfxfmid.h"])
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/get_itt.py b/tools/unitrace/scripts/get_itt.py
deleted file mode 100644
index a17bbb63..00000000
--- a/tools/unitrace/scripts/get_itt.py
+++ /dev/null
@@ -1,96 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import platform
-import os
-import sys
-import shutil
-import subprocess
-
-url = "https://github.com/intel/ittapi.git"
-
-def clone(url, commit, clone_path):
-  if (not os.path.exists(clone_path)):
-    subprocess.call(["git", "clone", url, clone_path])
-    subprocess.call(["git", "checkout", commit], cwd = os.path.abspath(clone_path))
-
-def copy(src_path, dst_path, file_list):
-  for file in file_list:
-    dst_file = os.path.join(dst_path, file)
-    if os.path.isfile(dst_file):
-      os.remove(dst_file)
-
-    src_file = os.path.join(src_path, file)
-    assert os.path.isfile(src_file)
-
-    shutil.copy(src_file, dst_file)
-
-def build(build_dir, install_path):
-  curr_wrkng_dir = os.getcwd()
-  itt_dir = build_dir + "/ittapi"
-  os.chdir(itt_dir)
-  cmake_flags = []
-  if (install_path != ""):
-    cmake_flags.append("-DCMAKE_INSTALL_PREFIX=" + install_path)
-  if platform.system() == 'Windows':
-    subprocess.check_call(["cmake", "-G", "NMake Makefiles"] + cmake_flags + ["."])
-    subprocess.check_call(["nmake"])
-    if (install_path != ""):
-      subprocess.check_call(["nmake", "install"])
-    shutil.copyfile("./bin/libittnotify.lib", build_dir + "/libittnotify.lib")
-  else :
-    subprocess.check_call(["cmake"] + cmake_flags + ["."])
-    subprocess.check_call(["make"])
-    if (install_path != ""):
-      subprocess.check_call(["make", "install"])
-    shutil.copyfile("./bin/libittnotify.a", build_dir + "/libittnotify.a")
-
-  # Restore back the location
-  os.chdir(curr_wrkng_dir)
-
-def main():
-  if len(sys.argv) < 4:
-    print("Usage: python get_itt.py <include_path> <build_path> <commit_hash> [<cmake flags>]")
-    return
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-  dst_path = os.path.join(dst_path, "ittheaders")
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  clone_path = sys.argv[2]
-  clone_path = os.path.join(clone_path, "ittapi")
-
-  commit = sys.argv[3]
-  clone(url, commit, clone_path)
-
-  if len(sys.argv) > 4:
-    install_path = sys.argv[4]
-  else:
-    install_path = ""
-
-  src_path = os.path.join(clone_path, "src")
-  src_path = os.path.join(src_path, "ittnotify")
-  copy(src_path, dst_path, ["disable_warnings.h", "ittnotify_config.h",
-    "ittnotify_static.c", "ittnotify_static.h", "ittnotify_types.h"])
-
-  src_path = os.path.join(clone_path, "include")
-  copy(src_path, dst_path, ["ittnotify.h"])
-
-  dst_path = os.path.join(dst_path, "legacy")
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  src_path = os.path.join(src_path, "legacy")
-  copy(src_path, dst_path, ["ittnotify.h"])
-
-  # build ittnotify
-  build(sys.argv[2], install_path)
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/scripts/get_protobuf.py b/tools/unitrace/scripts/get_protobuf.py
deleted file mode 100644
index e9f7b3bd..00000000
--- a/tools/unitrace/scripts/get_protobuf.py
+++ /dev/null
@@ -1,97 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Clone and build protobuf (libprotobuf + protoc) from source into the build
-# tree, so unitrace never depends on a system protobuf install. Installs a
-# static, -fPIC build (no zlib dep) to <build_dir>/protobuf-install. Skips the
-# work if protoc is already present there.
-
-import glob
-import os
-import shutil
-import sys
-import subprocess
-
-URL = "https://github.com/protocolbuffers/protobuf.git"
-
-
-def _installed(install):
-    protoc = os.path.join(install, "bin", "protoc.exe" if os.name == "nt" else "protoc")
-    have_lib = bool(glob.glob(os.path.join(install, "lib*", "libprotobuf.*")) or
-                    glob.glob(os.path.join(install, "lib*", "*protobuf*.lib")))
-    return os.path.exists(protoc) and have_lib
-
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python get_protobuf.py <build_dir> <tag> [generator] [make_program] [build_type]")
-        return 1
-
-    build_dir = sys.argv[1]
-    tag = sys.argv[2]
-    # Match the parent's generator; on Windows this keeps Ninja
-    generator = sys.argv[3] if len(sys.argv) > 3 else ""
-    make_program = sys.argv[4] if len(sys.argv) > 4 else ""
-    parent_build_type = sys.argv[5] if len(sys.argv) > 5 else ""
-    src = os.path.join(build_dir, "protobuf")
-    bld = os.path.join(src, "build")
-    install = os.path.join(build_dir, "protobuf-install")
-
-    # Skip only if a COMPLETE install (protoc + lib) is already present.
-    if _installed(install):
-        return 0
-    # Otherwise clear any partial install so this run starts clean.
-    shutil.rmtree(install, ignore_errors=True)
-
-    if not os.path.exists(src):
-        if subprocess.call(["git", "clone", "--depth", "1", "--branch", tag, URL, src]) != 0:
-            return 1
-
-    cfg = ["cmake", "-S", src, "-B", bld]
-    if generator:
-        cfg += ["-G", generator]
-        if make_program:
-            cfg += ["-DCMAKE_MAKE_PROGRAM=" + make_program]
-    # Follow the parent's build type so the MSVC runtime matches; default Debug on
-    # Windows (unitrace's no-build-type default is /MDd), Release elsewhere.
-    build_type = parent_build_type or ("Debug" if os.name == "nt" else "Release")
-    cfg += [
-        "-Wno-dev",
-        "-DCMAKE_BUILD_TYPE=" + build_type,
-        "-Dprotobuf_BUILD_TESTS=OFF",
-        "-Dprotobuf_BUILD_SHARED_LIBS=OFF",
-        "-Dprotobuf_WITH_ZLIB=OFF",
-        "-DCMAKE_POSITION_INDEPENDENT_CODE=ON",
-        "-DCMAKE_INSTALL_PREFIX=" + install,
-        "-Dprotobuf_DEBUG_POSTFIX="
-    ]
-    if os.name == "nt":
-        # Dynamic CRT (not protobuf's default /MT) so the lib links into unitrace.
-        cfg += ["-Dprotobuf_MSVC_STATIC_RUNTIME=OFF"]
-        # Build version.rc without passing compiler flags (/bigobj etc.) to
-        # rc.exe, which rejects them (RC1106). Redefine the RC command to drop
-        # <FLAGS>, keeping only <DEFINES>. protobuf does this itself but only for
-        # cl.exe, not icx.
-        cfg += ["-DCMAKE_RC_COMPILE_OBJECT="
-                "<CMAKE_RC_COMPILER> /l0x409 <DEFINES> /fo<OBJECT> <SOURCE>"]
-
-    # protobuf is third-party; we don't fix its compiler warnings. (-w on
-    # GCC/Clang, /w on MSVC.)
-    nowarn = "/w" if os.name == "nt" else "-w"
-    cfg += ["-DCMAKE_C_FLAGS=" + nowarn, "-DCMAKE_CXX_FLAGS=" + nowarn]
-    if subprocess.call(cfg) != 0:
-        return 1
-
-    jobs = str(os.cpu_count() or 1)
-    if subprocess.call(["cmake", "--build", bld, "--target", "install", "-j", jobs]) != 0:
-        return 1
-
-    # Confirm the install is actually complete before reporting success.
-    return 0 if _installed(install) else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/scripts/get_ze_headers.py b/tools/unitrace/scripts/get_ze_headers.py
deleted file mode 100644
index 24c5e924..00000000
--- a/tools/unitrace/scripts/get_ze_headers.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import sys
-import os
-
-import build_utils
-
-url = "https://github.com/oneapi-src/level-zero.git"
-
-def main():
-  # The Level Zero version is pinned once, by LEVEL_ZERO_COMMIT_ID in cmake.
-  if len(sys.argv) < 4 or not sys.argv[3]:
-    print("Usage: python get_ze_headers.py <include_path> <build_path> <tag-or-commit>")
-    return 1
-
-  dst_path = sys.argv[1]
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-  dst_path = os.path.join(dst_path, "level_zero")
-  if (not os.path.exists(dst_path)):
-    os.mkdir(dst_path)
-
-  clone_path = sys.argv[2]
-  clone_path = os.path.join(clone_path, "level-zero")
-
-  commit = sys.argv[3]
-  build_utils.clone(url, commit, clone_path)
-
-  src_path = os.path.join(clone_path, "include")
-  build_utils.copy(src_path, dst_path,\
-    ["ze_api.h", "zes_api.h", "zet_api.h", "zer_api.h"])
-
-  if (not os.path.exists(os.path.join(dst_path, "layers"))):
-    os.mkdir(os.path.join(dst_path, "layers"))
-  src_path = os.path.join(clone_path, "include", "layers")
-  build_utils.copy(src_path, os.path.join(dst_path, "layers"),\
-    ["zel_tracing_api.h", "zel_tracing_register_cb.h"])
-
-if __name__ == "__main__":
-  sys.exit(main())
diff --git a/tools/unitrace/scripts/metrics/addrasm.py b/tools/unitrace/scripts/metrics/addrasm.py
deleted file mode 100644
index b0474ec0..00000000
--- a/tools/unitrace/scripts/metrics/addrasm.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-
-import os
-import argparse
-
-def ParseArguments():
-    argparser = argparse.ArgumentParser(description = "Add instruction pointers in GPU assembly")
-    argparser.add_argument('-o', '--output', required = True, help = "output .asm file with instruction pointers")
-    argparser.add_argument('input', help = '.asm file withour instruction pointers')
-    
-    return argparser.parse_args()
-
-def main(args):
-    if (os.path.isfile(args.input) == False):
-        print("File " + args.input + " does not exist or cannot be opened")
-        return
-
-    if (os.stat(args.input).st_size ==0):
-        print("File " + args.input + " is empty")
-        return
-
-    ip = 0
-    with open(args.input, "r") as inf:
-        with open(args.output, "w") as outf:
-            for row in inf:
-                if ((row.startswith("//") == False) and ("//" in row)):
-                    outf.write("/* [" + str('{:08X}'.format(ip)) + "] */ " + row)
-                    if ("Compacted" in row):
-                        ip = ip + 0x8
-                    else:
-                        ip = ip + 0x10
-                else:
-                    outf.write(row)
-                
-if __name__=="__main__":
-    main(ParseArguments())
diff --git a/tools/unitrace/scripts/metrics/analyzeperfmetrics.py b/tools/unitrace/scripts/metrics/analyzeperfmetrics.py
deleted file mode 100644
index 97e0b01e..00000000
--- a/tools/unitrace/scripts/metrics/analyzeperfmetrics.py
+++ /dev/null
@@ -1,1479 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import io
-import csv
-import socket
-import ssl
-import sys
-import re
-import shlex
-import subprocess
-import argparse
-import tempfile
-import pandas as pd
-import matplotlib.pyplot as plt
-
-from itertools import islice
-
-from matplotlib.backends.backend_pdf import PdfPages as pdf
-from http.server import HTTPServer, ThreadingHTTPServer, BaseHTTPRequestHandler
-from urllib.parse import unquote
-from pathlib import Path
-from dataclasses import dataclass, field
-from typing import Optional, List, Dict, Union
-
-@dataclass
-class DeviceInfo:
-    """One device's metric table: which file holds it and which lines of that file."""
-    device_id: int
-    metrics_file: Path
-    header_line: int
-    kind: str                                           # what ClassifyHeaderRow made of the header row
-    last_line: Optional[int] = field(default = None)    # None means "to the end of the file"
-
-    def __post_init__(self):
-        if not (self.metrics_file.exists() and
-                self.metrics_file.is_file() and
-                self.metrics_file.stat().st_size > 0):
-            raise ValueError(
-                f"DeviceInfo for device {self.device_id}: "
-                f"File '{self.metrics_file}' does not exist, is not a file, or is empty"
-        )
-
-    def get_device_data(self) -> Optional[pd.DataFrame]:
-        """Read the device's metric table into a DataFrame."""
-        try:
-            return ReadMetricFrame(self.metrics_file, self.header_line, self.last_line, self.kind)
-        except Exception as e:
-            print(f"Error reading device file {self.metrics_file}: {e}")
-            return None
-
-    def _print_data_from_df(self, df, of):
-        """Print the device's metrics and kernels to of."""
-        if (self.kind != "stall"):
-            for m in df.columns.values.tolist():
-                if (m == 'Kernel'):
-                    continue
-                print("        " + m, file = of)
-                if (m == 'StreamMarker'):
-                    break
-
-            kernel_and_instances = dict()
-            kernel = ""
-            for index, row in df.iterrows():
-                if (pd.isna(row['Kernel']) == True):
-                    if kernel in kernel_and_instances:
-                        kernel_and_instances[kernel] = kernel_and_instances[kernel] + 1
-                    else:
-                        if (kernel != ""):
-                            kernel_and_instances[kernel] = 1
-
-                    kernel = ""	# reset kernel name to empty
-                else:
-                    if (kernel == ""):
-                        kernel = row['Kernel']
-
-            print("    Kernel, Number of Instances", file = of)
-            for kernel, instances in kernel_and_instances.items():
-                print("        \"" + kernel + "\", " + str(instances), file = of)
-        else:
-            for m in df.columns.values.tolist():
-                if (m in STALL_INFO_COLUMNS):   # describes the instruction, not a metric
-                    continue
-                print("        " + m, file = of)
-
-            # By identity, so same-named kernels are separate entries; -k takes the
-            # quoted name.
-            kernels = []
-            for kernel, pid, kernelid, start, stop in KernelRanges(df):
-                if ((kernel, pid, kernelid) not in kernels):
-                    kernels.append((kernel, pid, kernelid))
-
-            print("    Kernel, Pid, KernelId", file = of)
-            for kernel, pid, kernelid in kernels:
-                print("        \"" + str(kernel) + "\", " + str(pid) + ", " + str(kernelid), file = of)
-
-    def print_data(self, of):
-        df = self.get_device_data()
-        print("Device " + str(self.device_id), file=of)
-        if df is None:
-            print(f"    No data available for device {self.device_id}", file=of)
-            return
-
-        print("    Metric", file = of)
-        self._print_data_from_df(df, of)
-
-@dataclass
-class MetricsInfo:
-    """Database containing global info and all devices information."""
-    input_path: Union[Path, str]
-    is_result_directory: bool
-    is_eustall: bool = field(init=False, default=False)
-    devices: Dict[int, DeviceInfo] = field(init=False, default_factory=dict)
-
-    def __post_init__(self):
-        self._validate_input()
-        self._init_devices()
-        self._init_is_eustall()
-
-    def _init_is_eustall(self):
-        """Whether the lowest-numbered device's table is a stall table."""
-        if not self.devices:
-            return
-
-        self.is_eustall = (self.devices[min(self.devices)].kind == "stall")
-
-    def _init_devices(self):
-        if self.is_result_directory:
-            self._init_devices_from_directory()
-        else:
-            self._init_devices_from_single_file()
-
-    def _init_devices_from_directory(self):
-        """For result_directory mode, find metrics/metrics_<device>.csv files."""
-        filename_pattern = re.compile(r'^metrics_(\d+)\.csv$')
-
-        for metrics_file in sorted(self.input_path.rglob('metrics/metrics_*.csv')):
-            match = filename_pattern.match(metrics_file.name)
-            if match and metrics_file.stat().st_size > 0:
-                try:
-                    device_id = int(match.group(1))
-                except (ValueError, OverflowError) as e:
-                    print(f"Warning: Invalid device ID in {metrics_file.name}: {e}")
-                    continue
-                # One device per file, named by the file; its table runs to the end.
-                header_line, kind = ScanFirstHeader(metrics_file)
-                if kind is None:
-                    print(f"Warning: No metrics table found in {metrics_file}")
-                    continue
-                self.devices[device_id] = DeviceInfo(device_id=device_id,
-                                                     metrics_file=metrics_file,
-                                                     header_line=header_line,
-                                                     kind=kind)
-        if not self.devices:
-            print(f"Warning: No valid metrics files found in directory {self.input_path}")
-
-    def _init_devices_from_single_file(self):
-        """Find the devices in a single metrics file."""
-        for device_id, header_line, last_line, kind in ScanDeviceSections(self.input_path):
-            self.devices[device_id] = DeviceInfo(device_id=device_id,
-                                                 metrics_file=self.input_path,
-                                                 header_line=header_line,
-                                                 last_line=last_line,
-                                                 kind=kind)
-
-    def _validate_input(self):
-        if isinstance(self.input_path, str):
-            self.input_path = Path(self.input_path).resolve()
-        elif isinstance(self.input_path, Path):
-            self.input_path = self.input_path.resolve()
-        else:
-            raise TypeError(f"input_path must be a Path object or string, got {type(self.input_path).__name__}")
-
-        if not isinstance(self.is_result_directory, bool):
-            raise TypeError(f"is_result_directory must be a boolean, got {type(self.is_result_directory).__name__}")
-
-        if not self.input_path.exists():
-            raise FileNotFoundError(f"Input path '{self.input_path}' does not exist.")
-
-        if self.is_result_directory:
-            if not self.input_path.is_dir():
-                raise NotADirectoryError(f"'{self.input_path}' is not a directory")
-        else:
-            if not self.input_path.is_file():
-                raise FileNotFoundError(f"'{self.input_path}' is not a file")
-            if self.input_path.stat().st_size == 0:
-                raise ValueError(f"File '{self.input_path}' is empty")
-
-    def get_device(self, device_id: int) -> Optional[DeviceInfo]:
-        """Get device info by ID."""
-        return self.devices.get(device_id)
-
-    def get_device_ids(self) -> List[int]:
-        """Get sorted list of all device IDs."""
-        return sorted(self.devices.keys())
-
-    def print_data(self, output=None):
-        of = sys.stdout
-        if (output is not None):
-            of = open(output, "w")
-        for device_id in self.get_device_ids():
-            self.devices[device_id].print_data(of)
-        if (output is not None):
-            of.close()
-
-class ReadOptionsFromFile(argparse.Action):
-    def __call__ (self, parser, namespace, values, option_string = None):
-        if getattr(namespace, "_reading_options_file", False):
-            parser.error("an options file cannot contain -f/--config")
-        inputfile = vars(namespace)['input']    # save the input file argument
-        # Opened here, after the check above, so a nested -f naming a FIFO cannot block.
-        try:
-            f = sys.stdin if values == '-' else open(values, 'r')
-        except OSError as e:
-            parser.error(f"can't open '{values}': {e}")
-        with f:
-            try:
-                options = shlex.split(f.read().strip())
-            except ValueError as e:     # e.g. an unbalanced quote
-                parser.error(f"cannot parse options file {values}: {e}")
-            options.append("dummyinput")    # parse_args() requires an input file
-            namespace._reading_options_file = True
-            try:
-                parser.parse_args(options, namespace)
-            finally:
-                del namespace._reading_options_file
-            vars(namespace)['input'] = inputfile # restore input file
-
-def ParseArguments(argv):
-    argparser = argparse.ArgumentParser(description = "GPU Kernel Performance Hardware Metrics Analyzer")
-    argparser.add_argument('-l', '--list', action = 'store_true', help = "list devices, metrics and kernels in the input performance metric data file")
-    argparser.add_argument('-d', '--device', type = int, default = 0, help = "GPU device (device 0 by default)")
-    argparser.add_argument('-k', '--kernel', help = "kernel name, with shape for query or time-based data, all kernels if this option is not specified")
-    argparser.add_argument('-i', '--instance', type = int, default = 1, help = "kernel instance. all instances if < 1 (1 or the first instance by default)")
-    argparser.add_argument('-m', '--metrics', action = 'append', help = "list of comma-separated metric names")
-    argparser.add_argument('-b', '--throughput', action = 'append', help = "list of comma-separated metric names for throughput")
-    argparser.add_argument('-o', '--output', help = "output file in text format if -l is present, PDF format regardless of file extension if -k is not present or if instance < 1")
-    argparser.add_argument('-p', '--https', action = 'store_true', help = "start https server for backward compatibility only to view metrics with https link")
-    argparser.add_argument('-q', '--http', action = 'store_true', help = "start http server")
-    argparser.add_argument('-c', '--certificate', help = "certificate file for https server")
-    argparser.add_argument('-e', '--key', help = "private key file for https server")
-    argparser.add_argument('-n', '--numtopstalls', type = int, default = 10, help = "number of top most expensive stalls of each type to report for stall analysis(10 default, -1 unlimited)")
-    argparser.add_argument('-r', '--report', help = "stall analysis report in plain text")
-    argparser.add_argument('-y', '--ylabel', action = 'append', help = "label for Y axis")
-    argparser.add_argument('-x', '--xlabel', default = "Time(in sampling intervals)", help = "label for X axis (defaut is \"Time(in sampling intervals)\")")
-    argparser.add_argument('-t', '--title', default = "Performance Metrics", help = "performance metric plot title")
-    argparser.add_argument('-f', '--config', action = ReadOptionsFromFile, help = "read command options from file")
-    argparser.add_argument('--result-dir', action = 'store_true', help = "Process metrics from structured result directory instead of single CSV file")
-    argparser.add_argument('input', help = 'hardware performance metric data file in .csv format generated by unitrace -k/--stall-sampling')
-
-    return argparser.parse_args(argv)
-
-# Every collector writes sections, one per kernel (stall sampling) or kernel instance
-# (query, time-based sampling), each opened by a label line naming its identity columns:
-#     Kernel,Pid,KernelId           stall sampling
-#     Kernel, GlobalInstanceId      query and time-based sampling
-# (a query section has a row per sub-device, and a first column SubDeviceId only if there
-# is more than one). The stall label is matched in full, first; a first column of
-# "Kernel" routes the other two to one reader.
-# Labels are compared field by field, ignoring spacing (NormalizeFields).
-
-# A stall section's identity, copied onto its rows. Pid and KernelId also name the
-# kernel's <device>.<pid>.<kernel id>.asm file.
-STALL_IDENTITY_COLUMNS = ["Kernel", "Pid", "KernelId"]
-# The instruction columns the stall report reads.
-STALL_REQUIRED_COLUMNS = ["Source", "Offset", "Instruction", "Dependency"]
-
-# The first column of every label line, and of no other line.
-BLOCK_LABEL_FIRST_COLUMN = "Kernel"
-
-# Stall columns that are not metrics; every column after Dependency is one.
-STALL_INFO_COLUMNS = STALL_IDENTITY_COLUMNS + ["Source", "Offset", "Instruction", "Dependency"]
-
-# What unitrace writes for an unresolved source or dependency list, and for an
-# instruction it could not disassemble.
-NOT_AVAILABLE = "NA"
-UNKNOWN_INSTRUCTION = "unknown"
-
-def NormalizeFields(fields):
-    """Fields stripped of surrounding whitespace; applied once per row, before any comparison."""
-    return [f.strip() for f in fields]
-
-def IsBlockLabel(fields):
-    """Whether the normalized fields open a section: a first column of Kernel and at least one more.
-
-    Only the first column is checked; the rest name the identity columns, whatever they are.
-    """
-    return ((len(fields) >= 2) and (fields[0] == BLOCK_LABEL_FIRST_COLUMN))
-
-def ClassifyHeaderRow(row):
-    """The kind of table a label line opens: "stall", "time" or None."""
-    fields = NormalizeFields(next(csv.reader([row], skipinitialspace = True), []))
-    if (fields == STALL_IDENTITY_COLUMNS):
-        return "stall"
-    if (IsBlockLabel(fields)):
-        return "time"
-
-    return None
-
-def ScanFirstHeader(inputfile):
-    """(line, kind) of the first label line of a one-device file, or (None, None)."""
-    with open(inputfile, "r") as f:
-        for linenum, row in enumerate(f):
-            kind = ClassifyHeaderRow(row)
-            if (kind is not None):
-                return linenum, kind
-
-    return None, None
-
-def ScanDeviceSections(inputfile):
-    """Locate every device's metric table in a metrics file.
-
-    Returns a list of (device, header, last, kind): header is the 0-based line of the
-    device's first label line, last the line after its table (None for the end of the
-    file), and kind ClassifyHeaderRow's. A device with no label line is left out.
-    """
-    sections = []
-    device = 0		# a file with no banner at all is one unnamed device
-    header = None
-    kind = None
-    linenum = 0
-
-    with open(inputfile, "r") as f:
-        for row in f:
-            if (("=== Device" in row) and ("Metrics ===" in row)):
-                if (header is not None):	# the banner ends the section before it
-                    sections.append((device, header, linenum, kind))
-                    header = None
-                    kind = None
-                for word in row.split():	# "=== Device #N Metrics ==="
-                    if (word.startswith('#')):
-                        try:
-                            device = int(word[1:])
-                        except ValueError:
-                            print(f"Warning: Could not parse device ID from '{word}'")
-                        break
-            elif (header is None):
-                kind = ClassifyHeaderRow(row)
-                if (kind is not None):
-                    header = linenum
-            linenum += 1
-
-    if (header is not None):
-        sections.append((device, header, None, kind))
-
-    return sections
-
-def UniqueColumns(columns, inputfile):
-    """Check that no column name in a metric table repeats.
-
-    columns: the table's column names, identity columns included.
-    inputfile: the CSV path, used only in the warning.
-    Returns True if every name is unique. Otherwise prints a "Skipping a metric table
-    with repeated column names" warning and returns False; ReadStallFrame and
-    ReadTimedFrame then return an empty DataFrame for that table.
-    """
-    if (len(set(columns)) == len(columns)):
-        return True
-    print(f"Warning: Skipping a metric table with repeated column names in {inputfile}.")
-    return False
-
-def ReadStallFrame(inputfile, header, last):
-    """Read one device's stall sections, lines header to last, into one frame.
-
-    Each section's Kernel, Pid and KernelId are copied onto its rows. The csv module
-    handles the quoted cells, which contain commas; skipinitialspace lets a ", " delimiter
-    through too.
-    """
-    identity = None
-    columns = None
-    rows = []
-    pending = None
-
-    with open(inputfile, "r", newline = "") as f:
-        # Sliced lazily by line, since the table is bounded by line numbers.
-        for fields in csv.reader(islice(f, header, last), skipinitialspace = True):
-            if (len(fields) == 0):
-                # The blank line between sections, which must not fill a pending slot.
-                continue
-            fields = NormalizeFields(fields)
-            if (fields == STALL_IDENTITY_COLUMNS):
-                pending = "identity"
-                continue
-            if (pending == "identity"):
-                identity = fields[0 : len(STALL_IDENTITY_COLUMNS)]
-                pending = "columns"
-                continue
-            if (pending == "columns"):
-                if (columns is None):
-                    columns = fields		# identical across every block
-                pending = None
-                continue
-            # A row of the current section; wrong-width lines are skipped.
-            if ((columns is not None) and (identity is not None)
-                    and (len(identity) == len(STALL_IDENTITY_COLUMNS)) and (len(fields) == len(columns))):
-                rows.append(identity + fields)
-
-    if ((columns is None) or not UniqueColumns(STALL_IDENTITY_COLUMNS + columns, inputfile)):
-        return pd.DataFrame()
-    missing = [c for c in STALL_REQUIRED_COLUMNS if c not in columns]
-    if (len(missing) > 0):
-        print(f"Warning: Skipping a stall table without {', '.join(missing)} in {inputfile}.")
-        return pd.DataFrame()
-
-    df = pd.DataFrame(rows, columns = STALL_IDENTITY_COLUMNS + columns)
-
-    # The counts to integers; the text columns stay strings, "NA" included.
-    numeric = ["Pid", "KernelId"]
-    if ("Dependency" in columns):
-        numeric += columns[columns.index("Dependency") + 1:]
-    for column in numeric:
-        df[column] = pd.to_numeric(df[column], errors = "coerce").fillna(0).astype("int64")
-
-    return df
-
-def ReadTimedFrame(inputfile, header, last):
-    """Read one device's query or time-based sections, lines header to last, into one frame.
-
-    Each section (label, identity, counter names, one row per sample, or one for query) has
-    its identity, whose columns the label names, copied onto its rows. Instances are ended
-    by an all-NaN row. skipinitialspace matches the writer's ", " delimiter.
-    """
-    identity_columns = None
-    identity = None
-    columns = None
-    rows = []
-    pending = None
-
-    with open(inputfile, "r", newline = "") as f:
-        # Sliced lazily by line, since the table is bounded by line numbers.
-        for fields in csv.reader(islice(f, header, last), skipinitialspace = True):
-            if (len(fields) == 0):
-                # The blank line between sections, which must not fill a pending slot.
-                continue
-            fields = NormalizeFields(fields)
-            if (IsBlockLabel(fields)):
-                # A new section: end the previous instance with an all-NaN row.
-                if (len(rows) > 0):
-                    rows.append([float("nan")] * len(rows[-1]))
-                if (identity_columns is None):
-                    identity_columns = fields		# identical across every block
-                identity = None
-                pending = "identity"
-                continue
-            if (pending == "identity"):
-                identity = fields[0 : len(identity_columns)]
-                pending = "columns"
-                continue
-            if (pending == "columns"):
-                if (columns is None):
-                    columns = fields		# identical across every block
-                pending = None
-                continue
-            # A row of the current section; wrong-width lines are skipped.
-            if ((columns is not None) and (identity is not None)
-                    and (len(identity) == len(identity_columns)) and (len(fields) == len(columns))):
-                rows.append(identity + fields)
-
-    if ((columns is None) or not UniqueColumns(identity_columns + columns, inputfile)):
-        return pd.DataFrame()
-
-    # End the last instance too.
-    if (len(rows) > 0):
-        rows.append([float("nan")] * (len(identity_columns) + len(columns)))
-
-    df = pd.DataFrame(rows, columns = identity_columns + columns)
-
-    # Everything but Kernel to numbers.
-    for column in df.columns:
-        if (column != "Kernel"):
-            df[column] = pd.to_numeric(df[column], errors = "coerce")
-
-    return df
-
-def ReadMetricFrame(inputfile, header, last, kind):
-    """Read one device's metric table, lines header to last."""
-    if (kind == "stall"):
-        return ReadStallFrame(inputfile, header, last)
-
-    return ReadTimedFrame(inputfile, header, last)
-
-def StallColumns(df):
-    """The stall count columns: those after Dependency, except Active[Events]."""
-    cols = list(df.columns)
-    if ("Dependency" not in cols):
-        return []
-
-    return [c for c in cols[cols.index("Dependency") + 1:] if c != "Active[Events]"]
-
-def NonZeroStallRows(df, stalls):
-    """Drop the rows in which no stall of any type was sampled."""
-    if (len(stalls) == 0):
-        return df.iloc[0:0]
-
-    return df[(df[stalls] != 0).any(axis = 1)]
-
-def KernelRanges(df):
-    """Split the frame into (kernel, pid, kernelid, start, stop) ranges, one per kernel.
-
-    A change of any of the three identity columns ends a range, so same-named kernels
-    stay apart. start/stop are positions for iloc.
-    """
-    # an empty frame has no columns
-    if (not set(STALL_IDENTITY_COLUMNS).issubset(df.columns)):
-        return []
-
-    ranges = []
-    identity = None
-    start = 0
-    for index, row in enumerate(zip(df['Kernel'], df['Pid'], df['KernelId'])):
-        if (identity is None):
-            identity = row
-            start = index
-        else:
-            if (identity != row):
-                ranges.append(identity + (start, index))
-                identity = row
-                start = index
-
-    # don't forget the last kernel
-    if (identity is not None):
-        ranges.append(identity + (start, df.shape[0]))
-
-    return ranges
-
-def StallKernelLabel(kernel, pid, kernelid):
-    """How a stall report names a kernel; pid and kernel id also name its .asm file."""
-    return str(kernel) + " (pid " + str(pid) + ", kernel id " + str(kernelid) + ")"
-
-DEPENDENCY_SEPARATOR = " | "
-# One producer, as FormatDependencies() in src/levelzero/ze_metrics.h writes it:
-# "0x<offset> (<source>)[: <text>]", joined by DEPENDENCY_SEPARATOR.
-DEPENDENCY_ENTRY = re.compile(r"^(0x[0-9a-fA-F]+)(?:\s+\(([^)]*)\))?(?::\s(.*))?$")
-
-def ParseDependency(cell):
-    """Split a Dependency cell into (offset, source, text) producers.
-
-    Missing parts are None; an unrecognized entry is kept as (None, None, entry).
-    """
-    producers = []
-    if ((cell is None) or (cell == "") or (cell == NOT_AVAILABLE)):
-        return producers
-
-    for entry in cell.split(DEPENDENCY_SEPARATOR):
-        entry = entry.strip()
-        if (entry == ""):
-            continue
-        m = DEPENDENCY_ENTRY.match(entry)
-        if (m is None):
-            producers.append((None, None, entry))
-        else:
-            producers.append((m.group(1), m.group(2), m.group(3)))
-
-    return producers
-
-def FormatStallInstruction(offset, source, text, indent, missing = "<no disassembly available>"):
-    """One instruction of a stall report: offset, text and source."""
-    if ((text is None) or (text == "") or (text == UNKNOWN_INSTRUCTION)):
-        text = missing
-
-    line = indent
-    if ((offset is not None) and (offset != "")):
-        line += str(offset) + ": "
-    line += text + "\n"
-
-    if ((source is not None) and (source != "") and (source != NOT_AVAILABLE)):
-        line += indent + "Source: " + source + "\n"
-
-    return line
-
-def BuildStallReport(label, args, stalldf, stalls):
-    """Report a kernel's most expensive stalls and the instructions they wait on.
-
-    The instructions, sources and producers all come from the metrics file. label is
-    StallKernelLabel's.
-    """
-    report = "Kernel: " + label + "\n"
-    if (args.numtopstalls >= 0):
-        report += "\nReport of Top " + str(args.numtopstalls) + " Stalls of Each Type\n"
-    else:
-        report += "\nReport of Stalls of Each Type\n"
-
-    totals = []
-    for t in stalls:
-        total = int(stalldf[t].sum())
-        if (total > 0):
-            totals.append((t, total))
-
-    report += "***********************************************************************************************\n"
-    report += "Stall events by type: \n"
-    if (len(totals) == 0):
-        report += "  none\n"
-    else:
-        for t, total in sorted(totals, key = lambda e: e[1], reverse = True):
-            report += "  " + t + ": " + str(total) + "\n"
-
-    if ((stalldf["Instruction"] == UNKNOWN_INSTRUCTION).any()):
-        report += "\nSome instructions could not be disassembled and are reported by offset only.\n"
-
-    # one section per stall type, in the order the metrics file lists them
-    for t in stalls:
-        df = stalldf[stalldf[t] > 0]    # drop 0s
-        if (df.shape[0] == 0):  # zero stalls of this type. move to the next one
-            continue
-
-        # Offset breaks ties, for a stable order.
-        df = df.sort_values(by = [t, "Offset"], ascending = [False, True])
-
-        report += "***********************************************************************************************\n"
-        report += t.split("Stall")[0] + " Stalls: \n"
-
-        num_stalls_reported = 0
-        for index, row in df.iterrows():
-            if ((args.numtopstalls >= 0) and (num_stalls_reported >= args.numtopstalls)):
-                break
-
-            report += "\nInstruction\n"
-            report += FormatStallInstruction(row["Offset"], row["Source"], row["Instruction"], "  ")
-            report += "  " + t + ": " + str(row[t])
-            if ("Active[Events]" in row.index):
-                report += "   (Active[Events]: " + str(row["Active[Events]"]) + ")"
-            report += "\n"
-
-            producers = ParseDependency(row["Dependency"])
-            if (len(producers) == 0):
-                report += "is stalled (no dependency information)\n"
-            else:
-                report += "is stalled potentially by\n"
-                for offset, source, text in producers:
-                    report += "  instruction\n"
-                    report += FormatStallInstruction(offset, source, text, "    ", missing = "<instruction not available>")
-
-            num_stalls_reported = num_stalls_reported + 1
-
-    report += "===============================================================================================\n"
-    return report
-
-def WriteOutStallReport(report, p): # p is PDF object
-    if (p is None): # p should already be created, but just in case
-        return  # do nothing
-
-    lines = report.split('\n')
-    page = ""
-    num = 0
-    page_size = 48  # number of lines per page
-    line_width = 160 # number of characters per line
-    font_size = 4
-    for line in lines:
-        if (len(line) == 0):    # empty line
-            line = "\n"
-        s = 0
-        while (len(line[s:]) > line_width):
-            page += line[s:s + line_width]
-            page += '\n'
-            num += 1
-            if (num == page_size):
-                fig = plt.figure()
-                plt.axis('off')
-                page = page.replace('$', r'\$')  # escape '$'
-                plt.text(0.0, 0.0, page, fontsize = font_size, ha = 'left', wrap = True)
-                fig.savefig(p, format = 'pdf')
-                plt.close(fig) # close figure
-                page = ""  # reset for next page
-                num = 0
-            s += line_width
-        if (s < len(line)):
-            page += line[s:]
-            page += '\n'
-            num += 1
-            if (num == page_size):
-                fig = plt.figure()
-                plt.axis('off')
-                page = page.replace('$', r'\$')
-                plt.text(0.0, 0.0, page, fontsize = font_size, ha = 'left', wrap = True)
-                fig.savefig(p, format = 'pdf')
-                plt.close(fig) # close figure
-                page = ""  # reset for next page
-                num = 0
-
-    # don't forget the last page
-    if (num != 0):
-        fig = plt.figure()
-        plt.axis('off')
-        page = page.replace('$', r'\$')
-        plt.text(0.0, 0.0, page, fontsize = font_size, ha = 'left', wrap = True)
-        fig.savefig(p, format = 'pdf')
-        plt.close(fig) # close figure
-
-    return
-
-def PlotStallChart(args, kernel, df2, stalls, p):
-    """Chart the stall counts of one kernel, splitting a long kernel over pages.
-
-    Creates the PDF on first use if p is None, and returns it either way.
-    """
-    ins_per_page = 100  # number of instructions to chart per page
-
-    xlabels = []
-    xticks = []
-    for i, offset in enumerate(df2["Offset"]):
-        xlabels.append(offset)
-        xticks.append(i)
-
-    df3 = df2[stalls]
-    df3 = df3.reset_index()
-    numpages = (df3.shape[0] + (ins_per_page - 1)) // ins_per_page # multiple charts if more than ins_per_page instructions are stalled
-    for page in range(1, numpages + 1):
-        first = ins_per_page * (page - 1)
-        beyond = min([ins_per_page * page, df3.shape[0]])
-        df4 = df3[first : beyond]
-        if (df4.shape[0] > 1):	# draw line chart if there are at least 2 data points
-            ax = df4.plot(y = stalls, kind = 'line', xlabel = "Offset", ylabel = "Events", fontsize = 6)
-        else:	# draw bar chart otherwise
-            ax = df4.plot(y = stalls, kind = 'bar', xlabel = "Offset", ylabel = "Events", fontsize = 6)
-        ax.set_xticks(xticks[first : beyond], labels = xlabels[first : beyond], rotation = 90, fontsize = 4)
-        plt.grid(visible = True, which = 'both', axis = 'y')
-        plt.legend(loc = 'best', fontsize = 4)
-        title = args.title + "\n(" + kernel + ")"
-        if (numpages > 1):
-            title += "(" + str(page) + "/" + str(numpages) + ")"
-        plt.title(label = title, loc = 'center', fontsize = 8, wrap = True)
-        plt.tight_layout()
-        fig = ax.get_figure()
-        if (p == None):
-            p = pdf(args.output)
-        fig.savefig(p, format = 'pdf')
-        plt.close(fig)	# close figure to save memory
-
-    return p
-
-def AnalyzeStallMetrics(args, device_data_df, kernel, http = False):
-    if ((http == True) and (kernel is None)):
-        return None, None
-
-    buf = None
-    stall_analysis_report_out = None
-    if ((http == False) and (args.report is not None)):
-        stall_analysis_report_out = open(args.report, "w")
-
-    df = device_data_df
-    stalls = StallColumns(df)
-    if (len(stalls) == 0):
-        msg = "No stall metrics in the input data. Was it collected with unitrace --stall-sampling?"
-        if (http == False):
-            print(msg)
-        if (stall_analysis_report_out is not None):
-            stall_analysis_report_out.close()
-        return msg, None
-
-    ranges = KernelRanges(df)
-    if (kernel is not None):
-        kernels = [r for r in ranges if (r[0] == kernel)]
-        if (len(kernels) == 0):
-            # the name may still carry the kernel shape the trace shows
-            pos = kernel.rfind('[')
-            if (pos != -1):
-                kernel = kernel[0:pos]
-                kernels = [r for r in ranges if (r[0] == kernel)]
-        if (len(kernels) == 0):
-            msg = "No metric data for kernel " + kernel
-            if (http == False):
-                print(msg)
-            if (stall_analysis_report_out is not None):
-                stall_analysis_report_out.close()
-            return msg, None
-        ranges = kernels
-
-    p = None
-    tmpdir = None
-    tmpfile = None
-    if (http == True):
-        tmpdir = tempfile.TemporaryDirectory()
-        tmpfile = os.path.join(tmpdir.name, "stallchart.pdf")
-        p = pdf(tmpfile)
-
-    analyzed = 0
-    for kname, pid, kernelid, start, stop in ranges:
-        label = StallKernelLabel(kname, pid, kernelid)
-        df2 = NonZeroStallRows(df.iloc[start : stop], stalls)   # data frame of the kernel of interest
-        if (df2.shape[0] == 0):
-            print("\nNo stall events for kernel " + label)
-            continue
-
-        p = PlotStallChart(args, label, df2, stalls, p)
-
-        report = BuildStallReport(label, args, df2, stalls)
-        if (stall_analysis_report_out is not None):
-            print(report, file = stall_analysis_report_out)
-        WriteOutStallReport(report, p)
-
-        analyzed = analyzed + 1
-        print("\nAnalyzed kernel " + label)
-
-    if (p != None):
-        p.close()
-
-    if (http == True):
-        if (analyzed > 0):
-            buf = io.BytesIO()
-            fp = open(tmpfile, "rb")
-            buf.write(fp.read())
-            fp.close()
-            os.remove(tmpfile)
-        tmpdir.cleanup()
-    else:
-        if (analyzed > 0):
-            print("\nStall metric charts are stored in file " + args.output + " in PDF format")
-        if (stall_analysis_report_out is not None):
-            stall_analysis_report_out.close()
-            if (analyzed > 0):
-                print("Stall report is also stored in file " + args.report)
-
-    if (analyzed == 0):
-        msg = "No stall events in the input data"
-        if (kernel is not None):
-            msg = "No stall events for kernel " + kernel + " in the input data"
-        return msg, None
-
-    return None, buf
-
-def PlotKernelInstancePerfMetrics(args, kernel, df, metric_sets_cleansed, throughputs_sets_cleansed, p):
-    k = 0
-    counting = True
-    start = -1
-    stop = -1
-    instancefound = False
-
-    for index, row in df.iterrows():
-        if (pd.isna(row['Kernel']) == False):
-            if ((row['Kernel'] == kernel) and (counting == True)):
-                k = k + 1			# found kernel of interest
-                counting = False		# set to false so this block will not enter again for this instance
-                if (k == args.instance):	# found instance of interest
-                    start = index
-                    instancefound = True
-        else:
-            counting = True			# a new kernel and/or a new instance starts in the data frame
-            if (instancefound == True):
-                stop = index
-                break
-
-    if ((instancefound == True) and (stop == -1)):	# the instance of interest is at the end of data frame
-        stop = df.shape[0]
-
-    if (instancefound == False):
-        print("No metric data for instance " + str(args.instance) + " of kernel " + kernel)
-        return False, p
-
-    df2 = df[start : stop]	# data frame of the instance of interest
-    analyzed = False
-    for metrics_cleansed, label in zip(metric_sets_cleansed, args.ylabel):
-        df3 = df2[metrics_cleansed]
-
-        if (df3.shape[0] > 0):
-            if (df3.shape[0] > 1):
-                ax = df3.plot(y = metrics_cleansed, kind = 'line', xlabel = args.xlabel, ylabel = label)
-            else:
-                ax = df3.plot(y = metrics_cleansed, kind = 'bar', xlabel = args.xlabel, ylabel = label)
-            plt.grid(visible = True, which = 'both', axis = 'y')
-            plt.legend(loc = 'best', fontsize = 4)
-            plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-            plt.tight_layout()
-            if (p == None):
-                p = pdf(args.output)
-            fig = ax.get_figure()
-            fig.savefig(p, format = 'pdf')
-            plt.close(fig)	# close figure to save memory
-            analyzed = True
-        else:
-            break
-
-    if (analyzed == True):
-        for throughputs_cleansed in throughputs_sets_cleansed:
-            df3 = df2[throughputs_cleansed]
-            df3 = (df3.iloc[:, 1:]).div(df3.iloc[:, 0], axis = 0)
-
-            if (df3.shape[0] > 0):
-                if (df3.shape[0] > 1):
-                    ax = df3.plot(y = throughputs_cleansed[1:], kind = 'line', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-                else:
-                    ax = df3.plot(y = throughputs_cleansed[1:], kind = 'bar', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-
-                plt.grid(visible = True, which = 'both', axis = 'y')
-                plt.legend(loc = 'best', fontsize = 4)
-                plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                plt.tight_layout()
-                if (p == None):
-                    p = pdf(args.output)
-                fig = ax.get_figure()
-                fig.savefig(p, format = 'pdf')
-                plt.close(fig)	# close figure to save memory
-
-            else:
-                break
-
-    return analyzed, p
-
-def AnalyzePerfMetrics(args, device_data_df):
-    metric_sets_cleansed = []
-    for metric_set in args.metrics:
-        metrics = metric_set.split(sep = ',')
-        metrics_cleansed = []
-        for metric in metrics:
-            me = metric.strip()			# strip off leading and trailing whitespaces
-            if (me not in device_data_df.columns):
-                print("No metric data for " + metric)
-                return
-            else:
-                metrics_cleansed.append(me)
-        metric_sets_cleansed.append(metrics_cleansed)
-
-    throughputs_sets_cleansed = []
-    if (args.throughput is not None):
-        for throughput_set in args.throughput:
-            throughputs = throughput_set.split(sep = ',')
-            throughputs_cleansed = ['GpuTime[ns]']
-            for throughput in throughputs:
-                bw = throughput.strip()			# strip off leading and trailing whitespaces
-                if (bw not in device_data_df.columns):
-                    print("No throughput data for " + bw)
-                    return
-                else:
-                    throughputs_cleansed.append(bw)
-            throughputs_sets_cleansed.append(throughputs_cleansed)
-
-    p = None
-    if (args.kernel is None):
-        if (args.instance < 1):
-            # all kernels and all instances
-            start = 0
-            stop = -1
-            kernel = ""
-            for index, row in device_data_df.iterrows():
-                if (pd.isna(row['Kernel']) == True):
-                    stop = index	# current kernel instance ends
-
-                    df2 = device_data_df[start : stop]	# data frame of the instance of interest
-                    analyzed = False
-                    for metrics_cleansed, label in zip(metric_sets_cleansed, args.ylabel):
-                        df3 = df2[metrics_cleansed]
-                        if (df3.shape[0] > 0):
-                            if (df3.shape[0] > 1):
-                                ax = df3.plot(y = metrics_cleansed, kind = 'line', xlabel = args.xlabel, ylabel = label)
-                            else:
-                                ax = df3.plot(y = metrics_cleansed, kind = 'bar', xlabel = args.xlabel, ylabel = label)
-
-                            plt.grid(visible = True, which = 'both', axis = 'y')
-                            plt.legend(loc = 'best', fontsize = 4)
-                            plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                            plt.tight_layout()
-                            if (p == None):
-                                p = pdf(args.output)
-                            fig = ax.get_figure()
-                            fig.savefig(p, format = 'pdf')
-                            plt.close(fig)	# close figure to save memory
-                            analyzed = True
-                        else:
-                            break
-
-                    if (analyzed == True):
-                        for throughputs_cleansed in throughputs_sets_cleansed:
-                            df3 = df2[throughputs_cleansed]
-                            df3 = (df3.iloc[:, 1:]).div(df3.iloc[:, 0], axis = 0)
-
-                            if (df3.shape[0] > 0):
-                                if (df3.shape[0] > 1):
-                                    ax = df3.plot(y = throughputs_cleansed[1:], kind = 'line', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-                                else:
-                                    ax = df3.plot(y = throughputs_cleansed[1:], kind = 'bar', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-
-                                plt.grid(visible = True, which = 'both', axis = 'y')
-                                plt.legend(loc = 'best', fontsize = 4)
-                                plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                                plt.tight_layout()
-                                if (p == None):
-                                    p = pdf(args.output)
-                                fig = ax.get_figure()
-                                fig.savefig(p, format = 'pdf')
-                                plt.close(fig)	# close figure to save memory
-                                analyzed = True
-                            else:
-                                break
-
-                        print("Analyzed kernel " + kernel)
-                    else:
-                        print("No samples for kernel " + kernel)
-
-                    kernel = ""	# reset kernel name to empty
-                else:
-                    if (kernel == ""):
-                        start = index	# a new kernel instance starts
-                        kernel = row['Kernel']
-
-        else:
-            # specified instance of all kernels
-            kernels = device_data_df['Kernel'].unique()
-            for kernel in kernels:
-                if (pd.isna(kernel) == True):
-                    continue
-
-                analyzed, p = PlotKernelInstancePerfMetrics(args, kernel, device_data_df, metric_sets_cleansed, throughputs_sets_cleansed, p)
-                if (analyzed == True):
-                    print("Analyzed kernel " + kernel)
-
-    else:
-        if (args.instance < 1):
-            # specified kernel all instances
-            counting = True
-            start = -1
-            stop = -1
-            instance = 0
-            for index, row in device_data_df.iterrows():
-                if (pd.isna(row['Kernel']) == False):
-                    if ((row['Kernel'] == args.kernel) and (counting == True)):
-                        start = index			# found kernel of interest
-                        counting = False		# set to false so this block will not enter again for this instance
-                else:
-                    if (counting == False):
-                        # instance ends
-                        stop = index
-                        df2 = device_data_df[start : stop]	# data frame of the instance of interest
-                        analyzed = False
-                        for metrics_cleansed, label in zip(metric_sets_cleansed, args.ylabel):
-                            df3 = df2[metrics_cleansed]
-
-                            instance = instance + 1
-                            if (df3.shape[0] > 0):
-                                if (df3.shape[0] > 1):
-                                    ax = df3.plot(y = metrics_cleansed, kind = 'line', xlabel = args.xlabel, ylabel = label)
-                                else:
-                                    ax = df3.plot(y = metrics_cleansed, kind = 'bar', xlabel = args.xlabel, ylabel = label)
-
-                                plt.grid(visible = True, which = 'both', axis = 'y')
-                                plt.legend(loc = 'best', fontsize = 4)
-                                plt.title(label = args.title + "\n(" + args.kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                                plt.tight_layout()
-                                if (p == None):
-                                    p = pdf(args.output)
-                                fig = ax.get_figure()
-                                fig.savefig(p, format = 'pdf')
-                                plt.close(fig)	# close figure to save memory
-                                analyzed = True
-                            else:
-                                break
-
-                        if (analyzed):
-                            for throughputs_cleansed in throughputs_sets_cleansed:
-                                df3 = df2[throughputs_cleansed]
-                                df3 = (df3.iloc[:, 1:]).div(df3.iloc[:, 0], axis = 0)
-
-                                if (df3.shape[0] > 0):
-                                    if (df3.shape[0] > 1):
-                                        ax = df3.plot(y = throughputs_cleansed[1:], kind = 'line', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-                                    else:
-                                        ax = df3.plot(y = throughputs_cleansed[1:], kind = 'bar', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-
-                                    plt.grid(visible = True, which = 'both', axis = 'y')
-                                    plt.legend(loc = 'best', fontsize = 4)
-                                    plt.title(label = args.title + "\n(" + args.kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                                    plt.tight_layout()
-                                    if (p == None):
-                                        p = pdf(args.output)
-                                    fig = ax.get_figure()
-                                    fig.savefig(p, format = 'pdf')
-                                    plt.close(fig)	# close figure to save memory
-                                    analyzed = True
-                                else:
-                                    break
-
-                            print("Analyzed instance " + str(instance) + " of kernel " + args.kernel)
-                        else:
-                            print("No samples for instance " + str(instance) + " of kernel " + args.kernel)
-
-                        # continue scan for next instance
-                        counting = True			# a new kernel and/or a new instance starts in the data frame
-                        start = -1
-                        stop = -1
-
-            if ((start != -1) and (stop == -1)):	# the instance of interest is at the end of data frame
-                stop = device_data_df.shape[0]
-
-                df2 = device_data_df[start : stop]	# data frame of the instance of interest
-                analyzed = False
-                for metrics_cleansed, label in zip(metric_sets_cleansed, args.ylabel):
-                    df3 = df2[metrics_cleansed]
-
-                    instance = instance + 1
-                    if (df3.shape[0] > 0):
-                        if (df3.shape[0] > 1):
-                            ax = df3.plot(y = metrics_cleansed, kind = 'line', xlabel = args.xlabel, ylabel = label)
-                        else:
-                            ax = df3.plot(y = metrics_cleansed, kind = 'bar', xlabel = args.xlabel, ylabel = label)
-
-                        plt.grid(visible = True, which = 'both', axis = 'y')
-                        plt.legend(loc = 'best', fontsize = 4)
-                        plt.title(label = args.title + "\n(" + args.kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                        plt.tight_layout()
-                        if (p == None):
-                            p = pdf(args.output)
-                        fig = ax.get_figure()
-                        fig.savefig(p, format = 'pdf')
-                        plt.close(fig)	# close figure to save memory
-                        analyzed = True
-                    else:
-                        break
-
-                if (analyzed == True):
-                    for throughputs_cleansed in throughputs_sets_cleansed:
-                        df3 = df2[throughputs_cleansed]
-                        df3 = (df3.iloc[:, 1:]).div(df3.iloc[:, 0], axis = 0)
-
-                        if (df3.shape[0] > 0):
-                            if (df3.shape[0] > 1):
-                                ax = df3.plot(y = throughputs_cleansed[1:], kind = 'line', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-                            else:
-                                ax = df3.plot(y = throughputs_cleansed[1:], kind = 'bar', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-
-                            plt.grid(visible = True, which = 'both', axis = 'y')
-                            plt.legend(loc = 'best', fontsize = 4)
-                            plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                            plt.tight_layout()
-                            if (p == None):
-                                p = pdf(args.output)
-                            fig = ax.get_figure()
-                            fig.savefig(p, format = 'pdf')
-                            plt.close(fig)	# close figure to save memory
-                            analyzed = True
-                        else:
-                            break
-
-                    print("Analyzed instance " + str(instance) + " of kernel " + args.kernel)
-                else:
-                    print("No samples for " + str(instance) + " of kernel " + args.kernel)
-
-        else:
-            # specified kernel specified instance
-            analyzed, p = PlotKernelInstancePerfMetrics(args, args.kernel, device_data_df, metric_sets_cleansed, throughputs_sets_cleansed, p)
-            if (analyzed == True):
-                print("Performance metric chart for instance " + str(args.instance) + " of kernel " + args.kernel + " hsa been successfully generated")
-            else:
-                print("No performance data for instance " + str(args.instance) + " of kernel " + args.kernel)
-
-    if (p != None):
-        p.close()
-        print("Performance metric charts are successfully generated in PDF format")
-    else:
-        print("No performance metric data for kernel or kernel instance")
-
-def HttpAnalyzePerfMetrics(args, device_data_df, kname, instance):
-    if (args.metrics is None):
-        return None, None
-
-    device_data_df = device_data_df.loc[device_data_df['GlobalInstanceId'] == float(instance)]
-    if (device_data_df.shape[0] == 0):
-        return None, None
-
-    buf = None
-    metric_sets_cleansed = []
-    for metric_set in args.metrics:
-        metrics = metric_set.split(sep = ',')
-        metrics_cleansed = []
-        for metric in metrics:
-            me = metric.strip()			# strip off leading and trailing whitespaces
-            if (me not in device_data_df.columns):
-                msg = "No metric data for " + metric + ". Is the metric name correctly spelled?"
-                return msg, None
-            else:
-                metrics_cleansed.append(me)
-        metric_sets_cleansed.append(metrics_cleansed)
-
-    throughputs_sets_cleansed = []
-    if (args.throughput is not None):
-        for throughput_set in args.throughput:
-            throughputs = throughput_set.split(sep = ',')
-            throughputs_cleansed = ['GpuTime[ns]']
-            for throughput in throughputs:
-                bw = throughput.strip()			# strip off leading and trailing whitespaces
-                if (bw not in device_data_df.columns):
-                    msg = "No metric data for " + bw + ". Is the metric name correctly spelled?"
-                    return msg, None
-                else:
-                    throughputs_cleansed.append(bw)
-            throughputs_sets_cleansed.append(throughputs_cleansed)
-
-    p = None
-    for metrics_cleansed, label in zip(metric_sets_cleansed, args.ylabel):
-        df2 = device_data_df[metrics_cleansed]
-
-        if (df2.shape[0] > 0):
-            if (df2.shape[0] > 1):
-                ax = df2.plot(y = metrics_cleansed, kind = 'line', xlabel = args.xlabel, ylabel = label)
-            else:
-                ax = df2.plot(y = metrics_cleansed, kind = 'bar', xlabel = args.xlabel, ylabel = label)
-            plt.grid(visible = True, which = 'both', axis = 'y')
-            plt.legend(loc = 'best', fontsize = 4)
-            kernel = device_data_df.iloc[0]['Kernel']
-            plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-            plt.tight_layout()
-
-            fig = ax.get_figure()
-            if (p == None):
-                tmpdir = tempfile.TemporaryDirectory()
-                tmpfile = os.path.join(tmpdir.name, "perfchart.pdf")
-                p = pdf(tmpfile)
-            fig.savefig(p, format = 'pdf')
-            plt.close(fig)  # close figure to save memory
-        else:
-            break
-
-    if (p != None):
-        for throughputs_cleansed in throughputs_sets_cleansed:
-            df2 = device_data_df[throughputs_cleansed]
-            df2 = (df2.iloc[:, 1:]).div(df2.iloc[:, 0], axis = 0)
-            if (df2.shape[0] > 0):
-                if (df2.shape[0] > 1):
-                    ax = df2.plot(y = throughputs_cleansed[1:], kind = 'line', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-                else:
-                    ax = df2.plot(y = throughputs_cleansed[1:], kind = 'bar', xlabel = args.xlabel, ylabel = 'Throughput(GB/s)')
-
-                plt.grid(visible = True, which = 'both', axis = 'y')
-                plt.legend(loc = 'best', fontsize = 4)
-                plt.title(label = args.title + "\n(" + kernel + ")", loc = 'center', fontsize = 8, wrap = True)
-                plt.tight_layout()
-                fig = ax.get_figure()
-                fig.savefig(p, format = 'pdf')
-                plt.close(fig)	# close figure to save memory
-            else:
-                break
-
-        p.close()
-        buf = io.BytesIO()
-        fp = open(tmpfile, "rb")
-        buf.write(fp.read())
-        fp.close()
-        os.remove(tmpfile)
-        tmpdir.cleanup()
-
-    return None, buf
-
-
-def GenerateSelfSignedCertificate(cert, key):
-    # construct command to generate a self-signed certificate and private key
-    command = ["openssl", "req", "-x509", "-newkey", "rsa:2048", "-keyout", key, "-out", cert, "-days", "365", "-nodes", "-subj", "/CN=localhost"]
-
-    try:
-        subprocess.run(command, check = True)
-        print(f"Self-signed certificate and private key have been generated.")
-    except subprocess.CalledProcessError as e:
-        print(f"Error occurred while generating self-signed certificate: {e}", file = sys.stderr)
-
-def IsDecimal(text):
-    """Tell whether text is a non-empty run of ASCII digits.
-
-    text: a str, e.g. a path component of a metrics server request.
-    Returns a bool. str.isdigit() alone also accepts characters such as superscripts
-    that int() rejects; isascii() excludes them, and "" is rejected because
-    "".isdigit() is False. Used by ParseMetricsRequest.
-    """
-    return text.isascii() and text.isdigit()
-
-def ParseMetricsRequest(path, result_dir, is_eustall):
-    """Parse a request path to the metrics server.
-
-    path: the URL path, /name/instance, or /name/instance/device with --result-dir;
-    percent-escapes are decoded first. result_dir: True with --result-dir.
-    is_eustall: True for stall sampling data; a trailing "[...]" kernel shape is
-    stripped from the name.
-    Returns (status, kname, instance, device_id). status is "ignore" for
-    /favicon.ico, "invalid" for a path without "/", too few components, or an
-    instance or device id that is not ASCII decimal digits (see IsDecimal), or a
-    device id int() cannot convert (longer than sys.get_int_max_str_digits()), else
-    "ok". kname has its surrounding double quotes stripped; instance and device_id
-    stay strings (device_id is None without --result-dir). Called by do_GET.
-    """
-    request = unquote(path).split("/")  # format is /name/instance
-    if (len(request) < 2):
-        return "invalid", None, None, None
-    if (request[1] == "favicon.ico"): # ignore
-        return "ignore", None, None, None
-
-    expected_request_params = 4 if result_dir else 3
-    if (len(request) < expected_request_params):
-        return "invalid", None, None, None
-
-    kname = request[1].strip('"')   # strip leading and trailing double quotes
-    instance = request[2]
-    if (not IsDecimal(instance)):
-        return "invalid", None, None, None
-
-    device_id = None
-    if result_dir:
-        device_id = request[3]
-        if (not IsDecimal(device_id)):
-            return "invalid", None, None, None
-        try:
-            int(device_id)  # do_GET converts it; Python limits integer strings' length
-        except ValueError:
-            return "invalid", None, None, None
-
-    if (is_eustall):   # strip kernel shape for stall sampling
-        pos = kname.rfind('[')
-        if (pos != -1):
-            kname = kname[0:pos]
-    return "ok", kname, instance, device_id
-
-def PerfMetricsHTTPServer(args, metrics_info):
-    try:
-        class PerfMetricsRequestHandler(BaseHTTPRequestHandler):
-            def _send_invalid(self):
-                self.send_header('Content-type', 'text/plain')
-                self.end_headers()
-                self.wfile.write(b'Invalid')
-
-            def do_GET(self):
-                if (self.client_address[0] != "127.0.0.1"):
-                    return
-                status, kname, instance, device_id = ParseMetricsRequest(self.path, args.result_dir, metrics_info.is_eustall)
-                if (status == "ignore"):
-                    return
-
-                self.send_response(200)
-                if (status == "invalid"):
-                    self._send_invalid()
-                    return
-
-                msg = None
-                buf = None
-                target_devices = []
-
-                # for result_directory mode. device id is taken from request
-                # and we can search the kernel instance in this device only (not for eustall case)
-                if device_id is not None and not metrics_info.is_eustall:
-                    device_info = metrics_info.get_device(int(device_id))
-                    if device_info:
-                        target_devices.append(device_info)
-                else:
-                    target_devices = list(metrics_info.devices.values())
-
-                for device_info in target_devices:
-                    device_data_df = device_info.get_device_data()
-                    if (device_data_df is None) or (device_data_df.shape[0] == 0):
-                        msg = f"No metric data for device {device_info.device_id}"
-                        continue
-                    if metrics_info.is_eustall:
-                        msg, buf = AnalyzeStallMetrics(args, device_data_df, kname, http = True)
-                    else:
-                        msg, buf = HttpAnalyzePerfMetrics(args, device_data_df, kname, instance)
-
-                    if (buf is not None):
-                        buf.seek(0)
-                        try:
-                            self.send_header('Content-type', 'application/pdf')
-                            self.end_headers()
-                            self.wfile.write(buf.read())
-                        except BrokenPipeError:
-                            print("Try again please")
-                            return
-                        return
-                    else:
-                        if (msg is not None):
-                            break
-
-                self.send_header('Content-type', 'text/plain')
-                self.end_headers()
-                if (msg is not None):
-                    self.wfile.write(bytes(msg, 'utf-8'))
-                else:
-                    self.wfile.write(b'No metric data collected or no metrics specified')
-
-        # matplotlib does not like ThreadingHTTPServer
-        httpd = HTTPServer(('localhost', 8000), PerfMetricsRequestHandler)
-
-        if (args.https == True):
-            cert = args.certificate
-            key = args.key
-            tmpdir = None
-            if ((cert == None) and (key == None)):
-                # generate a self signed certificate
-                print("No certificate or private key is provided.")
-                print("Generating a self-signed certificate...")
-                tmpdir = tempfile.TemporaryDirectory()
-                cert = os.path.join(tmpdir.name, "selfsigned.crt")
-                key = os.path.join(tmpdir.name, "private.key")
-                GenerateSelfSignedCertificate(cert, key)
-            else:
-                if (cert is None):
-                    print("Certificate file is missing")
-                    return
-                if (key is None):
-                    print("Private key file is missing")
-                    return
-
-                if (os.path.isfile(cert) == False):
-                    print("Certificate file " + cert + " does not exist")
-                    return
-                if (os.path.isfile(key) == False):
-                    print("Private key file " + key + " does not exist")
-                    return
-
-            context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-            context.load_cert_chain(cert, key)
-            httpd.socket = context.wrap_socket(httpd.socket, server_side = True)
-            if (tmpdir is not None):
-                tmpdir.cleanup()
-
-        httpd.serve_forever()
-
-    except KeyboardInterrupt:
-        print("Goodbye!")
-        return
-
-def main(args):
-    try:
-        metrics_info = MetricsInfo(input_path=args.input,
-                                   is_result_directory=args.result_dir)
-    except Exception as e:
-        print(f"Error: {e}")
-        return
-
-    if (args.list == True):
-        metrics_info.print_data(args.output)
-        return
-
-    metric_ylabel_match = True
-    if (((args.metrics is not None) and (args.ylabel is None)) or ((args.metrics is None) and (args.ylabel is not None))):
-        metric_ylabel_match = False
-    else:
-        if ((args.metrics is not None) and (args.ylabel is not None) and (len(args.metrics) != len(args.ylabel))):
-            metric_ylabel_match = False
-
-    if (metric_ylabel_match == False):
-        print("Number of metric sets does not match number of Y labels")
-        return
-
-    if ((args.https == True) and (args.http == True)):
-        print("Options -p and -q cannot be used at the same time")
-        return
-
-    if ((args.https == True) or (args.http == True)):
-        print("No output to file")
-        print("Options -o/--output, -r/--report, -k/--kernel, -i/--instance and -d/--device are ignored if they are present")
-        PerfMetricsHTTPServer(args, metrics_info)
-        return
-
-    if (args.output is None):
-        print("Error: -o/--output is missing")
-        return
-
-    device_info = metrics_info.get_device(args.device)
-    if device_info is None:
-        print(f"Error: Device {args.device} not found in metrics data")
-        return
-
-    device_data_df = device_info.get_device_data()
-    if (device_data_df is None) or (device_data_df.shape[0] == 0):
-        print(f"No metric data for device {device_info.device_id}")
-        return
-
-    # The selected device's format, not is_eustall, which is the lowest-numbered device's.
-    if (device_info.kind != "stall"):
-        if (args.metrics is None):
-            print("-m option is missing")
-            return
-        if (args.ylabel is None):
-            print("-y option is missing")
-            return
-        if (len(args.metrics) != len(args.ylabel)):
-            print("Numbers of -m options and -y options do not match")
-            return
-        AnalyzePerfMetrics(args, device_data_df)
-    else:
-        AnalyzeStallMetrics(args, device_data_df, args.kernel)
-
-if __name__== "__main__":
-    main(ParseArguments(sys.argv[1:]))  # skip sys.argv[0]
diff --git a/tools/unitrace/scripts/metrics/config/bmg/ComputeBasic.txt b/tools/unitrace/scripts/metrics/config/bmg/ComputeBasic.txt
deleted file mode 100644
index 9da24bab..00000000
--- a/tools/unitrace/scripts/metrics/config/bmg/ComputeBasic.txt
+++ /dev/null
@@ -1,16 +0,0 @@
--m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU2_ALL_UTILIZATION[%]" -y "XVE Stall and ALU Utilizations (%)"
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)"
--m "XVE_INST_EXECUTED_ALU0_ALL[events],XVE_INST_EXECUTED_ALU1_ALL[events],XVE_INST_EXECUTED_SEND_ALL[events]" -y "ALU Instruction Events Executed"
--m "ICACHE_HIT[events],ICACHE_MISS[events]" -y "Instruction Cache Hit/Miss (events)"
--m "GPU_MEMORY_L3_READ[events],GPU_MEMORY_L3_WRITE[events]" -y "GPU Memory Read/Write Caused by L3 Miss (events)"
--m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory Read/Write (bytes)"
--b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]"
--m "L3_HIT[events],L3_MISS[events]" -y "L3 Cache Hit/Miss (events)"
--m "LOAD_STORE_CACHE_ACCESS[events],LOAD_STORE_CACHE_HIT[events]" -y "LSC Access/Hit (events)"
--m "LOAD_STORE_CACHE_BYTE_READ[bytes],LOAD_STORE_CACHE_BYTE_WRITE[bytes]" -y "LSC Read/Write Excluding SLM (bytes)"
--b "LOAD_STORE_CACHE_BYTE_READ[bytes],LOAD_STORE_CACHE_BYTE_WRITE[bytes]"
--m "SLM_BYTE_READ[bytes],SLM_BYTE_WRITE[bytes]" -y "SLM Read/Write (bytes)"
--b "SLM_BYTE_READ[bytes],SLM_BYTE_WRITE[bytes]"
--m "TLB_MISS[events]" -y "TLB Miss (events)"
--m "COMPRESSOR_INPUT[events],COMPRESSOR_OUTPUT[events]" -y "256B Write at Compressor Input/Output (events)"
--m "AvgGpuCoreFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/bmg/MemoryProfile.txt b/tools/unitrace/scripts/metrics/config/bmg/MemoryProfile.txt
deleted file mode 100644
index 5ca64a7c..00000000
--- a/tools/unitrace/scripts/metrics/config/bmg/MemoryProfile.txt
+++ /dev/null
@@ -1,12 +0,0 @@
--m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory Read/Write (bytes)"
--b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]"
--m "L3_HIT[events],L3_MISS[events]" -y "L3 Cache Hit/Miss (events)"
--m "L3_READ[events],L3_WRITE[events]" -y "L3 64-byte Read/Write (events)"
--m "HOST_TO_GPUMEM_TRANSACTION_READ[events],HOST_TO_GPUMEM_TRANSACTION_WRITE[events]" -y "Host 64B Read/Write GPU Memory (events)"
--b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]"
--m "SLM_ACCESS_COUNT[events],SLM_BANK_CONFLICT_COUNT[events]" -y "SLM Access and Bank Conflict (events)"
--m "SLM_BYTE_READ[bytes],SLM_BYTE_WRITE[bytes]" -y "SLM Read/Write (bytes)"
--b "SLM_BYTE_READ[bytes],SLM_BYTE_WRITE[bytes]"
--m "XVE_SLM_READ_MESSAGE_COUNT[messages],XVE_SLM_WRITE_MESSAGE_COUNT[messages],XVE_SLM_ATOMIC_MESSAGE_COUNT[events],XVE_SLM_FENCE_MESSAGE_COUNT[events]" -y "SLM Read/Write/Atomic/Fence (messages)"
--m "TLB_MISS[events]" -y "TLB miss (events)"
--m "AvgGpuCoreFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/ComputeBasic.txt b/tools/unitrace/scripts/metrics/config/pvc/ComputeBasic.txt
deleted file mode 100644
index 86a08f4f..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/ComputeBasic.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_STALL[%],XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%],XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%],XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%],XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%],XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%]" -y "XVE Stall and ALU Utilizations (%)" -m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "XVE_ATOMIC_ACCESS_COUNT[messages],XVE_BARRIER_MESSAGE_COUNT[messages]" -y "Atomics and Barriers Messages" -m "XVE_INST_EXECUTED_ALU0_ALL[events],XVE_INST_EXECUTED_ALU1_ALL[events],XVE_INST_EXECUTED_XMX_ALL[events],XVE_INST_EXECUTED_SEND_ALL[events],XVE_INST_EXECUTED_CONTROL_ALL[events]" -y "ALU Instruction Events Executed" -m "L3_BYTE_READ[bytes],L3_BYTE_WRITE[bytes],GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "L3 and GPU Memory (bytes)" -b "L3_BYTE_READ[bytes],L3_BYTE_WRITE[bytes],GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/GpuOffload.txt b/tools/unitrace/scripts/metrics/config/pvc/GpuOffload.txt
deleted file mode 100644
index 857c9d0f..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/GpuOffload.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory (bytes)" -m "SYSMEM_BYTE_READ[bytes],SYSMEM_BYTE_WRITE[bytes]" -y "System Memory (bytes)" -m "STACK_TO_STACK_DATA_BYTE_RECEIVE[bytes],STACK_TO_STACK_DATA_BYTE_TRANSMIT[bytes]" -y "Stack to Stack Traffic (bytes)" -b "SYSMEM_BYTE_READ[bytes],SYSMEM_BYTE_WRITE[bytes]" -b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -b "STACK_TO_STACK_DATA_BYTE_RECEIVE[bytes],STACK_TO_STACK_DATA_BYTE_TRANSMIT[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileReads.txt b/tools/unitrace/scripts/metrics/config/pvc/L1ProfileReads.txt
deleted file mode 100644
index 5f024a77..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileReads.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory (bytes)" -m "LOAD_STORE_CACHE_BYTE_READ[bytes],SLM_BYTE_READ[bytes]" -y "Load Store Cache Read (bytes)" -b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -b "LOAD_STORE_CACHE_BYTE_READ[bytes],SLM_BYTE_READ[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileSlmBankConflicts.txt b/tools/unitrace/scripts/metrics/config/pvc/L1ProfileSlmBankConflicts.txt
deleted file mode 100644
index 3e0f4d9e..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileSlmBankConflicts.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory (bytes)" -m "SLM_BANK_CONFLICT_COUNT[events]" -y "SLM Bank Conflicts" -b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileWrites.txt b/tools/unitrace/scripts/metrics/config/pvc/L1ProfileWrites.txt
deleted file mode 100644
index 59b3c8cc..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/L1ProfileWrites.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory (bytes)" -m "LOAD_STORE_CACHE_BYTE_WRITE[bytes],SLM_BYTE_WRITE[bytes]" -y "Load Store Cache Write(bytes)" -b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -b "LOAD_STORE_CACHE_BYTE_WRITE[bytes],SLM_BYTE_WRITE[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/config/pvc/MemProfile.txt b/tools/unitrace/scripts/metrics/config/pvc/MemProfile.txt
deleted file mode 100644
index 98843a7d..00000000
--- a/tools/unitrace/scripts/metrics/config/pvc/MemProfile.txt
+++ /dev/null
@@ -1 +0,0 @@
--m "XVE_ACTIVE[%],XVE_STALL[%],XVE_THREADS_OCCUPANCY_ALL[%]" -y "Active, Stall and Occupancy (%)" -m "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -y "GPU Memory (bytes)" -m "HOST_TO_GPUMEM_BYTE_READ[bytes],HOST_TO_GPUMEM_BYTE_WRITE[bytes]" -y "Host and GPU Traffic (bytes)" -m "SCALEUP_DATA_BYTE_RECEIVE[bytes],SCALEUP_DATA_BYTE_TRANSMIT[bytes]" -y "Scaleup Data Transfer (bytes)" -b "GPU_MEMORY_BYTE_READ[bytes],GPU_MEMORY_BYTE_WRITE[bytes]" -b "HOST_TO_GPUMEM_BYTE_READ[bytes],HOST_TO_GPUMEM_BYTE_WRITE[bytes]" -b "SCALEUP_DATA_BYTE_RECEIVE[bytes],SCALEUP_DATA_BYTE_TRANSMIT[bytes]" -m "AvgGpuCoreFrequencyMHz[MHz],AvgGpuSliceFrequencyMHz[MHz]" -y "Frequency (MHz)"
diff --git a/tools/unitrace/scripts/metrics/perfdashboard.py b/tools/unitrace/scripts/metrics/perfdashboard.py
deleted file mode 100644
index d5dd62b6..00000000
--- a/tools/unitrace/scripts/metrics/perfdashboard.py
+++ /dev/null
@@ -1,1335 +0,0 @@
-# perfdashboard.py
-#
-# Self-contained cutdown dashboard.
-# Features:
-#   - Upload a CSV performance file        (file_csv_input1)
-#   - Choose graph display mode            (graph_mode_group)
-#   - Select counters to visualise         (counter_multi_choice)
-#
-# All helper logic from visual_elements.py is inlined here.
-
-from bokeh.plotting import figure, curdoc
-from bokeh.models import (
-    TabPanel, Tabs,
-    MultiChoice, RadioButtonGroup, TextInput, CheckboxGroup, CustomJS,
-    ColumnDataSource, HoverTool, Range1d, FactorRange,
-    FixedTicker, BasicTickFormatter, BasicTicker,
-)
-from bokeh.models.widgets import Div, FileInput
-from bokeh.layouts import column, row
-from bokeh.palettes import Category10
-from bokeh.transform import dodge
-
-import argparse
-from html import escape
-import base64
-import json
-import os.path as osp
-import sys
-import tempfile
-import pandas as pd
-import re
-
-# The metrics file parsers live next to this file, whichever way it is launched.
-sys.path.insert(0, osp.dirname(osp.abspath(__file__)))
-import analyzeperfmetrics as apm
-
-
-# ── Startup arguments (bokeh serve --args --csv PATH) ─────────────────────────
-
-def parse_startup_args():
-    """Parse the --csv path forwarded by bokeh serve via --args.
-
-    Uses parse_known_args so that Bokeh's own argv entries are ignored silently.
-
-    Only a browser session of the dashboard takes its file paths from the command
-    line: the Bokeh server executes this file once per session, with the session
-    context set and the arguments create_server() passes in sys.argv.  Running
-    this file as the server launcher, see main() below, or importing it, has a
-    command line of its own, which the dashboard reads nothing from.
-    """
-    p = argparse.ArgumentParser(add_help=False)
-    p.add_argument("--csv", dest="csv_path", default=None)
-    p.add_argument("--eustall", action="store_true", default=False)
-    p.add_argument("--trace", dest="trace_path", default=None)
-    session = curdoc().session_context is not None
-    known, _ = p.parse_known_args(sys.argv[1:] if session else [])
-    return known
-
-startup_args = parse_startup_args()
-
-
-# ── Counter sort helper ───────────────────────────────────────────────────────
-
-def counter_unit_sort_key(name):
-    """Sort key that groups counters by the unit inside trailing [ ] brackets.
-
-    Primary key  : unit text, lower-cased  (e.g. '%', 'bytes', 'events', 'mhz')
-    Secondary key: counter name, lower-cased (alphabetical within each group)
-
-    Counters with no unit bracket sort last.
-    """
-    m = re.search(r'\[([^\]]+)\]\s*$', name)
-    unit = m.group(1).lower() if m else "\xff"   # \xff sorts after all ASCII
-    return (unit, name.lower())
-
-
-# ── CSV column classification ────────────────────────────────────────────────
-
-# Metadata columns that are NOT plottable counters.
-CSV_EXCLUDE_COLS = {
-    "querybegintime[ns]",
-    "corefrequencymhz[mhz]",
-}
-
-
-def counter_cols_from_df(df):
-    """Return a sorted list of plottable counter column names from the CSV DataFrame.
-
-    Requires a trailing [unit] and skips metadata columns ()
-    and columns whose sampled values are non-numeric strings.
-    """
-    counters = []
-    for col in df.columns:
-        unit = re.search(r'\[([^\[\]]+)\]\s*$', col)
-        if not unit or not unit.group(1).strip() or col.strip().lower() in CSV_EXCLUDE_COLS:
-            continue
-        # Quick check: if every value is a string, skip it
-        if not pd.api.types.is_numeric_dtype(df[col]):
-            sample = df[col].dropna().head(5)
-            if sample.empty:
-                continue
-            try:
-                pd.to_numeric(sample, errors="raise")
-            except (ValueError, TypeError):
-                continue
-        counters.append(col)
-    return sorted(counters, key=counter_unit_sort_key)
-
-
-# ── Data-access helpers ──────────────────────────────────────────────────────
-
-# Global map: id(df) -> column_map, populated after every CSV upload.
-df_col_map_dict = {}
-
-
-def build_counter_column_map(df):
-    """Build a case-insensitive lookup from short column names to full column names."""
-    col_map = {}
-    for col in df.columns:
-        last_part = col.split('.')[-1].lower()
-        col_map[last_part] = col
-        col_map[col.lower()] = col
-    return col_map
-
-
-# ── File-path loaders (used when invoked via bokeh serve --args) ──────────────
-
-def init_from_csv_path(csv_path):
-    """Load a metrics CSV directly from *csv_path* (no base64 / file-upload)."""
-    global df_input1, df_kernel, csv1_col_map
-    try:
-        df_input1 = read_metrics(csv_path)
-    except Exception as exc:
-        print(f"Error loading CSV from {csv_path}: {exc}")
-        return False
-    csv1_col_map = build_counter_column_map(df_input1)
-    df_col_map_dict[id(df_input1)] = csv1_col_map
-    df_kernel = df_input1
-    index_kernels(df_input1)
-
-    # Populate the counter list from the CSV headers
-    csv_counters = counter_cols_from_df(df_input1)
-    counter_multi_choice.options = csv_counters
-    counter_multi_choice.value = []
-
-    status_div.text = (
-        f"<b>CSV:</b> {df_input1.shape[0]} rows × {df_input1.shape[1]} columns. "
-        f"<b>{len(csv_counters)}</b> counters available."
-    )
-    return True
-
-
-# ── EU Stall Sampling ─────────────────────────────────────────────────────────
-#
-# Column names in the EU stall CSV match the official Intel EU Stall Sampling
-# field names (with [Events] suffix added by the unitrace collector).
-
-EU_STALL_COLUMNS = [
-    ('Active[Events]',          'Active (No Stall)',   '#2ca02c'),  # green  — healthy
-    ('SbidStall[Events]',       'SBID (DRAM latency)', '#d62728'),  # red    — memory latency
-    ('SendStall[Events]',       'Send (Memory access)','#ff7f0e'),  # orange — memory access
-    ('DistStall[Events]',       'Dist/Acc Dep',        '#bcbd22'),  # yellow — ALU dependency
-    ('PipeStall[Events]',       'Pipe Busy',           '#1f77b4'),  # blue   — compute bound
-    ('SyncStall[Events]',       'Sync/Barrier',        '#9467bd'),  # purple — barrier
-    ('InstrFetchStall[Events]', 'Instr Fetch',         '#e377c2'),  # pink   — I-cache miss
-    ('ControlStall[Events]',    'Control/Branch',      '#17becf'),  # cyan   — branch
-    ('PSDepStall[Events]',      'PS Dep (TDR)',        '#8c564b'),  # brown  — graphics only
-    ('OtherStall[Events]',      'Other',               '#7f7f7f'),  # gray   — misc
-]
-
-# Global EU stall chart container (populated by init_eustall_from_csv_path)
-eustall_status = Div(text='Loading EU stall data…', width=700)
-eustall_plot_layout = column()
-
-
-def fmt_ip(val):
-    """Format an instruction offset as a hex string (e.g. 0x0280)."""
-    try:
-        address = int(val.strip(), 16) if isinstance(val, str) else int(val)
-        return f'0x{address:04x}'
-    except Exception:
-        return str(val)
-
-
-def build_eu_stall_chart(df):
-    """Build a two-panel EU stall dashboard.
-
-    Panel 1 — Kernel Summary (vertical bars):
-        X axis : stall category names (one bar per category per kernel)
-        Y axis : total event count (summed across all IPs for that kernel)
-
-    Panel 2 — Instruction Hotspots (horizontal stacked bars):
-        Y axis : top-20 instruction offsets ranked by total stall count
-        X axis : stall event counts, stacked by category
-    """
-    df = df.copy()
-    df.columns = df.columns.str.strip()
-
-    kernel_col = 'Kernel'
-    ip_col = 'Offset' if 'Offset' in df.columns else None
-
-    # Filter to stall columns present in this CSV
-    available = [(col, label, color)
-                 for col, label, color in EU_STALL_COLUMNS
-                 if col in df.columns]
-    if not available:
-        return Div(text=(
-            "<b style='color:red'>EU stall columns not found in CSV.</b><br>"
-            f"Columns found: {list(df.columns)}<br>"
-            "Expected: 'Active[Events]', 'SbidStall[Events]', etc."
-        ))
-
-    stall_cols   = [col for col, _, _ in available]
-    stall_only   = [(col, lbl, clr) for col, lbl, clr in available if col != 'Active[Events]']
-    stall_only_cols = [col for col, _, _ in stall_only]
-
-    for c in stall_cols:
-        df[c] = pd.to_numeric(df[c], errors='coerce').fillna(0)
-
-    # ── Panel 1: Kernel Summary ───────────────────────────────────────────
-    df_agg = df.groupby(kernel_col, sort=False)[stall_cols].sum().reset_index()
-
-    cat_labels  = [lbl  for _, lbl,  _ in available]
-    cat_colors  = [clr  for _, _,    clr in available]
-    cat_cols    = [col  for col, _,  _ in available]
-    n_kernels   = len(df_agg)
-    bar_width   = 0.7 / max(n_kernels, 1)
-    offsets     = [i * bar_width - (n_kernels - 1) * bar_width / 2
-                   for i in range(n_kernels)]
-
-    n_cats      = len(available)
-    x_cat_pos   = list(range(n_cats))
-
-    fig1 = figure(
-        x_range=Range1d(-0.5, n_cats - 0.5),
-        height=420,
-        width=max(800, n_cats * 80 + 200),
-        title='EU Stall Sampling — Stall Category Totals per Kernel',
-        y_axis_label='Event Count (Samples)',
-        toolbar_location='above',
-        tools='pan,wheel_zoom,box_zoom,reset,save',
-    )
-    fig1.toolbar.logo = None
-    fig1.y_range.start = 0
-    fig1.xaxis.ticker = FixedTicker(ticks=x_cat_pos)
-    fig1.xaxis.major_label_overrides = {x_cat_pos[i]: cat_labels[i] for i in range(n_cats)}
-    fig1.xaxis.major_label_orientation = 0.6
-    fig1.xaxis.major_label_text_font_size = '10px'
-    fig1.yaxis.formatter = BasicTickFormatter(use_scientific=False)
-
-    for ki in range(n_kernels):
-        k_name = str(df_agg[kernel_col].iloc[ki]).strip('"').strip()
-        k_label = (k_name[:40] + '…') if len(k_name) > 40 else k_name
-        vals = [float(df_agg[col].iloc[ki]) for col in cat_cols]
-        src1 = ColumnDataSource({
-            'x':     [xp + offsets[ki] for xp in x_cat_pos],
-            'top':   vals,
-            'color': cat_colors,
-            'cat':   cat_labels,
-            'kern':  [k_label] * n_cats,
-        })
-        renderer = fig1.vbar(
-            x='x', top='top', width=bar_width * 0.9,
-            color='color', alpha=0.85,
-            legend_label=k_label,
-            source=src1,
-        )
-        fig1.add_tools(HoverTool(
-            renderers=[renderer],
-            tooltips=[
-                ('Kernel',   '@kern'),
-                ('Category', '@cat'),
-                ('Count',    '@top{0,}'),
-            ],
-        ))
-
-    fig1.legend.location    = 'top_right'
-    fig1.legend.click_policy = 'hide'
-
-    # ── Panel 2: Instruction Hotspots ─────────────────────────────────────────────
-    if ip_col and stall_only_cols:
-        df_ip = df.copy()
-        df_ip['_ip_str']   = df_ip[ip_col].apply(fmt_ip)
-        df_ip['_total']    = df_ip[stall_only_cols].sum(axis=1)
-        df_ip = (df_ip.nlargest(20, '_total')
-                      .sort_values('_total', ascending=True)
-                      .reset_index(drop=True))
-
-        m = len(df_ip)
-        y_pos    = list(range(m))
-        ip_labels = df_ip['_ip_str'].tolist()
-
-        data2 = {'y': y_pos, 'ip': ip_labels}
-        # the bars of a category start where the bars of the ones before it end, so
-        # the stack is summed up column by column; the rows of df_ip are numbered
-        # from 0 by the reset_index() above, which is the index left_arr aligns on
-        left_arr = pd.Series(0.0, index=df_ip.index)
-        for i, (col, lbl, clr) in enumerate(stall_only):
-            vals = df_ip[col]
-            right_arr = left_arr + vals
-            data2[f'left_{i}']  = left_arr.tolist()
-            data2[f'right_{i}'] = right_arr.tolist()
-            data2[f'val_{i}']   = vals.tolist()
-            left_arr = right_arr
-        src2 = ColumnDataSource(data2)
-
-        fig2 = figure(
-            y_range=Range1d(-0.5, m - 0.5),
-            height=max(350, m * 28 + 120),
-            width=max(800, 1000),
-            title='EU Stall Sampling — Top 20 Instruction Hotspots (Stall Events by Category)',
-            x_axis_label='Stall Event Count',
-            toolbar_location='above',
-            tools='pan,wheel_zoom,box_zoom,reset,save',
-        )
-        fig2.toolbar.logo = None
-        fig2.x_range.start = 0
-        fig2.yaxis.ticker = FixedTicker(ticks=y_pos)
-        fig2.yaxis.major_label_overrides = {y_pos[i]: ip_labels[i] for i in range(m)}
-        fig2.yaxis.major_label_text_font_size = '11px'
-        fig2.xaxis.formatter = BasicTickFormatter(use_scientific=False)
-
-        for i, (col, lbl, clr) in enumerate(stall_only):
-            renderer = fig2.hbar(
-                y='y', left=f'left_{i}', right=f'right_{i}',
-                height=0.65, color=clr, alpha=0.85,
-                legend_label=lbl, source=src2,
-            )
-            fig2.add_tools(HoverTool(
-                renderers=[renderer],
-                tooltips=[
-                    ('Offset',   '@ip'),
-                    ('Category', lbl),
-                    ('Count',    f'@val_{i}{{0,}}'),
-                ],
-            ))
-
-        fig2.legend.location    = 'bottom_right'
-        fig2.legend.click_policy = 'hide'
-        fig2.legend.orientation  = 'vertical'
-
-        return column(fig1, fig2)
-
-    return fig1
-
-
-def select_eustall_kernel(frame, gid=None, kernel_name=None, trace_path=None):
-    if gid is None and kernel_name is None:
-        return frame
-    if trace_path and gid is not None:
-        with open(trace_path, encoding="utf-8") as source:
-            trace = json.load(source)
-        events = trace.get("traceEvents", []) if isinstance(trace, dict) else trace
-        kernel_name = next((event.get("name") for event in events
-                            if str(event.get("args", {}).get("id")) == str(gid)
-                            and "metrics" in event.get("args", {})), None)
-    if not kernel_name:
-        raise ValueError(f"Cannot resolve kernel for GID {gid}; provide the matching trace JSON.")
-    kernel_name = re.sub(r"\[SIMD.*\]$", "", kernel_name.strip().strip('"'))
-    names = frame.iloc[:, 0].astype(str).str.strip().str.strip('"')
-    selected = frame.loc[names == kernel_name].copy()
-    if selected.empty:
-        raise ValueError(f"No EU stall samples found for kernel {kernel_name}")
-    return selected
-
-
-def session_argument(name):
-    context = curdoc().session_context
-    if context is None:
-        return None
-    value = context.request.arguments.get(name, [None])[0]
-    return value.decode("utf-8") if isinstance(value, bytes) else value
-
-
-def init_eustall_from_csv_path(csv_path):
-    """Load a EU stall CSV from disk and render the stall breakdown chart."""
-    import traceback
-    global df_input1
-    try:
-        df_input1 = read_metrics(csv_path)
-        df_input1 = select_eustall_kernel(
-            df_input1, session_argument("gid"), session_argument("kernel"), startup_args.trace_path
-        )
-    except Exception as exc:
-        print(f'Error loading EU stall CSV from {csv_path}: {exc}')
-        eustall_status.text = f"<b style='color:red'>Error loading CSV: {exc}</b>"
-        return False
-
-    try:
-        chart = build_eu_stall_chart(df_input1)
-    except Exception as exc:
-        tb = traceback.format_exc()
-        print(f'Error building EU stall chart: {tb}')
-        chart = Div(text=(
-            f"<b style='color:red'>Chart build error: {exc}</b>"
-            f"<pre style='font-size:11px'>{tb}</pre>"
-        ))
-
-    eustall_plot_layout.children = [chart] if chart is not None else [
-        Div(text='<b>No chart generated.</b>')
-    ]
-    eustall_status.text = (
-        f"<b>EU Stall CSV loaded:</b> {osp.basename(csv_path)} — "
-        f"{df_input1.shape[0]} instruction row(s), aggregated by kernel name across invocations."
-    )
-    return True
-
-
-def select_kernel_by_gid(gid):
-    """Select the primary kernel from a Perfetto link."""
-    global updating_kernel_inputs, primary_kernel_id
-    primary_kernel_id = str(gid)
-    updating_kernel_inputs = True
-    try:
-        compare_kernel_input.value = ""
-    finally:
-        updating_kernel_inputs = False
-    kernel_id_callback("value", "", str(gid))
-
-
-# ── Visualisation helpers ─────────────────────────────────────────────────────
-
-
-def normalize_series(series):
-    """Clean and sort a list of (frame, value) tuples into parallel x/y lists."""
-    cleaned = []
-    for frame, value in series:
-        try:
-            frame_val = float(frame)
-        except (TypeError, ValueError):
-            continue
-        if isinstance(value, str):
-            value = value.replace(",", "")
-        try:
-            value_val = float(value)
-        except (TypeError, ValueError):
-            continue
-        cleaned.append((frame_val, value_val))
-    cleaned.sort(key=lambda t: t[0])
-    return [f for f, _ in cleaned], [v for _, v in cleaned]
-
-
-def show_counters_overlaid(metric_name, counter_series_1, counter_series_2=None,
-                          x_axis_label="Time (ns)"):
-    """Plot every sample of each selected counter on a shared numeric axis."""
-    counter_series_1 = counter_series_1 or []
-    counter_series_2 = counter_series_2 or []
-    if not counter_series_1 and not counter_series_2:
-        return None
-
-    palette = Category10[10]
-    fig = figure(
-        height=550, width=900, title=metric_name,
-        x_axis_label=x_axis_label, y_axis_label="Counter Value",
-        toolbar_location="above", tools="pan,wheel_zoom,box_zoom,reset,save",
-        sizing_mode="stretch_width",
-    )
-    labels = list(dict.fromkeys(label for label, _ in counter_series_1 + counter_series_2))
-    for kernel_index, counters in enumerate((counter_series_1, counter_series_2)):
-        for label, series in counters:
-            xs, ys = normalize_series(series)
-            if not xs:
-                continue
-            legend = f"Kernel {kernel_index + 1}: {label}" if counter_series_2 else label
-            source = ColumnDataSource({"x": xs, "y": ys})
-            color = palette[labels.index(label) % len(palette)]
-            renderer = fig.line(
-                "x", "y", source=source, color=color, line_width=2,
-                line_dash="solid" if kernel_index == 0 else "dashed",
-                legend_label=legend,
-            )
-            if len(xs) == 1:
-                fig.scatter("x", "y", source=source, color=color, size=7, legend_label=legend)
-            fig.add_tools(HoverTool(
-                renderers=[renderer], tooltips=[("Counter", legend),
-                    (x_axis_label, "@x{0,0.###}"), ("Value", "@y{0,0.######}")],
-            ))
-    if not fig.renderers:
-        return None
-    fig.toolbar.logo = None
-    fig.y_range.start = 0
-    fig.xaxis.ticker = BasicTicker(desired_num_ticks=8)
-    fig.xaxis.formatter = BasicTickFormatter(use_scientific=False)
-    fig.xaxis.major_label_text_font_size = "10px"
-    fig.legend.visible = False
-    fig.legend.click_policy = "hide"
-    return fig
-
-
-def is_query_sampling(df):
-    columns = {str(col).strip().lower() for col in df.columns}
-    return {"querysplitoccurred", "reportid", "reportscount"}.issubset(columns)
-
-
-def show_query_counter_bars(metric_name, counter_series):
-    if not counter_series:
-        return None
-    reports = sorted({sample for _, series in counter_series for sample, _ in series})
-    factors = [f"{report:g}" for report in reports]
-    fig = figure(
-        x_range=FactorRange(factors=factors), height=550, width=900,
-        title=metric_name, x_axis_label="Query report", y_axis_label="Counter Value",
-        toolbar_location="above", tools="pan,wheel_zoom,box_zoom,reset,save",
-        sizing_mode="stretch_width",
-    )
-    width = 0.8 / len(counter_series)
-    for index, (label, series) in enumerate(counter_series):
-        samples, values = normalize_series(series)
-        source = ColumnDataSource({"x": [f"{sample:g}" for sample in samples], "top": values})
-        renderer = fig.vbar(
-            x=dodge("x", -0.4 + width * (index + 0.5), range=fig.x_range),
-            top="top", width=width, source=source,
-            color=Category10[10][index % 10], legend_label=label,
-        )
-        fig.add_tools(HoverTool(renderers=[renderer], tooltips=[
-            ("Counter", label), ("Query report", "@x"), ("Value", "@top{0,0.######}"),
-        ]))
-    fig.toolbar.logo = None
-    fig.y_range.start = 0
-    fig.legend.visible = False
-    return fig
-
-
-def counter_plot_with_legend(fig):
-    if fig is None:
-        return None
-    fig.min_border_left = 70
-    fig.margin = 0
-    items = list(fig.legend[0].items)
-    renderers = [item.renderers for item in items]
-    colors = [group[0].glyph.line_color for group in renderers]
-    legend = CheckboxGroup(
-        labels=[item.label.value for item in items],
-        active=list(range(len(items))), inline=True,
-        sizing_mode="stretch_width", max_height=140,
-        margin=(0, 0, 0, fig.min_border_left),
-        styles={"overflow-y": "auto", "overflow-x": "hidden"},
-        stylesheets=["""
-            .bk-input-group {
-                display: flex;
-                flex-wrap: wrap;
-                gap: 6px 16px;
-                max-height: 140px;
-                overflow-y: auto;
-                overflow-x: hidden;
-            }
-            label {
-                display: inline-flex;
-                align-items: center;
-                margin: 0;
-                min-width: 0;
-                max-width: 100%;
-                overflow-wrap: anywhere;
-                white-space: normal;
-            }
-            input { flex-shrink: 0; }
-        """ + "\n".join(
-            f"label:nth-child({index + 1}) {{ border-bottom: 3px solid {color}; }}"
-            for index, color in enumerate(colors)
-        )],
-    )
-    legend.js_on_change("active", CustomJS(args={"groups": renderers}, code="""
-        for (let index = 0; index < groups.length; index++) {
-            for (const renderer of groups[index]) {
-                renderer.visible = cb_obj.active.includes(index);
-            }
-        }
-    """))
-    return column(fig, legend, sizing_mode="stretch_width")
-
-
-def show_counter_timeseries_tabs(metric_name, counter_series_1, counter_series_2):
-    """One tab per counter showing a bar chart across all ReportIds."""
-    counter_series_1 = counter_series_1 or []
-    counter_series_2 = counter_series_2 or []
-    if not counter_series_1 and not counter_series_2:
-        return None
-
-    palette = Category10[10]
-
-    # Preserve counter ordering: series_1 first, then any extras from series_2
-    label_map = dict(counter_series_1)
-    for label, _ in counter_series_2:
-        if label not in label_map:
-            label_map[label] = []
-
-    panels = []
-    for idx, label in enumerate(label_map.keys()):
-        series1 = dict(counter_series_1).get(label, [])
-        series2 = dict(counter_series_2).get(label, [])
-        xs1, ys1 = normalize_series(series1)
-        xs2, ys2 = normalize_series(series2)
-        if not xs1 and not xs2:
-            continue
-
-        # Convert x values to strings for categorical axis
-        x_labels_1 = [str(int(x)) for x in xs1]
-        x_labels_2 = [str(int(x)) for x in xs2]
-        all_x = sorted(set(x_labels_1 + x_labels_2), key=lambda s: int(s))
-
-        fig = figure(
-            x_range=FactorRange(factors=all_x),
-            height=500,
-            width=max(900, len(all_x) * 40 + 200),
-            title=f"{metric_name} – {label}",
-            x_axis_label="ReportId",
-            y_axis_label="Counter Value",
-            toolbar_location="above",
-            tools="pan,wheel_zoom,box_zoom,reset,save",
-        )
-        fig.toolbar.logo = None
-        fig.y_range.start = 0
-
-        has_both = bool(xs1) and bool(xs2)
-        if xs1:
-            src1 = ColumnDataSource({"x": x_labels_1, "top": ys1})
-            if has_both:
-                fig.vbar(x=dodge("x", -0.2, range=fig.x_range), top="top", width=0.35,
-                         source=src1, color=palette[0], alpha=0.85, legend_label="Kernel 1")
-            else:
-                fig.vbar(x="x", top="top", width=0.65, source=src1,
-                         color=palette[idx % len(palette)], alpha=0.85, legend_label="Kernel 1")
-        if xs2:
-            src2 = ColumnDataSource({"x": x_labels_2, "top": ys2})
-            if has_both:
-                fig.vbar(x=dodge("x", 0.2, range=fig.x_range), top="top", width=0.35,
-                         source=src2, color=palette[1], alpha=0.85, legend_label="Kernel 2")
-            else:
-                fig.vbar(x="x", top="top", width=0.65, source=src2,
-                         color=palette[idx % len(palette)], alpha=0.85, legend_label="Kernel 2")
-
-        fig.add_tools(HoverTool(tooltips=[("ReportId", "@x"), ("Value", "@top{0,0.00}")]))
-        fig.xaxis.major_label_orientation = 0.8
-        fig.legend.location = "top_left"
-        fig.legend.click_policy = "hide"
-        panels.append(TabPanel(child=fig, title=label))
-
-    return Tabs(tabs=panels) if panels else None
-
-
-def show_counter_series_stack(metric_name, counter_series_1, counter_series_2=None):
-    """Stacked individual bar charts (one per counter) across all ReportIds."""
-    counter_series_1 = counter_series_1 or []
-    counter_series_2 = counter_series_2 or []
-    if not counter_series_1 and not counter_series_2:
-        return None
-
-    palette = Category10[10]
-    ordered_labels = []
-    seen = set()
-    for label, _ in counter_series_1:
-        if label not in seen:
-            ordered_labels.append(label)
-            seen.add(label)
-    for label, _ in counter_series_2:
-        if label not in seen:
-            ordered_labels.append(label)
-            seen.add(label)
-
-    figs = []
-    for idx, label in enumerate(ordered_labels):
-        series1 = dict(counter_series_1).get(label, [])
-        series2 = dict(counter_series_2).get(label, [])
-        xs1, ys1 = normalize_series(series1)
-        xs2, ys2 = normalize_series(series2)
-        if not xs1 and not xs2:
-            continue
-
-        x_labels_1 = [str(int(x)) for x in xs1]
-        x_labels_2 = [str(int(x)) for x in xs2]
-        all_x = sorted(set(x_labels_1 + x_labels_2), key=lambda s: int(s))
-
-        fig = figure(
-            x_range=FactorRange(factors=all_x),
-            height=300,
-            width=max(900, len(all_x) * 40 + 200),
-            title=f"{metric_name} – {label}",
-            x_axis_label="ReportId",
-            y_axis_label="Counter Value",
-            toolbar_location="above",
-            tools="pan,wheel_zoom,box_zoom,reset,save",
-        )
-        fig.toolbar.logo = None
-        fig.y_range.start = 0
-
-        has_both = bool(xs1) and bool(xs2)
-        if xs1:
-            src1 = ColumnDataSource({"x": x_labels_1, "top": ys1})
-            if has_both:
-                fig.vbar(x=dodge("x", -0.2, range=fig.x_range), top="top", width=0.35,
-                         source=src1, color=palette[0], alpha=0.85, legend_label="Kernel 1")
-            else:
-                fig.vbar(x="x", top="top", width=0.65, source=src1,
-                         color=palette[idx % len(palette)], alpha=0.85, legend_label="Kernel 1")
-        if xs2:
-            src2 = ColumnDataSource({"x": x_labels_2, "top": ys2})
-            if has_both:
-                fig.vbar(x=dodge("x", 0.2, range=fig.x_range), top="top", width=0.35,
-                         source=src2, color=palette[1], alpha=0.85, legend_label="Kernel 2")
-            else:
-                fig.vbar(x="x", top="top", width=0.65, source=src2,
-                         color=palette[idx % len(palette)], alpha=0.85, legend_label="Kernel 2")
-
-        fig.add_tools(HoverTool(tooltips=[("ReportId", "@x"), ("Value", "@top{0,0.00}")]))
-        fig.xaxis.major_label_orientation = 0.8
-        fig.legend.location = "top_left"
-        fig.legend.click_policy = "hide"
-        figs.append(fig)
-
-    return column(*figs) if figs else None
-
-
-# ── Widgets ───────────────────────────────────────────────────────────────────
-
-file_csv_input1 = FileInput(accept=".csv", width=400)
-compare_kernel_input = TextInput(title="Compare With", max_width=400, sizing_mode="stretch_width")
-kernel_name = Div(text="", sizing_mode="stretch_width", styles={"overflow-wrap": "anywhere"})
-compare_kernel_name = Div(text="", sizing_mode="stretch_width", styles={"overflow-wrap": "anywhere"})
-graph_mode_group = RadioButtonGroup(
-    labels=["plotOverlaid", "plotAllSampleAsTabs", "plotAllSampleAsStack"],
-    active=0,
-)
-counter_multi_choice = MultiChoice(
-    title="Counters to Plot", options=[], value=[], sizing_mode="stretch_width",
-    stylesheets=["""
-        .choices__list--multiple {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 4px;
-        }
-        .choices__list--multiple .choices__item {
-            display: inline-flex;
-            align-items: center;
-            width: auto;
-            max-width: 100%;
-            min-width: 0;
-            box-sizing: border-box;
-            margin: 0;
-            white-space: normal;
-            overflow-wrap: anywhere;
-        }
-        .choices__list--multiple .choices__button {
-            flex-shrink: 0;
-        }
-    """],
-)
-status_div = Div(text="No data loaded.", width=600)
-
-
-# ── Global state ──────────────────────────────────────────────────────────────
-
-df_input1 = None
-df_kernel = None        # filtered view of df_input1 for the first selected kernel
-df_kernel2 = None       # filtered view of df_input1 for the second selected kernel
-csv1_col_map = {}
-gid_col = None         # name of the GlobalInstanceId column once detected
-kernel_rows = {}
-kernel_labels = []
-selection_valid = False
-updating_kernel_inputs = False
-primary_kernel_id = ""
-
-# Dynamic plot container — its .children list is replaced on every plot action.
-metric_plot_layout = column(sizing_mode="stretch_width")
-
-GRAPH_MODES = ["plotOverlaid", "plotAllSampleAsTabs", "plotAllSampleAsStack"]
-
-
-# ── Callbacks ─────────────────────────────────────────────────────────────────
-
-def read_metrics(path):
-    """Read every device's metric table in *path* into one frame, aligned by column name.
-
-    The sections are parsed by analyzeperfmetrics, which reads all three layouts unitrace
-    writes: query, time-based and stall. The all-NaN rows it ends each instance with are
-    dropped; the dashboard tells instances apart by GlobalInstanceId.
-    """
-    frames = [apm.ReadMetricFrame(path, header, last, kind)
-              for _, header, last, kind in apm.ScanDeviceSections(path)]
-    frames = [frame.dropna(how="all") for frame in frames if not frame.empty]
-    if not frames:
-        raise ValueError("No metric data rows found in CSV")
-    return pd.concat(frames, ignore_index=True, sort=False)
-
-
-def index_kernels(df):
-    """Index sample row positions without building per-kernel UI options."""
-    global gid_col, kernel_rows, kernel_labels, selection_valid
-    global updating_kernel_inputs, primary_kernel_id, df_kernel, df_kernel2
-    gid_col = next(
-        (c for c in df.columns if c.strip().lower() == "globalinstanceid"), None
-    )
-    if gid_col is not None:
-        ids = pd.to_numeric(df[gid_col], errors="coerce")
-        ids = ids.where((ids >= 0) & (ids % 1 == 0))
-        kernel_rows = df.groupby(ids, sort=False).indices
-    else:
-        kernel_rows = {}
-    kernel_labels = []
-    selection_valid = gid_col is None
-    df_kernel = df if selection_valid else None
-    df_kernel2 = None
-    df_col_map_dict.clear()
-    df_col_map_dict[id(df)] = csv1_col_map
-    primary_kernel_id = ""
-    updating_kernel_inputs = True
-    try:
-        compare_kernel_input.value = ""
-    finally:
-        updating_kernel_inputs = False
-    compare_kernel_input.disabled = gid_col is None
-    kernel_name.text = ""
-    compare_kernel_name.text = ""
-    metric_plot_layout.children = []
-
-
-def upload_csv_input1(attr, old, new):
-    global df_input1, df_kernel, df_kernel2, csv1_col_map
-
-    try:
-        # The parsers read by line number from a path, so the upload goes to a file.
-        with tempfile.TemporaryDirectory() as tmpdir:
-            path = osp.join(tmpdir, "upload.csv")
-            with open(path, "wb") as upload:
-                upload.write(base64.b64decode(new))
-            df_input1 = read_metrics(path)
-    except Exception as e:
-        print("Error: Could not read file as CSV.", e)
-        status_div.text = "<b style='color:red'>Error: Could not read file as CSV.</b>"
-        metric_plot_layout.children = []
-        return
-
-    csv1_col_map = build_counter_column_map(df_input1)
-    df_col_map_dict[id(df_input1)] = csv1_col_map
-    df_kernel = df_input1   # default: no filter applied
-
-    index_kernels(df_input1)
-
-    df_kernel2 = None
-    metric_plot_layout.children = []
-    counter_multi_choice.value = []
-    counter_multi_choice.options = counter_cols_from_df(df_input1)
-    status_div.text = (
-        f"<b>CSV loaded:</b> {df_input1.shape[0]} rows × {df_input1.shape[1]} columns. "
-        f"<b>{len(counter_multi_choice.options)}</b> counters available."
-    )
-    print(f"CSV loaded: {df_input1.shape}")
-
-
-def build_counter_plot(metric_name, counters_1, counters_2,
-                        x_axis_label="Time (ns)", query_sampling=False):
-    """Dispatch to the correct plot type based on the active graph mode."""
-    if query_sampling:
-        return counter_plot_with_legend(show_query_counter_bars(metric_name, counters_1))
-    mode = GRAPH_MODES[graph_mode_group.active] if 0 <= graph_mode_group.active < len(GRAPH_MODES) else "plotOverlaid"
-    if mode == "plotOverlaid":
-        return counter_plot_with_legend(
-            show_counters_overlaid(metric_name, counters_1, counters_2, x_axis_label)
-        )
-    if mode == "plotAllSampleAsStack":
-        return show_counter_series_stack(metric_name, counters_1, counters_2)
-    return show_counter_timeseries_tabs(metric_name, counters_1, counters_2)
-
-
-def plot_custom_counters_callback():
-    """Main action: collect counter series from selected kernels and render plots."""
-    if df_input1 is None or df_input1.empty:
-        status_div.text = "<b style='color:red'>No data available. Upload a CSV first.</b>"
-        return
-    if not selection_valid:
-        metric_plot_layout.children = []
-        return
-
-    mode = GRAPH_MODES[graph_mode_group.active] if 0 <= graph_mode_group.active < len(GRAPH_MODES) else "plotAllSampleAsTabs"
-
-    # The counters are the CSV headers, so a counter is its own column name.
-    if not counter_multi_choice.options:
-        metric_plot_layout.children = []
-        status_div.text = "<b style='color:orange'>No counters available to plot.</b>"
-        return
-
-    selected_counters = counter_multi_choice.value or list(counter_multi_choice.options)
-
-    def resolve_column(df, counter_name):
-        """Resolve a counter name to its DataFrame column (once per counter)."""
-        col_map = df_col_map_dict.get(id(df))
-        if not col_map:
-            return None
-        key = counter_name.lower()
-        # Exact match
-        matched = col_map.get(key)
-        # Fallback: exact match after stripping [unit] suffix
-        if not matched:
-            for k, v in col_map.items():
-                if re.sub(r'\[.*?\]$', '', k).strip() == key:
-                    matched = v
-                    break
-        return matched
-
-    def collect_series(df):
-        if df is None or df.empty:
-            return []
-        query_sampling = is_query_sampling(df)
-        time_col = next(
-            (col for col in df.columns if col.strip().lower() == "querybegintime[ns]"), None
-        )
-        # Detect ReportId column for use as X axis
-        report_id_col = next(
-            (c for c in df.columns if c.strip().lower() == "reportid"), None
-        )
-        # Pre-compute X axis values once (vectorized)
-        if not query_sampling and mode == "plotOverlaid" and time_col is not None:
-            x_values = pd.to_numeric(df[time_col], errors="coerce")
-        elif report_id_col is not None:
-            x_values = pd.to_numeric(df[report_id_col], errors="coerce")
-        else:
-            x_values = None
-
-        series_list = []
-        for counter in selected_counters:
-            # Resolve column once per counter, then read entire column
-            col = resolve_column(df, counter)
-            if col is None or col not in df.columns:
-                continue
-            y_values = pd.to_numeric(
-                df[col].astype(str).str.replace(",", "", regex=False),
-                errors="coerce",
-            )
-            series = []
-            for idx in range(len(df)):
-                y = y_values.iloc[idx]
-                if pd.isna(y):
-                    continue
-                if not query_sampling and mode == "plotOverlaid" and time_col is not None and pd.isna(x_values.iloc[idx]):
-                    continue
-                x = x_values.iloc[idx] if x_values is not None and not pd.isna(x_values.iloc[idx]) else idx + 1
-                series.append((float(x), float(y)))
-            if series:
-                # Label the series with the counter the user selected, which
-                # keeps the [unit] suffix of the CSV header.
-                series_list.append((counter, series))
-        return series_list
-
-    selected = kernel_labels
-    active_df1 = df_kernel if df_kernel is not None else df_input1
-    label1 = selected[0] if len(selected) >= 1 else "Kernel 1"
-
-    counters_1 = collect_series(active_df1)
-    if any(col.strip().lower() == "querybegintime[ns]" for col in active_df1.columns):
-        x_axis_label = "Time (ns)"
-    elif any(col.strip().lower() == "reportid" for col in active_df1.columns):
-        x_axis_label = "ReportId"
-    else:
-        x_axis_label = "Sample number"
-    plot1 = build_counter_plot(label1, counters_1, [], x_axis_label,
-                                query_sampling=is_query_sampling(active_df1))
-
-    if df_kernel2 is not None:
-        label2 = selected[1] if len(selected) >= 2 else "Kernel 2"
-        counters_2 = collect_series(df_kernel2)
-        plot2 = build_counter_plot(label2, counters_2, [], x_axis_label,
-                        query_sampling=is_query_sampling(df_kernel2))
-        children = [p for p in (plot1, plot2) if p is not None]
-        result = row(*children, sizing_mode="stretch_width") if children else None
-    else:
-        result = plot1
-
-    metric_plot_layout.children = [result] if result else []
-    if not result:
-        status_div.text = "<b style='color:orange'>No data to plot for the selected counters.</b>"
-    elif df_kernel2 is not None:
-        status_div.text = f"<b>Plots updated</b> — two kernels compared, {len(counters_1)} counter series each, mode: {mode}."
-    else:
-        status_div.text = f"<b>Plot updated</b> ({len(counters_1)} counter series, mode: {mode})."
-
-
-def kernel_id_callback(attr, old, new):
-    global df_kernel, df_kernel2, kernel_labels, selection_valid
-    if updating_kernel_inputs or df_input1 is None or df_input1.empty:
-        return
-    layout.children = [controls, metric_plot_layout]
-    for frame in (df_kernel, df_kernel2):
-        if frame is not None and frame is not df_input1:
-            df_col_map_dict.pop(id(frame), None)
-    df_kernel = None
-    df_kernel2 = None
-    kernel_labels = []
-    selection_valid = False
-    metric_plot_layout.children = []
-    kernel_name.text = ""
-    compare_kernel_name.text = ""
-    status_div.text = ""
-    primary = primary_kernel_id.strip()
-    comparison = compare_kernel_input.value.strip()
-    if not primary:
-        kernel_name.text = "No primary kernel selected."
-        return
-    frames = []
-    selected_ids = []
-    for value, name_widget in ((primary, kernel_name), (comparison, compare_kernel_name)):
-        if not value:
-            continue
-        if not re.fullmatch(r"[0-9]{1,20}", value):
-            name_widget.text = "Kernel ID must be a non-negative whole number (up to 20 digits)."
-            return
-        gid = int(value)
-        positions = kernel_rows.get(gid)
-        if positions is None:
-            name_widget.text = f"Kernel ID {gid} not found."
-            if name_widget is kernel_name:
-                status_div.text = "No metric data collected or no metrics specified"
-                layout.children = [status_div]
-            return
-        if gid in selected_ids:
-            name_widget.text = "Comparison kernel must differ from the primary kernel."
-            return
-        selected_ids.append(gid)
-        filtered = df_input1.iloc[positions].reset_index(drop=True)
-        frames.append(filtered)
-        name_col = next((col for col in filtered.columns if col.strip().lower() == "kernel"), filtered.columns[0])
-        name = str(filtered.iloc[0][name_col])
-        short_name = name[:50] + ("..." if len(name) > 50 else "")
-        name_widget.text = f"Kernel {gid}: {escape(short_name)}"
-        kernel_labels.append(short_name)
-    df_kernel = frames[0]
-    df_kernel2 = frames[1] if len(frames) == 2 else None
-    for frame in frames:
-        df_col_map_dict[id(frame)] = csv1_col_map
-    selection_valid = True
-    status_div.text = ""
-    if counter_multi_choice.value:
-        plot_custom_counters_callback()
-
-
-def counter_selection_callback(attr, old, new):
-    if not new:
-        # All counters deselected — clear the plot
-        metric_plot_layout.children = []
-        status_div.text = "<b>Counters cleared.</b>"
-        return
-    # Always re-render when counter selection changes
-    try:
-        plot_custom_counters_callback()
-    except Exception as exc:
-        import traceback
-        traceback.print_exc()
-        status_div.text = f"<b style='color:red'>Error updating plot: {exc}</b>"
-        metric_plot_layout.children = []
-
-
-def graph_mode_changed(attr, old, new):
-    # Re-render with the new mode if a plot is already visible.
-    if metric_plot_layout.children:
-        plot_custom_counters_callback()
-
-
-# ── Wire up callbacks ─────────────────────────────────────────────────────────
-
-file_csv_input1.on_change('value', upload_csv_input1)
-compare_kernel_input.on_change('value', kernel_id_callback)
-counter_multi_choice.on_change("value", counter_selection_callback)
-graph_mode_group.on_change("active", graph_mode_changed)
-
-
-# ── Layout ────────────────────────────────────────────────────────────────────
-
-controls = column(
-    counter_multi_choice,
-    compare_kernel_input,
-    compare_kernel_name,
-    file_csv_input1,
-    status_div,
-    sizing_mode="stretch_width",
-)
-
-layout = column(
-    controls,
-    metric_plot_layout,
-    sizing_mode="stretch_width",
-)
-
-# ── Pre-load from startup arguments and/or session URL query params ───────────
-#
-# When invoked as:
-#   bokeh serve perfdashboard.py --args --csv PATH [--trace PATH] [--eustall]
-#
-# startup_args carries the file paths.  Each browser session also receives the
-# kernel GlobalInstanceId via the URL query parameter ?gid=N, which
-# KernelLinkHandler below appends when the user clicks a kernel in Perfetto.
-
-# ── EU Stall Sampling mode ────────────────────────────────────────────────────
-#
-# When --eustall is passed alongside --csv, render the EU stall chart directly
-# instead of the regular counter viewer.
-
-if startup_args.eustall and startup_args.csv_path:
-    init_eustall_from_csv_path(startup_args.csv_path)
-    eustall_root = column(
-        Div(text='<h2>EU Stall Sampling</h2>'),
-        eustall_status,
-        eustall_plot_layout,
-    )
-    curdoc().title = 'EU Stall Sampling'
-    curdoc().add_root(eustall_root)
-
-else:
-    # ── Regular OA metrics viewer ─────────────────────────────────────────────
-    if startup_args.csv_path:
-        init_from_csv_path(startup_args.csv_path)
-
-    # Read per-session query parameter ?gid=N (set by KernelLinkHandler below
-    # when Perfetto fires a kernel-selection request).
-    session_gid = None
-    try:
-        req_args = curdoc().session_context.request.arguments
-        gid_raw = req_args.get("gid", [None])[0]
-        if gid_raw is not None:
-            session_gid = int(
-                gid_raw.decode("utf-8") if isinstance(gid_raw, bytes) else str(gid_raw)
-            )
-    except Exception:
-        pass
-
-    if session_gid is not None:
-        select_kernel_by_gid(session_gid)
-
-    if startup_args.csv_path:
-        file_csv_input1.visible = False
-        curdoc().title = "UniTrace Counter Viewer"
-
-    curdoc().add_root(layout)
-
-
-# ── Server of the dashboard and of the kernel links of an event trace ─────────
-#
-# Everything above is the Bokeh application: the Bokeh server executes this file
-# once per browser session, so every session gets widgets and data of its own.
-# The launcher below serves that application — this very file, given to a
-# ScriptHandler — together with the kernel links of an event trace, on one port.
-# It runs when the file is the main program; sessions do not reach it, since
-# Bokeh executes them as a module of the application, not as __main__.
-
-import logging
-import os
-import socket
-import subprocess
-import time
-import urllib.request
-import warnings
-from urllib.parse import urlencode
-
-from bokeh.application import Application
-from bokeh.application.handlers.script import ScriptHandler
-from bokeh.core.validation import silence
-from bokeh.core.validation.warnings import EMPTY_LAYOUT
-from bokeh.server.server import Server
-from bokeh.util.warnings import BokehUserWarning
-from tornado.ioloop import IOLoop
-from tornado.web import RequestHandler
-
-
-APP = "perfdashboard"           # name of the dashboard application
-ROUTE = "/" + APP               # its path on the server
-DEFAULT_PORT = 8000             # the port the kernel links of an event trace use
-
-
-def check_port_available(port):
-    """Raise OSError if a server already listens on port, on either address family."""
-    for host in ("127.0.0.1", "::1"):
-        try:
-            connection = socket.create_connection((host, port), timeout=0.5)
-        except OSError:
-            continue
-        connection.close()
-        raise OSError(f"Port {port} is in use. Stop its server explicitly before retrying.")
-
-
-def stop_owned_process(proc):
-    """Stop a server this process started; never touches an unrelated process."""
-    if proc is not None and proc.poll() is None:
-        proc.terminate()
-        try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait(timeout=5)
-
-
-class KernelLinkHandler(RequestHandler):
-    def get(self, kernel_name, instance):
-        if not instance.isascii() or not instance.isdigit():
-            self.set_status(400)
-            self.finish("Missing or invalid kernel instance id")
-            return
-        query = urlencode({"gid": instance, "kernel": kernel_name.strip('"')})
-        self.redirect(ROUTE + "?" + query)
-
-
-def create_server(args, io_loop=None, port=DEFAULT_PORT):
-    warnings.filterwarnings(
-        "ignore", message=r"^reference already known '[^']+'$", category=BokehUserWarning,
-    )
-    for name in ("bokeh", "tornado"):
-        logging.getLogger(name).setLevel(logging.WARNING)
-    silence(EMPTY_LAYOUT, True)
-    script = os.path.abspath(__file__)      # the application is this file
-    arguments = ["--csv", os.path.abspath(args.input)]
-    if args.trace:
-        arguments.extend(["--trace", os.path.abspath(args.trace)])
-    if args.eustall or apm.ScanFirstHeader(args.input)[1] == "stall":
-        arguments.append("--eustall")
-    handler = ScriptHandler(filename=script, argv=arguments)
-    return Server(
-        {ROUTE: Application(handler)},
-        io_loop=io_loop,
-        address="localhost",
-        port=port,
-        session_token_expiration=3600,
-        allow_websocket_origin=[f"localhost:{port}", f"127.0.0.1:{port}"],
-        extra_patterns=[
-            (rf"/(?!{APP}(?:/|$)|static/)(.+)/([^/]+)", KernelLinkHandler),
-        ],
-    )
-
-
-def run_server(args, port=DEFAULT_PORT):
-    check_port_available(port)
-    loop = IOLoop()
-    server = None
-    try:
-        server = create_server(args, io_loop=loop, port=port)
-        server.start()
-        print(f"Server ready at {dashboard_url(port)}", flush=True)
-        print("Press Ctrl+C to exit.", flush=True)
-        loop.start()
-    except KeyboardInterrupt:
-        pass
-    finally:
-        if server is not None:
-            server.stop()
-        loop.close(all_fds=True)
-
-
-# ── Serving the dashboard for a viewer of an event trace ──────────────────────
-#
-# A viewer of an event trace, see scripts/uniview.py, opens the trace itself and
-# leaves the metrics of its kernels to the dashboard.  It therefore runs the
-# dashboard as a child process of its own, started and awaited below, instead of
-# calling run_server() and giving up its own control flow.
-
-def dashboard_url(port=DEFAULT_PORT):
-    """Return the URL a kernel link of an event trace redirects to."""
-    return f"http://localhost:{port}{ROUTE}"
-
-
-def start_server_process(metrics, trace=None, eustall=False,
-                         port=DEFAULT_PORT, timeout=30, prewarm=True):
-    """Serve metrics in a child process and return its handle, None if it fails.
-
-    The child is this file, run as the program of the command line parse_arguments()
-    reads.  It is ready, and warmed up if prewarm is set, when this returns.
-    """
-    check_port_available(port)
-    command = [sys.executable, os.path.abspath(__file__), os.path.abspath(metrics)]
-    if trace is not None:
-        command.extend(["--trace", os.path.abspath(trace)])
-    if eustall:
-        command.append("--eustall")
-
-    proc = subprocess.Popen(command, stdout=subprocess.DEVNULL)
-
-    for _ in range(2 * timeout):        # wait in steps of half a second
-        if proc.poll() is not None:
-            print(f"[ERROR] Server exited with code {proc.returncode}")
-            return None
-        time.sleep(0.5)
-        try:
-            with socket.create_connection(("localhost", port), timeout=1):
-                print(f"Server ready at {dashboard_url(port)}")
-                if prewarm:
-                    prewarm_session(port)
-                return proc
-        except OSError:
-            pass
-
-    print(f"[WARNING] Server did not start within {timeout} seconds.")
-    stop_owned_process(proc)
-    return None
-
-
-def prewarm_session(port=DEFAULT_PORT, timeout=60):
-    """Block until the server has built its first session.
-
-    This loads the metric data and populates the widgets before the viewer of the
-    event trace opens, so that the first kernel a user clicks renders at once.
-    """
-    try:
-        # Constant-scheme localhost URL (see dashboard_url); this only prewarms
-        # the Bokeh server this process just started, so B310 does not apply.
-        with urllib.request.urlopen(dashboard_url(port), timeout=timeout):  # nosec B310
-            pass
-    except Exception:
-        pass    # non-fatal; the first kernel click is just slightly slower
-
-
-def wait_for_exit(proc):
-    """Serve kernel links of an event trace until the server of proc exits."""
-    return proc.wait()
-
-
-def parse_arguments(argv=None):
-    """Parse the command line of the server: the metric data file and its options."""
-    p = argparse.ArgumentParser(
-        description="GPU Kernel Performance Hardware Metrics Dashboard")
-    p.add_argument("--trace",
-                   help="event trace in JSON format, used to resolve EU stall kernel selections")
-    p.add_argument("--eustall", action="store_true",
-                   help="treat the input file as EU stall sampling data (detected from the file if not specified)")
-    p.add_argument("input",
-                   help="hardware performance metric data file in .csv format generated by unitrace -k/-q/--stall-sampling")
-    return p.parse_args(argv)
-
-
-def main(argv=None):
-    """Serve the dashboard of a metric data file, see run_server()."""
-    try:
-        run_server(parse_arguments(argv))
-    except OSError as error:
-        print(f"[ERROR] {error}", file=sys.stderr)
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/scripts/parse_l0_headers.py b/tools/unitrace/scripts/parse_l0_headers.py
deleted file mode 100644
index f14526b9..00000000
--- a/tools/unitrace/scripts/parse_l0_headers.py
+++ /dev/null
@@ -1,220 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-"""
-Shared utilities for parsing Level Zero headers.
-
-This module provides common parsing functions used by multiple code generators:
-- gen_l0_loader.py
-- gen_tracing_callbacks.py
-"""
-
-import os
-import re
-from typing import List, NamedTuple
-
-
-class FunctionParam(NamedTuple):
-  """Represents a function parameter with type and name."""
-  type: str
-  name: str
-
-
-class FunctionDecl(NamedTuple):
-  """Represents a function declaration."""
-  name: str
-  return_type: str
-  params: List[FunctionParam]
-
-
-def parse_function_declaration(line: str) -> FunctionDecl:
-  """Parse a function declaration line.
-
-  Handles both single-line and accumulated multi-line declarations.
-  Format: ZE_APIEXPORT ze_result_t ZE_APICALL funcName(params);
-  """
-  # Remove ZE_APIEXPORT and ZE_APICALL
-  line = line.replace("ZE_APIEXPORT", "").replace("ZE_APICALL", "").strip()
-
-  # Extract return type and function signature
-  match = re.match(r'(\w+)\s+(\w+)\s*\((.*)\)\s*;?\s*$', line, re.DOTALL)
-  if not match:
-    return None
-
-  return_type = match.group(1)
-  func_name = match.group(2)
-  params_str = match.group(3).strip()
-
-  params = _parse_params(params_str)
-  return FunctionDecl(func_name, return_type, params)
-
-
-def _parse_params(params_str: str) -> List[FunctionParam]:
-  """Parse function parameters string into list of FunctionParam."""
-  params = []
-  if not params_str or params_str == "void":
-    return params
-
-  # Split by comma, handling nested parentheses
-  param_list = []
-  depth = 0
-  current = ""
-  for char in params_str:
-    if char == '(':
-      depth += 1
-    elif char == ')':
-      depth -= 1
-    elif char == ',' and depth == 0:
-      param_list.append(current.strip())
-      current = ""
-      continue
-    current += char
-  if current.strip():
-    param_list.append(current.strip())
-
-  for param in param_list:
-    param = param.strip()
-    if not param:
-      continue
-    # Split into type and name - last word is the name
-    parts = param.rsplit(None, 1)
-    if len(parts) == 2:
-      param_type = parts[0].strip()
-      param_name = parts[1].strip()
-      # Handle pointer that might be attached to name
-      while param_name.startswith('*'):
-        param_type += '*'
-        param_name = param_name[1:]
-      params.append(FunctionParam(param_type, param_name))
-
-  return params
-
-
-def get_extension_functions(file_path: str) -> List[FunctionDecl]:
-  """Parse an extension header file and extract all function declarations.
-
-  Args:
-    file_path: Path to the zex_*.h header file.
-
-  Returns:
-    List of FunctionDecl for each extension function found.
-  """
-  functions = []
-
-  if not os.path.exists(file_path):
-    return functions
-
-  with open(file_path, "rt") as f:
-    content = f.read()
-
-  # Remove all doxygen comments (///< ...) before processing
-  content = re.sub(r'///<[^\n]*', '', content)
-  # Remove regular comments (// ...)
-  content = re.sub(r'//[^\n]*', '', content)
-
-  lines = content.split('\n')
-  i = 0
-  while i < len(lines):
-    line = lines[i]
-
-    # Skip typedefs and pfn declarations
-    if "typedef" in line or "pfn" in line.lower():
-      i += 1
-      continue
-
-    if "ZE_APICALL" in line:
-      # Accumulate the full declaration if it spans multiple lines
-      full_decl = line.strip()
-      while ';' not in full_decl and ')' not in full_decl and i + 1 < len(lines):
-        i += 1
-        next_line = lines[i].strip()
-        if next_line:  # Skip empty lines
-          full_decl += " " + next_line
-
-      # Handle closing paren on separate line
-      while ';' not in full_decl and i + 1 < len(lines):
-        i += 1
-        next_line = lines[i].strip()
-        if next_line:
-          full_decl += " " + next_line
-        if ';' in full_decl or ')' in full_decl:
-          break
-
-      # Clean up whitespace
-      full_decl = ' '.join(full_decl.split())
-
-      func = parse_function_declaration(full_decl)
-      if func and func.name.startswith("ze"):
-        functions.append(func)
-    i += 1
-
-  return functions
-
-
-def get_extension_function_names(file_path: str) -> List[str]:
-  """Parse an extension header and return just the function names.
-
-  This is a lighter-weight alternative to get_extension_functions()
-  when you only need the names.
-  """
-  return [func.name for func in get_extension_functions(file_path)]
-
-
-def find_extension_headers(l0_include_path: str) -> List[str]:
-  """Find all extension header files in the driver_experimental directory.
-
-  Args:
-    l0_include_path: Path to level_zero include directory.
-
-  Returns:
-    List of full paths to zex_*.h header files.
-  """
-  exp_path = os.path.join(l0_include_path, "driver_experimental")
-  header_files = []
-
-  if os.path.exists(exp_path):
-    for filename in os.listdir(exp_path):
-      if filename.startswith("zex_") and filename.endswith(".h"):
-        # Skip common headers that don't define functions
-        if filename in ["zex_common.h"]:
-          continue
-        header_files.append(os.path.join(exp_path, filename))
-
-  return header_files
-
-
-def get_param_struct_field_name(param: FunctionParam) -> str:
-  """Get the field name for a parameter in a params struct. adds 'p' prefix
-
-  Example: phGraph -> pphGraph
-  """
-  return "p" + param.name
-
-
-def camel_to_snake(name: str) -> str:
-  """Convert CamelCase to snake_case.
-
-  Example: GraphCreateExp -> graph_create_exp
-  """
-  result = ""
-  for i, char in enumerate(name):
-    if char.isupper() and i > 0:
-      result += "_" + char.lower()
-    else:
-      result += char.lower()
-  return result
-
-
-def get_param_struct_name(func_name: str) -> str:
-  """Generate params struct name for extension function.
-
-  Example: zeGraphCreateExp -> ze_graph_create_exp_params_t
-  """
-  name = func_name
-  if name.startswith("ze"):
-    name = name[2:]  # Remove "ze" prefix
-
-  return "ze_" + camel_to_snake(name) + "_params_t"
diff --git a/tools/unitrace/scripts/roofline/device_configs/PVC_1tile.csv b/tools/unitrace/scripts/roofline/device_configs/PVC_1tile.csv
deleted file mode 100644
index c74bf96d..00000000
--- a/tools/unitrace/scripts/roofline/device_configs/PVC_1tile.csv
+++ /dev/null
@@ -1,8 +0,0 @@
-PlatformName,"PVC_1tile"
-FP16_GFLOPS,39000
-FP16_XMX_GFLOPS,314000
-BF16_XMX_GFLOPS,314000
-FP32_GFLOPS,32000
-FP64_GFLOPS,32000
-GPU_MEMORY_BW_in_GB_per_sec,1055
-L3_BW_in_GB_per_sec,2043
diff --git a/tools/unitrace/scripts/roofline/example/gemm_fp16_bytes.1799860 b/tools/unitrace/scripts/roofline/example/gemm_fp16_bytes.1799860
deleted file mode 100644
index 0d2bab8d..00000000
--- a/tools/unitrace/scripts/roofline/example/gemm_fp16_bytes.1799860
+++ /dev/null
@@ -1,44 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           5579618203
-    Total Device Time for L0 backend (ns):             22017040
-
-== L0 Backend ==
-
-                                                 Kernel,       Calls,           Time (ns), Time (%),        Average (ns),            Min (ns),            Max (ns)
-          zeCommandListAppendMemoryCopy(M2D)[128000000],           3,             9874480,    44.85,             3291493,             3238480,             3367280
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],           1,             4731360,    21.49,             4731360,             4731360,             4731360
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],           1,             4503360,    20.45,             4503360,             4503360,             4503360
-          zeCommandListAppendMemoryCopy(D2M)[128000000],           1,             2885120,    13.10,             2885120,             2885120,             2885120
-              zeCommandListAppendMemoryFill(D)[7340032],           1,                9120,     0.04,                9120,                9120,                9120
-                binary_test[SIMD16 {1; 1; 1} {4; 2; 1}],           1,                7360,     0.03,                7360,                7360,                7360
-                  zeCommandListAppendMemoryCopy(M2D)[4],           1,                4400,     0.02,                4400,                4400,                4400
-                  zeCommandListAppendMemoryCopy(D2M)[4],           1,                1840,     0.01,                1840,                1840,                1840
-
-
-=== Kernel Properties ===
-
-                                                 Kernel, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],                  27                  8                         0                       0
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],                  27                  8                         0                       0
-                binary_test[SIMD16 {1; 1; 1} {4; 2; 1}],                   8                  0                         0                       0
-
-
-
-== Kernel Metrics ==
-
-Kernel, Device, SubDeviceId
-"binary_test[SIMD16 {1; 1; 1} {4; 2; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], L3_BYTE_READ[bytes], L3_BYTE_WRITE[bytes], GPU_MEMORY_BYTE_READ[bytes], GPU_MEMORY_BYTE_WRITE[bytes], XVE_ACTIVE[%], XVE_STALL[%], XVE_BUSY[events], XVE_THREADS_OCCUPANCY_ALL[%], XVE_COMPUTE_THREAD_COUNT[threads], XVE_ATOMIC_ACCESS_COUNT[messages], XVE_BARRIER_MESSAGE_COUNT[messages], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_XMX_ALL[events], XVE_INST_EXECUTED_SEND_ALL[events], XVE_INST_EXECUTED_CONTROL_ALL[events], XVE_PIPE_ALU0_AND_ALU1_ACTIVE[%], XVE_PIPE_ALU0_AND_XMX_ACTIVE[%], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%], XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-563720, 817391, 1449, 873775, 1550, 9728, 132800, 5248, 512, 6.89741e-06, 0.00162064, 1, 0.00020258, 1, 0, 0, 0, 19, 0, 8, 0, 0, 0, 0, 4.85373e-06, 2.04368e-06, 0, 0, 1004293760, 1450, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
-
-Kernel, Device, SubDeviceId
-"hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], L3_BYTE_READ[bytes], L3_BYTE_WRITE[bytes], GPU_MEMORY_BYTE_READ[bytes], GPU_MEMORY_BYTE_WRITE[bytes], XVE_ACTIVE[%], XVE_STALL[%], XVE_BUSY[events], XVE_THREADS_OCCUPANCY_ALL[%], XVE_COMPUTE_THREAD_COUNT[threads], XVE_ATOMIC_ACCESS_COUNT[messages], XVE_BARRIER_MESSAGE_COUNT[messages], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_XMX_ALL[events], XVE_INST_EXECUTED_SEND_ALL[events], XVE_INST_EXECUTED_CONTROL_ALL[events], XVE_PIPE_ALU0_AND_ALU1_ACTIVE[%], XVE_PIPE_ALU0_AND_XMX_ACTIVE[%], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%], XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-4733040, 4730250, 999, 5121829, 1082, 6586575872, 98013760, 848934528, 125991296, 90.354, 3.26538, 1, 46.8018, 1792, 0, 3200000, 12102400, 84142328, 2048000000, 63305376, 6765824, 0.0231121, 0.00370355, 0.527434, 3.667, 2.75891, 0.294861, 89.2538, 1060957720, 1050, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
-
-Kernel, Device, SubDeviceId
-"hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], L3_BYTE_READ[bytes], L3_BYTE_WRITE[bytes], GPU_MEMORY_BYTE_READ[bytes], GPU_MEMORY_BYTE_WRITE[bytes], XVE_ACTIVE[%], XVE_STALL[%], XVE_BUSY[events], XVE_THREADS_OCCUPANCY_ALL[%], XVE_COMPUTE_THREAD_COUNT[threads], XVE_ATOMIC_ACCESS_COUNT[messages], XVE_BARRIER_MESSAGE_COUNT[messages], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_XMX_ALL[events], XVE_INST_EXECUTED_SEND_ALL[events], XVE_INST_EXECUTED_CONTROL_ALL[events], XVE_PIPE_ALU0_AND_ALU1_ACTIVE[%], XVE_PIPE_ALU0_AND_XMX_ACTIVE[%], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_SEND_ALL_UTILIZATION[%], XVE_INST_EXECUTED_CONTROL_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_ALL_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-4504960, 4662076, 1034, 5106076, 1133, 6584752640, 98013760, 874946432, 128000256, 90.63, 3.1351, 1, 46.8745, 1792, 0, 3200000, 12102400, 84142328, 2048000000, 63305376, 6765824, 0.0236497, 0.00405985, 0.529062, 3.67832, 2.76742, 0.295771, 89.5292, 1066080280, 1050, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
diff --git a/tools/unitrace/scripts/roofline/example/gemm_fp16_flops.1799853 b/tools/unitrace/scripts/roofline/example/gemm_fp16_flops.1799853
deleted file mode 100644
index 0433e28b..00000000
--- a/tools/unitrace/scripts/roofline/example/gemm_fp16_flops.1799853
+++ /dev/null
@@ -1,44 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           5580956648
-    Total Device Time for L0 backend (ns):             22005440
-
-== L0 Backend ==
-
-                                                 Kernel,       Calls,           Time (ns), Time (%),        Average (ns),            Min (ns),            Max (ns)
-          zeCommandListAppendMemoryCopy(M2D)[128000000],           3,             9865200,    44.83,             3288400,             3212160,             3382400
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],           1,             4706560,    21.39,             4706560,             4706560,             4706560
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],           1,             4491360,    20.41,             4491360,             4491360,             4491360
-          zeCommandListAppendMemoryCopy(D2M)[128000000],           1,             2922400,    13.28,             2922400,             2922400,             2922400
-              zeCommandListAppendMemoryFill(D)[7340032],           1,                9120,     0.04,                9120,                9120,                9120
-                binary_test[SIMD16 {1; 1; 1} {4; 2; 1}],           1,                7680,     0.03,                7680,                7680,                7680
-                  zeCommandListAppendMemoryCopy(D2M)[4],           1,                1840,     0.01,                1840,                1840,                1840
-                  zeCommandListAppendMemoryCopy(M2D)[4],           1,                1280,     0.01,                1280,                1280,                1280
-
-
-=== Kernel Properties ===
-
-                                                 Kernel, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],                  27                  8                         0                       0
-hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}],                  27                  8                         0                       0
-                binary_test[SIMD16 {1; 1; 1} {4; 2; 1}],                   8                  0                         0                       0
-
-
-
-== Kernel Metrics ==
-
-Kernel, Device, SubDeviceId
-"binary_test[SIMD16 {1; 1; 1} {4; 2; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_FP16[events], XVE_INST_EXECUTED_FP32[events], XVE_INST_EXECUTED_FP64[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_INT16[events], XVE_INST_EXECUTED_INT32[events], XVE_INST_EXECUTED_MATH[events], XVE_INST_EXECUTED_ALU2_ALL[events], XVE_INST_EXECUTED_XMX_INT4[events], XVE_INST_EXECUTED_XMX_INT8[events], XVE_INST_EXECUTED_XMX_FP16[events], XVE_INST_EXECUTED_XMX_BF16[events], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_FP16_UTILIZATION[%], XVE_INST_EXECUTED_FP32_UTILIZATION[%], XVE_INST_EXECUTED_FP64_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_INT16_UTILIZATION[%], XVE_INST_EXECUTED_INT32_UTILIZATION[%], XVE_INST_EXECUTED_MATH_UTILIZATION[%], XVE_INST_EXECUTED_ALU2_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT4_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT8_UTILIZATION[%], XVE_INST_EXECUTED_XMX_FP16_UTILIZATION[%], XVE_INST_EXECUTED_XMX_BF16_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-682680, 989888, 1450, 1058175, 1550, 0, 0, 0, 0, 19, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4.00791e-06, 4.21885e-07, 3.58603e-06, 0, 0, 0, 0, 0, 0, 143553989560, 1450, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
-
-Kernel, Device, SubDeviceId
-"hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_FP16[events], XVE_INST_EXECUTED_FP32[events], XVE_INST_EXECUTED_FP64[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_INT16[events], XVE_INST_EXECUTED_INT32[events], XVE_INST_EXECUTED_MATH[events], XVE_INST_EXECUTED_ALU2_ALL[events], XVE_INST_EXECUTED_XMX_INT4[events], XVE_INST_EXECUTED_XMX_INT8[events], XVE_INST_EXECUTED_XMX_FP16[events], XVE_INST_EXECUTED_XMX_BF16[events], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_FP16_UTILIZATION[%], XVE_INST_EXECUTED_FP32_UTILIZATION[%], XVE_INST_EXECUTED_FP64_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_INT16_UTILIZATION[%], XVE_INST_EXECUTED_INT32_UTILIZATION[%], XVE_INST_EXECUTED_MATH_UTILIZATION[%], XVE_INST_EXECUTED_ALU2_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT4_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT8_UTILIZATION[%], XVE_INST_EXECUTED_XMX_FP16_UTILIZATION[%], XVE_INST_EXECUTED_XMX_BF16_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-4708080, 4711317, 1000, 5110026, 1085, 12102400, 4000000, 8102400, 0, 84142328, 544160, 83326040, 25600, 2048000000, 0, 0, 2048000000, 0, 0.528653, 0.174727, 0.353926, 0, 3.67547, 0.0237698, 3.63982, 0.00111825, 89.46, 0, 0, 89.46, 0, 143612731800, 1050, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
-
-Kernel, Device, SubDeviceId
-"hgemm_nocopy_nn_64x40_4x8[SIMD16 {56; 1; 1} {64; 8; 1}]", 0, 0
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz], GpuSliceClocksCount[events], AvgGpuSliceFrequencyMHz[MHz], XVE_INST_EXECUTED_ALU0_ALL[events], XVE_INST_EXECUTED_FP16[events], XVE_INST_EXECUTED_FP32[events], XVE_INST_EXECUTED_FP64[events], XVE_INST_EXECUTED_ALU1_ALL[events], XVE_INST_EXECUTED_INT16[events], XVE_INST_EXECUTED_INT32[events], XVE_INST_EXECUTED_MATH[events], XVE_INST_EXECUTED_ALU2_ALL[events], XVE_INST_EXECUTED_XMX_INT4[events], XVE_INST_EXECUTED_XMX_INT8[events], XVE_INST_EXECUTED_XMX_FP16[events], XVE_INST_EXECUTED_XMX_BF16[events], XVE_INST_EXECUTED_ALU0_ALL_UTILIZATION[%], XVE_INST_EXECUTED_FP16_UTILIZATION[%], XVE_INST_EXECUTED_FP32_UTILIZATION[%], XVE_INST_EXECUTED_FP64_UTILIZATION[%], XVE_INST_EXECUTED_ALU1_ALL_UTILIZATION[%], XVE_INST_EXECUTED_INT16_UTILIZATION[%], XVE_INST_EXECUTED_INT32_UTILIZATION[%], XVE_INST_EXECUTED_MATH_UTILIZATION[%], XVE_INST_EXECUTED_ALU2_ALL_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT4_UTILIZATION[%], XVE_INST_EXECUTED_XMX_INT8_UTILIZATION[%], XVE_INST_EXECUTED_XMX_FP16_UTILIZATION[%], XVE_INST_EXECUTED_XMX_BF16_UTILIZATION[%], QueryBeginTime[ns], CoreFrequencyMHz[MHz], CoreFrequencyChanged, QuerySplitOccurred, ReportId, ReportsCount, OverrunOccured, MidQueryTimer, MidQueryProgramming, MidQueryMarker, MidQueryCtxSwitch, MidQueryC6, MidQueryFreqChange, MidQueryMmioTrigger, ReportError, ReportLost, ReportInconsistent, ReportCtxSwitchLost, ReportWithoutWorkload, ReportContextMismatch
-4493080, 4659587, 1037, 5099808, 1135, 12102400, 4000000, 8102400, 0, 84142328, 544160, 83326040, 25600, 2048000000, 0, 0, 2048000000, 0, 0.529712, 0.175077, 0.354635, 0, 3.68284, 0.0238174, 3.64711, 0.00112049, 89.6392, 0, 0, 89.6392, 0, 143617833720, 1050, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0
diff --git a/tools/unitrace/scripts/roofline/roofline.py b/tools/unitrace/scripts/roofline/roofline.py
deleted file mode 100644
index 1dc94669..00000000
--- a/tools/unitrace/scripts/roofline/roofline.py
+++ /dev/null
@@ -1,182 +0,0 @@
-import argparse
-import datetime
-import roofline_libs as tools  # Ensure this module is available in your environment
-import os
-import glob
-import shlex
-import shutil
-import subprocess
-import textwrap 
-
-
-def parse_arguments():
-    """Parse command-line arguments."""
-    description = textwrap.dedent('''\
-        GPU Kernel Roofline
-
-        Usage:
-          run unitrace and roofline model at the same time:
-             --app <application> --device <device-config> --output <output-file> 
-          
-          or
-          
-          run unitrace to profile the application, then run roofline model:
-             --compute <compute-profile> --memory <memory-profile> --device <device-config> --output <output-file>
-
-        Note: 
-             --device is always required.
-              
-             You must provide either --app (application to profile) or both --compute and --memory:  
-                                 
-                To create <compute-profile> file using unitrace :
-                    unitrace --g ComputeBasic -q --chrome-kernel-logging -o <compute-profile> <app>
-                To create <memory-profile> file using unitrace : 
-                    unitrace --g VectorEngine138 -q --chrome-kernel-logging -o <memory-profile> <app>                            
-
-            Use --unitrace to specify the path to unitrace executable if it is not set in PATH.
-
-        Examples:
-          1. To profile an application:
-
-             python /path/to//roofline.py  --device /path/to/device_configs/PVC_1tile.csv --output demm  --app ./a.out
-
-          2. To use pre-generated metrics files:
-
-             python /path/to/roofline.py --device device_configs/PVC_1tile.csv --compute example/gemm_fp16_flops.1799853  --memory  example/gemm_fp16_bytes.1799860  --output toto
-            
-          3. To specify the path to the unitrace executable:
-             python /path/to/roofline.py  --app ./my_application --device ./device_config.json --output result.html --unitrace /path/to/unitrace --output toto
-    ''')
-
-    parser = argparse.ArgumentParser(
-        description=description,
-        formatter_class=argparse.RawTextHelpFormatter
-    )
-
-    parser.add_argument('--compute', required=False,
-                        help='compute profile created by unitrace')
-    parser.add_argument('--memory', required=False,
-                        help='memory profile created by unitrace')
-    parser.add_argument('--app', required=False, help='application to profile')
-    parser.add_argument('--device', required=True, help='device configuration file')
-    parser.add_argument('--output', required=True, help='output file in HTML format')
-    parser.add_argument('--unitrace', required=False, help='path to unitrace executable if it is not set in PATH')
-    args = parser.parse_args()
-
-    # Ensure that either --app is provided or both --compute and --memory are provided
-    if not args.app and not (args.compute and args.memory):
-        parser.error("You must provide either --app or both --compute and --memory")
-
-    return args
-
-
-def find_unitrace(unitrace_path=None):
-    """Find the unitrace executable."""
-    if unitrace_path:
-        if os.path.isfile(unitrace_path) and os.access(unitrace_path, os.X_OK):
-            return unitrace_path
-        else:
-            raise FileNotFoundError(f"The specified unitrace path '{unitrace_path}' is not valid or not executable.")
-    else:
-        unitrace_path = shutil.which('unitrace')
-        if unitrace_path:
-            return unitrace_path
-        else:
-            raise EnvironmentError("The unitrace executable is not found in the PATH and no path was provided.")
-
-
-def create_output_directory():
-    """Create a directory with the current date."""
-    current_datetime = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-    output_dir = os.path.join(os.getcwd(), f"Unitrace_result_{current_datetime}")
-    os.makedirs(output_dir, exist_ok=True)
-    return output_dir
-
-
-def run_unitrace_commands(app, output_dir, unitrace_path):
-    """Run unitrace commands to generate metrics files."""
-    # --app is either a bare application path (possibly containing spaces) or
-    # an application plus its arguments in one string. Treat an existing file
-    # as a single token; otherwise split it with shell-like rules instead of
-    # handing the whole line to a shell (shell=False prevents metacharacter
-    # injection).
-    if os.path.isfile(app):
-        app_command = [app]
-    else:
-        app_command = shlex.split(app)
-    commands = [
-        [
-            unitrace_path,
-            '--group', 'ComputeBasic',
-            '--demangle', '-q',
-            '--chrome-kernel-logging',
-            '-o', os.path.join(output_dir, '_IntelGPUBasic'),
-            *app_command
-        ],
-        [
-            unitrace_path,
-            '--group', 'VectorEngine138',
-            '--demangle', '-q',
-            '--chrome-kernel-logging',
-            '-o', os.path.join(output_dir, '_IntelGPUCompute'),
-            *app_command
-        ]
-    ]
-
-    # Execute the commands
-    for command in commands:
-        print("The command is", command)
-        subprocess.run(command, check=True)
-
-
-def merge_metrics_files(output_dir, pattern, output_file):
-    """Merge all metrics files matching the pattern into a single file."""
-    merged_path = os.path.join(output_dir, output_file)
-    with open(merged_path, 'w') as merged_file:
-        for file_path in glob.glob(os.path.join(output_dir, pattern)):
-            with open(file_path, 'r') as f:
-                merged_file.write(f.read())
-                merged_file.write('\n')  # Add a newline between files for clarity
-    print(f"All {pattern} files have been merged into {merged_path}")
-    return merged_path
-
-
-def process_results(compute, memory, device, output_name):
-    """Process the results and generate the roofline plot."""
-    current_platform = tools.Platform(device)
-    result = tools.read_unitrace_report(compute, memory)
-    tools.summary(result, current_platform)
-    tools.plot_html_roofline(result, current_platform, output_name)
-
-
-def main():
-    args = parse_arguments()
-
-    if args.app:
-        unitrace_path = find_unitrace(args.unitrace)
-        output_dir = create_output_directory()
-        try:
-            run_unitrace_commands(args.app, output_dir, unitrace_path)
-        except BaseException:
-            # A failed or interrupted unitrace run must not leave partial
-            # metric files behind: the directory name has one-second
-            # granularity, so an immediate retry could reuse it and merge
-            # stale partial results.
-            shutil.rmtree(output_dir, ignore_errors=True)
-            raise
-        merged_flops_path = merge_metrics_files(output_dir, '*_IntelGPUCompute.metrics*', 'flops.txt')
-        merged_bytes_path = merge_metrics_files(output_dir, '*_IntelGPUBasic.metrics*', 'bytes.txt')
-    else:
-        merged_flops_path = args.compute
-        merged_bytes_path = args.memory
-
-    process_results(merged_flops_path, merged_bytes_path, args.device, args.output)
-
-    # Remove the output directory
-    if args.app:
-        shutil.rmtree(output_dir, ignore_errors=True)
-        print(f"Output directory {output_dir} has been removed.")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/unitrace/scripts/roofline/roofline_libs.py b/tools/unitrace/scripts/roofline/roofline_libs.py
deleted file mode 100755
index 256a23a9..00000000
--- a/tools/unitrace/scripts/roofline/roofline_libs.py
+++ /dev/null
@@ -1,392 +0,0 @@
-import pandas as pd
-import csv
-import re
-import math
-
-from bokeh.embed import file_html
-from bokeh.layouts import column, row
-from bokeh.models import (Button, CheckboxGroup, ColumnDataSource, CustomJS, DataRange1d, Div, Dropdown,
-                          HoverTool, InlineStyleSheet, Legend, LegendItem, NumeralTickFormatter,
-                          Spacer)
-from bokeh.plotting import figure
-from bokeh.resources import INLINE
-
-
-class Roofline:
-    def __init__(self, kernel_name, l3_read, l3_write, l3_bytes, gpu_memory_read, gpu_memory_write, gpu_memory_bytes,
-                 fp64, fp32, fp16, fp16_xmx, bf16_xmx, kernel_time, total_gpu_time, total_gpu_time_flops,
-                 average_core_freq, xve_threads_occupacy, fp16_xmx_utilization):
-        self.kernel_name = kernel_name
-        self.l3_read = l3_read
-        self.l3_write = l3_write
-        self.L3 = l3_bytes
-        self.gpu_memory_read = gpu_memory_read
-        self.gpu_memory_write = gpu_memory_write
-        self.gpu_memory = gpu_memory_bytes
-        self.FP64 = fp64 * 32
-        self.FP32 = fp32 * 32
-        self.FP16 = fp16 * 64
-        self.FP16_XMX = fp16_xmx * 512
-        self.BF16_XMX = bf16_xmx * 512
-        self.kernel_time = kernel_time
-        self.total_gpu_time = total_gpu_time
-        self.total_gpu_time_flops = total_gpu_time_flops
-        self.average_core_freq = average_core_freq
-        self.XVE_THREADS_OCCUPANCY = xve_threads_occupacy
-        self.fp16_xmx_utilization = fp16_xmx_utilization
-
-
-class Platform:
-    REQUIRED_KEYS = ('PlatformName', 'FP16_GFLOPS', 'FP16_XMX_GFLOPS', 'FP32_GFLOPS', 'FP64_GFLOPS',
-                     'BF16_XMX_GFLOPS', 'GPU_MEMORY_BW_in_GB_per_sec', 'L3_BW_in_GB_per_sec')
-
-    def __init__(self, config_file):
-        # squeeze("columns"), not squeeze(): a one-row file would collapse to a scalar.
-        config = pd.read_csv(config_file, index_col=0, header=None).squeeze("columns")
-        if not isinstance(config, pd.Series):
-            raise ValueError(f"Device config {config_file} must have two columns: name, value")
-        config = config.to_dict()
-        missing = [key for key in self.REQUIRED_KEYS if key not in config]
-        if missing:
-            raise ValueError(f"Device config {config_file} is missing {', '.join(missing)}")
-        self.PlatformName = config['PlatformName']
-        self.FP16 = float(config['FP16_GFLOPS'])
-        self.FP16_XMX = float(config['FP16_XMX_GFLOPS'])
-        self.FP32 = float(config['FP32_GFLOPS'])
-        self.FP64 = float(config['FP64_GFLOPS'])
-        self.BF16_XMX = float(config['BF16_XMX_GFLOPS'])
-        self.GPU_MEMORY_BW = float(config['GPU_MEMORY_BW_in_GB_per_sec'])
-        self.L3 = float(config['L3_BW_in_GB_per_sec'])
-
-
-def read_unitrace_report(path_to_flops, path_to_bytes):
-    entry_list = []
-    df = file_to_json(path_to_bytes)
-    df_flops = file_to_json(path_to_flops)
-    # Memory
-
-    grouped_df = df.groupby('Kernel').agg({'GpuTime[ns]': ['sum']})
-    sorted_df = grouped_df.sort_values(by=('GpuTime[ns]', 'sum'), ascending=False)
-    average_freq = df.groupby('Kernel').agg({'AvgGpuCoreFrequencyMHz[MHz]': ['mean']})
-    average_xve_threads_occupancy = df.groupby('Kernel').agg({'XVE_THREADS_OCCUPANCY_ALL[%]': ['mean']})
-    total_gpu_time = sorted_df[('GpuTime[ns]', 'sum')].sum()
-    sum_l3_byte_read = df.groupby('Kernel').agg({'L3_BYTE_READ[bytes]': ['sum']})
-    sum_l3_byte_write = df.groupby('Kernel').agg({'L3_BYTE_WRITE[bytes]': ['sum']})
-    sum_gpu_memory_byte_read = df.groupby('Kernel').agg({'GPU_MEMORY_BYTE_READ[bytes]': ['sum']})
-    sum_gpu_memory_byte_write = df.groupby('Kernel').agg({'GPU_MEMORY_BYTE_WRITE[bytes]': ['sum']})
-    # Flops
-    grouped_df_flops = df_flops.groupby('Kernel').agg({'GpuTime[ns]': ['sum']})
-    sorted_df_flops = grouped_df_flops.sort_values(by=('GpuTime[ns]', 'sum'), ascending=False)
-    total_gpu_time_flops = sorted_df_flops[('GpuTime[ns]', 'sum')].sum()
-
-    xve_inst_executed_fp64 = df_flops.groupby('Kernel').agg({'XVE_INST_EXECUTED_FP64[events]': ['sum']})
-    xve_inst_executed_fp32 = df_flops.groupby('Kernel').agg({'XVE_INST_EXECUTED_FP32[events]': ['sum']})
-    xve_inst_executed_fp16 = df_flops.groupby('Kernel').agg({'XVE_INST_EXECUTED_FP16[events]': ['sum']})
-    xve_inst_executed_xmx_bf16 = df_flops.groupby('Kernel').agg({'XVE_INST_EXECUTED_XMX_BF16[events]': ['sum']})
-    xve_inst_executed_xmx_fp16 = df_flops.groupby('Kernel').agg({'XVE_INST_EXECUTED_XMX_FP16[events]': ['sum']})
-    xve_inst_executed_xmx_fp16_utilization = df_flops.groupby('Kernel').agg(
-        {'XVE_INST_EXECUTED_XMX_FP16_UTILIZATION[%]': ['mean']})
-    for kernel in sorted_df.index.to_list():
-        if kernel in xve_inst_executed_fp64.index:
-            kernel_name = kernel
-            kernel_time = sorted_df.loc[kernel, ('GpuTime[ns]', 'sum')]
-            average_core_freq = average_freq.loc[kernel, ('AvgGpuCoreFrequencyMHz[MHz]', 'mean')]
-            xve_threads_occupancy = average_xve_threads_occupancy.loc[kernel, ('XVE_THREADS_OCCUPANCY_ALL[%]', 'mean')]
-            l3_byte_write = sum_l3_byte_write.loc[kernel, ('L3_BYTE_WRITE[bytes]', 'sum')]
-            l3_byte_read = sum_l3_byte_read.loc[kernel, ('L3_BYTE_READ[bytes]', 'sum')]
-            l3_byte = l3_byte_write + l3_byte_read
-            gpu_byte_read = sum_gpu_memory_byte_read.loc[kernel, ('GPU_MEMORY_BYTE_READ[bytes]', 'sum')]
-            gpu_byte_write = sum_gpu_memory_byte_write.loc[kernel, ('GPU_MEMORY_BYTE_WRITE[bytes]', 'sum')]
-            gpu_memory_bytes = gpu_byte_read + gpu_byte_write
-            fp64 = xve_inst_executed_fp64.loc[kernel, ('XVE_INST_EXECUTED_FP64[events]', 'sum')]
-            fp32 = xve_inst_executed_fp32.loc[kernel, ('XVE_INST_EXECUTED_FP32[events]', 'sum')]
-            fp16 = xve_inst_executed_fp16.loc[kernel, ('XVE_INST_EXECUTED_FP16[events]', 'sum')]
-            bf16_xmx = xve_inst_executed_xmx_bf16.loc[kernel, ('XVE_INST_EXECUTED_XMX_BF16[events]', 'sum')]
-            fp16_xmx = xve_inst_executed_xmx_fp16.loc[kernel, ('XVE_INST_EXECUTED_XMX_FP16[events]', 'sum')]
-            fp16_xmx_utilization = xve_inst_executed_xmx_fp16_utilization.loc[kernel, ('XVE_INST_EXECUTED_XMX_FP16_UTILIZATION[%]', 'mean')]
-            entry = Roofline(kernel_name, l3_byte_read, l3_byte_write, l3_byte, gpu_byte_read,
-                             gpu_byte_write, gpu_memory_bytes, fp64, fp32,
-                             fp16, fp16_xmx, bf16_xmx, kernel_time, total_gpu_time, total_gpu_time_flops,
-                             average_core_freq, xve_threads_occupancy, fp16_xmx_utilization)
-            entry_list.append(entry)
-    return entry_list
-
-
-def summary(entry_list, platform):
-    flop_fp16 = 0
-    flop_fp32 = 0
-    flop_fp64 = 0
-    flop_bf16_xmx = 0
-    flop_fp16_xmx = 0
-    total_kernel = 0
-    total_flops = 0
-    print("Kernel_name ,time_elapsed (s) ,% of Total time,  Bounded_by , FP16 (GFLOPS), FP32 (GFLOPS), FP64 (GFLOPS) ,"
-          " BF16_XMX (GFLOPS),FP16_XMX(Gops), FP16_XMX (GFLOPS),fp16_xmx_utilization [%], AI (gpu_memory), AI (L3) ,gpu_memory (GB/s), L3 (GB/s)")
-
-    for index, entry in enumerate(entry_list):
-
-        ops = {
-            'FP16': entry.FP16 / 1e9,
-            'BF16_XMX': entry.BF16_XMX / 1e9,
-            'FP32': entry.FP32 / 1e9,
-            'FP64': entry.FP64 / 1e9,
-            'FP16_XMX': entry.FP16_XMX / 1e9,
-        }
-
-        num_flops = max(ops.values()) + 1e-7
-        type_flops = max(ops, key=ops.get)
-        gflops = num_flops / (entry.kernel_time / 1e9)  # Tflops/s
-        headroom_current = {
-            'L3': ((num_flops / ((float(entry.L3) / 1024 ** 3) + 1e-7)) / (((num_flops / (
-                        (float(entry.L3) / 1024 ** 3) + 1e-7)) * (1 / float(getattr(platform, type_flops)))) + (
-                                                                                       1 / float(platform.L3)))) / (
-                              gflops + 1e-7),
-            'gpu_memory': ((num_flops / ((entry.gpu_memory / 1024 ** 3) + 1e-7)) / (((num_flops / (
-                        (entry.gpu_memory / 1024 ** 3) + 1e-7)) * (1 / float(getattr(platform, type_flops)))) + (
-                                                                                  1 / platform.GPU_MEMORY_BW))) / (gflops + 1e-7),
-        }
-
-        intesect_platform = {
-            'gpu_memory': platform.FP32 / platform.GPU_MEMORY_BW,
-            'L3': platform.FP32 / platform.L3,
-        }
-
-        limitation = min(headroom_current, key=headroom_current.get)
-        ai = num_flops / (getattr(entry, limitation) / 1024 ** 3)
-
-        if ai < intesect_platform[limitation]:
-            bounded_by = limitation
-        else:
-            bounded_by = "compute"
-
-        time_kernel = entry.kernel_time / 1e9
-        cleaned_kernel_name = re.sub(r'[^a-zA-Z]', '', entry.kernel_name)
-        print(cleaned_kernel_name, ",", entry.kernel_time / 1e9, ",", entry.kernel_time * 100 / entry.total_gpu_time, "%",
-              ',', bounded_by, ',', 1e9 * ops['FP16'] / entry.kernel_time, ',', 1e9 * ops['FP32'] / entry.kernel_time, ',', 1e9 * ops['FP64'] / entry.kernel_time, ',',
-              1e9 * ops['BF16_XMX'] / entry.kernel_time, ',', 1e9 * ops['FP16_XMX'], ',',
-              1e9 * ops['FP16_XMX'] / entry.kernel_time, ',',
-              entry.fp16_xmx_utilization, ',', 1e9 * ops['FP16_XMX'] / entry.gpu_memory, ',', 1e9 * ops['FP16_XMX'] / entry.L3,
-              ',', (entry.gpu_memory / 1000 ** 3) / (entry.kernel_time / 1e9), ',',
-              (entry.L3 / 1000 ** 3) / (entry.kernel_time / 1e9))
-
-        flop_bf16_xmx += entry.BF16_XMX
-        flop_fp16 += entry.FP16
-        flop_fp16_xmx += entry.FP16_XMX
-        flop_fp32 += entry.FP32
-        flop_fp64 += entry.FP64
-        total_flops += sum(ops.values())
-        total_kernel += time_kernel
-    print('FP16_total TFlop :', flop_fp16)
-    print('FP16_XMX_total TFlop :', flop_fp16_xmx)
-    print('BF16_XMX_total TFlop :', flop_bf16_xmx)
-    print('FP32_total Tflop :', flop_fp32)
-    print('FP64_total Tflop :', flop_fp64)
-    print('Total_time', total_kernel)
-    print('Total achieved Flops', total_flops / total_kernel)
-
-
-def plot_html_roofline(entry_list, platform, test_case):
-    variable_dict = {
-        'FP16': sum(entry.FP16 for entry in entry_list),
-        'FP16_XMX': sum(entry.FP16_XMX for entry in entry_list),
-        'BF16_XMX': sum(entry.BF16_XMX for entry in entry_list),
-        'FP32': sum(entry.FP32 for entry in entry_list),
-        'FP64': sum(entry.FP64 for entry in entry_list),
-    }
-    precision = max(variable_dict, key=variable_dict.get)
-    ai = [0.001 * 2 ** n for n in range(0, int(math.log2(1000000 / 0.001)) + 1)]
-    peak_flops = float(getattr(platform, precision))
-    roofs = []
-    for bandwidth in (platform.L3, platform.GPU_MEMORY_BW):
-        # The ridge, where the roof turns flat, is a vertex of its own: the samples rarely
-        # hit it, and a straight segment between the two around it cuts below the roof.
-        roof_ai = sorted(set(ai + [peak_flops / bandwidth]))
-        roofs.append((roof_ai, [min(x * bandwidth, peak_flops) for x in roof_ai]))
-
-    l3_points = {'x': [], 'y': [], 'size': [], 'label': []}
-    gpu_memory_points = {'x': [], 'y': [], 'size': [], 'label': []}
-    min_pixel = 10
-    max_pixel = 100
-    for entry in entry_list:
-        if (entry.kernel_time * 100 / entry.total_gpu_time > 0.001) and getattr(entry, precision) > 0:
-            scale_factor = min(1, math.log(entry.total_gpu_time) / math.log(100))
-            size_cercle = min_pixel + (max_pixel - min_pixel) * scale_factor * entry.kernel_time / entry.total_gpu_time
-            porcentage_total_time = entry.kernel_time * 100 / entry.total_gpu_time
-            label = str("{:.2f}".format(porcentage_total_time)) + '  % ' + entry.kernel_name
-            gflops = float(getattr(entry, precision)) / float(entry.kernel_time)
-            for points, num_bytes in ((l3_points, entry.L3), (gpu_memory_points, entry.gpu_memory)):
-                points['x'].append(float(getattr(entry, precision)) / float(num_bytes))
-                points['y'].append(gflops)
-                points['size'].append(float(size_cercle))
-                points['label'].append(label)
-
-    # Bokeh (BSD-3, in requirements.txt) with its JavaScript inlined: the report is one
-    # self-contained file that opens offline and loads nothing from a third-party server.
-    # It keeps the look and interactions of the CanvasJS chart it replaced: no pan or zoom,
-    # a menu to print or save the chart, the legend above the plot (click to hide a series),
-    # and a kernel panel that collapses to widen the chart.
-    # The range fits the dot centres, not their size: a decade of headroom above the highest
-    # point keeps the biggest dots (up to max_pixel wide) inside the plot.
-    top = max([peak_flops] + l3_points['y'] + gpu_memory_points['y'])
-    plot = figure(title=test_case + '  ' + precision, x_axis_type='log', y_axis_type='log',
-                  x_range=(0.001, 100000), y_range=DataRange1d(start=0.1, end=top * 10),
-                  x_axis_label='Arithmetic Intensity (Flop/Byte)', y_axis_label='Performance (GFlop/s)',
-                  tools='', toolbar_location=None, sizing_mode='stretch_both')
-    plot.title.text_font_size = '50px'
-    plot.title.text_font_style = 'normal'
-    plot.title.align = 'center'
-    plot.xgrid.visible = False
-    for axis in (plot.xaxis, plot.yaxis):
-        axis.axis_label_text_font_size = '20px'
-        axis.axis_label_text_font_style = 'normal'
-        axis.major_label_text_font_size = '16px'
-        axis.formatter = NumeralTickFormatter(format='0,0.[000]')  # 1,000 rather than 10^3
-    legend_items = []
-    for (name, color), (roof_ai, peak) in zip((('L3_ROOF', '#4F81BC'), ('Gpu_memory_ROOF', '#C0504E')), roofs):
-        roof = plot.line(roof_ai, peak, color=color, line_width=2)
-        plot.add_tools(HoverTool(renderers=[roof], tooltips='@y{0,0.[00]} GF/s'))
-        legend_items.append(LegendItem(label=name, renderers=[roof]))
-
-    # Wrap long (templated C++) kernel names onto several lines instead of cutting them off.
-    wrap_labels = InlineStyleSheet(css='label { white-space: normal; overflow-wrap: anywhere; align-items: flex-start; }')
-    sections = []
-    groups = []
-    for name, color, points in (('L3_data', 'blue', l3_points), ('Gpu_memory_data', 'red', gpu_memory_points)):
-        all_points = ColumnDataSource(points)
-        shown_points = ColumnDataSource(dict(points))
-        scatter = plot.scatter('x', 'y', size='size', source=shown_points, color=color,
-                               hover_fill_color=color, hover_line_color='black', hover_line_width=2)
-        plot.add_tools(HoverTool(renderers=[scatter], tooltips='@label<br/>@y{0,0.[00]} GF/s'))
-        legend_items.append(LegendItem(label=name, renderers=[scatter]))
-        group = CheckboxGroup(labels=points['label'], active=list(range(len(points['label']))),
-                              sizing_mode='stretch_width', stylesheets=[wrap_labels])
-        # Show only the checked kernels: copy them from the full data into the plotted source.
-        group.js_on_change('active', CustomJS(args=dict(all_points=all_points, shown_points=shown_points), code='''
-            const keep = new Set(cb_obj.active);
-            const data = {};
-            for (const key of Object.keys(all_points.data)) {
-                data[key] = Array.from(all_points.data[key]).filter((_, i) => keep.has(i));
-            }
-            shown_points.data = data;
-        '''))
-        sections += [Div(text='<h3>' + name + '</h3>'), group]
-        groups.append(group)
-    plot.add_layout(Legend(items=legend_items, orientation='horizontal', location='top_left',
-                           click_policy='hide', label_text_font_size='14px', label_text_font_style='bold',
-                           border_line_color=None), 'above')
-
-    menu = Dropdown(label='\u2630', width=50, menu=[('Print', 'print'), ('Save as JPEG', 'jpeg'),
-                                                ('Save as PNG', 'png')])
-    menu.js_on_event('menu_item_click', CustomJS(args=dict(plot=plot, name=test_case), code='''
-        if (this.item === 'print') {
-            window.print();
-            return;
-        }
-        const canvas = Bokeh.index.get_one(plot).export('png').canvas;
-        const link = document.createElement('a');
-        link.href = canvas.toDataURL('image/' + this.item);
-        link.download = name + (this.item === 'jpeg' ? '.jpg' : '.png');
-        link.click();
-    '''))
-    chart = column(row(Spacer(sizing_mode='stretch_width'), menu, sizing_mode='stretch_width'), plot,
-                   sizing_mode='stretch_both')
-
-    select_all = CheckboxGroup(labels=['Select/Deselect All'], active=[0])
-    select_all.js_on_change('active', CustomJS(args=dict(groups=groups), code='''
-        for (const group of groups) {
-            group.active = cb_obj.active.length ? group.labels.map((_, i) => i) : [];
-        }
-    '''))
-    kernel_list = column([select_all] + sections)
-    toggle = Button(label='Kernel Names', width=120)
-    panel = column(toggle, kernel_list, width=350, sizing_mode='stretch_height',
-                   styles={'border': '1px solid #ccc', 'padding': '10px', 'overflow-y': 'auto'})
-    toggle.js_on_event('button_click', CustomJS(args=dict(kernel_list=kernel_list, panel=panel), code='''
-        kernel_list.visible = !kernel_list.visible;
-        panel.width = kernel_list.visible ? 350 : 140;  // collapsed, the chart takes the room
-    '''))
-    layout = row(chart, panel, sizing_mode='stretch_both')
-    with open(test_case + ".html", "w+") as file:
-        file.write(file_html(layout, INLINE, title=test_case))
-
-
-def file_to_json(file_name):
-    """Read the metrics of a unitrace query profile into one flat frame, a row per instance.
-
-    Metrics come in blocks: a label line naming the identity columns the block carries, then
-    those values, then the counter names, then the counter values. The identity is copied
-    onto every counter row so the frame can be grouped by 'Kernel', and because the label is
-    what names the identity columns, the SubDeviceId or Device an older unitrace wrote there
-    needs no special case here; a current one writes SubDeviceId as the first counter when
-    there is more than one sub-device.
-
-    Reading starts at the metrics banner, as it always has: the timing summary ahead of it
-    has a 'Kernel'-headed table of its own that would otherwise be taken for a block. Only
-    kernels are of interest, so rows whose name carries no SIMD width - memory copies and
-    the like - are dropped at the end, as they were when this read the flat format.
-    """
-    identity_columns = None
-    identity = None
-    columns = None
-    rows = []
-    pending = None
-    reading = False
-
-    try:
-        with open(file_name, "r", newline="") as file:
-            lines = file.readlines()
-
-        for fields in csv.reader(lines, skipinitialspace=True):
-            if len(fields) == 1 and 'Metrics ==' in fields[0]:
-                reading = True    # a banner, and in a merged file there is one per profile
-                continue
-            if not reading:
-                continue
-            if len(fields) == 0:
-                # The blank line between blocks. Nothing a block is waiting for, so skip it rather
-                # than let it fill the pending identity or counter-header slot: a file truncated
-                # between an identity line and its counter header would otherwise latch an empty
-                # column list and drop every row that follows.
-                continue
-            if fields[0] == 'Kernel':
-                if identity_columns is None:
-                    identity_columns = fields  # identical across every block
-                identity = None
-                pending = 'identity'
-                continue
-            if pending == 'identity':
-                identity = fields[0:len(identity_columns)]
-                pending = 'columns'
-                continue
-            if pending == 'columns':
-                if columns is None:
-                    columns = fields
-                pending = None
-                continue
-            # A counter row of the block in progress. Anything of the wrong width - a stray
-            # banner, a truncated last line - is skipped rather than padded.
-            if columns is not None and identity is not None \
-                    and len(identity) == len(identity_columns) and len(fields) == len(columns):
-                rows.append(identity + fields)
-
-        if not reading:
-            print(f"Warning: marker line 'Metrics ==' not found in {file_name}.")
-            return None
-        if columns is None:
-            print(f"Warning: no metric blocks found in {file_name}.")
-            return None
-
-        df = pd.DataFrame(rows, columns=identity_columns + columns)
-        for column in df.columns:
-            if column != 'Kernel':
-                df[column] = pd.to_numeric(df[column], errors='coerce')
-
-        return df[df['Kernel'].str.contains('SIMD')]
-    except FileNotFoundError:
-        print(f"The file {file_name} not found.")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-
-# Example usage
-# df = process_file("your_file.txt")
-# print(df)
diff --git a/tools/unitrace/scripts/summary/categorize.py b/tools/unitrace/scripts/summary/categorize.py
deleted file mode 100755
index 3c34097b..00000000
--- a/tools/unitrace/scripts/summary/categorize.py
+++ /dev/null
@@ -1,133 +0,0 @@
-#!/usr/bin/env -S python3 -OO
-import sys
-if sys.platform == 'win32': import os; sys.path.append( os.path.dirname( os.path.realpath( __file__ ) ) )
-
-import argparse
-import asyncio
-from collections import defaultdict
-import configparser
-from configparser import ConfigParser
-import json
-import logging
-from pathlib import Path
-
-
-logger = logging.getLogger( __name__ )
-
-
-# sys.argv = 'categorize --ini=LLaMA.ini --json=LLaMA.json -v'.split()
-
-
-def build_search_tree( tags:list[tuple[str,str,bool]] ):
-   # No tags of this kind (e.g. no "ends with" section): a tree that matches nothing.
-   if not tags: return {}
-   key_length = min( len( tag[0] ) for tag in tags )
-   next_nodes:dict[str,int|str|dict] = {}
-   tree:dict[str,int|str|dict] = { 'length':key_length, 'next':next_nodes }
-   next_tags:dict[str,list[tuple[str,str,bool]]] = defaultdict(list)
-   for tag, category, is_exact in tags:
-      key, next_tag = tag[:key_length], tag[key_length:]
-      if   next_tag: next_tags[key].append( ( next_tag, category, is_exact ) )
-      elif is_exact: next_nodes[key] = { 'next': { '': { 'category': category } } }
-      else         : next_nodes[key] = { 'category': category }
-   for key, tags in next_tags.items():
-      sub_tree = build_search_tree( tags )
-      if ( node := next_nodes.get( key, None ) ) is None: next_nodes[key] = sub_tree
-      else:
-         if 'next' in node and 'next' in sub_tree: sub_tree['next'].update( node['next'] )
-         node.update( sub_tree )
-   return tree
-
-
-def build_tree_from_ini( ini_path, remove_tag_spaces ):
-   """Build the category search trees from a categories INI file.
-
-   ini_path: the INI path; sections are "<category>[.<sub>] if <verb>", keys are
-   tags, ":=" is the only delimiter and "#" starts comments.
-   remove_tag_spaces: remove spaces and tabs from the tags.
-   Returns {'ignore_spaces', 'direct', 'reverse'}: "ends with" tags go reversed
-   into the reverse tree, "equals to" tags are exact, the rest are prefixes.
-   A missing file is ignored by ConfigParser.read (empty trees).
-   Raises configparser.Error (e.g. ParsingError, DuplicateSectionError) on
-   malformed INI; the AttributeError CPython 3.12 and earlier raise on a
-   continuation line after a key without a value is re-raised as ParsingError.
-   """
-   remove_spaces = str.maketrans( '', '', ' \t' )
-   assign_op = ':='
-   config = ConfigParser( allow_no_value=True, delimiters=( assign_op, ), comment_prefixes=( '#', ) )
-   config.optionxform = str
-   try:
-      config.read( ini_path )
-   except AttributeError as ex:
-      # CPython's configparser (3.12 and earlier) fails this way on a continuation line
-      # after a key without a value; report it as the parse error it is.
-      raise configparser.ParsingError( str( ini_path ) ) from ex
-   direct_search:list[tuple[str,str,bool]] = []
-   reverse_search:list[tuple[str,str,bool]] = []
-   for name, section in config.items():
-      if name != config.default_section:
-         category, sep, verb = name.partition( ' if ' )
-         category, sep, sub_category = category.strip().partition( '.' )
-         verb = verb.translate( remove_spaces )
-         if verb == 'endswith':
-            for tag1, tag2 in section.items():
-               tag = tag1 if tag2 is None else tag1 + assign_op + tag2
-               if remove_tag_spaces: tag = tag.translate( remove_spaces )
-               reverse_search.append( ( tag[::-1], category, False ) )
-         else:
-            is_exact = verb == 'equalsto'
-            for tag1, tag2 in section.items():
-               tag = tag1 if tag2 is None else tag1 + assign_op + tag2
-               if remove_tag_spaces: tag = tag.translate( remove_spaces )
-               direct_search.append( ( tag, category, is_exact ) )
-   return { 'ignore_spaces': remove_tag_spaces, 'direct': build_search_tree( direct_search ), 'reverse': build_search_tree( reverse_search ) }
-
-
-async def aprocess( args ):
-   tree = build_tree_from_ini( args.ini, args.remove_spaces )
-   if logger.isEnabledFor( logging.INFO ):
-      indent, separators = 3, None
-   else:
-      indent, separators = None, ( ',', ':' )
-   with args.json.open( 'w' ) as f: json.dump( tree, f, indent=indent, separators=separators )
-
-
-def main():
-   """Command-line entry point of the categorize tool.
-
-   Parses --ini, --remove-spaces/--no-remove-spaces, --json and -v, configures
-   logging from the -v count and runs aprocess, which writes the search trees
-   from build_tree_from_ini to --json (indented with -v and above).
-   With more than three -v the run is profiled with cProfile instead.
-   argparse exits on invalid arguments.
-   """
-   parser = argparse.ArgumentParser( description='Process INI file with categories description and generate JSON file to use with `summary` tool' )
-
-   parser.add_argument( '-v', '--verbose', action='count', default=0,
-      help='Show verbose messages' )
-
-   parser.add_argument( '--ini', '--input', type=Path, required=True,
-      help='INI file with categories description' )
-   parser.add_argument( '--remove-spaces', action=argparse.BooleanOptionalAction, default=True,
-      help='Remove spaces from tags' )
-   parser.add_argument( '--json', '--output', type=Path, required=True,
-      help='Name of output JSON file to be used with `summary` tool' )
-
-   args = parser.parse_args()
-
-   logging.basicConfig( format='[%(levelname)s] <%(name)s.%(funcName)s> %(message)s', level=[ logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG ][ min( 3, args.verbose ) ] )
-
-   action = aprocess( args )
-
-   if args.verbose <= 3: asyncio.run( action )
-   else:
-      import cProfile
-      import pstats
-
-      logging.getLogger().setLevel( logging.ERROR )
-      cProfile.runctx( 'asyncio.run( action )', globals(), locals(), f'{__name__}.profile' )
-      pstats.Stats( f'{__name__}.profile' ).strip_dirs().sort_stats( 'time' ).print_stats()
-
-
-if __name__ == '__main__':
-   main()
diff --git a/tools/unitrace/scripts/summary/schemas/LLaMA.ini b/tools/unitrace/scripts/summary/schemas/LLaMA.ini
deleted file mode 100644
index a64d0c5f..00000000
--- a/tools/unitrace/scripts/summary/schemas/LLaMA.ini
+++ /dev/null
@@ -1,102 +0,0 @@
-[total if equals to]
-L0_backend
-
-[wallclock if equals to]
-Wallclock
-
-[allreduce if starts with]
-Allreduce_small_kernel
-sycl_allreducer_small
-at::AtenIpexTypeXPU::reduce_kernel
-at::AtenIpexTypeXPU::segment_scan
-at::AtenIpexTypeXPU::AccumulateCarrier
-
-[allreduce.nocopy if starts with]
-NoCopyKernel_gather_from_remote_and_dist_to_rank_pair
-NoCopyKernel_local_sum_and_distribute_to_remote_ranks
-NoCopyKernel_all_sum
-NoCopyKernel_2rank
-NoCopyKernel_compute
-
-[allreduce.ccl if ends with]
-ALLREDUCE_SMALL
-ALLREDUCE_MEDIUM
-ALLREDUCE_LARGE
-
-[sync.allreduce if starts with]
-AllreduceMediumKernel_GlobalSync
-AllreduceMediumKernel_LocalSync
-AllreduceLargeKernel_GlobalSync
-AllreduceLargeKernel_LocalSync
-
-[sync.ze if starts with]
-zeCommandListAppendBarrier
-
-[sync.ccl if ends with]
-::SYNC
-::BARRIER
-::barrier
-
-[matmul if equals to]
-gemm_kernel
-
-[matmul if starts with]
-xpu::xetla::hgemm_caller
-xpu::xetla::HgemmQKVKernel
-
-[attn if starts with]
-gpu::xetla::fmha::IfmhaForwardKernel
-gpu::xetla::fmha::FmhaForwardKernel      
-at::AtenIpexTypeXPU::RotaryEmbeddingKernel
-
-[norm if starts with]
-at::AtenIpexTypeXPU::normalization  
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::pow_
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::rsqrt_
-
-[slice if starts with]
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::BinaryFunctor<long, long, bool, at::AtenIpexTypeXPU::impl::NeKernel
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::BinaryFunctor<c10::Half, c10::Half, c10::Half, at::AtenIpexTypeXPU::impl::mul_
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::BinaryFunctor<c10::Half, c10::Half, c10::Half, at::impl::AddKernel           
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::impl::direct_copy_kernel_gpu_functor<long
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::BinaryFunctor<long, long, bool, at::AtenIpexTypeXPU::impl::NeKernel
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::BinaryFunctor<c10::Half, c10::Half, c10::Half, at::AtenIpexTypeXPU::impl::mul_kernel_dpcpp_functor<c10::
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::BinaryFunctor<c10::Half, c10::Half, c10::Half, at::impl::AddKernel
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::impl::direct_copy
-DpcppIndexKernelImplFunctor<at::AtenIpexTypeXPU::impl::index_
-IndexKernel<IndexKernelConfig<xpu::dpcpp::detail::TensorInfo
-at::AtenIpexTypeXPU::impl::CatArrayBatched
-at::AtenIpexTypeXPU::impl::Arange
-
-[vector if starts with]
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::Binary
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::BUnary
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::Binary
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::BUnary
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::AUnary
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::cos_
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::sin_
-at::AtenIpexTypeXPU::UnrolledElementwiseKernelFunctor<4, at::AtenIpexTypeXPU::sqrt_
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::reciprocal_
-
-[beam if starts with]
-at::AtenIpexTypeXPU::impl::Batch
-at::AtenIpexTypeXPU::impl::SoftmaxForwardKernel
-at::AtenIpexTypeXPU::impl::BeamSearch       
-at::AtenIpexTypeXPU::impl::UpdateBeamIndice
-at::AtenIpexTypeXPU::impl::UpdateTokenKernel
-at::AtenIpexTypeXPU::impl::InsertToCandidateListKernel
-at::AtenIpexTypeXPU::impl::FinalizeKernel
-at::AtenIpexTypeXPU::impl::CopyInputToOutputKernel
-
-[mem_op if starts with]
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::impl::memcpy
-at::AtenIpexTypeXPU::UnrolledElementwiseKernelFunctor<4, at::impl::direct_copy
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::impl::direct_copy
-at::AtenIpexTypeXPU::ElementwiseKernelFunctor2<4, at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_dynamic_casting_functor<at::impl::direct_copy
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::masked_fill
-at::AtenIpexTypeXPU::VectorizedElementwiseKernelFunctor<at::AtenIpexTypeXPU::impl::fill_
-
-[mem_op.ze if starts with]
-zeCommandListAppendMemoryCopy
-zeCommandListAppendMemoryFill
diff --git a/tools/unitrace/scripts/summary/schemas/LLaMA.json b/tools/unitrace/scripts/summary/schemas/LLaMA.json
deleted file mode 100644
index fdee5f10..00000000
--- a/tools/unitrace/scripts/summary/schemas/LLaMA.json
+++ /dev/null
@@ -1 +0,0 @@
-{"ignore_spaces":true,"direct":{"length":9,"next":{"Wallclock":{"next":{"":{"category":"wallclock"}}},"L0_backen":{"length":1,"next":{"d":{"next":{"":{"category":"total"}}}}},"Allreduce":{"length":13,"next":{"_small_kernel":{"category":"allreduce"},"MediumKernel_":{"length":9,"next":{"LocalSync":{"category":"sync"},"GlobalSyn":{"length":1,"next":{"c":{"category":"sync"}}}}},"LargeKernel_G":{"length":9,"next":{"lobalSync":{"category":"sync"}}},"LargeKernel_L":{"length":8,"next":{"ocalSync":{"category":"sync"}}}}},"sycl_allr":{"length":12,"next":{"educer_small":{"category":"allreduce"}}},"at::AtenI":{"length":23,"next":{"pexTypeXPU::impl::Batch":{"category":"beam"},"pexTypeXPU::reduce_kern":{"length":2,"next":{"el":{"category":"allreduce"}}},"pexTypeXPU::segment_sca":{"length":1,"next":{"n":{"category":"allreduce"}}},"pexTypeXPU::AccumulateC":{"length":6,"next":{"arrier":{"category":"allreduce"}}},"pexTypeXPU::RotaryEmbed":{"length":10,"next":{"dingKernel":{"category":"attn"}}},"pexTypeXPU::normalizati":{"length":2,"next":{"on":{"category":"norm"}}},"pexTypeXPU::VectorizedE":{"length":40,"next":{"lementwiseKernelFunctor<at::impl::memcpy":{"category":"mem_op"},"lementwiseKernelFunctor<at::AtenIpexType":{"length":9,"next":{"XPU::pow_":{"category":"norm"},"XPU::cos_":{"category":"vector"},"XPU::sin_":{"category":"vector"},"XPU::rsqr":{"length":2,"next":{"t_":{"category":"norm"}}},"XPU::Bina":{"length":2,"next":{"ry":{"category":"vector","length":57,"next":{"Functor<c10::Half,c10::Half,c10::Half,at::impl::AddKernel":{"category":"slice"},"Functor<long,long,bool,at::AtenIpexTypeXPU::impl::NeKerne":{"length":1,"next":{"l":{"category":"slice"}}},"Functor<c10::Half,c10::Half,c10::Half,at::AtenIpexTypeXPU":{"length":38,"next":{"::impl::mul_kernel_dpcpp_functor<c10::":{"category":"slice"}}}}}}},"XPU::BUna":{"length":2,"next":{"ry":{"category":"vector"}}},"XPU::AUna":{"length":2,"next":{"ry":{"category":"vector"}}},"XPU::reci":{"length":7,"next":{"procal_":{"category":"vector"}}},"XPU::mask":{"length":7,"next":{"ed_fill":{"category":"mem_op"}}},"XPU::impl":{"length":7,"next":{"::fill_":{"category":"mem_op"}}}}},"lementwiseKernelFunctor<at::impl::direct":{"length":5,"next":{"_copy":{"category":"slice"}}}}},"pexTypeXPU::Elementwise":{"length":97,"next":{"KernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::impl::direct_copy":{"category":"mem_op","length":24,"next":{"_kernel_gpu_functor<long":{"category":"slice"}}},"KernelFunctor<at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_functor<at::AtenIpexTypeXPU::":{"length":6,"next":{"Binary":{"category":"vector","length":57,"next":{"Functor<c10::Half,c10::Half,c10::Half,at::impl::AddKernel":{"category":"slice"},"Functor<long,long,bool,at::AtenIpexTypeXPU::impl::NeKerne":{"length":1,"next":{"l":{"category":"slice"}}},"Functor<c10::Half,c10::Half,c10::Half,at::AtenIpexTypeXPU":{"length":12,"next":{"::impl::mul_":{"category":"slice"}}}}},"BUnary":{"category":"vector"}}},"KernelFunctor2<4,at::AtenIpexTypeXPU::dpcpp_loops_launch_legacy_kernel_dynamic_casting_functor<at":{"length":19,"next":{"::impl::direct_copy":{"category":"mem_op"}}}}},"pexTypeXPU::impl::CatAr":{"length":10,"next":{"rayBatched":{"category":"slice"}}},"pexTypeXPU::impl::Arang":{"length":1,"next":{"e":{"category":"slice"}}},"pexTypeXPU::UnrolledEle":{"length":45,"next":{"mentwiseKernelFunctor<4,at::impl::direct_copy":{"category":"mem_op"},"mentwiseKernelFunctor<4,at::AtenIpexTypeXPU::":{"length":5,"next":{"sqrt_":{"category":"vector"}}}}},"pexTypeXPU::impl::Softm":{"length":15,"next":{"axForwardKernel":{"category":"beam"}}},"pexTypeXPU::impl::BeamS":{"length":5,"next":{"earch":{"category":"beam"}}},"pexTypeXPU::impl::Updat":{"length":11,"next":{"eBeamIndice":{"category":"beam"},"eTokenKerne":{"length":1,"next":{"l":{"category":"beam"}}}}},"pexTypeXPU::impl::Inser":{"length":22,"next":{"tToCandidateListKernel":{"category":"beam"}}},"pexTypeXPU::impl::Final":{"length":9,"next":{"izeKernel":{"category":"beam"}}},"pexTypeXPU::impl::CopyI":{"length":18,"next":{"nputToOutputKernel":{"category":"beam"}}}}},"NoCopyKer":{"length":9,"next":{"nel_2rank":{"category":"allreduce"},"nel_gathe":{"length":35,"next":{"r_from_remote_and_dist_to_rank_pair":{"category":"allreduce"}}},"nel_local":{"length":35,"next":{"_sum_and_distribute_to_remote_ranks":{"category":"allreduce"}}},"nel_all_s":{"length":2,"next":{"um":{"category":"allreduce"}}},"nel_compu":{"length":2,"next":{"te":{"category":"allreduce"}}}}},"zeCommand":{"length":17,"next":{"ListAppendBarrier":{"category":"sync"},"ListAppendMemoryC":{"length":3,"next":{"opy":{"category":"mem_op"}}},"ListAppendMemoryF":{"length":3,"next":{"ill":{"category":"mem_op"}}}}},"gemm_kern":{"length":2,"next":{"el":{"next":{"":{"category":"matmul"}}}}},"xpu::xetl":{"length":15,"next":{"a::hgemm_caller":{"category":"matmul"},"a::HgemmQKVKern":{"length":2,"next":{"el":{"category":"matmul"}}}}},"gpu::xetl":{"length":26,"next":{"a::fmha::FmhaForwardKernel":{"category":"attn"},"a::fmha::IfmhaForwardKerne":{"length":1,"next":{"l":{"category":"attn"}}}}},"DpcppInde":{"length":52,"next":{"xKernelImplFunctor<at::AtenIpexTypeXPU::impl::index_":{"category":"slice"}}},"IndexKern":{"length":51,"next":{"el<IndexKernelConfig<xpu::dpcpp::detail::TensorInfo":{"category":"slice"}}}}},"reverse":{"length":6,"next":{"CNYS::":{"category":"sync"},"LLAMS_":{"length":9,"next":{"ECUDERLLA":{"category":"allreduce"}}},"MUIDEM":{"length":10,"next":{"_ECUDERLLA":{"category":"allreduce"}}},"EGRAL_":{"length":9,"next":{"ECUDERLLA":{"category":"allreduce"}}},"REIRRA":{"length":3,"next":{"B::":{"category":"sync"}}},"reirra":{"length":3,"next":{"b::":{"category":"sync"}}}}}}
\ No newline at end of file
diff --git a/tools/unitrace/scripts/summary/summary.py b/tools/unitrace/scripts/summary/summary.py
deleted file mode 100755
index 72d88821..00000000
--- a/tools/unitrace/scripts/summary/summary.py
+++ /dev/null
@@ -1,296 +0,0 @@
-#!/usr/bin/env -S python3 -OO
-import sys
-if sys.platform == 'win32': import os; sys.path.append( os.path.dirname( os.path.realpath( __file__ ) ) )
-
-import argparse
-import asyncio
-from collections import defaultdict
-from collections.abc import Iterator
-from csv import DictReader, Error as CsvError
-from io import TextIOBase, TextIOWrapper
-import json
-import logging
-from math import fsum
-from operator import itemgetter
-from pathlib import Path
-from statistics import fmean, median
-import tarfile
-
-
-logger = logging.getLogger( __name__ )
-
-
-# sys.argv = 'summary --tarfile=unitrace_4_mpi_100iter.tgz --schema=LLaMA.json -vvv'.split()
-# sys.argv = 'summary --tarfile=unitrace_4_mpi_100iter.tgz --schema=LLaMA.json --json=summary_4_mpi_100iter.json -vv'.split()
-# sys.argv = 'summary --tarfile=unitrace_512_256_1_1_200_iters_8ranks.tgz --schema=LLaMA.json -vvv'.split()
-
-
-def skip_to( labels:list[str], f:TextIOBase ):
-   for line in f:
-      for index, label in enumerate( labels ):
-         if label in line: return index, line
-   return -1, None
-
-
-def skip_empty( f:TextIOBase ):
-   for line in f:
-      if line.strip(): return line 
-   return None
-
-
-def stop_on_empty( f:TextIOBase ):
-   for line in f:
-      if not line.strip(): break
-      yield line
-
-
-class SummaryFormatError( ValueError ):
-   """A summary file that does not have the layout unitrace writes.
-
-   Raised by csv_from (table without a header), field (row without a column) and
-   to_int (value that is not an integer). A ValueError subclass; read_summary_tar
-   catches it and skips the archive member with a warning.
-   """
-
-
-def csv_from( f:TextIOBase ):
-   if ( header_line := skip_empty( f ) ) is None: raise SummaryFormatError( 'table without a header' )
-   header = tuple( map( str.strip, header_line.strip().split( ',' ) ) )
-   return DictReader( stop_on_empty( f ), header, skipinitialspace=True )
-
-
-def field( record:dict, name:str ):
-   """Return the value of column name in a CSV record.
-
-   record: a dict from csv.DictReader. name: the column name.
-   Returns the value as a string.
-   Raises SummaryFormatError("row without <name>") if the column is missing or
-   its value is None (a row shorter than the header).
-   """
-   if ( value := record.get( name ) ) is None: raise SummaryFormatError( f'row without {name}' )
-   return value
-
-
-def to_int( text ):
-   """Convert a summary value to int.
-
-   text: the string (or other value) read from the summary.
-   Returns int(text).
-   Raises SummaryFormatError("not a number: ...") instead of the TypeError or
-   ValueError int() raises, e.g. for None or non-numeric text.
-   """
-   try: return int( text )
-   except ( TypeError, ValueError ): raise SummaryFormatError( f'not a number: {text!r}' ) from None
-
-
-def search_tree( tree:dict[str,int|str|dict], tag:str ):
-   category = None
-   while True:
-      category = tree.get( 'category', category )
-      if tag:
-         if ( key_length := tree.get( 'length', -1 ) ) == -1: return category
-         elif len( tag ) < key_length: return category
-         else:
-            key, tag = tag[:key_length], tag[key_length:]
-            if ( next_tree := tree['next'].get( key, None ) ) is not None: tree = next_tree
-            else: return category
-      else:
-         # The name ends here: the exact match if this node has one, else the
-         # category matched so far (a node may only have longer keys).
-         if ( next_nodes := tree.get( 'next', None ) ) is None: return category
-         else: return next_nodes.get( '', {} ).get( 'category', category )
-
-
-def categorize( schema:dict[str,int|str|dict], name:str, default='other' ):
-   if   ( category := search_tree( schema['direct' ], name       ) ) is not None: return category
-   elif ( category := search_tree( schema['reverse'], name[::-1] ) ) is not None: return category
-   else:
-      logger.debug( f'U: {name}' )
-      return default
-
-
-def min_p_1( val_iter:Iterator[float|int] ):
-   values = sorted( val_iter )
-   match len( values ):
-      case 1: return values[0]
-      case 2: return 0.5 * fsum( values ) if isinstance( values[0], float ) else sum( values ) // 2
-      case 0: return 0
-      case _: 
-         values.sort()
-         return values[1]
-
-
-def max_m_1( val_iter:Iterator[float|int] ):
-   values = sorted( val_iter )
-   match len( values ):
-      case 1: return values[-1]
-      case 2: return 0.5 * fsum( values ) if isinstance( values[-1], float ) else sum( values ) // 2
-      case 0: return 0
-      case _: 
-         values.sort()
-         return values[-2]
-
-
-SUMMARY_LABELS = ( 'API Timing Summary',               # 0
-                   'Device Timing Summary',            # 1
-                   '****************************',     # 2
-                   'Total Execution Time',             # 3
-                   'Total API Time for L0 backend',    # 4
-                   'Total Device Time for L0 backend', # 5
-                   'L0 Backend' )                      # 6
-
-
-def new_metrics():
-   """Create an empty metrics container.
-
-   Returns a tuple of three defaultdict(list), one per section: 0 API (host),
-   1 device, 2 communication. Each maps a function or kernel name to a list of
-   (time_ns, calls) tuples. Used by read_summary_tar for the total and for each
-   archive member.
-   """
-   metrics:tuple[defaultdict[str,list[tuple[int|float,...]]],...] = ( defaultdict(list), defaultdict(list), defaultdict(list) )
-   return metrics
-
-
-def parse_summary( f:TextIOBase, metrics ):
-   """Parse one unitrace summary text file into metrics.
-
-   f: the text stream of the summary. metrics: a container from new_metrics,
-   appended to in place: per-function/kernel (Time (ns), Calls) rows of the API,
-   device and communication tables, and "Wallclock" / "L0_backend" totals.
-   Returns None. Lines without a known section label are skipped.
-   Raises SummaryFormatError for a table without a header, a row missing the
-   Function/Kernel, Time (ns) or Calls column, or a value that is not an integer.
-   Called by read_summary_tar, which discards the partial result on error.
-   """
-   metric_labels = ( 'Time (ns)', 'Calls' )
-   row = lambda record, name: ( field( record, name ), tuple( to_int( field( record, label ) ) for label in metric_labels ) )
-   section = -1
-   while ( action_line := skip_to( SUMMARY_LABELS, f ) )[0] >= 0:
-      action, line = action_line
-      match action:
-         case 0 | 1:
-            section = action
-         case 2 if section != 2:
-            section = action
-         case 2 if section == 2:
-            for record in csv_from( f ):
-               name, values = row( record, 'Function' )
-               metrics[section][name].append( values )
-            section = -1
-         case 3:
-            label, sep, metric = line.rpartition( ':' )
-            metrics[section]['Wallclock'].append( ( to_int( metric ), 1 ) )
-         case 4 | 5:
-            label, sep, metric = line.rpartition( ':' )
-            metrics[section]['L0_backend'].append( ( to_int( metric ), 1 ) )
-         case 6 if section == 0:
-            for record in csv_from( f ):
-               name, values = row( record, 'Function' )
-               metrics[section][name].append( values )
-         case 6 if section == 1:
-            for record in csv_from( f ):
-               name, values = row( record, 'Kernel' )
-               metrics[section][name].append( values )
-
-
-def read_summary_tar( tarfile_path ):
-   """Read every unitrace summary in a tar archive and merge their metrics.
-
-   tarfile_path: path of the tar file (any compression tarfile.open detects).
-   Returns the merged container from new_metrics. Each regular member is parsed
-   on its own with parse_summary; a member raising SummaryFormatError,
-   UnicodeDecodeError or csv.Error (e.g. a field above csv.field_size_limit()) is
-   skipped with a warning and contributes nothing.
-   Non-file members are ignored. Errors opening or reading the archive itself
-   (tarfile.TarError, OSError) propagate. Called by aprocess.
-   """
-   metrics = new_metrics()
-   with tarfile.open( tarfile_path ) as tar:
-      for summary in tar:
-         # Only regular files: extractfile() follows a link, and raises KeyError for
-         # one whose target is not in the archive.
-         if not summary.isfile(): continue
-         if ( bin_file := tar.extractfile( summary ) ) is not None:
-            with TextIOWrapper( bin_file ) as f:
-               logger.info( f'Processing {summary.name} ...' )
-               # Parsed on its own, so a malformed file contributes nothing.
-               member = new_metrics()
-               try:
-                  parse_summary( f, member )
-               except ( SummaryFormatError, UnicodeDecodeError, CsvError ) as ex:
-                  logger.warning( f'Skipping {summary.name}: not a unitrace summary ({ex})' )
-                  continue
-               for section, values in zip( metrics, member ):
-                  for name, rows in values.items(): section[name].extend( rows )
-   return metrics
-
-
-async def aprocess( args ):
-   metrics = read_summary_tar( args.tarfile )
-   remove_spaces = str.maketrans( '', '', ' \t' )
-   with args.schema.open() as f: schema = json.load( f )
-   aggregator = { 'min':min, 'max':max, 'mean':fmean, 'median':median, 'sum':fsum, 'min+1':min_p_1, 'max-1':max_m_1 }[args.aggregator]
-   extractors = { 'time': itemgetter( 0 ), 'calls': itemgetter( 1 ) }
-   output:dict[str,int|float] = {}
-   for section in range( 1, 3 ):
-      default_category = ( 'host', 'device', 'comm' )[section]
-      for name, values in metrics[section].items():
-         if schema['ignore_spaces']: name = name.translate( remove_spaces )
-         if ( category := categorize( schema, name, default_category ) ):
-            for label, getter in extractors.items():
-               value = aggregator( map( getter, values ) )
-               sub_category = category + '_' + label
-               if sub_category in output: output[sub_category] += value
-               else                     : output[sub_category]  = value
-   if output or not args.skip_empty:
-      if args.json is None:
-         json.dump( output, sys.stdout, indent=2 )
-      else:
-         with args.json.open( 'w' ) as f: json.dump( output, f, indent=2 )
-
-
-def main():
-   """Command-line entry point of the summary tool.
-
-   Parses --tarfile, --schema (JSON from categorize), --aggregator, --skip-empty,
-   --json and -v, configures logging from the -v count and runs aprocess, which
-   writes the per-category time and call totals as JSON to --json or stdout.
-   With more than three -v the run is profiled with cProfile instead.
-   argparse exits on invalid arguments.
-   """
-   parser = argparse.ArgumentParser( description='Process unitrace summary and generate JSON file' )
-
-   parser.add_argument( '-v', '--verbose', action='count', default=0,
-      help='Show verbose messages' )
-
-   parser.add_argument( '--tarfile', '--input', type=Path, required=True,
-      help='TAR file with summary outputs from unitrace' )
-   parser.add_argument( '--schema', type=Path, required=True,
-      help='JSON output of `categorize` tool with mapping functions names to categories' )
-   parser.add_argument( '--aggregator', type=str, choices=('min','max','mean','median','sum','min+1','max-1'), default='mean',
-      help='How to aggregate metrics between different summary files from TAR file' )
-   parser.add_argument( '--skip-empty', action=argparse.BooleanOptionalAction, default=True,
-      help='Do not output empty JSON files' )
-   parser.add_argument( '--json', '--output', type=Path,
-      help='Name of output JSON file' )
-
-
-   args = parser.parse_args()
-
-   logging.basicConfig( format='[%(levelname)s] <%(name)s.%(funcName)s> %(message)s', level=[ logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG ][ min( 3, args.verbose ) ] )
-
-   action = aprocess( args )
-
-   if args.verbose <= 3: asyncio.run( action )
-   else:
-      import cProfile
-      import pstats
-
-      logging.getLogger().setLevel( logging.ERROR )
-      cProfile.runctx( 'asyncio.run( action )', globals(), locals(), f'{__name__}.profile' )
-      pstats.Stats( f'{__name__}.profile' ).strip_dirs().sort_stats( 'time' ).print_stats()
-
-
-if __name__ == '__main__':
-   main()
diff --git a/tools/unitrace/scripts/tracemerge/mergetrace.py b/tools/unitrace/scripts/tracemerge/mergetrace.py
deleted file mode 100755
index 736aa616..00000000
--- a/tools/unitrace/scripts/tracemerge/mergetrace.py
+++ /dev/null
@@ -1,199 +0,0 @@
-#!/usr/bin/env python3
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import sys
-import argparse
-import json
-import math
-import shutil
-from pathlib import Path
-
-def ParseCommandLineArgs():
-    parser = argparse.ArgumentParser(description = 'Merge unitrace result files')
-    parser.add_argument('inputFiles', nargs = '*', help = 'list of files to merge')
-    parser.add_argument('--result-dir', help = 'path to result directory containing trace files')    
-    parser.add_argument('--ranks', type=int, nargs = '+', help = 'list of MPI ranks to include in merge (e.g., --ranks 0 1 2)')
-    parser.add_argument('-o', '--outputFile', default = 'unitrace.all.json', help = 'output file')
-
-    args = parser.parse_args()
-
-    if args.result_dir and args.inputFiles:
-        parser.error("Cannot use both input files and --result-dir")
-    
-    if not args.result_dir and not args.inputFiles:
-        parser.error("Must provide either input files or --result-dir")
-
-    if args.ranks and not args.result_dir:
-        parser.error("--ranks can only be used with --result-dir")
-    
-    input_files = []
-    if args.result_dir:
-        result_dir = Path(args.result_dir)
-        if not result_dir.exists():
-            parser.error(f"Directory '{args.result_dir}' does not exist")
-
-        if not result_dir.is_dir():
-            parser.error(f"'{args.result_dir}' is not a directory")
-
-        if args.ranks:
-            input_files = []
-            for rank in args.ranks:
-                rank_pattern = f"**/rank_{rank}.*/**/chrome_trace.json"
-                input_files.extend([str(json_file) for json_file in result_dir.glob(rank_pattern)])
-            if (len(input_files) == 0):
-                for rank in args.ranks:
-                    rank_pattern = f"**/rank_{rank}.*/**/chrome_trace.pftrace"
-                    input_files.extend([str(json_file) for json_file in result_dir.glob(rank_pattern)])
-            if (len(input_files) == 0):
-                print(f'Trace file is missing under {result_dir}')
-                exit(1)
-        else:
-            input_files = [str(json_file) for json_file in result_dir.rglob('chrome_trace.json')]
-            if not input_files:
-                input_files = [str(json_file) for json_file in result_dir.rglob('chrome_trace.pftrace')]
-                if not input_files:
-                    print(f'Trace file is missing under {result_dir}')
-                    exit(1)
-    else:
-        input_files = args.inputFiles
-        if not input_files:
-            print("No input files provided")
-            exit(1)
-
-    return input_files, args.outputFile
-
-def MergePerfettoTraces(inputFiles, outputFile):
-    # Perfetto protobuf traces are a sequence of TracePacket messages; the
-    # concatenation of valid traces is itself a valid trace, and unitrace emits
-    # all ranks on a shared clock domain (REALTIME/BOOTTIME), so they align.
-    # Merging is therefore a plain byte concatenation -- no JSON repair needed.
-    try:
-        with open(outputFile, 'wb') as ofp:
-            for f in inputFiles:
-                if os.stat(f).st_size == 0:
-                    continue
-                with open(f, 'rb') as fp:
-                    shutil.copyfileobj(fp, ofp)  # streamed copy, bounded memory
-        return True
-
-    except Exception as e:
-        print(f"Error merging trace files: {e}")
-        return False
-
-def RejectJsonConstant(name):
-    """parse_constant for json.load: NaN and Infinity are not JSON, and a merged
-    file holding one would not load in the trace viewers."""
-    raise ValueError(f"{name} is not valid JSON")
-
-def ParseFiniteFloat(text):
-    """parse_float for json.load: a number too large for a float (1e400) would be
-    written back as Infinity, which is not JSON either."""
-    value = float(text)
-    if not math.isfinite(value):
-        raise ValueError(f"{text} does not fit a float")
-    return value
-
-def merge_trace_files(input_files, output_file):
-    """
-    Merge multiple unitrace JSON files into a single output file.
-    
-    Args:
-        input_files (list): List of input file paths to merge
-        output_file (str): Path to the output file
-    
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    try:
-        with open(output_file, 'w') as ofp:
-            ofp.write('{\n')
-            ofp.write('"traceEvents": [\n')
-            has_events = False
-
-            for i in range(0, len(input_files)):
-                fsize = os.stat(input_files[i]).st_size
-                if (fsize != 0):
-                    valid = True
-                    with open(input_files[i], 'r') as fp:
-                        try:
-                            data = json.load(fp, parse_constant=RejectJsonConstant, parse_float=ParseFiniteFloat)
-                        except Exception as ex:
-                            valid = False
-                    if (valid == False):
-                        # closing tags are likely missing in most cases
-                        # add closing tags
-                        with open(input_files[i], 'a') as fp:
-                            try:
-                                fp.write("\n]\n}\n")
-                            except Exception as ex:
-                                # give up
-                                print("Failed to add closing tags to trace file " + input_files[i])
-                                continue
-
-                        # read the file again
-                        rollback = False
-                        with open(input_files[i], 'r') as fp:
-                            try:
-                                data = json.load(fp, parse_constant=RejectJsonConstant, parse_float=ParseFiniteFloat)
-                            except Exception as ex:
-                                # give up, but need to roll back the changes made to the file
-                                rollback = True
-                        if (rollback == True):
-                            with open(input_files[i], 'a') as fp:
-                                try:
-                                    fp.truncate(fsize)
-                                except Exception as ex:
-                                    print("Failed to rollback the changes to trace file " + input_files[i])
-                            print("Skip invalid trace file " + input_files[i])
-                            continue
-                        else:
-                            print("File " + input_files[i] + " is modified with proper closing tags added")
-
-                    if 'traceEvents' in data:
-                        for e in data['traceEvents']:
-                            ofp.write(json.dumps(e))
-                            ofp.write(',\n')
-                            has_events = True
-
-            if has_events:
-                pos = ofp.tell() - 2  # undo last ',\n'
-                ofp.seek(pos, os.SEEK_SET)
-            ofp.write('\n]\n')
-            ofp.write('}\n')
-            
-        return True
-        
-    except Exception as e:
-        print(f"Error merging trace files: {e}")
-        return False
-
-if __name__ == "__main__":
-
-    inputFiles, outputFile = ParseCommandLineArgs()
-
-    # Route by format: .pftrace inputs merge by byte concatenation;
-    # legacy .json inputs by the JSON path below. The two formats cannot be
-    # merged together, so reject a mixed set
-    perfetto_inputs = [f for f in inputFiles if f.endswith(".pftrace")]
-    if perfetto_inputs or outputFile.endswith(".pftrace"):
-        if len(perfetto_inputs) != len(inputFiles):
-            json_inputs = [f for f in inputFiles if f not in perfetto_inputs]
-            print("[ERROR] cannot merge mixed trace formats; got .pftrace "
-                  "inputs {} and non-perfetto inputs {}. Merge each format "
-                  "separately.".format(perfetto_inputs, json_inputs))
-            sys.exit(1)
-        MergePerfettoTraces(perfetto_inputs, outputFile)
-        sys.exit(0)
-
-    success = merge_trace_files(inputFiles, outputFile)
-    if success:
-        print(f"Successfully merged {len(inputFiles)} files into {outputFile}")
-        sys.exit(0)
-    else:
-        print("Failed to merge trace files")
-        sys.exit(1)
diff --git a/tools/unitrace/scripts/uniview.py b/tools/unitrace/scripts/uniview.py
deleted file mode 100755
index 5260957f..00000000
--- a/tools/unitrace/scripts/uniview.py
+++ /dev/null
@@ -1,347 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import argparse
-import http.server
-import os
-import socketserver
-import sys
-import webbrowser
-import json
-import gc
-import re
-from pathlib import Path
-
-# analyzeperfmetrics module is either at the same folder of this script or subfolder "metrics"
-# add the paths
-modpath = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(modpath)
-sys.path.append(modpath + "/metrics")
-sys.path.append(modpath + "/tracemerge")
-
-import analyzeperfmetrics as apm
-from mergetrace import merge_trace_files, MergePerfettoTraces
-
-def parse_args(argparser):
-    args = argparser.parse_args()
-    if args.result_dir:
-        if not os.path.exists(args.result_dir):
-            argparser.error(f"Result directory '{args.result_dir}' does not exist")
-        if not os.path.isdir(args.result_dir):
-            argparser.error(f"Result directory '{args.result_dir}' is not a directory")
-        if args.trace:
-            argparser.error("--result-dir cannot be used together with --trace")
-        if args.metrics:
-            argparser.error("--result-dir cannot be used together with --metrics")
-    else:
-        if not args.trace:
-            argparser.error("--trace is required when --result-dir is not provided")
-
-    if args.ranks and not args.result_dir:
-        argparser.error("--ranks can only be used with --result-dir")
-    return args
-            
-def ParseArguments():
-    argparser = argparse.ArgumentParser(description = "View trace and hardware metrics in https://ui.perfetto.dev")
-    argparser.add_argument('-t', '--trace', help = "trace file (.pftrace or legacy .json)")
-    argparser.add_argument('-f', '--config', help = "metric view config file ")
-    argparser.add_argument('-m', '--metrics', help = "hardware performance metrics file (stall sampling, or query/time-based with -f)")
-    argparser.add_argument('-n', '--numtopstalls', type = int, default = 10, help = "number of top most expensive stalls of each type to report for stall analysis(10 default, -1 unlimited)")
-    argparser.add_argument('--dashboard', action = 'store_true', help = "open the interactive Bokeh dashboard instead of the default static matplotlib PDF")
-    argparser.add_argument('--result-dir', help = "directory that holds metrics files and trace file")
-    argparser.add_argument('--ranks', type=int, nargs='+', help='list of MPI ranks to include in merge (e.g., --ranks 0 1 2)')
-    
-    args = parse_args(argparser)
-         
-    return args
-
-class TraceLoadingHttpHandler(http.server.SimpleHTTPRequestHandler):
-    def log_request(self, code='-', size='-'):
-        if isinstance(code, int) and code >= 400:
-            super().log_request(code, size)
-
-    def end_headers(self):
-        self.send_header('Access-Control-Allow-Origin',  'https://ui.perfetto.dev')
-        self.send_header('Cache-Control', 'no-cache')
-        super().end_headers()
-
-    def do_GET(self):
-      super().do_GET()
-      self.server.done = True
-
-    def do_POST(self):
-        pass    # do nothing
-
-def LoadTrace(tracefile):
-    port = 9001    # perfetto likes 9001
-    path = os.path.abspath(tracefile)
-    fname = os.path.basename(path)
-    cwd = os.getcwd()     # save current working directory
-    try:
-        os.chdir(os.path.dirname(path))
-        socketserver.TCPServer.allow_reuse_address = True
-        with socketserver.TCPServer(('127.0.0.1', port), TraceLoadingHttpHandler) as httpd:
-            address = f'https://ui.perfetto.dev/#!/?url=http://127.0.0.1:{port}/{fname}'
-            webbrowser.open_new_tab(address)
-        
-            httpd.done = None
-            while httpd.done is None:
-                httpd.handle_request()
-    finally:
-        os.chdir(cwd)    # restore current working directory
-
-def get_trace_file_path(args):
-    if args.result_dir:
-        result_dir = Path(args.result_dir)
-        chrome_log_files = []
-        ext_suffix = 'json'
-        if args.ranks:
-            # Search for chrome_trace.json files only in rank directories we care about
-            for rank in args.ranks:
-                rank_pattern = f"**/rank_{rank}.*/**/chrome_trace.json"
-                chrome_log_files.extend([str(json_file) for json_file in result_dir.glob(rank_pattern)])
-            if len(chrome_log_files) == 0:
-                # If no chrome_trace.json files found, search for chrome_trace.pftrace files
-                for rank in args.ranks:
-                    rank_pattern = f"**/rank_{rank}.*/**/chrome_trace.pftrace"
-                    chrome_log_files.extend([str(json_file) for json_file in result_dir.glob(rank_pattern)])
-                ext_suffix = 'pftrace'
-        else:
-            chrome_log_files.extend([str(json_file) for json_file in result_dir.rglob('chrome_trace.json')])
-            if len(chrome_log_files) == 0:
-                chrome_log_files.extend([str(json_file) for json_file in result_dir.rglob('chrome_trace.pftrace')])
-                ext_suffix = 'pftrace'
-        if len(chrome_log_files) == 0:
-            print(f'Trace file is missing under {result_dir}')
-            exit(1)
-        elif len(chrome_log_files) > 1:
-            ranks_info = f" for ranks {args.ranks}" if args.ranks else ""
-            print(f'Multiple chrome_trace.json files found under {result_dir}{ranks_info}')
-            # Save the combined trace inside the result directory so future
-            # uniview runs can reuse it instead of merging again. The file name
-            # encodes the rank filter so different rank subsets get their own
-            # cached merge and never collide.
-            if args.ranks:
-                ranks_suffix = '_ranks_' + '_'.join(str(r) for r in sorted(args.ranks))
-            else:
-                ranks_suffix = ''
-            combined_file = result_dir / f'combined_trace{ranks_suffix}.{ext_suffix}'
-            # Reuse an existing merge only if it is at least as new as every
-            # input trace; otherwise a stale cache could hide newer data.
-            if combined_file.exists():
-                combined_mtime = combined_file.stat().st_mtime
-                inputs_mtime = max(os.path.getmtime(f) for f in chrome_log_files)
-                if combined_mtime >= inputs_mtime:
-                    print(f'Reusing existing combined trace file: {combined_file}')
-                    return str(combined_file)
-                print(f'Combined trace file is stale, re-merging: {combined_file}')
-            if ext_suffix == 'pftrace':
-                success = MergePerfettoTraces(chrome_log_files, combined_file)
-            else:
-                success = merge_trace_files(chrome_log_files, combined_file)
-            if not success:
-                print(f'Failed to merge trace files under {result_dir}')
-                exit(1)
-            else:
-                print(f'Combined trace file created: {combined_file}')
-                return str(combined_file)
-        else:
-            print(f'Using trace file: {chrome_log_files[0]}')
-            return str(chrome_log_files[0])
-    else:
-        if args.trace is None:
-            print(f'Trace file is missing')
-            exit(1)
-        if not os.path.exists(args.trace):
-            print(f'Trace file {args.trace} is not found')
-            exit(1)
-        return args.trace
-
-def get_sorted_metrics_files(metrics_files):
-    def extract_number(file_path):
-        """Extract number from metrics_X.csv filename"""
-        match = re.search(r'metrics_(\d+)\.csv', file_path.name)
-        if match:
-            try:
-                return int(match.group(1))
-            except (ValueError, OverflowError) as e:
-                print(f'Warning: Could not parse number in {file_path.name}: {e}')
-                return 0
-        return 0
-    
-    return sorted(metrics_files, key=extract_number)
-
-def get_metrics_files_paths(args):
-    if args.result_dir:
-        result_dir = Path(args.result_dir)
-        metrics_files = list(result_dir.rglob('metrics/metrics_*.csv'))
-        print(f'Found {len(metrics_files)} : {metrics_files}')
-        sorted_metrics_files = get_sorted_metrics_files(metrics_files)
-        return sorted_metrics_files
-    else:
-        return [Path(args.metrics)] if args.metrics else []
-
-def main():
-    args = ParseArguments();
-
-    trace_file_path = get_trace_file_path(args)
-    metrics_files_paths = get_metrics_files_paths(args)
-    eustall = False
-    if metrics_files_paths:
-        for metrics_file in metrics_files_paths:
-            if not metrics_file.exists():
-                print(f'Metrics file {metrics_file} is not found')
-                return 1
-
-        # Classify the first file from the label line that opens its first block. All
-        # three collectors write blocks and all three are comma-separated, so the
-        # discriminator is the label itself: stall sampling names the kernel and the two
-        # values that identify it, while the query and time-based collectors name the
-        # kernel and its instance. analyzeperfmetrics tells them apart for its own
-        # reading, so ask it rather than keeping a second copy of the format here.
-        first_metrics_file = metrics_files_paths[0]
-        kind = None
-        with first_metrics_file.open('r') as fp:
-            for line in fp:
-                kind = apm.ClassifyHeaderRow(line)
-                if (kind is not None):
-                    break
-                if ((line.strip() == '') or ('=== Device' in line)):
-                    continue    # blank lines and the device banner precede the header
-                break           # first non-blank, non-banner line is not a header
-
-        if (kind is None):
-            print(f'Metrics file {first_metrics_file} does not have a recognizable metrics header')
-            return 1
-
-        eustall = (kind == 'stall')
-
-        if not args.dashboard and not eustall:
-            # OA metrics select their view with a config file; stall data does not
-            if args.config is None:
-                print(f'Config file is missing')
-                return 1
-            if not os.path.exists(args.config):
-                print(f'Config file {args.config} is not found')
-                return 1
-
-    else:
-        if (args.config is not None):
-            print(f'Metrics file is missing')
-            return 1
-
-    # validate trace file
-    is_perfetto = trace_file_path.endswith(".pftrace")
-    fsize = os.stat(trace_file_path).st_size
-    if (fsize != 0):
-        # Perfetto protobuf is binary and self-terminating; skip the JSON
-        # validity check and closing-tag repair (those are JSON-only).
-        # ui.perfetto.dev auto-detects the protobuf format.
-        if (is_perfetto == False):
-            valid = True
-            with open(trace_file_path, 'r') as fp:
-                try:
-                    data = json.load(fp)
-                    del data
-                    gc.collect()
-                except Exception:
-                    valid = False
-            if (valid == False):
-                # trace file may not be closely closed
-                # Try to add closing tags
-                with open(trace_file_path, 'a') as fp:
-                    try:
-                        fp.write("\n]\n}\n")
-                    except Exception:
-                        # give up
-                        print("Failed to add closing tags to trace file " + trace_file_path)
-                        return 1
-                # read the file again
-                rollback = False
-                with open(trace_file_path, 'r') as fp:
-                    try:
-                        data = json.load(fp)
-                        del data
-                        gc.collect()
-                    except Exception:
-                        # give up, but need to roll back the changes made to the file
-                        rollback = True
-                if (rollback == True):
-                    with open(trace_file_path, 'a') as fp:
-                        try:
-                            fp.truncate(fsize)
-                        except Exception:
-                            print("Failed to rollback the changes to trace file " + trace_file_path)
-                    print("Trace file " + trace_file_path + " is invalid")
-                    return 1
-                else:
-                    print("Trace file " + trace_file_path + " is modified with proper closing tags added")
-    else:
-        print("Trace file " + trace_file_path + " is empty")
-        return 1
-
-    dbs = None
-    perfdashboard = None
-    try:
-        if args.dashboard and metrics_files_paths:
-            if len(metrics_files_paths) > 1:
-                print("--dashboard option is not supported with multi metrics files in a result directory")
-                return 1
-            import perfdashboard as perfdashboard
-            dbs = perfdashboard.start_server_process(
-                first_metrics_file, trace = trace_file_path, eustall = eustall)
-            if dbs is None:
-                return 1
-
-        LoadTrace(trace_file_path)
-
-        if dbs is not None and perfdashboard is not None:
-            return perfdashboard.wait_for_exit(dbs)
-          
-        if metrics_files_paths:
-            https = False
-            # The https-vs-local decision is driven by a metrics URL embedded in the
-            # trace. For JSON it can be found by a text scan; the binary
-            # Perfetto trace carries it in a debug annotation, so skip the scan and
-            # use the local (-q) path, matching the http://localhost URL the emitter
-            # writes for protobuf output.
-            if (is_perfetto == False):
-                with open(trace_file_path, 'r') as fp:
-                    for line in fp:
-                        if ("https://" in line):
-                            https = True
-                            break
-                        elif ("http://" in line):
-                            break
-
-            options = []
-            if (eustall is True):
-                options.extend(['-n', str(args.numtopstalls)])
-            else:
-                options.extend(['-f', str(args.config)])
-
-            if (https == True):
-                options.append('-p')
-            else:
-                options.append('-q')
-            if args.result_dir:
-                options.extend(['--result-dir', str(args.result_dir)])
-            else:
-                options.append(str(metrics_files_paths[0]))
-
-            apm.main(apm.ParseArguments(options))
-    except (OSError, ValueError) as error:
-        print(f"Error: {error}")
-        return 1
-    except KeyboardInterrupt:
-        print("\nStopping metrics server.")
-        return 0
-    finally:
-        if perfdashboard is not None and dbs is not None:
-            perfdashboard.stop_owned_process(dbs)
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/tools/unitrace/src/chromelogger.h b/tools/unitrace/src/chromelogger.h
deleted file mode 100644
index 78da3e9f..00000000
--- a/tools/unitrace/src/chromelogger.h
+++ /dev/null
@@ -1,2421 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_CHROME_LOGGER_H_
-#define PTI_TOOLS_UNITRACE_CHROME_LOGGER_H_
-
-#include <chrono>
-#include <cstdint>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <mutex>
-#include <new>
-#include <sstream>
-#include <string>
-#include <algorithm>
-#include <thread>
-#include <tuple>
-#include <set>
-#include <vector>
-#include "unitimer.h"
-#include "unikernel.h"
-#include "unievent.h"
-#include "unimemory.h"
-#include "logger_factory.h"
-#include "utils_host.h"
-
-#include "common_header.gen"
-
-#if BUILD_WITH_PERFETTO
-#include "perfettologger.h"
-#endif /* BUILD_WITH_PERFETTO */
-
-static constexpr uint32_t num_device_timestamps_cahced_ = 1024;
-
-#ifdef _WIN32
-#define strdup _strdup
-#else /* _WIN32 */
-#define strdup strdup
-#endif /* _WIN32 */
-
-// name without the quotes GetZeKernelCommandName() and the OpenCL collector put
-// around a kernel name (a name itself may contain ","). A name not quoted on both
-// ends is returned as it is.
-inline std::string UnquoteName(const std::string& name) {
-  if (name.size() >= 2 && name.front() == '"' && name.back() == '"') {
-    return name.substr(1, name.size() - 2);
-  }
-  return name;
-}
-
-// The "name" field of a Chrome trace event for a kernel or an API call.
-//   name    the kernel name, quoted or not (UnquoteName())
-//   prefix  text put before the name, e.g. "Tile #0: " for implicit scaling
-// Returns `, "name": "<prefix><name>"`, escaped, so any name gives valid JSON.
-inline std::string JsonNameField(const std::string& name, const std::string& prefix = "") {
-  return ", \"name\": " + JsonString(prefix + UnquoteName(name));
-}
-
-static std::string EncodeURI(const std::string &input) {
-  std::ostringstream encoded;
-  encoded.fill('0');
-  encoded << std::hex;
-
-  for (auto c : input) {
-    // accepted characters
-    if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
-      encoded << c;
-      continue;
-    }
-
-    // percent-encoded otherwise
-    encoded << std::uppercase;
-    encoded << '%' << std::setw(2) << int(c);
-    encoded << std::nouppercase;
-  }
-
-  return encoded.str();
-}
-
-static std::string rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-// The MPI rank in value, or the pid as a dummy rank id when value is empty or not
-// a number.
-static uint32_t InitMpiRankVal(const std::string& value) {
-  uint32_t r = 0;
-#ifdef _WIN32
-  return ToUint32(value, r) ? r : static_cast<uint32_t>(_getpid());
-#else /* _WIN32 */
-  return ToUint32(value, r) ? r : static_cast<uint32_t>(getpid());
-#endif /* _WIN32 */
-}
-#define INIT_MPI_RANK_VAL(rank) InitMpiRankVal(rank)
-static uint32_t mpi_rank = INIT_MPI_RANK_VAL(rank);
-
-static std::string pmi_hostname = GetHostName();
-
-std::string GetZeKernelCommandName(uint64_t id, ze_group_count_t& group_count, size_t size, bool detailed);
-ze_pci_ext_properties_t *GetZeDevicePciPropertiesAndId(ze_device_handle_t device, int32_t *parent_device_id, int32_t *device_id, int32_t *subdevice_id);
-std::string GetClKernelCommandName(uint64_t id);
-std::string GetZeDeviceName(ze_device_handle_t device);
-std::string GetZeEngineName(ze_device_handle_t device, uint32_t ordinal);
-#if BUILD_WITH_OMP
-extern const char *GetOmptEventName(uint32_t);
-#endif /* BUILD_WITH_OMP */
-
-static std::shared_ptr<UniLogger> logger_ = nullptr;
-
-std::recursive_mutex logger_lock_; //lock to synchronize file write
-
-static bool device_logging_no_thread_ = (utils::GetEnv("UNITRACE_ChromeNoThreadOnDevice") == "1") ? true : false;
-static bool device_logging_no_engine_ = (utils::GetEnv("UNITRACE_ChromeNoEngineOnDevice") == "1") ? true : false;
-
-static std::mutex device_pid_tid_map_lock_;
-
-#ifndef _WIN32
-// atfork hooks for the chrome logger's process-wide locks (see tracer.cc).
-// Prepare holds logger_lock_ -> EmitLock (the order flush paths nest them) so
-// no other thread can hold either across fork().
-inline void ChromeLoggerLockForFork() {
-  logger_lock_.lock();
-#if BUILD_WITH_PERFETTO
-  perfetto_emit::EmitLock().lock();
-#endif /* BUILD_WITH_PERFETTO */
-}
-
-inline void ChromeLoggerUnlockAfterForkParent() {
-#if BUILD_WITH_PERFETTO
-  perfetto_emit::EmitLock().unlock();
-#endif /* BUILD_WITH_PERFETTO */
-  logger_lock_.unlock();
-}
-
-// Child (single-threaded): recursive mutexes record the parent's tid as owner,
-// so unlock would fail (EPERM); re-create them in place. device_pid_tid_map_lock_
-// nests both ways with logger_lock_, so it is not held across fork; re-create too.
-inline void ChromeLoggerUnlockAfterForkChild() {
-#if BUILD_WITH_PERFETTO
-  new (&perfetto_emit::EmitLock()) std::recursive_mutex();
-#endif /* BUILD_WITH_PERFETTO */
-  new (&logger_lock_) std::recursive_mutex();
-  new (&device_pid_tid_map_lock_) std::mutex();
-}
-#endif /* _WIN32 */
-
-struct ZeDevicePidKey {
-  ze_pci_address_ext_t pci_addr_;
-  int32_t parent_device_id_;
-  int32_t device_id_;
-  int32_t subdevice_id_;
-  int32_t host_pid_;
-};
-
-struct ZeDeviceTidKey {
-  ze_pci_address_ext_t pci_addr_;
-  int32_t parent_device_id_;
-  int32_t device_id_;
-  int32_t subdevice_id_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-  int32_t host_pid_;
-  int32_t host_tid_;
-  uint32_t track_id_;
-};
-
-struct ZeDevicePidKeyCompare {
-  bool operator()(const ZeDevicePidKey& lhs, const ZeDevicePidKey& rhs) const {
-    return (memcmp((char *)(&lhs), (char *)(&rhs), sizeof(ZeDevicePidKey)) < 0);
-  }
-};
-static std::map<ZeDevicePidKey, std::tuple<uint32_t, uint64_t>, ZeDevicePidKeyCompare> device_pid_map_;
-struct ZeDeviceTidKeyCompare {
-  bool operator()(const ZeDeviceTidKey& lhs, const ZeDeviceTidKey& rhs) const {
-    return (memcmp((char *)(&lhs), (char *)(&rhs), sizeof(ZeDeviceTidKey)) < 0);
-  }
-};
-
-static std::map<ZeDeviceTidKey, std::tuple<uint32_t, uint32_t, uint64_t>, ZeDeviceTidKeyCompare> device_tid_map_;
-
-static uint32_t next_device_pid_ = (uint32_t)(~0) - (mpi_rank << 5);  // each rank uses no more than 32 devices
-static uint32_t next_device_tid_ = (uint32_t)(~0) - (mpi_rank << 5);  // the first device thread is the "main" thread which has the same id as the device process id
-
-// Emit a device process/thread metadata record in the active format (Perfetto
-// track vs JSON "M").
-static void EmitDeviceProcessMetadata(uint32_t device_pid, const std::string& name,
-                                      double start_time) {
-#if BUILD_WITH_PERFETTO
-  if (UseProtobufOutput()) {
-    // Called once per device pid (the device_pid_map_ miss branch), so emit the
-    // descriptor directly -- no MarkTrackEmitted dedup needed.
-    perfetto_emit::EmitProcessTrack(perfetto_emit::MakeUuid(device_pid),
-                                    device_pid, name,
-                                    UniTimer::GetEpochTime(UniTimer::GetHostTimestamp()),
-                                    perfetto_emit::DescriptorSeqId());
-    return;
-  }
-#endif /* BUILD_WITH_PERFETTO */
-  logger_->Log(",\n{\"ph\": \"M\", \"name\": \"process_name\", \"pid\": " + std::to_string(device_pid) +
-               ", \"ts\": " + std::to_string(start_time) + ", \"args\": {\"name\": " + JsonString(name) + "}}");
-  logger_->Flush();
-}
-
-static void EmitDeviceThreadMetadata(uint32_t device_pid, uint32_t device_tid,
-                                     const std::string& name, double start_time) {
-#if BUILD_WITH_PERFETTO
-  if (UseProtobufOutput()) {
-    // Called once per device tid (the device_tid_map_ miss branch), so emit the
-    // descriptor directly -- no MarkTrackEmitted dedup needed.
-    perfetto_emit::EmitThreadTrack(perfetto_emit::MakeUuid(device_pid, device_tid),
-                                   perfetto_emit::MakeUuid(device_pid),
-                                   device_pid, device_tid, name,
-                                   UniTimer::GetEpochTime(UniTimer::GetHostTimestamp()),
-                                   perfetto_emit::DescriptorSeqId());
-    return;
-  }
-#endif /* BUILD_WITH_PERFETTO */
-  logger_->Log(",\n{\"ph\": \"M\", \"name\": \"thread_name\", \"pid\": " + std::to_string(device_pid) + ", \"tid\": " +
-               std::to_string(device_tid) + ", \"ts\": " + std::to_string(start_time) + ", \"args\": {\"name\": " +
-               JsonString(name) + "}}");
-  logger_->Flush();
-}
-
-static std::tuple<uint32_t, uint32_t, int32_t> GetDevicePidTid(ze_device_handle_t device, uint32_t engine_ordinal, uint32_t engine_index, int host_pid, int host_tid, uint32_t track_id) {
-  if (device_logging_no_thread_) {
-    // map all threads to the process
-    host_tid = host_pid;
-  }
-
-  if (device_logging_no_engine_) {
-    // ignore engine ordinal and index
-    engine_ordinal = (uint32_t)(-1);
-    engine_index = (uint32_t)(-1);
-  }
-
-  uint32_t device_pid;
-  uint32_t device_tid;
-  const std::lock_guard<std::mutex> lock(device_pid_tid_map_lock_);
-
-  ze_pci_ext_properties_t *props;
-  int32_t device_id;
-  int32_t parent_device_id;
-  int32_t subdevice_id;
-  props = GetZeDevicePciPropertiesAndId(device, &parent_device_id, &device_id, &subdevice_id);
-  UNITRACE_ASSERT(props != nullptr);
-
-  ZeDeviceTidKey tid_key;
-
-  memset(&tid_key, 0, sizeof(ZeDeviceTidKey));
-  tid_key.pci_addr_ = props->address;
-  tid_key.parent_device_id_ = parent_device_id;
-  tid_key.device_id_ = device_id;
-  tid_key.subdevice_id_ = subdevice_id;
-  tid_key.engine_ordinal_ = engine_ordinal;
-  tid_key.engine_index_ = engine_index;
-  tid_key.host_pid_ = host_pid;
-  tid_key.host_tid_ = host_tid;
-  tid_key.track_id_ = track_id;
-
-  auto it = device_tid_map_.find(tid_key);
-  if (it != device_tid_map_.cend()) {
-    device_pid = std::get<0>(it->second);
-    device_tid = std::get<1>(it->second);
-  }
-  else {
-    ZeDevicePidKey pid_key;
-
-    memset(&pid_key, 0, sizeof(ZeDevicePidKey));
-    pid_key.pci_addr_ = props->address;
-    pid_key.parent_device_id_ = parent_device_id;
-    pid_key.device_id_ = device_id;
-    pid_key.subdevice_id_ = subdevice_id;
-    pid_key.host_pid_ = host_pid;
-
-    auto it2 = device_pid_map_.find(pid_key);
-    if (it2 != device_pid_map_.cend()) {
-      device_pid = std::get<0>(it2->second);
-    }
-    else {
-      device_pid = next_device_pid_--;
-      auto start_time = UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestamp());
-      device_pid_map_.insert({pid_key, std::make_tuple(device_pid, start_time)});
-
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-
-      // Build the device process display name (shared by both output formats).
-      std::string device_proc_name;
-      if (rank.empty()) {
-        device_proc_name = "DEVICE<" + pmi_hostname + ">";
-      }
-      else {
-        device_proc_name = "RANK " + std::to_string(mpi_rank) + " DEVICE<" + pmi_hostname + ">";
-      }
-
-      std::string device_name = GetZeDeviceName(device);
-      if (device_name.size() > 0) {
-        device_proc_name += "[" + device_name + "] ";
-      }
-
-      char str2[128];
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.domain);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.bus);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.device);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.function);
-      device_proc_name += std::string(str2);
-
-      if (pid_key.parent_device_id_ >= 0) {
-        device_proc_name += " #" + std::to_string(pid_key.parent_device_id_) + "." + std::to_string(pid_key.subdevice_id_);
-      }
-      else {
-        device_proc_name += " #" + std::to_string(pid_key.device_id_);
-      }
-
-      EmitDeviceProcessMetadata(device_pid, device_proc_name, start_time);
-    }
-
-    device_tid = next_device_tid_--;
-    auto start_time = UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestamp());
-    device_tid_map_.insert({tid_key, std::make_tuple(device_pid, device_tid, start_time)});
-
-    std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-
-    // Build the device thread display name (shared by both output formats).
-    std::string device_thread_name;
-    if (device_logging_no_thread_) {
-      if (device_logging_no_engine_) {
-        device_thread_name = "L0";
-      } else {
-        device_thread_name = GetZeEngineName(device, tid_key.engine_ordinal_);
-        device_thread_name += "<" + std::to_string(tid_key.engine_ordinal_) + "," + std::to_string(tid_key.engine_index_) + ">";
-      }
-    } else {
-      if (device_logging_no_engine_) {
-        device_thread_name = "Thread " + std::to_string(tid_key.host_tid_) + " L0";
-      } else {
-        device_thread_name = "Thread " + std::to_string(tid_key.host_tid_);
-        device_thread_name += " " + GetZeEngineName(device, tid_key.engine_ordinal_);
-        device_thread_name += "<" + std::to_string(tid_key.engine_ordinal_) + "," + std::to_string(tid_key.engine_index_) + ">";
-      }
-    }
-
-    EmitDeviceThreadMetadata(device_pid, device_tid, device_thread_name, start_time);
-  }
-
-  return std::tuple<uint32_t, uint32_t, int32_t>(device_pid, device_tid, device_id);
-}
-
-#if BUILD_WITH_OPENCL
-
-struct ClDevicePidKey {
-  cl_device_pci_bus_info_khr pci_addr_;
-  cl_device_id device_;
-  int32_t host_pid_;
-};
-
-struct ClDeviceTidKey {
-  cl_device_pci_bus_info_khr pci_addr_;
-  cl_device_id device_;
-  cl_command_queue queue_;
-  int32_t host_pid_;
-  int32_t host_tid_;
-  uint32_t track_id_;
-};
-
-std::pair<uint32_t, std::string> GetClDeviceName(cl_device_id device);
-
-struct ClDevicePidKeyCompare {
-  bool operator()(const ClDevicePidKey& lhs, const ClDevicePidKey& rhs) const {
-    return (memcmp((char *)(&lhs), (char *)(&rhs), sizeof(ClDevicePidKey)) < 0);
-  }
-};
-static std::map<ClDevicePidKey, std::tuple<uint32_t, uint32_t, uint64_t>, ClDevicePidKeyCompare> cl_device_pid_map_;
-struct ClDeviceTidKeyCompare {
-  bool operator()(const ClDeviceTidKey& lhs, const ClDeviceTidKey& rhs) const {
-    return (memcmp((char *)(&lhs), (char *)(&rhs), sizeof(ClDeviceTidKey)) < 0);
-  }
-};
-
-static std::map<ClDeviceTidKey, std::tuple<uint32_t, uint32_t, uint32_t, uint64_t>, ClDeviceTidKeyCompare> cl_device_tid_map_;
-
-static std::tuple<uint32_t, uint32_t, uint32_t> ClGetDevicePidTid(cl_device_pci_bus_info_khr& pci, cl_device_id device, cl_command_queue queue, int host_pid, int host_tid, uint32_t track_id) {
-  if (device_logging_no_thread_) {
-    // map all threads to the process
-    host_tid = host_pid;
-  }
-
-  if (device_logging_no_engine_) {
-    // ignore engine ordinal and index
-    queue = (cl_command_queue)(-1);
-  }
-
-  uint32_t device_pid;
-  uint32_t device_tid;
-  uint32_t device_id;
-  const std::lock_guard<std::mutex> lock(device_pid_tid_map_lock_);
-
-  ClDeviceTidKey tid_key;
-
-  memset(&tid_key, 0, sizeof(ClDeviceTidKey));
-  tid_key.pci_addr_ = pci;
-  tid_key.device_ = device;
-  tid_key.queue_ = queue;
-  tid_key.host_pid_ = host_pid;
-  tid_key.host_tid_ = host_tid;
-  tid_key.track_id_ = track_id;
-
-  auto it = cl_device_tid_map_.find(tid_key);
-  if (it != cl_device_tid_map_.cend()) {
-    device_id = std::get<0>(it->second);
-    device_pid = std::get<1>(it->second);
-    device_tid = std::get<2>(it->second);
-  }
-  else {
-    ClDevicePidKey pid_key;
-
-    memset(&pid_key, 0, sizeof(ClDevicePidKey));
-    pid_key.pci_addr_ = pci;
-    pid_key.device_ = device;
-    pid_key.host_pid_ = host_pid;
-    auto it2 = cl_device_pid_map_.find(pid_key);
-    if (it2 != cl_device_pid_map_.cend()) {
-      device_id = std::get<0>(it2->second);
-      device_pid = std::get<1>(it2->second);
-    }
-    else {
-      device_pid = next_device_pid_--;
-      auto start_time = UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestamp());
-
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-
-      // Build the device process display name (shared by both output formats).
-      std::string device_proc_name;
-      if (rank.empty()) {
-        device_proc_name = "DEVICE<" + pmi_hostname + ">";
-      }
-      else {
-        device_proc_name = "RANK " + std::to_string(mpi_rank) + " DEVICE<" + pmi_hostname + ">";
-      }
-
-      std::pair<uint32_t, std::string> device_id_name = GetClDeviceName(device);
-      if (device_id_name.second.size() > 0) {
-        device_proc_name += "[" + device_id_name.second + "] ";
-      }
-
-      device_id = device_id_name.first;
-      cl_device_pid_map_.insert({pid_key, std::make_tuple(device_id, device_pid, start_time)});
-
-      char str2[128];
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.pci_domain);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.pci_bus);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.pci_device);
-      device_proc_name += std::string(str2) + ":";
-      snprintf(str2, sizeof(str2), "%x", pid_key.pci_addr_.pci_function);
-      device_proc_name += std::string(str2);
-
-      EmitDeviceProcessMetadata(device_pid, device_proc_name, start_time);
-    }
-    device_tid = next_device_tid_--;
-    auto start_time = UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestamp());
-    cl_device_tid_map_.insert({tid_key, std::make_tuple(device_id, device_pid, device_tid, start_time)});
-
-    std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-
-    // Build the device thread display name (shared by both output formats).
-    std::string device_thread_name;
-    if (device_logging_no_thread_) {
-      if (device_logging_no_engine_) {
-        device_thread_name = "CL";
-      }
-      else {
-        char str2[128];
-        snprintf(str2, sizeof(str2), "%p", tid_key.queue_);
-        device_thread_name = "CL Queue<" + std::string(str2) + ">";
-      }
-    }
-    else {
-      if (device_logging_no_engine_) {
-        device_thread_name = "Thread " + std::to_string(tid_key.host_tid_) + " CL";
-      }
-      else {
-        char str2[128];
-        snprintf(str2, sizeof(str2), "%p", tid_key.queue_);
-        device_thread_name = "Thread " + std::to_string(tid_key.host_tid_) + " CL Queue<" + std::string(str2) + ">";
-      }
-    }
-
-    EmitDeviceThreadMetadata(device_pid, device_tid, device_thread_name, start_time);
-  }
-
-  return std::tuple<uint32_t, uint32_t, uint32_t>(device_pid, device_tid, device_id);
-}
-#endif /* BUILD_WITH_OPENCL */
-
-#if BUILD_WITH_ITT
-// The values of an ITT metadata argument as text: numbers comma-separated, a
-// string quoted. json: the string JSON-escaped, for the Chrome trace; otherwise
-// as the application gave it, for Perfetto annotations, which store it verbatim.
-static std::string ConvertDataToString(IttArgs* args, bool json = true) {
-  std::string strData = "";
-  void* dataPtr = args->isIndirectData ? args->data[0] : args->data;
-  if (args->count) {
-    switch (args->type) {
-      case __itt_metadata_u64: {
-        const uint64_t* uint64Ptr = reinterpret_cast<const uint64_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(uint64Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_s64: {
-        const int64_t* int64Ptr = reinterpret_cast<const int64_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(int64Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_u32: {
-        const uint32_t* uint32Ptr = reinterpret_cast<const uint32_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(uint32Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_s32: {
-        const int32_t* int32Ptr = reinterpret_cast<const int32_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(int32Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_u16: {
-        const uint16_t* uint16Ptr = reinterpret_cast<const uint16_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(uint16Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_s16: {
-        const int16_t* uint16Ptr = reinterpret_cast<const int16_t*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(uint16Ptr + i));
-        }
-        break;
-      }
-      case __itt_metadata_float: {
-        const float* floatPtr = reinterpret_cast<const float*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(floatPtr + i));
-        }
-        break;
-      }
-      case __itt_metadata_double: {
-        const double* doublePtr = reinterpret_cast<const double*>(dataPtr);
-        for (size_t i=0; i < args->count; i++) {
-          if (i) {
-            strData += ",";
-          }
-          strData += std::to_string(*(doublePtr + i));
-        }
-        break;
-      }
-      default: {  // default is string
-        const char* stringPtr = reinterpret_cast<const char*>(dataPtr);
-        const std::string value(stringPtr, args->count);
-        strData += json ? JsonString(value) : "\"" + value + "\"";
-        break;
-      }
-    }
-  }
-  return strData;
-}
-#else /* BUILD_WITH_ITT */
-static std::string ConvertDataToString(IttArgs* args, bool json = true) {
-  return "";
-}
-#endif /* BUILD_WITH_ITT */
-
-#if BUILD_WITH_OMP
-static void OmpArgsToString(const OmpArgs &args, std::string &o) {
-  switch (args.ompt.type) {
-  case ompt_callback_implicit_task:
-    o += "\"actual_parallelism\": ";
-    o += std::to_string(args.ompt.record.implicit_task.actual_parallelism);
-    o += ", \"index\": ";
-    o += std::to_string(args.ompt.record.implicit_task.index);
-    break;
-  case ompt_callback_dispatch:
-    if (args.ompt.record.dispatch.kind == ompt_dispatch_iteration) {
-      o += "\"iteration\": ";
-      o += std::to_string(args.ompt.record.dispatch.instance.value);
-    } else if (args.ompt.record.dispatch.kind == ompt_dispatch_section) {
-      o += "\"section\": ";
-      o += std::to_string(args.ompt.record.dispatch.instance.value);
-    } else {
-      o += "\"chunk_start\": " + std::to_string(args.data[0]);
-      o += ", \"chunk_iterations\": " + std::to_string(args.data[1]);
-    }
-    break;
-  case ompt_callback_task_create:
-    o += "\"new_task_id\": ";
-    o += std::to_string(args.ompt.record.task_create.new_task_id);
-    break;
-  case ompt_callback_task_dependence:
-    o += "\"src_task_id\": ";
-    o += std::to_string(args.ompt.record.task_dependence.src_task_id);
-    o += ", \"sink_task_id\": ";
-    o += std::to_string(args.ompt.record.task_dependence.sink_task_id);
-    break;
-  default:
-    ;
-  }
-}
-#endif /* BUILD_WITH_OMP */
-
-// comparator for std::pair<start_time, end_time> of device timestamps
-struct DeviceTimestampComparator {
-  bool operator()(const std::pair<uint64_t, uint64_t>& a, const std::pair<uint64_t, uint64_t>& b) const {
-    // sort by end_time ascending, then start_time ascending
-    if (a.second != b.second) {
-      return a.second < b.second; // primary sort
-    }
-    return a.first< b.first;   // secondary sort
-  }
-};
-
-// overlap but not completely nested events go to different tracks
-uint32_t GetDeviceEventTrack(std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>& timestamps, uint64_t start_time, uint64_t end_time) {
-  bool track_found = false;
-  uint32_t track = 0;
-  for (uint32_t i = 0; i < timestamps.size(); i++) {
-    auto& rdt = timestamps[i];
-    bool overlap = false;
-    for (auto it = rdt.rbegin(); it != rdt.rend(); ++it) {
-      auto s = std::get<0>(*it);
-      auto t = std::get<1>(*it);
-      if (start_time > t) {
-        // ok to put in this track
-        break;
-      }
-      else {
-        if (((start_time < s) && (end_time > s) && (end_time < t)) || ((start_time  > s) && (start_time < t) && (end_time > t))) {
-          // overlap but not nested
-          // check the next track
-          overlap = true;
-          break;
-        }
-      }
-    }
-    if (!overlap) {
-      track_found = true;
-      track = i;
-      rdt.erase(rdt.begin());
-      rdt.insert({start_time, end_time});
-      break;
-    }
-  }
-
-  if (!track_found) {
-    // create a new track
-    track = timestamps.size();
-    timestamps.push_back(std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>());
-    auto& rdt = timestamps[track];
-    // populate the recent device timestamps with dummies
-    for (int i = 0; i < num_device_timestamps_cahced_; i++) {
-      rdt.insert({0, i});
-    }
-    rdt.erase(rdt.begin());
-    rdt.insert({start_time, end_time});
-  }
-
-  return track;
-}
-
-class TraceBuffer;
-std::set<TraceBuffer *> *trace_buffers_ = nullptr;
-
-#define BUFFER_SLICE_SIZE_DEFAULT  (0x1 << 20)
-
-#if BUILD_WITH_PERFETTO
-// H2D flow ids (from EVENT_FLOW_SOURCE records) awaiting the next host slice.
-// Per host-thread buffer: the callback pushes a call's flow records right before
-// its EVENT_COMPLETE on one thread, so they stay contiguous.
-struct PendingFlows {
-  std::vector<uint64_t> source;  // -> flow_ids on the submit slice
-};
-
-// Host process track uuid, scoped by mpi_rank so concatenated per-rank traces
-// with repeating pids don't merge (thread tracks use this as parent_uuid).
-inline uint64_t HostProcessTrackUuid(uint32_t pid) {
-  constexpr uint64_t kHostProcMarker = 0x50524f43;  // "PROC"
-  return perfetto_emit::MakeUuid(pid, mpi_rank, kHostProcMarker);
-}
-
-// Emit a HostEventRecord as Perfetto TrackEvent(s) on its host thread track.
-// Shared by TraceBuffer and ClTraceBuffer; reproduces the JSON host output
-// (cpu_op category, "id" arg, MPI/ITT args) and frees name_/ITT data like
-// StringifyHostEvent. Flow ids accumulate in |pending| and ride on the next slice.
-// |host_track_emitted| is the buffer's once-per-thread flag: the host thread track
-// uuid is constant for a buffer (pid/tid fixed), so the descriptor is emitted on
-// the first host event only, avoiding a global-locked MarkTrackEmitted probe per
-// event.
-inline void PerfettoEmitHostEvent(HostEventRecord& rec, uint32_t pid, uint32_t tid,
-                                  uint32_t seq_id, PendingFlows& pending,
-                                  bool& host_track_emitted) {
-  // "HOST" marker keeps host uuids off device uuids; +mpi_rank scopes per rank.
-  constexpr uint64_t kHostTrackMarker = 0x484f5354;
-  uint64_t track_uuid = perfetto_emit::MakeUuid(pid, tid, kHostTrackMarker + mpi_rank);
-  if (!host_track_emitted) {
-    perfetto_emit::EmitThreadTrack(track_uuid, HostProcessTrackUuid(pid),
-                                   pid, tid, "Thread " + std::to_string(tid),
-                                   UniTimer::GetEpochTime(rec.start_time_),
-                                   perfetto_emit::DescriptorSeqId());
-    host_track_emitted = true;
-  }
-  uint64_t ts_ns = UniTimer::GetEpochTime(rec.start_time_);
-
-  // Flow records emit no slice of their own. Only H2D (submit) ids are kept; they
-  // ride as flow_ids on the EVENT_COMPLETE that follows, and the kernel carries
-  // the same id -> Perfetto draws submit -> kernel. D2H (sink) ids are dropped:
-  // the host wait begins before the device work it waits on, so a shared flow_id
-  // would render backwards (wait -> kernel). The fix is GpuCorrelation (see
-  // UNITRACEI-107); until then the submit -> kernel arrow shows the association.
-  if (rec.type_ == EVENT_FLOW_SOURCE || rec.type_ == EVENT_FLOW_SINK) {
-    if (rec.type_ == EVENT_FLOW_SOURCE) {
-      pending.source.push_back(rec.id_);
-    }
-    if (rec.name_ != nullptr) { free(rec.name_); rec.name_ = nullptr; }
-    return;
-  }
-
-  perfetto_emit::SliceOptions opts;
-  opts.category = "cpu_op";
-  if (rec.name_ != nullptr) {
-    opts.name = rec.name_;
-    if (opts.name.size() >= 2 && opts.name.front() == '"' && opts.name.back() == '"') {
-      opts.name = opts.name.substr(1, opts.name.size() - 2);
-    }
-  } else if ((rec.api_id_ != XptiTracingId) && (rec.api_id_ != IttTracingId)) {
-    opts.name = get_symbol(rec.api_id_);
-  }
-  if (rec.name_ != nullptr) { free(rec.name_); rec.name_ = nullptr; }
-
-  // Build args (mirror the JSON args), replicating ITT free side effects.
-  bool has_args = false;
-  if (rec.api_type_ == API_TYPE_MPI) {
-    const MpiArgs& args = rec.mpi_args_;
-    if (args.src_size != 0) {
-      opts.annotations.push_back(perfetto_emit::Annotation::Uint("ssize", args.src_size));
-      if (args.is_tagged) {
-        opts.annotations.push_back(perfetto_emit::Annotation::Int("src", args.src_location));
-        opts.annotations.push_back(perfetto_emit::Annotation::Int("stag", args.src_tag));
-      }
-      has_args = true;
-    }
-    if (args.dst_size != 0) {
-      opts.annotations.push_back(perfetto_emit::Annotation::Uint("dsize", args.dst_size));
-      if (args.is_tagged) {
-        opts.annotations.push_back(perfetto_emit::Annotation::Int("dst", args.dst_location));
-        opts.annotations.push_back(perfetto_emit::Annotation::Int("dtag", args.dst_tag));
-      }
-      has_args = true;
-    }
-    if (args.mpi_counter >= 0) {
-      opts.annotations.push_back(perfetto_emit::Annotation::Int("mpi_counter", args.mpi_counter));
-      has_args = true;
-    }
-  } else if (rec.api_type_ == API_TYPE_ITT) {
-    opts.annotations.push_back(perfetto_emit::Annotation::Str(rec.itt_args_.key, ConvertDataToString(&rec.itt_args_, false)));
-    if (rec.itt_args_.isIndirectData) {
-      free(rec.itt_args_.data[0]);
-    }
-    IttArgs* args = rec.itt_args_.next;
-    while (args != nullptr) {
-      opts.annotations.push_back(perfetto_emit::Annotation::Str(args->key, ConvertDataToString(args, false)));
-      IttArgs* toFree = args;
-      args = args->next;
-      free(toFree);
-    }
-    rec.itt_args_.count = 0;
-    rec.api_type_ = API_TYPE_NONE;
-    has_args = true;
-  }
-  // The JSON path emits a top-level "id" only when there are no args.
-  if (!has_args) {
-    opts.annotations.push_back(perfetto_emit::Annotation::Uint("id", rec.id_));
-  }
-
-  if (rec.type_ == EVENT_COMPLETE) {
-    // Attach the H2D flow ids accumulated from this call's FLOW_SOURCE records.
-    if (!pending.source.empty()) {
-      opts.flow_ids = std::move(pending.source);
-      pending.source.clear();
-    }
-    perfetto_emit::EmitSliceBegin(seq_id, track_uuid, ts_ns, opts);
-    perfetto_emit::EmitSliceEnd(seq_id, track_uuid, UniTimer::GetEpochTime(rec.end_time_));
-  } else if (rec.type_ == EVENT_DURATION_START) {
-    perfetto_emit::EmitSliceBegin(seq_id, track_uuid, ts_ns, opts);
-  } else if (rec.type_ == EVENT_DURATION_END) {
-    perfetto_emit::EmitSliceEnd(seq_id, track_uuid, ts_ns);
-  } else if (rec.type_ == EVENT_MARK) {
-    perfetto_emit::EmitInstant(seq_id, track_uuid, ts_ns, opts);
-  }
-}
-
-// Emit one device kernel command as a Perfetto slice (begin+end) on its device
-// thread track. The Level Zero and OpenCL device emitters differ only in how
-// pid/tid/kname are resolved, so they resolve those and call this with the
-// common fields. Carries the gpu_op category, the kernel id arg, optional
-// metrics arg, and (non-implicit-scaling) the kid as a flow_id -- the device end
-// of the H2D submit -> kernel arrow (the host submit slice carries the same id).
-// Shared device-slice emit for both ZE and CL (the wrappers resolve the backend).
-inline void PerfettoEmitDeviceSlice(uint32_t seq_id, uint32_t pid, uint32_t tid, uint32_t device_id,
-                                    const std::string& kname, uint64_t kid,
-                                    bool implicit_scaling, uint32_t tile,
-                                    bool metrics_enabled, uint64_t start_time,
-                                    uint64_t end_time) {
-  perfetto_emit::SliceOptions opts;
-  opts.category = "gpu_op";
-  if (implicit_scaling) {
-    opts.name = "Tile #" + std::to_string(tile) + ": " + kname;
-  } else {
-    opts.name = kname;
-    // The JSON path emits a dep flow tied to kid for non-scaled commands.
-    opts.flow_ids.push_back(kid);
-  }
-  opts.annotations.push_back(perfetto_emit::Annotation::Str("id", std::to_string(kid)));
-  if (metrics_enabled) {
-    opts.annotations.push_back(perfetto_emit::Annotation::Str(
-        "metrics", "http://localhost:8000/" + EncodeURI(kname) + "/" + std::to_string(kid) +
-        (device_id != UINT32_MAX ? "/" + std::to_string(device_id) : "")));
-  }
-
-  uint64_t track_uuid = perfetto_emit::MakeUuid(pid, tid);
-  perfetto_emit::EmitSliceBegin(seq_id, track_uuid, UniTimer::GetEpochTime(start_time), opts);
-  perfetto_emit::EmitSliceEnd(seq_id, track_uuid, UniTimer::GetEpochTime(end_time));
-}
-#endif /* BUILD_WITH_PERFETTO */
-
-// TODO(refactor): TraceBuffer (Level Zero) and ClTraceBuffer (OpenCL) differ only
-// in the record type and device-id resolution; a TraceBuffer templated on the
-// record + a device-id trait would fold both into one. Deferred to keep this
-// change scoped to the Perfetto output.
-class TraceBuffer {
-  public:
-    TraceBuffer() : flush_immediately_(false) {
-      std::string szstr = utils::GetEnv("UNITRACE_ChromeEventBufferSize");
-      // unitrace rejects an invalid size; unbounded if the variable was set by hand.
-      ParseChromeEventBufferSize(szstr, buffer_capacity_);
-      if (buffer_capacity_ == -1) {
-        slice_capacity_ = BUFFER_SLICE_SIZE_DEFAULT;
-      }
-      else {
-        if (buffer_capacity_ == 0) {
-          buffer_capacity_ = 1;  // at least one event slot
-          flush_immediately_ = true;
-        }
-        slice_capacity_ = buffer_capacity_;
-      }
-      ZeKernelCommandExecutionRecord *der = (ZeKernelCommandExecutionRecord *)(malloc(sizeof(ZeKernelCommandExecutionRecord) * slice_capacity_));
-      UniMemory::ExitIfOutOfMemory((void *)(der));
-
-      device_event_buffer_.push_back(der);
-
-      HostEventRecord *her = (HostEventRecord *)(malloc(sizeof(HostEventRecord) * slice_capacity_));
-      UniMemory::ExitIfOutOfMemory((void *)(her));
-
-      host_event_buffer_.push_back(her);
-      tid_= utils::GetTid();
-      pid_= utils::GetPid();
-#if BUILD_WITH_PERFETTO
-      // One packet sequence per writer thread; slices on the same track from the
-      // same sequence stack correctly. Per-rank files are already separate.
-      seq_id_ = perfetto_emit::NextSequenceId();
-#endif /* BUILD_WITH_PERFETTO */
-
-      current_device_event_buffer_slice_ = 0;
-      current_host_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      next_host_event_index_ = 0;
-      device_event_buffer_flushed_ = false;
-      host_event_buffer_flushed_ = false;
-      finalized_.store(false, std::memory_order_release);
-      if ((utils::GetEnv("UNITRACE_MetricQuery") == "1") || (utils::GetEnv("UNITRACE_KernelMetrics") == "1")) {
-        metrics_enabled_ = true;
-      }
-      else {
-        metrics_enabled_ = false;
-      }
-
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);  // use this lock to protect trace_buffers_
-
-      if (trace_buffers_ == NULL) {
-        trace_buffers_ = new std::set<TraceBuffer *>;
-        UniMemory::ExitIfOutOfMemory((void *)(trace_buffers_));
-      }
-      trace_buffers_->insert(this);
-    }
-
-    ~TraceBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (!finalized_.exchange(true)) {
-        // finalize if not finalized
-        if (!device_event_buffer_flushed_) {
-          for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushDeviceEvent(device_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_device_event_index_; j++) {
-            FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-          }
-          device_event_buffer_flushed_ = true;
-        }
-        if (!host_event_buffer_flushed_) {
-          for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushHostEvent(host_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_host_event_index_; j++) {
-            FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-          }
-          host_event_buffer_flushed_ = true;
-        }
-        for (auto& slice : device_event_buffer_) {
-          free(slice);
-        }
-        device_event_buffer_.clear();
-
-        for (auto& slice : host_event_buffer_) {
-          free(slice);
-        }
-        host_event_buffer_.clear();
-        trace_buffers_->erase(this);
-      }
-    }
-
-    TraceBuffer(const TraceBuffer& that) = delete;
-    TraceBuffer& operator=(const TraceBuffer& that) = delete;
-
-    // device event timestampes cached are <device, engine_ordinal, engine_index> specific
-    std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>&
-    GetRecentDeviceTimestamps(ze_device_handle_t device, uint32_t engine_ordinal, uint32_t engine_index) {
-      auto it = recent_device_timestamps_.find({device, engine_ordinal, engine_index});
-      if (it == recent_device_timestamps_.end()) {
-        auto rdt = std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>();
-        rdt.push_back(std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>());
-        auto& ts = rdt[0];
-        // populate the recent device timestamps with dummies
-        for (int i = 0; i < num_device_timestamps_cahced_; i++) {
-          ts.insert({0, i});
-        }
-        recent_device_timestamps_.insert({{device, engine_ordinal, engine_index}, std::move(rdt)});
-
-        it = recent_device_timestamps_.find({device, engine_ordinal, engine_index});
-      }
-
-      return it->second;
-    }
-
-    ZeKernelCommandExecutionRecord *GetDeviceEvent(void) {
-      if (next_device_event_index_ ==  slice_capacity_) {
-        if (buffer_capacity_ == -1) {
-          ZeKernelCommandExecutionRecord *der = (ZeKernelCommandExecutionRecord *)(malloc(sizeof(ZeKernelCommandExecutionRecord) * slice_capacity_));
-          UniMemory::ExitIfOutOfMemory((void *)(der));
-
-          device_event_buffer_.push_back(der);
-          current_device_event_buffer_slice_++;
-          next_device_event_index_ = 0;
-        }
-        else {
-          FlushDeviceBuffer();
-        }
-      }
-      return &(device_event_buffer_[current_device_event_buffer_slice_][next_device_event_index_]);
-    }
-
-    HostEventRecord *GetHostEvent(void) {
-      if (next_host_event_index_ ==  slice_capacity_) {
-        if (buffer_capacity_ == -1) {
-          HostEventRecord *her = (HostEventRecord *)(malloc(sizeof(HostEventRecord) * slice_capacity_));
-          UniMemory::ExitIfOutOfMemory((void *)(her));
-          host_event_buffer_.push_back(her);
-          current_host_event_buffer_slice_++;
-          next_host_event_index_ = 0;
-        }
-        else {
-          FlushHostBuffer();
-        }
-      }
-      return &(host_event_buffer_[current_host_event_buffer_slice_][next_host_event_index_]);
-    }
-
-    void BufferHostEvent(void) {
-      if (flush_immediately_) {
-        std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-        FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][next_host_event_index_]);
-        // in case that flush_immediately_ is true, only one slice and one event slot, so set the flushed flag to true
-        host_event_buffer_flushed_ = true;
-      }
-      else {
-        next_host_event_index_++;
-        host_event_buffer_flushed_ = false;
-      }
-    }
-
-    void BufferDeviceEvent(void) {
-      if (flush_immediately_) {
-        std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-        FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][next_device_event_index_]);
-        // in case that flush_immediately_ is true, only one slice and one event slot, so set the flushed flag to true
-        device_event_buffer_flushed_ = true;
-      }
-      else {
-        next_device_event_index_++;
-        device_event_buffer_flushed_ = false;
-      }
-    }
-
-    uint32_t GetTid() { return tid_; }
-    uint32_t GetPid() { return pid_; }
-
-
-    std::string StringifyDeviceEvent(ZeKernelCommandExecutionRecord& rec) {
-      auto& rdt = GetRecentDeviceTimestamps(rec.device_, rec.engine_ordinal_, rec.engine_index_);
-      uint32_t track = GetDeviceEventTrack(rdt, rec.start_time_, rec.end_time_);
-      auto [pid, tid, device_id] = GetDevicePidTid(rec.device_, rec.engine_ordinal_, rec.engine_index_, pid_, rec.tid_, track);
-      std::string kname = GetZeKernelCommandName(rec.kernel_command_id_, rec.group_count_, rec.mem_size_);
-      std::string str = ",\n{";
-
-      str += "\"ph\": \"X\"";
-      str += ", \"tid\": " + std::to_string(tid);
-      str += ", \"pid\": " + std::to_string(pid);
-
-      if (rec.implicit_scaling_) {
-        str += JsonNameField(kname, "Tile #" + std::to_string(rec.tile_) + ": ");
-      } else {
-        if (!kname.empty()) {
-          str += JsonNameField(kname);
-        }
-      }
-
-      str += ", \"cat\": \"gpu_op\"";
-      str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-      str += ", \"dur\": " + std::to_string(UniTimer::GetTimeInUs(rec.end_time_ - rec.start_time_));
-      str += ", \"args\": {\"id\": \"" + std::to_string(rec.kid_) + "\"";
-      if (metrics_enabled_) {
-        // viewing the metrics on the same local host, no need to use https
-        str += ", \"metrics\": \"http://localhost:8000/" + EncodeURI(kname) + "/" + std::to_string(rec.kid_) + "/" + std::to_string(device_id) + "\"";
-      }
-      str += "}}";
-
-      if (!rec.implicit_scaling_) {
-        str += ",\n{";
-        str += "\"ph\": \"t\"";
-        str += ", \"tid\": " + std::to_string(tid);
-        str += ", \"pid\": " + std::to_string(pid);
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"Flow_H2D_" + std::to_string(rec.kid_) + "_" + std::to_string(mpi_rank) + "\"";
-        str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-        str += ", \"id\": " + std::to_string(rec.kid_);
-        str += "},\n";
-
-        str += "{";
-        str += "\"ph\": \"s\"";
-        str += ", \"tid\": " + std::to_string(tid);
-        str += ", \"pid\": " + std::to_string(pid);
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"Flow_D2H_" + std::to_string(rec.kid_) + "_" + std::to_string(mpi_rank) + "\"";
-        str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-        str += ", \"id\": " + std::to_string(rec.kid_);
-        str += "}";
-      }
-
-      return str;
-    }
-
-    std::string StringifyHostEvent(HostEventRecord& rec) {
-      std::string str = ",\n{";  // header
-
-      if (rec.type_ == EVENT_COMPLETE) {
-        str += "\"ph\": \"X\"";
-      } else if (rec.type_ == EVENT_DURATION_START) {
-        str += "\"ph\": \"B\"";
-      } else if (rec.type_ == EVENT_DURATION_END) {
-        str += "\"ph\": \"E\"";
-      } else if (rec.type_ == EVENT_FLOW_SOURCE) {
-        str += "\"ph\": \"s\"";
-      } else if (rec.type_ == EVENT_FLOW_SINK) {
-        str += "\"ph\": \"t\"";
-      } else if (rec.type_ == EVENT_MARK) {
-        str += "\"ph\": \"R\"";
-      } else {
-        // should never get here
-      }
-
-      str += ", \"tid\": " + std::to_string(tid_);
-      str += ", \"pid\": " + std::to_string(pid_);
-
-      if (rec.type_ == EVENT_FLOW_SOURCE) {
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"Flow_H2D_" + std::to_string(rec.id_) + "_" + std::to_string(mpi_rank) + "\"";
-      } else if (rec.type_ == EVENT_FLOW_SINK) {
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"Flow_D2H_" + std::to_string(rec.id_) + "_" + std::to_string(mpi_rank) + "\"";
-      } else {
-        if (rec.name_ != nullptr) {
-          str += JsonNameField(rec.name_);
-#if BUILD_WITH_OMP
-        } else if (rec.api_id_ == OmpTracingId) {
-          str += ", \"name\": \"" + std::string(GetOmptEventName(rec.id_)) + "\"";
-#endif /* BUILD_WITH_OMP */
-        } else {
-          if ((rec.api_id_ != XptiTracingId) && (rec.api_id_ != IttTracingId)) {
-            str += ", \"name\": \"" + get_symbol(rec.api_id_) + "\"";
-          }
-        }
-        str += ", \"cat\": \"cpu_op\"";
-      }
-
-      // free rec.name_. It is not needed any more
-      if (rec.name_ != nullptr) {
-        free(rec.name_);
-        rec.name_ = nullptr;
-      }
-
-      // It is always present
-      str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-
-      if (rec.type_ == EVENT_COMPLETE) {
-        str += ", \"dur\": " + std::to_string(UniTimer::GetTimeInUs(rec.end_time_ - rec.start_time_));
-      }
-
-      std::string str_args = "";  // build arguments
-      if (rec.api_type_ == API_TYPE_MPI) {
-        const MpiArgs& args = rec.mpi_args_;
-
-        bool isFirst = true;  // First argument can be zero and second non zero
-        if (args.src_size != 0) {
-          str_args += "\"ssize\": " + std::to_string(args.src_size);
-          if (args.is_tagged) {
-            str_args += ", \"src\": " + std::to_string(args.src_location);
-            str_args += ", \"stag\": " + std::to_string(args.src_tag);
-          }
-          isFirst = false;
-        }
-
-        if (args.dst_size != 0) {
-          str_args += (isFirst ? "" : ", ");
-          str_args += "\"dsize\": " + std::to_string(args.dst_size);
-          if (args.is_tagged) {
-            str_args += ", \"dst\": " + std::to_string(args.dst_location);
-            str_args += ", \"dtag\": " + std::to_string(args.dst_tag);
-          }
-        }
-
-        if (args.mpi_counter >= 0) {
-          str_args += ", \"mpi_counter\": " + std::to_string(args.mpi_counter);
-        }
-      } else if (rec.api_type_ == API_TYPE_ITT) {
-        str_args += JsonString(rec.itt_args_.key) + ":[";
-        str_args += ConvertDataToString(&rec.itt_args_);
-        str_args += "]";
-        if (rec.itt_args_.isIndirectData) {
-          free(rec.itt_args_.data[0]);
-        }
-        IttArgs* args = rec.itt_args_.next;
-        while (args != nullptr) {
-          str_args += ",";
-          str_args += JsonString(args->key) + ":[";
-          str_args += ConvertDataToString(args);
-          str_args += "]";
-          IttArgs* toFree = args;
-          args = args->next;
-          free(toFree);
-        }
-        // reset count to 0 and type to API_TYPE_NONE
-        rec.itt_args_.count = 0;
-        rec.api_type_ = API_TYPE_NONE;
-#if BUILD_WITH_OMP
-      } else if (rec.api_type_ == API_TYPE_OMP) {
-        OmpArgsToString(rec.omp_args_, str_args);
-#endif /* BUILD_WITH_OMP */
-      }
-
-      if (!str_args.empty()) {
-        str += ", \"args\": {" + str_args + "}";
-      } else {
-        str += ", \"id\": " + std::to_string(rec.id_);
-      }
-
-      // end
-      str += "}";  // footer
-
-      return str;
-    }
-
-#if BUILD_WITH_PERFETTO
-    // Emit a Level Zero device kernel command as a Perfetto slice. Resolves the
-    // ZE-specific pid/tid/kname (reusing the same track allocation as the JSON
-    // path) and defers the shared slice emit to PerfettoEmitDeviceSlice.
-    void PerfettoEmitDeviceEvent(ZeKernelCommandExecutionRecord& rec) {
-      auto& rdt = GetRecentDeviceTimestamps(rec.device_, rec.engine_ordinal_, rec.engine_index_);
-      uint32_t track = GetDeviceEventTrack(rdt, rec.start_time_, rec.end_time_);
-      auto [pid, tid, deviceid] = GetDevicePidTid(rec.device_, rec.engine_ordinal_, rec.engine_index_, pid_, rec.tid_, track);
-      std::string kname = GetZeKernelCommandName(rec.kernel_command_id_, rec.group_count_, rec.mem_size_);
-      // GetZeKernelCommandName may return a quoted string; unquote for the proto.
-      if (!kname.empty() && kname.front() == '"' && kname.back() == '"') {
-        kname = kname.substr(1, kname.size() - 2);
-      }
-      PerfettoEmitDeviceSlice(seq_id_, pid, tid, deviceid, kname, rec.kid_, rec.implicit_scaling_,
-                              rec.tile_, metrics_enabled_, rec.start_time_, rec.end_time_);
-    }
-#endif /* BUILD_WITH_PERFETTO */
-
-    void FlushDeviceEvent(ZeKernelCommandExecutionRecord& rec) {
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) { PerfettoEmitDeviceEvent(rec); return; }
-#endif /* BUILD_WITH_PERFETTO */
-      logger_->Log(StringifyDeviceEvent(rec));
-    }
-
-    void FlushDeviceBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (device_event_buffer_flushed_) {
-        return;
-      }
-
-      for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-        for (int j = 0; j < slice_capacity_; j++) {
-          FlushDeviceEvent(device_event_buffer_[i][j]);
-        }
-      }
-      for (int j = 0; j < next_device_event_index_; j++) {
-        FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-      }
-
-      current_device_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      device_event_buffer_flushed_ = true;
-    }
-
-    void FlushHostEvent(HostEventRecord& rec) {
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) { PerfettoEmitHostEvent(rec, pid_, tid_, seq_id_, pending_flows_, host_track_emitted_); return; }
-#endif /* BUILD_WITH_PERFETTO */
-      logger_->Log(StringifyHostEvent(rec));
-    }
-
-    void FlushHostBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (host_event_buffer_flushed_) {
-        return;
-      }
-
-      for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-        for (int j = 0; j < slice_capacity_; j++) {
-          FlushHostEvent(host_event_buffer_[i][j]);
-        }
-      }
-      for (int j = 0; j < next_host_event_index_; j++) {
-        FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-      }
-      current_host_event_buffer_slice_ = 0;
-      next_host_event_index_ = 0;
-      host_event_buffer_flushed_ = true;
-    }
-
-    void Finalize() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (!finalized_.exchange(true)) {
-        if (!device_event_buffer_flushed_) {
-          for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushDeviceEvent(device_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_device_event_index_; j++) {
-            FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-          }
-          device_event_buffer_flushed_ = true;
-        }
-        if (!host_event_buffer_flushed_) {
-          for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushHostEvent(host_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_host_event_index_; j++) {
-            FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-          }
-          host_event_buffer_flushed_ = true;
-        }
-      }
-    }
-
-#ifndef _WIN32
-    // Fork child: drop the copied (parent-owned) pending events, retag with the
-    // child's pid and restart the per-file Perfetto state.
-    void ResetAfterFork() {
-      current_device_event_buffer_slice_ = 0;
-      current_host_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      next_host_event_index_ = 0;
-      device_event_buffer_flushed_ = true;
-      host_event_buffer_flushed_ = true;
-      pid_ = utils::GetPid();
-      tid_ = utils::GetTid();  // the forking thread is the child's main thread
-#if BUILD_WITH_PERFETTO
-      pending_flows_ = PendingFlows();
-      host_track_emitted_ = false;
-#endif /* BUILD_WITH_PERFETTO */
-    }
-#endif /* _WIN32 */
-
-    bool IsFinalized() {
-      return finalized_.load(std::memory_order_acquire);
-    }
-
-  private:
-    int32_t buffer_capacity_;
-    int32_t slice_capacity_;  // each buffer can have multiple slices
-    int32_t current_device_event_buffer_slice_;  // device slice in use
-    int32_t current_host_event_buffer_slice_;  // host slice in use
-    int32_t next_device_event_index_;  // next free device event in in-use slice
-    int32_t next_host_event_index_;  // next free host event in in-use slice
-    uint32_t tid_;
-    uint32_t pid_;
-#if BUILD_WITH_PERFETTO
-    uint32_t seq_id_;  // Perfetto packet sequence id for this writer thread
-    // Flow ids from FLOW_SOURCE/SINK records awaiting the next real host slice.
-    PendingFlows pending_flows_;
-    // Whether this buffer's host thread TrackDescriptor has been emitted (it is
-    // emitted once on the first host event; the uuid is constant per buffer).
-    bool host_track_emitted_ = false;
-#endif /* BUILD_WITH_PERFETTO */
-    std::vector<ZeKernelCommandExecutionRecord *> device_event_buffer_;
-    std::vector<HostEventRecord *> host_event_buffer_;
-    // device event timestampes cached are <device, engine_ordinal, engine_index> specific
-    std::map<std::tuple<ze_device_handle_t, uint32_t, uint32_t>, std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>> recent_device_timestamps_;
-    bool flush_immediately_;
-    bool host_event_buffer_flushed_;
-    bool device_event_buffer_flushed_;
-    std::atomic<bool> finalized_;
-    bool metrics_enabled_;
-};
-
-thread_local TraceBuffer thread_local_buffer_;
-
-#if BUILD_WITH_OPENCL
-class ClTraceBuffer;
-std::set<ClTraceBuffer *> *cl_trace_buffers_ = nullptr;
-class ClTraceBuffer {
-  public:
-    ClTraceBuffer() : flush_immediately_(false) {
-      std::string szstr = utils::GetEnv("UNITRACE_ChromeEventBufferSize");
-      // unitrace rejects an invalid size; unbounded if the variable was set by hand.
-      ParseChromeEventBufferSize(szstr, buffer_capacity_);
-      if (buffer_capacity_ == -1) {
-        slice_capacity_ = BUFFER_SLICE_SIZE_DEFAULT;
-      } else {
-        if (buffer_capacity_ == 0) {
-          buffer_capacity_ = 1;  // at least one event slot
-          flush_immediately_ = true;
-        }
-        slice_capacity_ = buffer_capacity_;
-      }
-      ClKernelCommandExecutionRecord *der = (ClKernelCommandExecutionRecord *)(malloc(sizeof(ClKernelCommandExecutionRecord) * slice_capacity_));
-      UniMemory::ExitIfOutOfMemory((void *)(der));
-
-      device_event_buffer_.push_back(der);
-
-      HostEventRecord *her = (HostEventRecord *)(malloc(sizeof(HostEventRecord) * slice_capacity_));
-      UniMemory::ExitIfOutOfMemory((void *)(her));
-
-      host_event_buffer_.push_back(her);
-      tid_= utils::GetTid();
-      pid_= utils::GetPid();
-#if BUILD_WITH_PERFETTO
-      // One packet sequence per writer thread; slices on the same track from the
-      // same sequence stack correctly. Per-rank files are already separate.
-      seq_id_ = perfetto_emit::NextSequenceId();
-#endif /* BUILD_WITH_PERFETTO */
-
-      current_device_event_buffer_slice_ = 0;
-      current_host_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      next_host_event_index_ = 0;
-      device_event_buffer_flushed_ = false;
-      host_event_buffer_flushed_ = false;
-      finalized_.store(false, std::memory_order_release);
-      if ((utils::GetEnv("UNITRACE_MetricQuery") == "1") || (utils::GetEnv("UNITRACE_KernelMetrics") == "1")) {
-        metrics_enabled_ = true;
-      } else {
-        metrics_enabled_ = false;
-      }
-
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);  // use this lock to protect trace_buffers_
-
-      if (cl_trace_buffers_ == nullptr) {
-        cl_trace_buffers_ = new std::set<ClTraceBuffer *>;
-        UniMemory::ExitIfOutOfMemory((void *)(cl_trace_buffers_));
-      }
-      cl_trace_buffers_->insert(this);
-    }
-
-    ~ClTraceBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (!finalized_.exchange(true)) {
-        // finalize if not finalized
-        if (!device_event_buffer_flushed_) {
-          for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushDeviceEvent(device_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_device_event_index_; j++) {
-            FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-          }
-          device_event_buffer_flushed_ = true;
-        }
-        if (!host_event_buffer_flushed_) {
-          for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushHostEvent(host_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_host_event_index_; j++) {
-            FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-          }
-          host_event_buffer_flushed_ = true;
-        }
-
-        for (auto& slice : device_event_buffer_) {
-          free(slice);
-        }
-        device_event_buffer_.clear();
-
-        for (auto& slice : host_event_buffer_) {
-          free(slice);
-        }
-        host_event_buffer_.clear();
-
-        cl_trace_buffers_->erase(this);
-      }
-    }
-
-    ClTraceBuffer(const ClTraceBuffer& that) = delete;
-    ClTraceBuffer& operator=(const ClTraceBuffer& that) = delete;
-
-    // device event timestampes cached are <device, queue> specific
-    std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>&
-    GetRecentDeviceTimestamps(cl_device_id device, cl_command_queue queue) {
-      auto it = recent_device_timestamps_.find({device, queue});
-      if (it == recent_device_timestamps_.end()) {
-        auto rdt = std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>();
-        rdt.push_back(std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>());
-        auto& ts = rdt[0];
-        // populate the recent device timestamps with dummies
-        for (int i = 0; i < num_device_timestamps_cahced_; i++) {
-          ts.insert({0, i});
-        }
-        recent_device_timestamps_.insert({{device, queue}, std::move(rdt)});
-
-        it = recent_device_timestamps_.find({device, queue});
-      }
-
-      return it->second;
-    }
-
-    ClKernelCommandExecutionRecord *GetDeviceEvent(void) {
-      if (next_device_event_index_ ==  slice_capacity_) {
-        if (buffer_capacity_ == -1) {
-          ClKernelCommandExecutionRecord *der = (ClKernelCommandExecutionRecord *)(malloc(sizeof(ClKernelCommandExecutionRecord) * slice_capacity_));
-          UniMemory::ExitIfOutOfMemory((void *)(der));
-
-          device_event_buffer_.push_back(der);
-          current_device_event_buffer_slice_++;
-          next_device_event_index_ = 0;
-        } else {
-          FlushDeviceBuffer();
-        }
-      }
-      return &(device_event_buffer_[current_device_event_buffer_slice_][next_device_event_index_]);
-    }
-
-    HostEventRecord *GetHostEvent(void) {
-      if (next_host_event_index_ ==  slice_capacity_) {
-        if (buffer_capacity_ == -1) {
-          HostEventRecord *her = (HostEventRecord *)(malloc(sizeof(HostEventRecord) * slice_capacity_));
-          UniMemory::ExitIfOutOfMemory((void *)(her));
-
-          host_event_buffer_.push_back(her);
-          current_host_event_buffer_slice_++;
-          next_host_event_index_ = 0;
-        } else {
-          FlushHostBuffer();
-        }
-      }
-      return &(host_event_buffer_[current_host_event_buffer_slice_][next_host_event_index_]);
-    }
-
-    void BufferHostEvent(void) {
-      if (flush_immediately_) {
-        std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-        FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][next_host_event_index_]);
-        // in case that flush_immediately_ is true, only one slice and one event slot, so set the flushed flag to true
-        host_event_buffer_flushed_ = true;
-      }
-      else {
-        next_host_event_index_++;
-        host_event_buffer_flushed_ = false;
-      }
-    }
-
-    void BufferDeviceEvent(void) {
-      if (flush_immediately_) {
-        std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-        FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][next_device_event_index_]);
-        // in case that flush_immediately_ is true, only one slice and one event slot, so set the flushed flag to true
-        device_event_buffer_flushed_ = true;
-      }
-      else {
-        next_device_event_index_++;
-        device_event_buffer_flushed_ = false;
-      }
-    }
-
-    uint32_t GetTid() { return tid_; }
-    uint32_t GetPid() { return pid_; }
-
-    std::string StringifyDeviceEvent(ClKernelCommandExecutionRecord& rec) {
-      auto& rdt = GetRecentDeviceTimestamps(rec.device_, rec.queue_);
-      uint32_t track = GetDeviceEventTrack(rdt, rec.start_time_, rec.end_time_);
-      auto [pid, tid, device_id] = ClGetDevicePidTid(rec.pci_, rec.device_, rec.queue_, pid_, rec.tid_, track);
-      std::string kname = GetClKernelCommandName(rec.kernel_command_id_);
-
-      std::string str = ",\n{";
-
-      str += "\"ph\": \"X\"";
-      str += ", \"tid\": " + std::to_string(tid);
-      str += ", \"pid\": " + std::to_string(pid);
-
-      if (rec.implicit_scaling_) {
-        str += JsonNameField(kname, "Tile #" + std::to_string(rec.tile_) + ": ");
-      } else {
-        if (!kname.empty()) {
-          str += JsonNameField(kname);
-        }
-      }
-
-      str += ", \"cat\": \"gpu_op\"";
-      str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-      str += ", \"dur\": " + std::to_string(UniTimer::GetTimeInUs(rec.end_time_ - rec.start_time_));
-      str += ", \"args\": {\"id\": \"" + std::to_string(rec.kid_) + "\"";
-      if (metrics_enabled_) {
-        // viewing the metrics on the same local host, so no need to use https
-        str += ", \"metrics\": \"http://localhost:8000/" + EncodeURI(kname) + "/" + std::to_string(rec.kid_) +
-               (device_id != UINT32_MAX ? "/" + std::to_string(device_id) : "") +
-               "\"";
-      }
-      str += "}}";
-
-      if (!rec.implicit_scaling_) {
-        str += ",\n{";
-        str += "\"ph\": \"t\"";
-        str += ", \"tid\": " + std::to_string(tid);
-        str += ", \"pid\": " + std::to_string(pid);
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"CL_Flow_H2D_" + std::to_string(rec.kid_) + "_" + std::to_string(mpi_rank) + "\"";
-        str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-        str += ", \"id\": " + std::to_string(rec.kid_);
-        str += "},\n";
-
-        str += "{";
-        str += "\"ph\": \"s\"";
-        str += ", \"tid\": " + std::to_string(tid);
-        str += ", \"pid\": " + std::to_string(pid);
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"CL_Flow_D2H_" + std::to_string(rec.kid_) + "_" + std::to_string(mpi_rank) + "\"";
-        str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-        str += ", \"id\": " + std::to_string(rec.kid_);
-        str += "}";
-      }
-
-      return str;
-    }
-
-#if BUILD_WITH_PERFETTO
-    // Emit an OpenCL device kernel command as a Perfetto slice. Mirrors the L0
-    // emitter: resolves the CL-specific pid/tid/kname and defers to the shared
-    // PerfettoEmitDeviceSlice.
-    void PerfettoEmitDeviceEvent(ClKernelCommandExecutionRecord& rec) {
-      auto& rdt = GetRecentDeviceTimestamps(rec.device_, rec.queue_);
-      uint32_t track = GetDeviceEventTrack(rdt, rec.start_time_, rec.end_time_);
-      auto [pid, tid, device_id] = ClGetDevicePidTid(rec.pci_, rec.device_, rec.queue_, pid_, rec.tid_, track);
-      std::string kname = GetClKernelCommandName(rec.kernel_command_id_);
-      if (!kname.empty() && kname.front() == '"' && kname.back() == '"') {
-        kname = kname.substr(1, kname.size() - 2);
-      }
-      PerfettoEmitDeviceSlice(seq_id_, pid, tid, device_id, kname, rec.kid_, rec.implicit_scaling_,
-                              rec.tile_, metrics_enabled_, rec.start_time_, rec.end_time_);
-    }
-#endif /* BUILD_WITH_PERFETTO */
-
-    void FlushDeviceEvent(ClKernelCommandExecutionRecord& rec) {
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) { PerfettoEmitDeviceEvent(rec); return; }
-#endif /* BUILD_WITH_PERFETTO */
-      logger_->Log(StringifyDeviceEvent(rec));
-    }
-
-    void FlushDeviceBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (device_event_buffer_flushed_) {
-        return;
-      }
-
-      for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-        for (int j = 0; j < slice_capacity_; j++) {
-          FlushDeviceEvent(device_event_buffer_[i][j]);
-        }
-      }
-      for (int j = 0; j < next_device_event_index_; j++) {
-        FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-      }
-
-      current_device_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      device_event_buffer_flushed_ = true;
-    }
-
-    std::string StringifyHostEvent(HostEventRecord& rec) {
-      std::string str = ",\n{";  // header
-
-      if (rec.type_ == EVENT_COMPLETE) {
-        str += "\"ph\": \"X\"";
-      } else if (rec.type_ == EVENT_DURATION_START) {
-        str += "\"ph\": \"B\"";
-      } else if (rec.type_ == EVENT_DURATION_END) {
-        str += "\"ph\": \"E\"";
-      } else if (rec.type_ == EVENT_FLOW_SOURCE) {
-        str += "\"ph\": \"s\"";
-      } else if (rec.type_ == EVENT_FLOW_SINK) {
-        str += "\"ph\": \"t\"";
-      } else if (rec.type_ == EVENT_MARK) {
-        str += "\"ph\": \"R\"";
-      } else {
-        // should never get here
-      }
-
-      str += ", \"tid\": " + std::to_string(tid_);
-      str += ", \"pid\": " + std::to_string(pid_);
-
-      if (rec.type_ == EVENT_FLOW_SOURCE) {
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"CL_Flow_H2D_" + std::to_string(rec.id_) + "_" + std::to_string(mpi_rank) + "\"";
-      } else if (rec.type_ == EVENT_FLOW_SINK) {
-        str += ", \"name\": \"dep\"";
-        str += ", \"cat\": \"CL_Flow_D2H_" + std::to_string(rec.id_) + "_" + std::to_string(mpi_rank) + "\"";
-      } else {
-        if (rec.name_ != nullptr) {
-          str += JsonNameField(rec.name_);
-        } else {
-          if ((rec.api_id_ != XptiTracingId) && (rec.api_id_ != IttTracingId)) {
-            str += ", \"name\": \"" + get_symbol(rec.api_id_) + "\"";
-          }
-        }
-        str += ", \"cat\": \"cpu_op\"";
-      }
-
-      // free rec.name_. It is not needed any more
-      if (rec.name_ != nullptr) {
-        free(rec.name_);
-        rec.name_ = nullptr;
-      }
-
-      // It is always present
-      str += ", \"ts\": " + std::to_string(UniTimer::GetEpochTimeInUs(rec.start_time_));
-
-      if (rec.type_ == EVENT_COMPLETE) {
-        str += ", \"dur\": " + std::to_string(UniTimer::GetTimeInUs(rec.end_time_ - rec.start_time_));
-      }
-
-      std::string str_args = "";  // build arguments
-      if (rec.api_type_ == API_TYPE_MPI) {
-        const MpiArgs& args = rec.mpi_args_;
-
-        bool isFirst = true;  // First argument can be zero and second non zero
-
-        if (args.src_size != 0) {
-          str_args += "\"ssize\": " + std::to_string(args.src_size);
-          if (args.is_tagged) {
-            str_args += ", \"src\": " + std::to_string(args.src_location);
-            str_args += ", \"stag\": " + std::to_string(args.src_tag);
-          }
-          isFirst = false;
-        }
-
-        if (args.dst_size != 0) {
-          str_args += (isFirst ? "" : ", ");
-          str_args += "\"dsize\": " + std::to_string(args.dst_size);
-          if (args.is_tagged) {
-            str_args += ", \"dst\": " + std::to_string(args.dst_location);
-            str_args += ", \"dtag\": " + std::to_string(args.dst_tag);
-          }
-        }
-
-        if (args.mpi_counter >= 0) {
-          str_args += ", \"mpi_counter\": " + std::to_string(args.mpi_counter);
-        }
-
-      } else if (rec.api_type_ == API_TYPE_ITT) {
-        str_args += JsonString(rec.itt_args_.key) + ":[";
-        str_args += ConvertDataToString(&rec.itt_args_);
-        str_args += "]";
-        if (rec.itt_args_.isIndirectData) {
-          free(rec.itt_args_.data[0]);
-        }
-        IttArgs* args = rec.itt_args_.next;
-        while (args != nullptr) {
-          str_args += ",";
-          str_args += JsonString(args->key) + ":[";
-          str_args += ConvertDataToString(args);
-          str_args += "]";
-          IttArgs* toFree = args;
-          args = args->next;
-          free(toFree);
-        }
-        // reset count to 0 and type to API_TYPE_NONE
-        rec.itt_args_.count = 0;
-        rec.api_type_ = API_TYPE_NONE;
-      }
-
-      if (!str_args.empty()) {
-        str += ", \"args\": {" + str_args + "}";
-      } else {
-        str += ", \"id\": " + std::to_string(rec.id_);
-      }
-
-      // end
-      str += "}";  // footer
-
-      return str;
-    }
-
-    void FlushHostEvent(HostEventRecord& rec) {
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) { PerfettoEmitHostEvent(rec, pid_, tid_, seq_id_, pending_flows_, host_track_emitted_); return; }
-#endif /* BUILD_WITH_PERFETTO */
-      logger_->Log(StringifyHostEvent(rec));
-    }
-
-    void FlushHostBuffer() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (host_event_buffer_flushed_) {
-        return;
-      }
-
-      for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-        for (int j = 0; j < slice_capacity_; j++) {
-          FlushHostEvent(host_event_buffer_[i][j]);
-        }
-      }
-      for (int j = 0; j < next_host_event_index_; j++) {
-        FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-      }
-      current_host_event_buffer_slice_ = 0;
-      next_host_event_index_ = 0;
-      host_event_buffer_flushed_ = true;
-    }
-
-    void Finalize() {
-      std::lock_guard<std::recursive_mutex> lock(logger_lock_);
-      if (!finalized_.exchange(true)) {
-        if (!device_event_buffer_flushed_) {
-          for (int i = 0; i < current_device_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushDeviceEvent(device_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_device_event_index_; j++) {
-            FlushDeviceEvent(device_event_buffer_[current_device_event_buffer_slice_][j]);
-          }
-          device_event_buffer_flushed_ = true;
-        }
-        if (!host_event_buffer_flushed_) {
-          for (int i = 0; i < current_host_event_buffer_slice_; i++) {
-            for (int j = 0; j < slice_capacity_; j++) {
-              FlushHostEvent(host_event_buffer_[i][j]);
-            }
-          }
-          for (int j = 0; j < next_host_event_index_; j++) {
-            FlushHostEvent(host_event_buffer_[current_host_event_buffer_slice_][j]);
-          }
-          host_event_buffer_flushed_ = true;
-        }
-      }
-    }
-
-#ifndef _WIN32
-    // Fork child: drop the copied (parent-owned) pending events, retag with the
-    // child's pid and restart the per-file Perfetto state.
-    void ResetAfterFork() {
-      current_device_event_buffer_slice_ = 0;
-      current_host_event_buffer_slice_ = 0;
-      next_device_event_index_ = 0;
-      next_host_event_index_ = 0;
-      device_event_buffer_flushed_ = true;
-      host_event_buffer_flushed_ = true;
-      pid_ = utils::GetPid();
-      tid_ = utils::GetTid();  // the forking thread is the child's main thread
-#if BUILD_WITH_PERFETTO
-      pending_flows_ = PendingFlows();
-      host_track_emitted_ = false;
-#endif /* BUILD_WITH_PERFETTO */
-    }
-#endif /* _WIN32 */
-
-    bool IsFinalized() {
-      return finalized_.load(std::memory_order_acquire);
-    }
-
-  private:
-    int32_t buffer_capacity_;
-    int32_t slice_capacity_;  // each buffer can have multiple slices
-    int32_t current_device_event_buffer_slice_;  // device slice in use
-    int32_t current_host_event_buffer_slice_;  // host slice in use
-    int32_t next_device_event_index_;  // next free device event in in-use slice
-    int32_t next_host_event_index_;  // next free host event in in-use slice
-    uint32_t tid_;
-    uint32_t pid_;
-#if BUILD_WITH_PERFETTO
-    uint32_t seq_id_;  // Perfetto packet sequence id for this writer thread
-    // Flow ids from FLOW_SOURCE/SINK records awaiting the next real host slice.
-    PendingFlows pending_flows_;
-    // Whether this buffer's host thread TrackDescriptor has been emitted (it is
-    // emitted once on the first host event; the uuid is constant per buffer).
-    bool host_track_emitted_ = false;
-#endif /* BUILD_WITH_PERFETTO */
-    std::vector<ClKernelCommandExecutionRecord *> device_event_buffer_;
-    std::vector<HostEventRecord *> host_event_buffer_;
-    // device event timestampes cached are <device, queue> specific
-    std::map<std::tuple<cl_device_id, cl_command_queue>, std::vector<std::set<std::pair<uint64_t, uint64_t>, DeviceTimestampComparator>>> recent_device_timestamps_;
-    bool flush_immediately_;
-    bool host_event_buffer_flushed_;
-    bool device_event_buffer_flushed_;
-    std::atomic<bool> finalized_;
-    bool metrics_enabled_;
-};
-
-thread_local ClTraceBuffer cl_thread_local_buffer_;
-#endif /* BUILD_WITH_OPENCL */
-
-class ChromeLogger {
-  private:
-    LoggerFactory* logger_factory_;
-    std::string process_name_;
-    double process_start_time_;
-    bool flushed_ = false;  // true once Flush() has drained buffers and written the JSON close
-    bool closed_ = false;   // true once Close() has finalized buffers and released the trace file
-
-    ChromeLogger(const char* process_name)
-      : logger_factory_(LoggerFactory::Create())
-    {
-      process_name_ = process_name;
-
-      std::string rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-      mpi_rank = INIT_MPI_RANK_VAL(rank);
-
-#if !BUILD_WITH_PERFETTO
-      if (utils::GetEnv("UNITRACE_OutputFormat") == "protobuf") {
-        std::cerr << "[WARNING] --output-format=protobuf requested, but unitrace was built "
-                     "without Perfetto support (BUILD_WITH_PERFETTO=OFF). Falling back to JSON." << std::endl;
-      }
-#endif /* !BUILD_WITH_PERFETTO */
-
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) {
-        // Protobuf is opened in binary mode (4th GetLogger arg = binary).
-        logger_ = logger_factory_->GetLogger(LOGGER_TYPE_CHROME_TRACE_UNITRACE, true, true, /*binary=*/true);
-        if (!logger_) {
-          UniMemory::ExitIfOutOfMemory((void *)(logger_.get()));
-        }
-        perfetto_emit::EmitLogger() = logger_;
-
-        // Clock domain: REALTIME (epoch ns) by default -- globally meaningful
-        // across hosts, enabling cross-rank Timeline Sync. Under
-        // UNITRACE_SystemTime=1, GetEpochTime returns raw monotonic ns instead, so
-        // resolve to MONOTONIC_RAW in that mode.
-        perfetto_emit::ClockId() = (utils::GetEnv("UNITRACE_SystemTime") == "1")
-                                       ? perfetto_emit::kClockMonotonicRaw
-                                       : perfetto_emit::kClockRealtime;
-        WriteFileHeader();
-        return;
-      }
-#endif /* BUILD_WITH_PERFETTO */
-      logger_ = logger_factory_->GetLogger(LOGGER_TYPE_CHROME_TRACE_UNITRACE, true, true);
-      if (!logger_) {
-        UniMemory::ExitIfOutOfMemory((void *)(logger_.get()));
-      }
-      WriteFileHeader();
-    }
-
-    // Per-file preamble (JSON envelope or Perfetto clock snapshot + process
-    // track), ending with the empty-file mark. Called at construction and again
-    // for a forked child's new file.
-    void WriteFileHeader() {
-      std::string host = GetHostName();
-      std::string rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-      std::string host_proc_name = rank.empty() ? ("HOST<" + host + ">")
-                                                : ("RANK " + rank + " HOST<" + host + ">");
-
-#if BUILD_WITH_PERFETTO
-      if (UseProtobufOutput()) {
-        // Sample BOOTTIME and the event clock back-to-back so the ClockSnapshot
-        // relates them accurately (needed for the trace processor's clock sync).
-        uint64_t boot_ns = UniTimer::GetHostBootTimestamp();
-        uint64_t now_ns = UniTimer::GetEpochTime(UniTimer::GetHostTimestamp());
-        perfetto_emit::EmitClockSnapshot(now_ns, boot_ns, perfetto_emit::DescriptorSeqId());
-        // Emitted once per file, so direct emit -- no dedup needed.
-        perfetto_emit::EmitProcessTrack(HostProcessTrackUuid(utils::GetPid()),
-                                        utils::GetPid(), host_proc_name, now_ns,
-                                        perfetto_emit::DescriptorSeqId());
-        // After the clock snapshot so "no events -> delete file" still holds.
-        logger_->SetEmptyPosition();
-        return;
-      }
-#endif /* BUILD_WITH_PERFETTO */
-
-      process_start_time_ = UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestamp());
-
-      logger_->Log("{ \"traceEvents\":[\n");
-
-      std::string str("{\"ph\": \"M\", \"name\": \"process_name\", \"pid\": ");
-      str += std::to_string(utils::GetPid()) + ", \"ts\": " + std::to_string(process_start_time_) + ", \"args\": {\"name\": \"";
-      str += host_proc_name + "\"}}";
-
-      logger_->Log(str);
-      logger_->SetEmptyPosition();
-    }
-
-  public:
-    ChromeLogger(const ChromeLogger& that) = delete;
-    ChromeLogger& operator=(const ChromeLogger& that) = delete;
-
-#ifndef _WIN32
-    // Fork child: logger_ already points at the child's file (factory reopened
-    // it). Drop buffers of threads that do not exist here, reset the forking
-    // thread's buffer, re-arm the flush latch and write a fresh header.
-    // Locks were re-created by ChromeLoggerUnlockAfterForkChild() beforehand.
-    void ReopenAfterFork() {
-      if (logger_ == nullptr || closed_) {
-        return;  // session already stopped before the fork: nothing to write
-      }
-      if (trace_buffers_) {
-        TraceBuffer* mine = &thread_local_buffer_;
-        for (auto it = trace_buffers_->begin(); it != trace_buffers_->end();) {
-          it = (*it == mine) ? std::next(it) : trace_buffers_->erase(it);
-        }
-        mine->ResetAfterFork();
-      }
-#if BUILD_WITH_OPENCL
-      if (cl_trace_buffers_) {
-        ClTraceBuffer* mine = &cl_thread_local_buffer_;
-        for (auto it = cl_trace_buffers_->begin(); it != cl_trace_buffers_->end();) {
-          it = (*it == mine) ? std::next(it) : cl_trace_buffers_->erase(it);
-        }
-        mine->ResetAfterFork();
-      }
-#endif /* BUILD_WITH_OPENCL */
-      flushed_ = false;
-      WriteFileHeader();
-    }
-#endif /* _WIN32 */
-
-    ~ChromeLogger() {
-      // Close() is idempotent: if the session was stopped it has already
-      // finalized the buffers, closed the file and printed the message, so this
-      // becomes a no-op.
-      Close();
-    }
-
-    // Finalize all buffers, write the JSON close, release the trace file and
-    // print where the timeline is stored, so a stopped session's result is
-    // complete on disk immediately. Idempotent (early stop and destructor).
-    void Close() {
-      logger_lock_.lock();
-      if (closed_ || logger_ == nullptr) {
-        logger_lock_.unlock();
-        return;
-      }
-      closed_ = true;
-      logger_lock_.unlock();
-
-      // Make sure any data that was buffered after the last Flush() (or if Flush() was never
-      // called at all) reaches disk and the JSON is properly closed.
-      Flush();
-
-      std::string chrome_trace_file_name_ = logger_->GetLogFileName();
-      logger_lock_.lock();
-      if (trace_buffers_) {
-        for (auto it = trace_buffers_->begin(); it != trace_buffers_->end();) {
-          (*it)->Finalize();
-          it = trace_buffers_->erase(it);
-        }
-      }
-
-#if BUILD_WITH_OPENCL
-      if (cl_trace_buffers_) {
-        for (auto it = cl_trace_buffers_->begin(); it != cl_trace_buffers_->end();) {
-          (*it)->Finalize();
-          it = cl_trace_buffers_->erase(it);
-        }
-      }
-#endif /* BUILD_WITH_OPENCL */
-
-      const bool empty = logger_->IsEmpty();
-      // Release the file so its data is durable and the handle is free even
-      // though the profiled process keeps running after a stop.
-      logger_->Close();
-      logger_lock_.unlock();
-
-      if (empty) {
-        // no data has been logged
-        std::cerr << "[INFO] No event of interest is logged for process " << utils::GetPid() << " (" << process_name_ << ")" << std::endl;
-      } else {
-        std::cerr << "[INFO] Timeline is stored in " << chrome_trace_file_name_ << std::endl;
-      }
-    }
-
-    static ChromeLogger* Create(const char* process_name) {
-      ChromeLogger *chrome_logger  = new ChromeLogger(process_name);
-      UniMemory::ExitIfOutOfMemory((void *)(chrome_logger));
-      return chrome_logger;
-    }
-
-    void Flush() {
-      if (logger_ == nullptr) {
-        return;
-      }
-      logger_lock_.lock();
-      if (!flushed_) {
-        if (trace_buffers_) {
-          for (auto it = trace_buffers_->begin(); it != trace_buffers_->end(); ++it) {
-            (*it)->FlushDeviceBuffer();
-            (*it)->FlushHostBuffer();
-          }
-        }
-
-#if BUILD_WITH_OPENCL
-        if (cl_trace_buffers_) {
-          for (auto it = cl_trace_buffers_->begin(); it != cl_trace_buffers_->end(); ++it) {
-            (*it)->FlushDeviceBuffer();
-            (*it)->FlushHostBuffer();
-          }
-        }
-#endif /* BUILD_WITH_OPENCL */
-
-        // Write closing brackets so the JSON is valid if the process terminates
-        // abnormally. The protobuf stream is binary and self-terminating, so the
-        // tags would corrupt it -- the closing tags are JSON-only.
-        if (!UseProtobufOutput() && !logger_->IsEmpty()) {
-          logger_->Log("\n]\n}\n");
-        }
-        // Push buffered bytes to disk for BOTH formats so a stopped session's
-        // trace is durable now; protobuf packets would otherwise be stranded
-        // in the ofstream buffer and lost if the process is killed later.
-        if (!logger_->IsEmpty()) {
-          logger_->Flush();
-        }
-        flushed_ = true;
-      }
-      logger_lock_.unlock();
-    }
-
-    static void XptiLoggingCallback(EVENT_TYPE etype, const char *name, uint64_t start_ts, uint64_t end_ts) {
-      if (!thread_local_buffer_.IsFinalized()) {
-        HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-        rec->type_ = etype;
-
-        if (name != nullptr) {
-          rec->name_ = strdup(name);
-        } else {
-          rec->name_ = nullptr;
-        }
-
-        rec->api_type_ = API_TYPE_NONE;
-        rec->api_id_ = XptiTracingId;
-        rec->start_time_ = start_ts;
-        if (etype == EVENT_COMPLETE) {
-          rec->end_time_ = end_ts;
-        }
-        rec->id_ = 0;
-        thread_local_buffer_.BufferHostEvent();
-      }
-    }
-
-#if BUILD_WITH_OMP
-    static void OmptLoggingCallback(uint64_t event_id, uint64_t start_ts,
-                                    uint64_t end_ts, EVENT_TYPE etype,
-                                    OmpArgs *omp_args) {
-      if (thread_local_buffer_.IsFinalized())
-        return;
-
-      HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-      rec->name_ = nullptr;
-      rec->type_ = etype;
-      rec->api_id_ = OmpTracingId;
-      rec->start_time_ = start_ts;
-      rec->end_time_ = end_ts;
-      rec->id_ = event_id;
-      if (omp_args) {
-        rec->api_type_ = API_TYPE_OMP;
-        rec->omp_args_ = *omp_args;
-      } else {
-        rec->api_type_ = API_TYPE_NONE;
-      }
-
-      thread_local_buffer_.BufferHostEvent();
-    }
-#endif /* BUILD_WITH_OMP */
-
-    static void IttLoggingCallback(const char *name, uint64_t start_ts, uint64_t end_ts, IttArgs* metadata_args) {
-      if (!thread_local_buffer_.IsFinalized()) {
-        HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-
-        rec->type_ = EVENT_COMPLETE;
-
-        if (name != nullptr) {
-          rec->name_ = strdup(name);
-        } else {
-          rec->name_ = nullptr;
-        }
-
-        rec->api_id_ = IttTracingId;
-        rec->start_time_ = start_ts;
-        rec->end_time_ = end_ts;
-        rec->id_ = 0;
-        if ((metadata_args != nullptr) && (metadata_args->count != 0)) {
-          rec->api_type_ = API_TYPE_ITT;
-          rec->itt_args_ = *metadata_args;
-        } else {
-          // no arguments so set api_type_ to API_TYPE_NONE
-          rec->api_type_ = API_TYPE_NONE;
-          rec->itt_args_.count = 0;
-        }
-
-        thread_local_buffer_.BufferHostEvent();
-      }
-    }
-
-    static void MpiLoggingCallback(const char *name, uint64_t start_ts, uint64_t end_ts, size_t src_size, int src_location, int src_tag,
-                                   size_t dst_size, int dst_location, int dst_tag) {
-      if (!thread_local_buffer_.IsFinalized()) {
-        HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-        rec->type_ = EVENT_COMPLETE;
-
-        if (name != nullptr) {
-          rec->name_ = strdup(name);
-        } else {
-          rec->name_ = nullptr;
-        }
-
-        rec->api_id_ = IttTracingId;
-        rec->start_time_ = start_ts;
-        rec->end_time_ = end_ts;
-        rec->id_ = 0;
-        rec->api_type_ = API_TYPE_MPI;
-        rec->mpi_args_.src_size = src_size;
-        rec->mpi_args_.src_location = src_location;
-        rec->mpi_args_.src_tag = src_tag;
-        rec->mpi_args_.dst_size = dst_size;
-        rec->mpi_args_.dst_location = dst_location;
-        rec->mpi_args_.dst_tag = dst_tag;
-        rec->mpi_args_.mpi_counter = -1;
-        rec->mpi_args_.is_tagged = true;
-
-        thread_local_buffer_.BufferHostEvent();
-      }
-    }
-
-    static void MpiInternalLoggingCallback(const char *name, uint64_t start_ts, uint64_t end_ts, int64_t mpi_counter, size_t src_size, size_t dst_size) {
-      if (!thread_local_buffer_.IsFinalized()) {
-        HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-        rec->type_ = EVENT_COMPLETE;
-
-        if (name != nullptr) {
-          rec->name_ = strdup(name);
-        } else {
-          rec->name_ = nullptr;
-        }
-
-        rec->api_id_ = IttTracingId;
-        rec->start_time_ = start_ts;
-        rec->end_time_ = end_ts;
-        rec->id_ = 0;
-        rec->api_type_ = API_TYPE_MPI;
-        rec->mpi_args_.mpi_counter = mpi_counter;
-        rec->mpi_args_.src_size = src_size;
-        rec->mpi_args_.dst_size = dst_size;
-        rec->mpi_args_.is_tagged = false;
-
-        thread_local_buffer_.BufferHostEvent();
-      }
-    }
-
-    static void ZeChromeKernelLoggingCallback(uint64_t kid, uint64_t tid, uint64_t start, uint64_t end, uint32_t ordinal, uint32_t index, int32_t tile, const ze_device_handle_t device, const uint64_t kernel_command_id, bool implicit_scaling, const ze_group_count_t &group_count, size_t mem_size) {
-      if (thread_local_buffer_.IsFinalized()) {
-        return;
-      }
-
-      ZeKernelCommandExecutionRecord *rec = thread_local_buffer_.GetDeviceEvent();
-      rec->kid_ = kid;
-      rec->tid_ = tid;
-      rec->tile_ = tile;
-      rec->start_time_ = start;
-      rec->end_time_ = end;
-      rec->device_ = device;
-      rec->engine_ordinal_ = ordinal;
-      rec->engine_index_ = index;
-      rec->implicit_scaling_ = implicit_scaling;
-      rec->kernel_command_id_ = kernel_command_id;
-      rec->group_count_ = group_count;
-      rec->mem_size_ = mem_size;
-      thread_local_buffer_.BufferDeviceEvent();
-    }
-
-    static void ChromeCallLoggingCallback(std::vector<uint64_t> *kids, FLOW_DIR flow_dir, API_TRACING_ID api_id,
-                                          uint64_t started, uint64_t ended) {
-      if (thread_local_buffer_.IsFinalized()) {
-        return;
-      }
-
-      // The protobuf emitter attaches the flow ids to the next slice, so protobuf
-      // must buffer the flow records before the EVENT_COMPLETE; JSON keeps the
-      // COMPLETE first (its ph:s/ph:t follow).
-      // NOTE: this body is identical to ClChromeCallLoggingCallback except for the
-      // thread-local buffer it writes to; both would collapse if the ZE/CL trace
-      // buffers were unified (templatized) -- see the TraceBuffer note above.
-      bool flows_first = false;
-#if BUILD_WITH_PERFETTO
-      flows_first = UseProtobufOutput();
-#endif /* BUILD_WITH_PERFETTO */
-
-      auto buffer_complete = [&]() {
-        HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-        rec->type_ = EVENT_COMPLETE;
-        rec->api_type_ = API_TYPE_NONE;
-        rec->api_id_ = api_id;
-        rec->start_time_ = started;
-        rec->end_time_ = ended;
-        rec->id_ = 0;
-        rec->name_ = nullptr;
-        thread_local_buffer_.BufferHostEvent();
-      };
-
-      if (!flows_first) {
-        buffer_complete();
-      }
-
-      if ((kids != nullptr) && (flow_dir == FLOW_H2D)) {
-        for (auto id : *kids) {
-          HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-
-          rec->type_ = EVENT_FLOW_SOURCE;
-          rec->api_type_ = API_TYPE_NONE;
-          rec->api_id_ = DummyTracingId;
-          rec->start_time_ = started;
-          rec->id_ = id;
-          rec->name_ = nullptr;
-          thread_local_buffer_.BufferHostEvent();
-        }
-      }
-      if ((kids != nullptr) && (flow_dir == FLOW_D2H)) {
-        for (auto id : *kids) {
-          HostEventRecord *rec = thread_local_buffer_.GetHostEvent();
-
-          rec->type_ = EVENT_FLOW_SINK;
-          rec->api_type_ = API_TYPE_NONE;
-          rec->api_id_ = DummyTracingId;
-          rec->start_time_ = started;
-          rec->id_ = id;
-          rec->name_ = nullptr;
-          thread_local_buffer_.BufferHostEvent();
-        }
-      }
-
-      if (flows_first) {
-        buffer_complete();
-      }
-    }
-
-#if BUILD_WITH_OPENCL
-    // OnenCL tracer callbacks.
-    static void ClChromeKernelLoggingCallback(
-      cl_device_pci_bus_info_khr& pci,
-      cl_device_id device,
-      cl_command_queue& queue,
-      int tile,
-      bool implicit,
-      const uint64_t id,
-      uint64_t started,
-      uint64_t ended) {
-
-      if (cl_thread_local_buffer_.IsFinalized()) {
-        return;
-      }
-
-      UNITRACE_ASSERT(ended > started);
-
-      ClKernelCommandExecutionRecord *rec = cl_thread_local_buffer_.GetDeviceEvent();
-
-      rec->tid_ = utils::GetTid();
-      rec->tile_ = tile;
-      rec->start_time_ = started;
-      rec->end_time_ = ended;
-      rec->device_ = device;
-      rec->pci_ = pci;
-      rec->queue_ = queue;
-      rec->implicit_scaling_ = implicit;
-      rec->kid_ = id;
-      rec->kernel_command_id_ = id;
-      cl_thread_local_buffer_.BufferDeviceEvent();
-    }
-
-    static void ClChromeCallLoggingCallback(std::vector<uint64_t> *kids, FLOW_DIR flow_dir, API_TRACING_ID api_id,
-                                            uint64_t started, uint64_t ended) {
-      if (cl_thread_local_buffer_.IsFinalized()) {
-        return;
-      }
-
-      // See ChromeCallLoggingCallback: protobuf buffers the flow records before
-      // the EVENT_COMPLETE so the emitter can attach them to that slice; JSON
-      // keeps COMPLETE first. This body mirrors ChromeCallLoggingCallback exactly
-      // but for the cl_ buffer -- another pair that a templatized TraceBuffer
-      // would unify (see the TraceBuffer note above).
-      bool flows_first = false;
-#if BUILD_WITH_PERFETTO
-      flows_first = UseProtobufOutput();
-#endif /* BUILD_WITH_PERFETTO */
-
-      auto buffer_complete = [&]() {
-        HostEventRecord *rec = cl_thread_local_buffer_.GetHostEvent();
-        rec->type_ = EVENT_COMPLETE;
-        rec->api_type_ = API_TYPE_NONE;
-        rec->api_id_ = api_id;
-        rec->start_time_ = started;
-        rec->end_time_ = ended;
-        rec->id_ = 0;
-        rec->name_ = nullptr;
-        cl_thread_local_buffer_.BufferHostEvent();
-      };
-
-      if (!flows_first) {
-        buffer_complete();
-      }
-
-      if ((kids != nullptr) && (flow_dir == FLOW_H2D)) {
-        for (auto id : *kids) {
-          HostEventRecord *rec = cl_thread_local_buffer_.GetHostEvent();
-
-          rec->type_ = EVENT_FLOW_SOURCE;
-          rec->api_type_ = API_TYPE_NONE;
-          rec->api_id_ = DummyTracingId;
-          rec->start_time_ = started;
-          rec->id_ = id;
-          rec->name_ = nullptr;
-          cl_thread_local_buffer_.BufferHostEvent();
-        }
-      }
-
-      if ((kids != nullptr) && (flow_dir == FLOW_D2H)) {
-        for (auto id : *kids) {
-          HostEventRecord *rec = cl_thread_local_buffer_.GetHostEvent();
-
-          rec->type_ = EVENT_FLOW_SINK;
-          rec->api_type_ = API_TYPE_NONE;
-          rec->api_id_ = DummyTracingId;
-          rec->start_time_ = started;
-          rec->id_ = id;
-          rec->name_ = nullptr;
-          cl_thread_local_buffer_.BufferHostEvent();
-        }
-      }
-
-      if (flows_first) {
-        buffer_complete();
-      }
-    }
-#endif /* BUILD_WITH_OPENCL */
-};
-
-#endif // PTI_TOOLS_UNITRACE_CHROME_LOGGER_H_
diff --git a/tools/unitrace/src/collector_options.h b/tools/unitrace/src/collector_options.h
deleted file mode 100644
index 00002c09..00000000
--- a/tools/unitrace/src/collector_options.h
+++ /dev/null
@@ -1,72 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_COLLECTOR_OPTIONS_
-#define PTI_TOOLS_UNITRACE_COLLECTOR_OPTIONS_
-
-struct CollectorOptions {
-  union {
-    struct {
-      // Core collector flags
-      unsigned int device_timing : 1;
-      unsigned int device_timeline : 1;
-      unsigned int kernel_submission : 1;
-      unsigned int host_timing : 1;
-      unsigned int kernel_tracing : 1;
-      unsigned int api_tracing : 1;
-      unsigned int call_logging : 1;
-      unsigned int need_tid : 1;
-      unsigned int need_pid : 1;
-      unsigned int verbose : 1;
-      unsigned int demangle : 1;
-      unsigned int kernels_per_tile : 1;
-      unsigned int metric_query : 1;
-      unsigned int metric_stream : 1;
-      unsigned int stall_sampling : 1;
-      unsigned int opencl : 1;
-      unsigned int start_paused : 1;
-      // Chrome logging flags
-      unsigned int chrome_call_logging : 1;
-      unsigned int chrome_kernel_logging : 1;
-      unsigned int chrome_device_logging : 1;
-      unsigned int chrome_syclrt_logging : 1;
-      unsigned int chrome_ur_logging : 1;
-      unsigned int chrome_itt_logging : 1;
-      unsigned int chrome_no_thread_on_device : 1;
-      unsigned int chrome_no_engine_on_device : 1;
-      unsigned int chrome_mpi_logging : 1;
-      unsigned int chrome_omp_logging : 1;
-
-      // Other flags
-      unsigned int log_to_file : 1;
-      unsigned int output_dir_path : 1;
-      unsigned int ccl_summary_report : 1;
-      unsigned int protobuf_output : 1;
-    };
-    uint64_t flags_ = 0;  // Default member initializer zeros all bitfields
-  };
-
-  void DeriveFlags() {
-    // If no flags are set, default to host and device timing
-    if (flags_ == 0) {
-      host_timing = 1;
-      device_timing = 1;
-    }
-
-    // Set kernel_tracing if any related features are enabled
-    if (device_timing || device_timeline || kernel_submission ||
-        chrome_device_logging || chrome_kernel_logging) {
-      kernel_tracing = 1;
-    }
-
-    // Set api_tracing if any related features are enabled
-    if (call_logging || chrome_call_logging || host_timing) {
-      api_tracing = 1;
-    }
-  }
-};
-
-#endif //PTI_TOOLS_UNITRACE_COLLECTOR_OPTIONS_
diff --git a/tools/unitrace/src/itt/itt_collector.h b/tools/unitrace/src/itt/itt_collector.h
deleted file mode 100644
index 93b7cb83..00000000
--- a/tools/unitrace/src/itt/itt_collector.h
+++ /dev/null
@@ -1,1119 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_ITT_COLLECTOR_H_
-#define PTI_TOOLS_UNITRACE_ITT_COLLECTOR_H_
-
-#include <chrono>
-#include <cstdio>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <stack>
-#include <tuple>
-
-#include "unicontrol.h"
-#include "unievent.h"
-
-static std::string rank_mpi = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-typedef void (*OnIttLoggingCallback)(const char *name, uint64_t start_ts, uint64_t end_ts, IttArgs* metadata_args);
-typedef void (*OnMpiLoggingCallback)(const char *name, uint64_t start_ts, uint64_t end_ts, size_t src_size, int src_location, int src_tag,
-                                     size_t dst_size, int dst_location, int dst_tag);
-typedef void (*OnMpiInternalLoggingCallback)(const char *name, uint64_t start_ts, uint64_t end_ts, int64_t mpi_counter, size_t src_size, size_t dst_size);
-
-struct ittFunction {
-  uint64_t total_time;
-  uint64_t min_time;
-  uint64_t max_time;
-  uint64_t call_count;
-
-  bool operator>(const ittFunction& r) const {
-    if (total_time != r.total_time) {
-      return total_time > r.total_time;
-    }
-    return call_count > r.call_count;
-  }
-
-  bool operator!=(const ittFunction& r) const {
-    if (total_time == r.total_time) {
-      return call_count != r.call_count;
-    }
-    return true;
-  }
-};
-using ittFunctionInfoMap = std::map<std::string, ittFunction>;
-
-ittFunctionInfoMap ccl_function_info_map;
-std::mutex lock_func_info;
-
-const size_t metadata_type_sizes[] = {
-    1,                  // __itt_metadata_unknown
-    sizeof(uint64_t),   // __itt_metadata_u64
-    sizeof(int64_t),    // __itt_metadata_s64
-    sizeof(uint32_t),   // __itt_metadata_u32
-    sizeof(int32_t),    // __itt_metadata_s32
-    sizeof(uint16_t),   // __itt_metadata_u16
-    sizeof(int16_t),    // __itt_metadata_s16
-    sizeof(float),      // __itt_metadata_float
-    sizeof(double)      // __itt_metadata_double
-};
-
-void AddFunctionTime(const std::string& name, uint64_t time) {
-  if (name.rfind("oneCCL::", 0) == 0) {
-    const std::lock_guard<std::mutex> lock(lock_func_info);
-    if (ccl_function_info_map.count(name) == 0) {
-      ccl_function_info_map[name] = {time, time, time, 1};
-    } else {
-      ittFunction& function = ccl_function_info_map[name];
-      function.total_time += time;
-      if (time < function.min_time) {
-        function.min_time = time;
-      }
-      if (time > function.max_time) {
-        function.max_time = time;
-      }
-      ++function.call_count;
-    }
-  }
-}
-
-class IttCollector {
- public: // Interface
-
-  static IttCollector *Create(OnIttLoggingCallback callback = nullptr) {
-    IttCollector* collector = new IttCollector(callback);
-
-    if (collector == nullptr) {
-      std::cerr << "[WARNING] Unable to create ITT tracer" << std::endl;
-    }
-
-    return collector;
-  }
-
-  void EnableCclSummary() {is_itt_ccl_summary_ = true;}
-  bool IsCclSummaryOn() { return is_itt_ccl_summary_; }
-
-  void EnableChromeLogging() { is_itt_chrome_logging_on_ = true;}
-  bool IsEnableChromeLoggingOn() { return is_itt_chrome_logging_on_; }
-
-  ~IttCollector() {
-  }
-
-  IttCollector(const IttCollector& copy) = delete;
-  IttCollector& operator=(const IttCollector& copy) = delete;
-
-  void Log(const char *name, uint64_t start_ts, uint64_t end_ts, IttArgs* metadata_args) {
-    if (callback_) {
-      callback_(name, start_ts, end_ts, metadata_args);
-    }
-  }
-
-  void Log(const char *name, uint64_t start_ts, uint64_t end_ts, size_t src_size, int src_location, int src_tag,
-                                     size_t dst_size, int dst_location, int dst_tag) {
-    if (mpi_callback_) {
-      mpi_callback_(name, start_ts, end_ts, src_size, src_location, src_tag,
-                                    dst_size, dst_location, dst_tag);
-    }
-  }
-
-  void Log(const char *name, uint64_t start_ts, uint64_t end_ts, int64_t mpi_counter, size_t src_size, size_t dst_size) {
-    if (mpi_internal_callback_) {
-      mpi_internal_callback_(name, start_ts, end_ts, mpi_counter, src_size, dst_size);
-    }
-  }
-
-  void SetMpiCallback(OnMpiLoggingCallback callback) {
-    mpi_callback_ = callback;
-  }
-
-  void SetMpiInternalCallback(OnMpiInternalLoggingCallback callback) {
-    mpi_internal_callback_ = callback;
-  }
-
-  std::string CclSummaryReport() const {
-    const uint32_t kFunctionLength = 10;
-    const uint32_t kCallsLength = 12;
-    const uint32_t kTimeLength = 20;
-    const uint32_t kPercentLength = 12;
-
-    if (ccl_function_info_map.empty()) {
-      return "";
-    }
-
-    std::set< std::pair<std::string, ittFunction>,
-              utils::Comparator > sorted_list(
-        ccl_function_info_map.begin(), ccl_function_info_map.end());
-
-    uint64_t total_duration = 0;
-    size_t max_name_length = kFunctionLength;
-    for (auto& value : sorted_list) {
-      total_duration += value.second.total_time;
-      if (value.first.size() > max_name_length) {
-        max_name_length = value.first.size();
-      }
-    }
-
-    // return early if there is not API in the list
-    if (total_duration == 0) {
-      return "";
-    }
-    std::string str;
-    str += "************************************************************\n";
-    str += "*  Process ID : " + std::to_string(utils::GetPid()) + " | Rank ID : " + rank_mpi + "\n";
-    str += "************************************************************\n";
-
-    str += std::string(std::max(int(max_name_length - sizeof("Function") + 1), 0), ' ') + "Function, " +
-      std::string(std::max(int(kCallsLength - sizeof("Calls") + 1), 0), ' ') + "Calls, " +
-      std::string(std::max(int(kTimeLength - sizeof("Time (ns)") + 1), 0), ' ') + "Time (ns), " +
-      std::string(std::max(int(kPercentLength - sizeof("Time (%)") + 1), 0), ' ') + "Time (%), " +
-      std::string(std::max(int(kTimeLength - sizeof("Average (ns)") + 1), 0), ' ') + "Average (ns), " +
-      std::string(std::max(int(kTimeLength - sizeof("Min (ns)") + 1), 0), ' ') + "Min (ns), " +
-      std::string(std::max(int(kTimeLength - sizeof("Max (ns)") + 1), 0), ' ') + "Max (ns)\n";
-
-    for (auto& value : sorted_list) {
-      const std::string& function = value.first;
-      uint64_t call_count = value.second.call_count;
-      uint64_t duration = value.second.total_time;
-      uint64_t avg_duration = duration / call_count;
-      uint64_t min_duration = value.second.min_time;
-      uint64_t max_duration = value.second.max_time;
-      float percent_duration = (100.0f * duration / total_duration);
-      str += std::string(std::max(int(max_name_length - function.length()), 0), ' ') + function + ", " +
-              std::string(std::max(int(kCallsLength - std::to_string(call_count).length()), 0), ' ') + std::to_string(call_count) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(duration).length()), 0), ' ') + std::to_string(duration) + ", " +
-
-              std::string(std::max(int(kPercentLength - std::to_string(percent_duration).length()), 0), ' ') +
-              std::to_string(percent_duration) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(avg_duration).length()), 0), ' ') + std::to_string(avg_duration) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(min_duration).length()), 0), ' ') + std::to_string(min_duration) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(max_duration).length()), 0), ' ') + std::to_string(max_duration) + "\n";
-    }
-    return str;
-  }
-
- private: // Implementation
-
-  IttCollector(OnIttLoggingCallback callback) : callback_(callback) {
-  }
-
- private: // Data
-  OnIttLoggingCallback callback_ = nullptr;
-  OnMpiLoggingCallback mpi_callback_ = nullptr;
-  OnMpiInternalLoggingCallback mpi_internal_callback_ = nullptr;
-  bool is_itt_ccl_summary_ = false;
-  bool is_itt_chrome_logging_on_ = false;
-};
-
-static IttCollector *itt_collector = nullptr;
-
-#define INTEL_NO_MACRO_BODY
-#define INTEL_ITTNOTIFY_API_PRIVATE
-#include "ittnotify.h"
-#include "ittnotify_config.h"
-
-struct ThreadTaskDescriptor {
-  char domain[512];
-  char name[512];
-  uint64_t start_time;
-  IttArgs metadata_args;
-};
-
-thread_local std::stack<ThreadTaskDescriptor> task_desc;
-
-thread_local std::map<__itt_event, uint64_t> event_desc;
-
-static std::vector<std::string> itt_events;
-static int num_itt_events = 0;
-
-static __itt_global *itt_global = NULL;
-
-static void fill_func_ptr_per_lib(__itt_global* p)
-{
-  __itt_api_info* api_list = (__itt_api_info*)p->api_list_ptr;
-
-  for (int i = 0; api_list[i].name != NULL; i++) {
-    *(api_list[i].func_ptr) = (void*)__itt_get_proc(p->lib, api_list[i].name);
-    if (*(api_list[i].func_ptr) == NULL)
-    {
-      *(api_list[i].func_ptr) = api_list[i].null_func;
-    }
-  }
-}
-
-ITT_EXTERN_C void ITTAPI __itt_api_init(__itt_global* p, __itt_group_id /* init_groups */)
-{
-  if (p != NULL) {
-    fill_func_ptr_per_lib(p);
-    itt_global = p;
-  }
-}
-
-ITT_EXTERN_C __itt_domain* ITTAPI __itt_domain_create(const char *name)
-{
-  if (itt_global == NULL) {
-    return NULL;
-  }
-
-  __itt_domain *h_tail = NULL, *h = NULL;
-
-  __itt_mutex_lock(&(itt_global->mutex));
-  for (h_tail = NULL, h = itt_global->domain_list; h != NULL; h_tail = h, h = h->next) {
-    if (h->nameA != NULL && !__itt_fstrcmp(h->nameA, name)) break;
-  }
-  if (h == NULL) {
-    NEW_DOMAIN_A(itt_global, h, h_tail, name);
-  }
-  __itt_mutex_unlock(&(itt_global->mutex));
-
-  return h;
-}
-
-ITT_EXTERN_C __itt_string_handle* ITTAPI __itt_string_handle_create(const char* name)
-{
-  if (itt_global == NULL) {
-    return NULL;
-  }
-  __itt_string_handle *h_tail = NULL, *h = NULL;
-
-  __itt_mutex_lock(&(itt_global->mutex));
-  for (h_tail = NULL, h = itt_global->string_list; h != NULL; h_tail = h, h = h->next) {
-    if (h->strA != NULL && !__itt_fstrcmp(h->strA, name)) break;
-  }
-  if (h == NULL) {
-    NEW_STRING_HANDLE_A(itt_global, h, h_tail, name);
-  }
-  __itt_mutex_unlock(&(itt_global->mutex));
-
-  return h;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_pause(void)
-{
-  UniController::IttPause();
-}
-
-ITT_EXTERN_C void ITTAPI __itt_pause_scoped(__itt_collection_scope /* scope */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_resume(void)
-{
-  UniController::IttResume();
-}
-
-ITT_EXTERN_C void ITTAPI __itt_detach(void)
-{
-  UniController::IttStop();
-}
-
-ITT_EXTERN_C void ITTAPI __itt_resume_scoped(__itt_collection_scope /* scope */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin(const __itt_domain *domain, __itt_id /* taskid */, __itt_id /* parentid */, __itt_string_handle *name) {
-  if (!UniController::IsCollectionEnabled()) {
-    return;
-  }
-
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-
-  ThreadTaskDescriptor desc;
-
-  desc.metadata_args.count = 0;
-  desc.metadata_args.key = nullptr;
-  desc.metadata_args.next = nullptr;
-  desc.metadata_args.isIndirectData = false;
-  desc.metadata_args.type = __itt_metadata_unknown;
-
-#ifdef _WIN32
-  if (domain && domain->nameA) {
-    strncpy_s(desc.domain, sizeof(desc.domain), domain->nameA, sizeof(desc.domain) - 2);
-  }
-  else {
-    desc.domain[0] = 0;
-  }
-  if (name && name->strA) {
-    strncpy_s(desc.name, sizeof(desc.name), name->strA, sizeof(desc.name) - 2);
-  }
-  else {
-    desc.name[0] = 0;
-  }
-#else /* _WIN32 */
-  if (domain && domain->nameA) {
-    strncpy(desc.domain, domain->nameA, sizeof(desc.domain) - 2);
-    desc.domain[sizeof(desc.domain) - 2] = 0;  // strncpy does not terminate a truncated name
-  }
-  else {
-    desc.domain[0] = 0;
-  }
-  if (name && name->strA) {
-    strncpy(desc.name, name->strA, sizeof(desc.name) - 2);
-    desc.name[sizeof(desc.name) - 2] = 0;  // strncpy does not terminate a truncated name
-  }
-  else {
-    desc.name[0] = 0;
-  }
-#endif /* _WIN32 */
-
-  desc.start_time = UniTimer::GetHostTimestamp();
-  task_desc.push(desc);
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end(const __itt_domain *domain)
-{
-  if (!UniController::IsCollectionEnabled()) {
-    return;
-  }
-
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-
-  if (!task_desc.empty() && !strncmp(task_desc.top().domain, (domain && domain->nameA) ? domain->nameA : "", sizeof(task_desc.top().domain) - 2)) {
-    char task[1057];
-
-    snprintf(task, 1056, "%s::%s", task_desc.top().domain, task_desc.top().name);
-
-    std::string name = task_desc.top().domain;
-    name+="::";
-    name+=task_desc.top().name;
-    auto start = task_desc.top().start_time;
-    auto end = UniTimer::GetHostTimestamp();
-
-    if (itt_collector->IsCclSummaryOn()) {
-      AddFunctionTime(name, end-start);
-    }
-    if (itt_collector->IsEnableChromeLoggingOn()) {
-      itt_collector->Log(task, start, end, &task_desc.top().metadata_args);
-    }
-    task_desc.pop();
-  }
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_internal_ex_info(const __itt_domain *domain,
-                                     size_t src_size, int src_location, int src_tag,
-                                     size_t dst_size, int dst_location, int dst_tag)
-{
-  if (!UniController::IsCollectionEnabled() || !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-
-  if (task_desc.empty() || strncmp(task_desc.top().domain, (domain && domain->nameA) ? domain->nameA : "", sizeof(task_desc.top().domain) - 2)) {
-    return;
-  }
-
-  std::string display(task_desc.top().domain);
-  display += "::";
-  display += task_desc.top().name;
-  auto start = task_desc.top().start_time;
-  auto end = UniTimer::GetHostTimestamp();
-
-  if (itt_collector->IsEnableChromeLoggingOn()) {
-    itt_collector->Log(display.c_str(), start, end, src_size, src_location, src_tag,
-                                     dst_size, dst_location, dst_tag);
-  }
-  task_desc.pop();
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_internal_callback_info(const __itt_domain *domain,
-                                     int64_t mpi_counter,  size_t src_size, size_t dst_size)
-{
-  if (!UniController::IsCollectionEnabled() || !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-
-  if (task_desc.empty() || strncmp(task_desc.top().domain, (domain && domain->nameA) ? domain->nameA : "", sizeof(task_desc.top().domain) - 2)) {
-    return;
-  }
-
-  std::string display(task_desc.top().domain);
-  display += "::";
-  display += task_desc.top().name;
-  auto start = task_desc.top().start_time;
-  auto end = UniTimer::GetHostTimestamp();
-
-  if (itt_collector->IsEnableChromeLoggingOn()) {
-    itt_collector->Log(display.c_str(), start, end, mpi_counter, src_size, dst_size);
-  }
-  task_desc.pop();
-}
-
-ITT_EXTERN_C __itt_event ITTAPI __itt_event_create(const char *name, int namelen)
-{
-  if (itt_global == NULL) {
-    return -1;
-  }
-
-  __itt_mutex_lock(&(itt_global->mutex));
-  itt_events.push_back(std::string(name, namelen));
-  num_itt_events = itt_events.size();
-  int i = num_itt_events - 1;
-  __itt_mutex_unlock(&(itt_global->mutex));
-
-  return (__itt_event)i;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_event_start(__itt_event event) {
-  if (!UniController::IsCollectionEnabled()) {
-    return __itt_error_success;
-  }
-
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return __itt_error_success;
-  }
-
-  if ((event < 0) || (event >= num_itt_events)) { // let it race
-    return __itt_error_no_symbol;  // which error code to return?
-  }
-
-  uint64_t start = UniTimer::GetHostTimestamp();
-  event_desc.insert({event, start});
-
-  return __itt_error_success;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_event_end(__itt_event event) {
-  if (!UniController::IsCollectionEnabled()) {
-    return __itt_error_success;
-  }
-
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return __itt_error_success;
-  }
-  if ((event < 0) || (event >= num_itt_events)) { // let it race
-    return __itt_error_no_symbol;  // which error code to return?
-  }
-
-  auto it = event_desc.find(event);
-  if (it != event_desc.end()) {
-    uint64_t start = it->second;
-    event_desc.erase(it);
-    // trust the event has already been created
-    //__itt_mutex_lock(&(itt_global->mutex));
-
-    auto end = UniTimer::GetHostTimestamp();
-    if (itt_collector->IsCclSummaryOn()) {
-      AddFunctionTime(itt_events[event], end-start);
-    }
-    if (itt_collector->IsEnableChromeLoggingOn()) {
-      itt_collector->Log(itt_events[event].c_str(), start, end, nullptr);
-    }
-    //__itt_mutex_unlock(&(itt_global->mutex));
-    return __itt_error_success;
-  }
-
-  return __itt_error_no_symbol;    // which error code to return?
-}
-
-
-ITT_EXTERN_C void ITTAPI __itt_marker(const __itt_domain *domain, __itt_id id, __itt_string_handle *name, __itt_scope /* scope */)
-{
-  if (!UniController::IsCollectionEnabled()) {
-    return;
-  }
-
-  if (!itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-
-  char marker[1025];
-
-  if (domain && domain->nameA) {
-    if (name && name->strA) {
-      if ((id.d1 != __itt_null.d1) || (id.d2 != __itt_null.d2) || (id.d3 != __itt_null.d3)) {
-        snprintf(marker, 1024, "%s::%s::%lld::%lld::%lld", domain->nameA, name->strA, id.d1, id.d2, id.d3);
-      }
-      else {
-        snprintf(marker, 1024, "%s::%s", domain->nameA, name->strA);
-      }
-    }
-    else {
-      if ((id.d1 != __itt_null.d1) || (id.d2 != __itt_null.d2) || (id.d3 != __itt_null.d3)) {
-        snprintf(marker, 1024, "%s::%lld::%lld::%lld", domain->nameA, id.d1, id.d2, id.d3);
-      }
-      else {
-        snprintf(marker, 1024, "%s", domain->nameA);
-      }
-    }
-  }
-  else {
-    if (name && name->strA) {
-      if ((id.d1 != __itt_null.d1) || (id.d2 != __itt_null.d2) || (id.d3 != __itt_null.d3)) {
-        snprintf(marker, 1024, "%s::%lld::%lld::%lld", name->strA, id.d1, id.d2, id.d3);
-      }
-      else {
-        snprintf(marker, 1024, "%s", name->strA);
-      }
-    }
-    else {
-      if ((id.d1 != __itt_null.d1) || (id.d2 != __itt_null.d2) || (id.d3 != __itt_null.d3)) {
-        snprintf(marker, 1024, "%lld::%lld::%lld", id.d1, id.d2, id.d3);
-      }
-      else {
-        snprintf(marker, 1024, "UNNAMED_MARKER");
-      }
-    }
-  }
-
-  uint64_t ts = UniTimer::GetHostTimestamp();
-  itt_collector->Log(marker, ts, ts, nullptr);
-}
-
-// Need these empty stubs to make sure symbols are resolved in case any of these symbols are present in target application
-ITT_EXTERN_C __itt_pt_region ITTAPI __itt_pt_region_create(const char * /* name */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_thread_set_name(const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_thread_ignore(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_push(unsigned int /* mask */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_pop(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_mark_range(__itt_suppress_mode_t /* mode */, unsigned int /* mask */, void * /* address */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_suppress_clear_range(__itt_suppress_mode_t /* mode */, unsigned int /* mask */, void * /* address */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_create (void* /* addr */, const char * /* objtype */, const char * /* objname */, int /* attribute */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_rename(void* /* addr */, const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_destroy(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_prepare(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_cancel(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_acquired(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_sync_releasing(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_prepare(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_cancel(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_acquired(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_fsync_releasing(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_begin(__itt_model_site * /* site */, __itt_model_site_instance * /* instance */, const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_beginA(const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_beginAL(const char * /* name */, size_t /* siteNameLen */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_end  (__itt_model_site * /* site */, __itt_model_site_instance * /* instance */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_site_end_2(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_begin(__itt_model_task * /* task */, __itt_model_task_instance * /* instance */, const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_beginA(const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_beginAL(const char * /* name */, size_t /* taskNameLen */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_iteration_taskA(const char * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_iteration_taskAL(const char * /* name */, size_t /* taskNameLen */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_end  (__itt_model_task * /* task */, __itt_model_task_instance * /* instance */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_task_end_2(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_acquire(void * /* lock */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_acquire_2(void * /* lock */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_release(void * /* lock */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_lock_release_2(void * /* lock */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_record_allocation  (void * /* addr */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_record_deallocation(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_induction_uses(void* /* addr */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_reduction_uses(void* /* addr */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_observe_uses(void* /* addr */, size_t /* size */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_clear_uses(void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_disable_push(__itt_model_disable /* x */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_disable_pop(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_model_aggregate_task(size_t /* x */)
-{
-}
-
-ITT_EXTERN_C __itt_heap_function ITTAPI __itt_heap_function_create(const char* /* name */, const char* /* domain */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_allocate_begin(__itt_heap_function /* h */, size_t /* size */, int /* initialized */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_allocate_end(__itt_heap_function /* h */, void** /* addr */, size_t /* size */, int /* initialized */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_free_begin(__itt_heap_function /* h */, void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_free_end(__itt_heap_function /* h */, void* /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reallocate_begin(__itt_heap_function /* h */, void* /* addr */, size_t /* new_size */, int /* initialized */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reallocate_end(__itt_heap_function /* h */, void* /* addr */, void** /* new_addr */, size_t /* new_size */, int /* initialized */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_internal_access_begin(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_internal_access_end(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record_memory_growth_begin(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record_memory_growth_end(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_reset_detection(unsigned int /* reset_mask */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_heap_record(unsigned int /* record_mask */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_create(const __itt_domain * /* domain */, __itt_id /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_destroy(const __itt_domain * /* domain */, __itt_id /* id */)
-{
-}
-
-ITT_EXTERN_C __itt_timestamp ITTAPI __itt_get_timestamp(void)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_region_begin(const __itt_domain * /* domain */, __itt_id /* id */, __itt_id /* parentid */, __itt_string_handle * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_region_end(const __itt_domain * /* domain */, __itt_id /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_begin_v3(const __itt_domain * /* domain */, __itt_id * /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_end_v3(const __itt_domain * /* domain */, __itt_id * /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_frame_submit_v3(const __itt_domain * /* domain */, __itt_id * /* id */, __itt_timestamp /* begin */, __itt_timestamp /* end */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_group(const __itt_domain * /* domain */, __itt_id /* id */, __itt_id /* parentid */, __itt_string_handle * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_fn(const __itt_domain * /* domain */, __itt_id /* taskid */, __itt_id /* parentid */, void* /* fn */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_overlapped(const __itt_domain* /* domain */, __itt_id /* taskid */, __itt_id /* parentid */, __itt_string_handle* /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_overlapped(const __itt_domain * /* domain */, __itt_id /* taskid */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_add(const __itt_domain * /* domain */, __itt_id /* id */, __itt_string_handle *key, __itt_metadata_type type, size_t count, void *data)
-{
-  if (!UniController::IsCollectionEnabled()) {
-    return;
-  }
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-  if (count && data && !task_desc.empty() && type > __itt_metadata_unknown && type < __itt_metadata_double) {
-    ThreadTaskDescriptor &task = task_desc.top();
-    IttArgs* newArgs = &task.metadata_args, *next = newArgs->next;
-    void* dataDest = task.metadata_args.data;
-    size_t metadataSize = count * metadata_type_sizes[type];
-    if (newArgs->count) {
-      newArgs->next = (IttArgs*)calloc(1, std::max(metadataSize, sizeof(void*)) + sizeof(IttArgs) - sizeof(void*));
-      UniMemory::ExitIfOutOfMemory(newArgs->next);
-      newArgs = newArgs->next;
-      dataDest = newArgs->data;
-    }
-    else if (metadataSize > sizeof(void*)) {
-      dataDest = malloc(metadataSize);
-      UniMemory::ExitIfOutOfMemory(dataDest);
-      newArgs->isIndirectData = true;
-      newArgs->data[0] = dataDest;
-    }
-    memcpy(dataDest, data, metadataSize);
-    newArgs->key = key->strA;
-    newArgs->count = count;
-    newArgs->type = type;
-    newArgs->next = next;
-  }
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_str_add(const __itt_domain * /* domain */, __itt_id /* id */, __itt_string_handle *key, const char *data, size_t length) {
-  if (!UniController::IsCollectionEnabled()) {
-    return;
-  }
-  if (!itt_collector->IsCclSummaryOn() && !itt_collector->IsEnableChromeLoggingOn()) {
-    return;
-  }
-  if (length && data && !task_desc.empty()) {
-    ThreadTaskDescriptor &task = task_desc.top();
-    IttArgs* newArgs = &task.metadata_args, *next = newArgs->next;
-    void* dataDest = task.metadata_args.data;
-    size_t metadataSize = length * metadata_type_sizes[0];
-    if (newArgs->count) {
-      newArgs->next = (IttArgs*)calloc(1, std::max(metadataSize, sizeof(void*)) + sizeof(IttArgs) - sizeof(void*));
-      UniMemory::ExitIfOutOfMemory(newArgs->next);
-      newArgs = newArgs->next;
-      dataDest = newArgs->data;
-    }
-    else if (metadataSize > sizeof(void*)) {
-      dataDest = malloc(metadataSize);
-      UniMemory::ExitIfOutOfMemory(dataDest);
-      newArgs->isIndirectData = true;
-      newArgs->data[0] = dataDest;
-    }
-    memcpy(dataDest, data, metadataSize);
-    newArgs->key = key->strA;
-    newArgs->count = length;
-    newArgs->type = 0;  // itt_metadata_unknown is considered a string for us
-    newArgs->next = next;
-  }
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_add_with_scope(const __itt_domain * /* domain */, __itt_scope /* scope */, __itt_string_handle * /* key */, __itt_metadata_type /* type */, size_t /* count */, void * /* data */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_metadata_str_add_with_scope(const __itt_domain * /* domain */, __itt_scope /* scope */, __itt_string_handle * /* key */, const char * /* data */, size_t /* length */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_to_current(const __itt_domain * /* domain */, __itt_relation /* relation */, __itt_id /* tail */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add(const __itt_domain * /* domain */, __itt_id /* head */, __itt_relation /* relation */, __itt_id /* tail */)
-{
-}
-
-ITT_EXTERN_C __itt_clock_domain* ITTAPI __itt_clock_domain_create(__itt_get_clock_info_fn /* fn */, void* /* fn_data */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_clock_domain_reset(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_create_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_id_destroy_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* taskid */, __itt_id /* parentid */, __itt_string_handle* /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_fn_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* taskid */, __itt_id /* parentid */, void* /* fn */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */)
-{
-}
-
-ITT_EXTERN_C __itt_counter ITTAPI __itt_counter_create(const char * /* name */, const char * /* domain */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc(__itt_counter /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_delta(__itt_counter /* id */, unsigned long long /* value */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec(__itt_counter /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_delta(__itt_counter /* id */, unsigned long long /* value */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_v3(const __itt_domain * /* domain */, __itt_string_handle * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_inc_delta_v3(const __itt_domain * /* domain */, __itt_string_handle * /* name */, unsigned long long /* delta */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_v3(const __itt_domain * /* domain */, __itt_string_handle * /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_dec_delta_v3(const __itt_domain * /* domain */, __itt_string_handle * /* name */, unsigned long long /* delta */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_set_value(__itt_counter /* id */, void * /* value_ptr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_set_value_ex(__itt_counter /* id */, __itt_clock_domain * /* clock_domain */, unsigned long long /* timestamp */, void * /* value_ptr */)
-{
-}
-
-ITT_EXTERN_C __itt_counter ITTAPI __itt_counter_create_typed(const char * /* name */, const char * /* domain */, __itt_metadata_type /* type */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_counter_destroy(__itt_counter /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_marker_ex(const __itt_domain * /* domain */,  __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* id */, __itt_string_handle * /* name */, __itt_scope /* scope */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_to_current_ex(const __itt_domain * /* domain */,  __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_relation /* relation */, __itt_id /* tail */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_relation_add_ex(const __itt_domain * /* domain */,  __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* head */, __itt_relation /* relation */, __itt_id /* tail */)
-{
-}
-
-ITT_EXTERN_C __itt_track_group* ITTAPI __itt_track_group_create(__itt_string_handle* /* name */, __itt_track_group_type /* track_group_type */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C __itt_track* ITTAPI __itt_track_create(__itt_track_group* /* track_group */, __itt_string_handle* /* name */, __itt_track_type /* track_type */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_set_track(__itt_track* /* track */)
-{
-}
-
-ITT_EXTERN_C int ITTAPI __itt_av_save(void * /* data */, int /* rank */, const int * /* dimensions */, int /* type */, const char * /* filePath */, int /* columnOrder */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_enable_attach(void)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_load(void * /* start_addr */, void * /* end_addr */, const char * /* path */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_unload(void * /* addr */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_load_with_sections(__itt_module_object* /* module_obj */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_module_unload_with_sections(__itt_module_object* /* module_obj */)
-{
-}
-
-ITT_EXTERN_C __itt_histogram* ITTAPI __itt_histogram_create(const __itt_domain* /* domain */, const char* /* name */, __itt_metadata_type /* x_type */, __itt_metadata_type /* y_type */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_histogram_submit(__itt_histogram* /* hist */, size_t /* length */, void* /* x_data */, void* /* y_data */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_begin_overlapped_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* taskid */, __itt_id /* parentid */, __itt_string_handle* /* name */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_task_end_overlapped_ex(const __itt_domain* /* domain */, __itt_clock_domain* /* clock_domain */, unsigned long long /* timestamp */, __itt_id /* taskid */)
-{
-}
-
-ITT_EXTERN_C __itt_mark_type ITTAPI __itt_mark_create(const char * /* name */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark(__itt_mark_type /* mt */, const char * /* parameter */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_global(__itt_mark_type /* mt */, const char * /* parameter */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_off(__itt_mark_type /* mt */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C int ITTAPI __itt_mark_global_off(__itt_mark_type /* mt */)
-{
-  return 0;
-}
-
-ITT_EXTERN_C __itt_caller ITTAPI __itt_stack_caller_create(void)
-{
-  return 0;
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_caller_destroy(__itt_caller /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_callee_enter(__itt_caller /* id */)
-{
-}
-
-ITT_EXTERN_C void ITTAPI __itt_stack_callee_leave(__itt_caller /* id */)
-{
-}
-
-
-#endif // PTI_TOOLS_UNITRACE_ITT_COLLECTOR_H_
diff --git a/tools/unitrace/src/levelzero/ze_collector.h b/tools/unitrace/src/levelzero/ze_collector.h
deleted file mode 100644
index 3c4c0d3b..00000000
--- a/tools/unitrace/src/levelzero/ze_collector.h
+++ /dev/null
@@ -1,6397 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_LEVEL_ZERO_COLLECTOR_H_
-#define PTI_TOOLS_UNITRACE_LEVEL_ZERO_COLLECTOR_H_
-
-#include <chrono>
-#include <atomic>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <set>
-#include <string>
-#include <vector>
-#include <cmath>
-#include <fstream>
-#include <sstream>
-
-#if !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__))
-#include <dlfcn.h>
-#endif /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-
-#include <level_zero/ze_api.h>
-#include <level_zero/layers/zel_tracing_api.h>
-#include <level_zero/layers/zel_tracing_register_cb.h>
-
-#include "utils/utils.h"
-#include "ze_event_cache.h"
-#include "utils_ze.h"
-#include "collector_options.h"
-#include "unikernel.h"
-#include "unitimer.h"
-#include "unicontrol.h"
-#include "unimemory.h"
-
-#include "ze_loader.h"
-#include "common_header.gen"
-#include "logger_factory.h"
-#include "ze_metrics_config.h"
-
-struct ZeMetricQueryPoolKey {
-  ze_context_handle_t context_;
-  ze_device_handle_t device_;
-  zet_metric_group_handle_t group_;
-};
-
-struct ZeMetricQueryPoolKeyCompare {
-  bool operator()(const ZeMetricQueryPoolKey& lhs, const ZeMetricQueryPoolKey& rhs) const {
-    if (lhs.context_ < rhs.context_) {
-      return true;
-    }
-    if (lhs.context_ == rhs.context_) {
-      if (lhs.device_ < rhs.device_) {
-        return true;
-      }
-      if (lhs.device_ == rhs.device_) {
-        return (lhs.group_ < rhs.group_);
-      }
-    }
-    return false;
-  }
-};
-
-struct ZeMetricQueryPools {
-  // 64 rather than 128, to save memory
-  constexpr static uint32_t pool_size_ = 64;
-  std::mutex query_pool_mutex_;
-  std::map<zet_metric_query_handle_t, ZeMetricQueryPoolKey> query_pool_map_;
-  std::map<ZeMetricQueryPoolKey, std::vector<zet_metric_query_handle_t>, ZeMetricQueryPoolKeyCompare> free_pool_;
-  std::vector<zet_metric_query_pool_handle_t> pools_;
-
-  ZeMetricQueryPools() {}
-
-  ZeMetricQueryPools(const struct ZeMetricQueryPools& that) = delete;
-
-  ZeMetricQueryPools& operator=(const struct ZeMetricQueryPools& that) = delete;
-
-  ~ZeMetricQueryPools() {
-#ifdef _WIN32
-    // on Windows, it is very possible that L0 has been unloaded or is being unloaded at this point and L0 calls may have undefined behavior
-    // hence skipping all destroy calls and returning early.
-    return;
-#else /* _WIN32 */
-    ze_result_t status;
-
-    const std::lock_guard<std::mutex> lock(query_pool_mutex_);
-    for (auto it = query_pool_map_.begin(); it != query_pool_map_.end(); it++) {
-      status = ZE_FUNC(zetMetricQueryDestroy)(it->first);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[WARNING] Failed to destroy metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      }
-    }
-    query_pool_map_.clear();
-
-    for (auto it = pools_.begin(); it != pools_.end(); it++) {
-      status = ZE_FUNC(zetMetricQueryPoolDestroy)(*it);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[WARNING] Failed to destroy metric query pool (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      }
-    }
-
-    pools_.clear();
-
-    free_pool_.clear();
-#endif /* _WIN32 */
-  }
-
-  zet_metric_query_handle_t
-  GetQuery(ze_context_handle_t context, ze_device_handle_t device, zet_metric_group_handle_t group) {
-    ze_result_t status;
-    zet_metric_query_handle_t query;
-
-    const std::lock_guard<std::mutex> lock(query_pool_mutex_);
-    auto it = free_pool_.find({context, device, group});
-    if (it == free_pool_.end()) {
-      // no pools created
-
-      zet_metric_query_pool_desc_t desc = {ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC, nullptr, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE, pool_size_};
-      zet_metric_query_pool_handle_t pool;
-
-      status = ZE_FUNC(zetMetricQueryPoolCreate)(context, device, group, &desc, &pool);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Failed to create metric query pool (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        _Exit(-1);  // immediately exit
-      }
-      pools_.push_back(pool);
-
-      std::vector<zet_metric_query_handle_t> queries;
-      for (uint32_t i = 0; i < pool_size_ - 1; i++) {
-        status = ZE_FUNC(zetMetricQueryCreate)(pool, i, &query);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to create metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          _Exit(-1);  // exit immediately
-        }
-        queries.push_back(query);
-        query_pool_map_.insert({query, {context, device, group}});
-      }
-      status = ZE_FUNC(zetMetricQueryCreate)(pool, pool_size_ - 1, &query);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Failed to create metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        _Exit(-1);  // exit immediately
-      }
-      query_pool_map_.insert({query, {context, device, group}});
-
-      free_pool_.insert({{context, device, group}, std::move(queries)});
-    }
-    else {
-      if (it->second.size() == 0) {
-        // no free queries, create a new pool
-
-        zet_metric_query_pool_desc_t desc = {ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC, nullptr, ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE, pool_size_};
-        zet_metric_query_pool_handle_t pool;
-
-        status = ZE_FUNC(zetMetricQueryPoolCreate)(context, device, group, &desc, &pool);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to create metric query pool (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          _Exit(-1);  // immediately exit
-        }
-        pools_.push_back(pool);
-
-        for (uint32_t i = 0; i < pool_size_ - 1; i++) {
-          status = ZE_FUNC(zetMetricQueryCreate)(pool, i, &query);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Failed to create metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            _Exit(-1);  // exit immediately
-          }
-          it->second.push_back(query);
-          query_pool_map_.insert({query, {context, device, group}});
-        }
-        status = ZE_FUNC(zetMetricQueryCreate)(pool, pool_size_ - 1, &query);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to create metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          _Exit(-1);  // exit immediately
-        }
-        query_pool_map_.insert({query, {context, device, group}});
-      }
-      else {
-        query = it->second.back();
-        it->second.pop_back();
-      }
-    }
-
-    return query;
-  }
-
-  void
-  PutQuery(zet_metric_query_handle_t query) {
-    if (query == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::mutex> lock(query_pool_mutex_);
-    auto it = query_pool_map_.find(query);
-    if (it == query_pool_map_.end()) {
-      return;
-    }
-    auto it2 = free_pool_.find(it->second);
-    UNITRACE_ASSERT(it2 != free_pool_.end());
-    it2->second.push_back(query);
-  }
-
-  void
-  ResetQuery(zet_metric_query_handle_t query) {
-    const std::lock_guard<std::mutex> lock(query_pool_mutex_);
-    if (query_pool_map_.find(query) == query_pool_map_.end()) {
-      return;
-    }
-    ze_result_t status = ZE_FUNC(zetMetricQueryReset)(query);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Failed to reset metric query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      _Exit(-1);  // exit immediately
-    }
-  }
-};
-
-struct ZeInstanceData {
-  uint64_t start_time_host;  // in ns
-  uint64_t timestamp_host;  // in ns
-  uint64_t timestamp_device;  // in ticks
-  uint64_t kid;  // passing kid from enter callback to exit callback
-
-  // These used in Append commands
-  zet_metric_query_handle_t query_; // Appended command query handle
-  ze_event_handle_t in_order_counter_event_;  // Appended command event counter based event or null
-  bool instrument_;                 // false if command should be skipped
-};
-
-thread_local ZeInstanceData ze_instance_data;
-
-struct ZeFunctionTime {
-  uint64_t total_time_;
-  uint64_t min_time_;
-  uint64_t max_time_;
-  uint64_t call_count_;
-
-  bool operator>(const ZeFunctionTime& r) const {
-    if (total_time_ != r.total_time_) {
-      return total_time_ > r.total_time_;
-    }
-    return call_count_ > r.call_count_;
-  }
-
-  bool operator!=(const ZeFunctionTime& r) const {
-    if (total_time_ == r.total_time_) {
-      return call_count_ != r.call_count_;
-    }
-    return true;
-  }
-};
-
-struct ZeKernelGroupSize {
-  uint32_t x;
-  uint32_t y;
-  uint32_t z;
-};
-
-enum ZeKernelCommandType {
-  KERNEL_COMMAND_TYPE_INVALID = 0,
-  KERNEL_COMMAND_TYPE_COMPUTE = 1,
-  KERNEL_COMMAND_TYPE_MEMORY = 2,
-  KERNEL_COMMAND_TYPE_COMMAND = 3
-};
-
-enum ZeDeviceCommandHandle {
-  MemoryCopy = 0,
-  MemoryCopyH2H = MemoryCopy,
-  MemoryCopyH2D,
-  MemoryCopyH2M,
-  MemoryCopyH2S,
-  MemoryCopyD2H,
-  MemoryCopyD2D,
-  MemoryCopyD2M,
-  MemoryCopyD2S,
-  MemoryCopyM2H,
-  MemoryCopyM2D,
-  MemoryCopyM2M,
-  MemoryCopyM2S,
-  MemoryCopyS2H,
-  MemoryCopyS2D,
-  MemoryCopyS2M,
-  MemoryCopyS2S,
-  MemoryCopyRegion,
-  MemoryCopyRegionH2H = MemoryCopyRegion,
-  MemoryCopyRegionH2D,
-  MemoryCopyRegionH2M,
-  MemoryCopyRegionH2S,
-  MemoryCopyRegionD2H,
-  MemoryCopyRegionD2D,
-  MemoryCopyRegionD2M,
-  MemoryCopyRegionD2S,
-  MemoryCopyRegionM2H,
-  MemoryCopyRegionM2D,
-  MemoryCopyRegionM2M,
-  MemoryCopyRegionM2S,
-  MemoryCopyRegionS2H,
-  MemoryCopyRegionS2D,
-  MemoryCopyRegionS2M,
-  MemoryCopyRegionS2S,
-  MemoryCopyFromContext,
-  MemoryCopyFromContextH2H = MemoryCopyFromContext,
-  MemoryCopyFromContextH2D,
-  MemoryCopyFromContextH2M,
-  MemoryCopyFromContextH2S,
-  MemoryCopyFromContextD2H,
-  MemoryCopyFromContextD2D,
-  MemoryCopyFromContextD2M,
-  MemoryCopyFromContextD2S,
-  MemoryCopyFromContextM2H,
-  MemoryCopyFromContextM2D,
-  MemoryCopyFromContextM2M,
-  MemoryCopyFromContextM2S,
-  MemoryCopyFromContextS2H,
-  MemoryCopyFromContextS2D,
-  MemoryCopyFromContextS2M,
-  MemoryCopyFromContextS2S,
-  ImageCopy,
-  ImageCopyH2H = ImageCopy,
-  ImageCopyH2D,
-  ImageCopyH2M,
-  ImageCopyH2S,
-  ImageCopyD2H,
-  ImageCopyD2D,
-  ImageCopyD2M,
-  ImageCopyD2S,
-  ImageCopyM2H,
-  ImageCopyM2D,
-  ImageCopyM2M,
-  ImageCopyM2S,
-  ImageCopyS2H,
-  ImageCopyS2D,
-  ImageCopyS2M,
-  ImageCopyS2S,
-  ImageCopyRegion,
-  ImageCopyRegionH2H = ImageCopyRegion,
-  ImageCopyRegionH2D,
-  ImageCopyRegionH2M,
-  ImageCopyRegionH2S,
-  ImageCopyRegionD2H,
-  ImageCopyRegionD2D,
-  ImageCopyRegionD2M,
-  ImageCopyRegionD2S,
-  ImageCopyRegionM2H,
-  ImageCopyRegionM2D,
-  ImageCopyRegionM2M,
-  ImageCopyRegionM2S,
-  ImageCopyRegionS2H,
-  ImageCopyRegionS2D,
-  ImageCopyRegionS2M,
-  ImageCopyRegionS2S,
-  ImageCopyFromMemory,
-  ImageCopyFromMemoryH2H = ImageCopyFromMemory,
-  ImageCopyFromMemoryH2D,
-  ImageCopyFromMemoryH2M,
-  ImageCopyFromMemoryH2S,
-  ImageCopyFromMemoryD2H,
-  ImageCopyFromMemoryD2D,
-  ImageCopyFromMemoryD2M,
-  ImageCopyFromMemoryD2S,
-  ImageCopyFromMemoryM2H,
-  ImageCopyFromMemoryM2D,
-  ImageCopyFromMemoryM2M,
-  ImageCopyFromMemoryM2S,
-  ImageCopyFromMemoryS2H,
-  ImageCopyFromMemoryS2D,
-  ImageCopyFromMemoryS2M,
-  ImageCopyFromMemoryS2S,
-  ImageCopyToMemory,
-  ImageCopyToMemoryH2H = ImageCopyToMemory,
-  ImageCopyToMemoryH2D,
-  ImageCopyToMemoryH2M,
-  ImageCopyToMemoryH2S,
-  ImageCopyToMemoryD2H,
-  ImageCopyToMemoryD2D,
-  ImageCopyToMemoryD2M,
-  ImageCopyToMemoryD2S,
-  ImageCopyToMemoryM2H,
-  ImageCopyToMemoryM2D,
-  ImageCopyToMemoryM2M,
-  ImageCopyToMemoryM2S,
-  ImageCopyToMemoryS2H,
-  ImageCopyToMemoryS2D,
-  ImageCopyToMemoryS2M,
-  ImageCopyToMemoryS2S,
-  MemoryFill,
-  MemoryFillH = MemoryFill,
-  MemoryFillD,
-  MemoryFillM,
-  MemoryFillS,
-  Barrier,
-  MemoryRangesBarrier,
-  EventReset,
-  LastCommand = EventReset
-};
-
-static const char *device_command_names[] = {
-  "zeCommandListAppendMemoryCopy(H2H)",
-  "zeCommandListAppendMemoryCopy(H2D)",
-  "zeCommandListAppendMemoryCopy(H2M)",
-  "zeCommandListAppendMemoryCopy(H2S)",
-  "zeCommandListAppendMemoryCopy(D2H)",
-  "zeCommandListAppendMemoryCopy(D2D)",
-  "zeCommandListAppendMemoryCopy(D2M)",
-  "zeCommandListAppendMemoryCopy(D2S)",
-  "zeCommandListAppendMemoryCopy(M2H)",
-  "zeCommandListAppendMemoryCopy(M2D)",
-  "zeCommandListAppendMemoryCopy(M2M)",
-  "zeCommandListAppendMemoryCopy(M2S)",
-  "zeCommandListAppendMemoryCopy(S2H)",
-  "zeCommandListAppendMemoryCopy(S2D)",
-  "zeCommandListAppendMemoryCopy(S2M)",
-  "zeCommandListAppendMemoryCopy(S2S)",
-  "zeCommandListAppendMemoryCopyRegion(H2H)",
-  "zeCommandListAppendMemoryCopyRegion(H2D)",
-  "zeCommandListAppendMemoryCopyRegion(H2M)",
-  "zeCommandListAppendMemoryCopyRegion(H2S)",
-  "zeCommandListAppendMemoryCopyRegion(D2H)",
-  "zeCommandListAppendMemoryCopyRegion(D2D)",
-  "zeCommandListAppendMemoryCopyRegion(D2M)",
-  "zeCommandListAppendMemoryCopyRegion(D2S)",
-  "zeCommandListAppendMemoryCopyRegion(M2H)",
-  "zeCommandListAppendMemoryCopyRegion(M2D)",
-  "zeCommandListAppendMemoryCopyRegion(M2M)",
-  "zeCommandListAppendMemoryCopyRegion(M2S)",
-  "zeCommandListAppendMemoryCopyRegion(S2H)",
-  "zeCommandListAppendMemoryCopyRegion(S2D)",
-  "zeCommandListAppendMemoryCopyRegion(S2M)",
-  "zeCommandListAppendMemoryCopyRegion(S2S)",
-  "zeCommandListAppendMemoryCopyFromContext(H2H)",
-  "zeCommandListAppendMemoryCopyFromContext(H2D)",
-  "zeCommandListAppendMemoryCopyFromContext(H2M)",
-  "zeCommandListAppendMemoryCopyFromContext(H2S)",
-  "zeCommandListAppendMemoryCopyFromContext(D2H)",
-  "zeCommandListAppendMemoryCopyFromContext(D2D)",
-  "zeCommandListAppendMemoryCopyFromContext(D2M)",
-  "zeCommandListAppendMemoryCopyFromContext(D2S)",
-  "zeCommandListAppendMemoryCopyFromContext(M2H)",
-  "zeCommandListAppendMemoryCopyFromContext(M2D)",
-  "zeCommandListAppendMemoryCopyFromContext(M2M)",
-  "zeCommandListAppendMemoryCopyFromContext(M2S)",
-  "zeCommandListAppendMemoryCopyFromContext(S2H)",
-  "zeCommandListAppendMemoryCopyFromContext(S2D)",
-  "zeCommandListAppendMemoryCopyFromContext(S2M)",
-  "zeCommandListAppendMemoryCopyFromContext(S2S)",
-  "zeCommandListAppendImageCopy(H2H)",
-  "zeCommandListAppendImageCopy(H2D)",
-  "zeCommandListAppendImageCopy(H2M)",
-  "zeCommandListAppendImageCopy(H2S)",
-  "zeCommandListAppendImageCopy(D2H)",
-  "zeCommandListAppendImageCopy(D2D)",
-  "zeCommandListAppendImageCopy(D2M)",
-  "zeCommandListAppendImageCopy(D2S)",
-  "zeCommandListAppendImageCopy(M2H)",
-  "zeCommandListAppendImageCopy(M2D)",
-  "zeCommandListAppendImageCopy(M2M)",
-  "zeCommandListAppendImageCopy(M2S)",
-  "zeCommandListAppendImageCopy(S2H)",
-  "zeCommandListAppendImageCopy(S2D)",
-  "zeCommandListAppendImageCopy(S2M)",
-  "zeCommandListAppendImageCopy(S2S)",
-  "zeCommandListAppendImageCopyRegion(H2H)",
-  "zeCommandListAppendImageCopyRegion(H2D)",
-  "zeCommandListAppendImageCopyRegion(H2M)",
-  "zeCommandListAppendImageCopyRegion(H2S)",
-  "zeCommandListAppendImageCopyRegion(D2H)",
-  "zeCommandListAppendImageCopyRegion(D2D)",
-  "zeCommandListAppendImageCopyRegion(D2M)",
-  "zeCommandListAppendImageCopyRegion(D2S)",
-  "zeCommandListAppendImageCopyRegion(M2H)",
-  "zeCommandListAppendImageCopyRegion(M2D)",
-  "zeCommandListAppendImageCopyRegion(M2M)",
-  "zeCommandListAppendImageCopyRegion(M2S)",
-  "zeCommandListAppendImageCopyRegion(S2H)",
-  "zeCommandListAppendImageCopyRegion(S2D)",
-  "zeCommandListAppendImageCopyRegion(S2M)",
-  "zeCommandListAppendImageCopyRegion(S2S)",
-  "zeCommandListAppendImageCopyFromMemory(H2H)",
-  "zeCommandListAppendImageCopyFromMemory(H2D)",
-  "zeCommandListAppendImageCopyFromMemory(H2M)",
-  "zeCommandListAppendImageCopyFromMemory(H2S)",
-  "zeCommandListAppendImageCopyFromMemory(D2H)",
-  "zeCommandListAppendImageCopyFromMemory(D2D)",
-  "zeCommandListAppendImageCopyFromMemory(D2M)",
-  "zeCommandListAppendImageCopyFromMemory(D2S)",
-  "zeCommandListAppendImageCopyFromMemory(M2H)",
-  "zeCommandListAppendImageCopyFromMemory(M2D)",
-  "zeCommandListAppendImageCopyFromMemory(M2M)",
-  "zeCommandListAppendImageCopyFromMemory(M2S)",
-  "zeCommandListAppendImageCopyFromMemory(S2H)",
-  "zeCommandListAppendImageCopyFromMemory(S2D)",
-  "zeCommandListAppendImageCopyFromMemory(S2M)",
-  "zeCommandListAppendImageCopyFromMemory(S2S)",
-  "zeCommandListAppendImageCopyToMemory(H2H)",
-  "zeCommandListAppendImageCopyToMemory(H2D)",
-  "zeCommandListAppendImageCopyToMemory(H2M)",
-  "zeCommandListAppendImageCopyToMemory(H2S)",
-  "zeCommandListAppendImageCopyToMemory(D2H)",
-  "zeCommandListAppendImageCopyToMemory(D2D)",
-  "zeCommandListAppendImageCopyToMemory(D2M)",
-  "zeCommandListAppendImageCopyToMemory(D2S)",
-  "zeCommandListAppendImageCopyToMemory(M2H)",
-  "zeCommandListAppendImageCopyToMemory(M2D)",
-  "zeCommandListAppendImageCopyToMemory(M2M)",
-  "zeCommandListAppendImageCopyToMemory(M2S)",
-  "zeCommandListAppendImageCopyToMemory(S2H)",
-  "zeCommandListAppendImageCopyToMemory(S2D)",
-  "zeCommandListAppendImageCopyToMemory(S2M)",
-  "zeCommandListAppendImageCopyToMemory(S2S)",
-  "zeCommandListAppendMemoryFill(H)",
-  "zeCommandListAppendMemoryFill(D)",
-  "zeCommandListAppendMemoryFill(M)",
-  "zeCommandListAppendMemoryFill(S)",
-  "zeCommandListAppendBarrier",
-  "zeCommandListAppendMemoryRangesBarrier",
-  "zeCommandListAppendEventReset"
-};
-
-struct ZeKernelCommandTime {
-  uint64_t append_time_;
-  uint64_t submit_time_;
-  uint64_t execute_time_;
-  uint64_t min_time_;
-  uint64_t max_time_;
-  uint64_t call_count_;
-
-  bool operator>(const ZeKernelCommandTime& r) const {
-    if (execute_time_ != r.execute_time_) {
-      return execute_time_ > r.execute_time_;
-    }
-    return call_count_ > r.call_count_;
-  }
-
-  bool operator!=(const ZeKernelCommandTime& r) const {
-    if (execute_time_ == r.execute_time_) {
-      return call_count_ != r.call_count_;
-    }
-    return true;
-  }
-};
-
-struct ZeKernelCommandNameKey {
-  uint64_t kernel_command_id_;
-  uint64_t mem_size_;
-  int tile_;
-  ze_group_count_t group_count_;
-
-  bool operator>(const ZeKernelCommandNameKey& r) const {
-    if (kernel_command_id_ != r.kernel_command_id_) {
-      return kernel_command_id_ > r.kernel_command_id_;
-    }
-    if (mem_size_ != r.mem_size_) {
-      return mem_size_ > r.mem_size_;
-    }
-    if (tile_ != r.tile_) {
-      return tile_ > r.tile_;
-    }
-
-    if (group_count_.groupCountX != r.group_count_.groupCountX) {
-      return (group_count_.groupCountX > r.group_count_.groupCountX);
-    }
-
-    if (group_count_.groupCountY != r.group_count_.groupCountY) {
-      return (group_count_.groupCountY > r.group_count_.groupCountY);
-    }
-
-    return (group_count_.groupCountZ > r.group_count_.groupCountZ);
-  }
-
-  bool operator!=(const ZeKernelCommandNameKey& r) const {
-    if (kernel_command_id_ == r.kernel_command_id_) {
-      if (mem_size_ == r.mem_size_) {
-        if (tile_ == r.tile_) {
-          return ((group_count_.groupCountX != r.group_count_.groupCountX) ||
-              (group_count_.groupCountY != r.group_count_.groupCountY) || (group_count_.groupCountZ != r.group_count_.groupCountZ));
-        }
-      }
-    }
-
-    return true;
-  }
-};
-
-struct ZeKernelCommandNameKeyCompare {
-  bool operator()(const ZeKernelCommandNameKey& lhs, const ZeKernelCommandNameKey& rhs) const {
-    if (lhs.kernel_command_id_ != rhs.kernel_command_id_) {
-      return (lhs.kernel_command_id_ < rhs.kernel_command_id_);
-    }
-    if (lhs.mem_size_ != rhs.mem_size_) {
-      return (lhs.mem_size_ < rhs.mem_size_);
-    }
-    if (lhs.tile_ != rhs.tile_) {
-      return (lhs.tile_ < rhs.tile_);
-    }
-    if (lhs.group_count_.groupCountX != rhs.group_count_.groupCountX) {
-      return (lhs.group_count_.groupCountX < rhs.group_count_.groupCountX);
-    }
-    if (lhs.group_count_.groupCountY != rhs.group_count_.groupCountY) {
-      return (lhs.group_count_.groupCountY < rhs.group_count_.groupCountY);
-    }
-    if (lhs.group_count_.groupCountZ != rhs.group_count_.groupCountZ) {
-      return (lhs.group_count_.groupCountZ < rhs.group_count_.groupCountZ);
-    }
-    return false;
-  }
-};
-
-struct ZeKernelProfileTimestamps {
-  uint64_t metric_start;
-  uint64_t metric_end;
-  int32_t subdevice_id;
-};
-
-struct ZeKernelProfileRecord {
-  ze_device_handle_t device_ = nullptr;
-  std::vector<ZeKernelProfileTimestamps> timestamps_;
-  uint64_t kernel_command_id_;
-  uint64_t instance_id_;
-  ze_group_count_t group_count_;
-  size_t mem_size_;
-  std::vector<uint8_t> *metrics_ = nullptr;
-};
-
-using ZeKernelProfiles = std::map<uint64_t, ZeKernelProfileRecord>;
-
-struct ZeCommand;
-struct ZeCommandMetricQuery;
-
-struct ZeGraph {
-  // Captured command descriptors and metric queries, cloned on each
-  // graph execution.
-  std::vector<ZeCommand *> commands_;
-  std::vector<ZeCommandMetricQuery *> metric_queries_;
-
-  // Maps each captured signal event to the cmdlist that signaled it.
-  // Used for fork detection (a non-capturing cmdlist waits on one of these)
-  // and join detection (primary cmdlist waits on a forked cmdlist's event).
-  std::map<ze_event_handle_t, ze_command_list_handle_t> event_to_cmdlist_;
-
-  // The cmdlist that initiated capture (BeginGraphCapture / BeginCaptureIntoGraph).
-  ze_command_list_handle_t primary_command_list_ = nullptr;
-
-  // Cmdlists that auto-entered capture via fork detection.
-  // Cleaned up on EndGraphCapture if not already joined.
-  std::set<ze_command_list_handle_t> forked_command_lists_;
-};
-
-// Global graph tracking data structures
-static std::shared_mutex graphs_mutex_;
-static std::map<ze_graph_handle_t, ZeGraph*> graphs_;
-
-// Map from executable graph to source graph (for looking up captured commands on execution)
-static std::shared_mutex executable_graphs_mutex_;
-static std::map<ze_executable_graph_handle_t, ZeGraph*> executable_to_source_graph_;
-
-static std::mutex global_kernel_profiles_mutex_;
-static ZeKernelProfiles global_kernel_profiles_;
-
-void SweepKernelProfiles(ZeKernelProfiles& profiles) {
-  const std::lock_guard<std::mutex> lock(global_kernel_profiles_mutex_);
-  global_kernel_profiles_.insert(profiles.begin(), profiles.end());
-}
-
-static std::mutex global_device_time_stats_mutex_;
-static std::map<ZeKernelCommandNameKey, ZeKernelCommandTime, ZeKernelCommandNameKeyCompare> *global_device_time_stats_ = nullptr;
-
-void SweepKernelCommandTimeStats(std::map<ZeKernelCommandNameKey, ZeKernelCommandTime, ZeKernelCommandNameKeyCompare>& stats) {
-  global_device_time_stats_mutex_.lock();
-  if (global_device_time_stats_ == nullptr) {
-    global_device_time_stats_ = new std::map<ZeKernelCommandNameKey, ZeKernelCommandTime, ZeKernelCommandNameKeyCompare>;
-    UniMemory::ExitIfOutOfMemory((void *)(global_device_time_stats_));
-  }
-  for (auto it = stats.begin(); it != stats.end(); it++) {
-    auto it2 = global_device_time_stats_->find(it->first);
-    if (it2 == global_device_time_stats_->end()) {
-      ZeKernelCommandTime stat;
-      stat.append_time_ = it->second.append_time_;
-      stat.submit_time_ = it->second.submit_time_;
-      stat.execute_time_ = it->second.execute_time_;
-      stat.min_time_ = it->second.min_time_;
-      stat.max_time_ = it->second.max_time_;
-      stat.call_count_ = it->second.call_count_;
-      global_device_time_stats_->insert({it->first, std::move(stat)});
-    }
-    else {
-      it2->second.append_time_ += it->second.append_time_;
-      it2->second.submit_time_ +=  it->second.submit_time_;
-      it2->second.execute_time_ += it->second.execute_time_;
-      if (it->second.max_time_ > it2->second.max_time_) {
-        it2->second.max_time_ = it->second.max_time_;
-      }
-      if (it->second.min_time_ < it2->second.min_time_) {
-        it2->second.min_time_ = it->second.min_time_;
-      }
-      it2->second.call_count_ += it->second.call_count_;
-    }
-  }
-  global_device_time_stats_mutex_.unlock();
-}
-
-static std::mutex global_host_time_stats_mutex_;
-static std::map<uint32_t, ZeFunctionTime> *global_host_time_stats_ = nullptr;
-
-void SweepHostFunctionTimeStats(std::map<uint32_t, ZeFunctionTime>& stats) {
-  global_host_time_stats_mutex_.lock();
-  if (global_host_time_stats_ == nullptr) {
-    global_host_time_stats_ = new std::map<uint32_t, ZeFunctionTime>;
-    UniMemory::ExitIfOutOfMemory((void *)(global_host_time_stats_));
-  }
-  for (auto it = stats.begin(); it != stats.end(); it++) {
-    auto it2 = global_host_time_stats_->find(it->first);
-    if (it2 == global_host_time_stats_->end()) {
-      ZeFunctionTime stat;
-      stat.total_time_ = it->second.total_time_;
-      stat.min_time_ = it->second.min_time_;
-      stat.max_time_ = it->second.max_time_;
-      stat.call_count_ = it->second.call_count_;
-      global_host_time_stats_->insert({it->first, std::move(stat)});
-    }
-    else {
-      it2->second.total_time_ += it->second.total_time_;
-      if (it->second.max_time_ > it2->second.max_time_) {
-        it2->second.max_time_ = it->second.max_time_;
-      }
-      if (it->second.min_time_ < it2->second.min_time_) {
-        it2->second.min_time_ = it->second.min_time_;
-      }
-      it2->second.call_count_ += it->second.call_count_;
-    }
-  }
-  global_host_time_stats_mutex_.unlock();
-}
-
-struct ZeCommandMetricQuery {
-  uint64_t instance_id_;        // unique kernel or command instance identifier
-  zet_metric_query_handle_t metric_query_;
-  ze_event_handle_t metric_query_event_;
-  ze_device_handle_t device_;
-  ZeKernelCommandType type_;
-  bool immediate_;
-};
-
-struct ZeCommand {
-  uint64_t kernel_command_id_;  // kernel or command identifier
-  uint64_t instance_id_;        // unique kernel or command instance identifier
-  ze_event_handle_t event_;
-  ze_event_handle_t timestamp_event_;
-  ze_event_handle_t in_order_counter_event_;
-  ze_device_handle_t device_;
-  uint64_t host_time_origin_;   // in ns
-  uint64_t device_timer_frequency_;
-  uint64_t device_timer_mask_;
-  double device_ns_per_cycle_;
-  uint64_t append_time_;
-  uint64_t submit_time_;        // in ns
-  uint64_t submit_time_device_; // in ticks
-  ze_command_list_handle_t command_list_;
-  ze_command_queue_handle_t queue_;
-  ze_fence_handle_t fence_;
-  uint64_t tid_;
-  uint64_t mem_size_;           // memory copy/fill size
-  ZeCommandMetricQuery *command_metric_query_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-  ZeKernelGroupSize group_size_;
-  ze_group_count_t group_count_;
-  ZeKernelCommandType type_;
-  std::vector<ze_kernel_timestamp_result_t *> *timestamps_on_event_reset_;  // points to timestamps_on_event_reset_ in the command list
-  ze_kernel_timestamp_result_t **timestamps_on_commands_completion_;  // points to timestamps_on_commands_completion_ in command list
-  uint64_t *device_global_timestamps_;  // points to device_global_timestamps_
-  int timestamp_seq_;  // sequence number in the command list for timestamps
-  std::vector<int> *index_timestamps_on_commands_completion_;  // indices to timestamps_on_commands_completion_
-  std::vector<int> *index_timestamps_on_event_reset_;  // indices to timestamps_on_event_reset_
-  bool implicit_scaling_;
-  bool immediate_;
-  bool graph_command_;  // true if this command is part of a graph execution (event is owned by graph)
-};
-
-
-struct ZeDeviceSubmissions;
-std::shared_mutex global_device_submissions_mutex_;
-std::set<ZeDeviceSubmissions *> *global_device_submissions_ = nullptr;
-
-struct ZeDeviceSubmissions {
-  std::list<ZeCommand *> commands_submitted_;
-  std::list<ZeCommand *> commands_staged_;
-  std::list<ZeCommand *> commands_free_pool_;
-  std::list<ZeCommandMetricQuery *> metric_queries_submitted_;
-  std::list<ZeCommandMetricQuery *> metric_queries_staged_;
-  std::list<ZeCommandMetricQuery *> metric_queries_free_pool_;
-  std::map<ZeKernelCommandNameKey, ZeKernelCommandTime, ZeKernelCommandNameKeyCompare> device_time_stats_;
-  std::map<uint32_t, ZeFunctionTime> host_time_stats_;
-  ZeKernelProfiles kernel_profiles_;
-  std::atomic<bool> finalized_;
-
-  ZeDeviceSubmissions() {
-    finalized_.store(false, std::memory_order_release);
-
-    ZeCommand *command = new ZeCommand;
-
-    UniMemory::ExitIfOutOfMemory((void *)(command));
-
-    commands_free_pool_.push_back(command);
-    global_device_submissions_mutex_.lock();
-    if (global_device_submissions_ == nullptr) {
-      global_device_submissions_ = new std::set<ZeDeviceSubmissions *>;
-      UniMemory::ExitIfOutOfMemory((void *)(global_device_submissions_));
-    }
-
-    global_device_submissions_->insert(this);
-    global_device_submissions_mutex_.unlock();
-  }
-
-  ~ZeDeviceSubmissions() {
-    global_device_submissions_mutex_.lock();
-    if (!finalized_.exchange(true)) {
-      // finalize if not finalized
-      SweepKernelCommandTimeStats(device_time_stats_);
-      SweepHostFunctionTimeStats(host_time_stats_);
-      SweepKernelProfiles(kernel_profiles_);
-      global_device_submissions_->erase(this);
-    }
-    global_device_submissions_mutex_.unlock();
-  }
-
-  ZeDeviceSubmissions(const struct ZeDeviceSubmissions& that) = delete;
-
-  ZeDeviceSubmissions& operator=(const struct ZeDeviceSubmissions& that) = delete;
-
-  inline void SubmitKernelCommand(ZeCommand *command) {
-    if (!IsFinalized()) {
-      commands_submitted_.push_back(command);
-    }
-    else {
-      commands_free_pool_.push_back(command);
-    }
-  }
-
-  inline void StageKernelCommand(ZeCommand *command) {
-    commands_staged_.push_back(command);
-  }
-
-  inline ZeCommand *GetKernelCommand(void) {
-    ZeCommand *command;
-
-    if (commands_free_pool_.empty()) {
-      command = new ZeCommand;
-      UniMemory::ExitIfOutOfMemory((void *)(command));
-    }
-    else {
-      command = commands_free_pool_.front();
-      commands_free_pool_.pop_front();
-    }
-
-    // Explicitly initialize ZeCommand members.
-    command->instance_id_ = 0;
-    command->event_ = nullptr;
-    command->in_order_counter_event_ = nullptr;
-    command->device_ = nullptr;
-    command->append_time_ = 0;
-    command->submit_time_ = 0;
-    command->submit_time_device_ = 0;
-    command->command_list_ = nullptr;
-    command->queue_ = nullptr;
-    command->mem_size_ = 0;
-
-    command->timestamp_seq_ = -1;
-    command->timestamp_event_ = nullptr;
-    command->timestamps_on_event_reset_ = nullptr;  // points to timestamps_on_event_reset_ in the command list
-    command->timestamps_on_commands_completion_ = nullptr;    // points to timestamps_on_commands_completion_ in command list
-    command->device_global_timestamps_ = nullptr;
-    command->index_timestamps_on_commands_completion_ = nullptr;   // indices to timestamps_on_commands_completion_
-    command->index_timestamps_on_event_reset_ = nullptr;
-    command->graph_command_ = false;
-
-    return command;
-  }
-
-  inline void SubmitCommandMetricQuery(ZeCommandMetricQuery *query) {
-    if (!IsFinalized()) {
-      metric_queries_submitted_.push_back(query);
-    }
-    else {
-      metric_queries_free_pool_.push_back(query);
-    }
-  }
-
-  inline void StageCommandMetricQuery(ZeCommandMetricQuery *query) {
-    metric_queries_staged_.push_back(query);
-  }
-
-  inline void SubmitStagedKernelCommandAndMetricQueries(ZeEventCache& event_cache, std::vector<uint64_t> *kids) {
-    auto cit = commands_staged_.begin();
-    auto mit = metric_queries_staged_.begin();
-    for (; cit != commands_staged_.end(); cit++, mit++) {
-      ZeCommand *cmd = *cit;
-      ZeCommandMetricQuery *cmd_query = *mit;
-
-      // back fill kernel instance id and reset event
-      cmd->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-      // Do not reset cmd->event_ here: the command may have completed and signaled it.
-      // ProcessCommandSubmitted() resets it.
-
-      if (kids) {
-        kids->push_back(cmd->instance_id_);
-      }
-      SubmitKernelCommand(cmd);
-
-      if (cmd_query != nullptr) {
-        cmd_query->instance_id_ = cmd->instance_id_;
-        SubmitCommandMetricQuery(cmd_query);
-      }
-    }
-    commands_staged_.clear();
-    metric_queries_staged_.clear();
-  }
-
-  inline void RevertStagedKernelCommandAndMetricQueries(void) {
-    auto cit = commands_staged_.begin();
-    auto mit = metric_queries_staged_.begin();
-    for (; cit != commands_staged_.end(); cit++, mit++) {
-      ZeCommand *cmd = *cit;
-      ZeCommandMetricQuery *cmd_query = *mit;
-
-      commands_free_pool_.push_back(cmd);
-      if (cmd_query != nullptr) {
-        metric_queries_free_pool_.push_back(cmd_query);
-      }
-    }
-    commands_staged_.clear();
-    metric_queries_staged_.clear();
-  }
-
-  inline void RevertStagedKernelCommandAndMetricQueriesForEvent(ze_event_handle_t event) {
-    auto cit = commands_staged_.begin();
-    auto mit = metric_queries_staged_.begin();
-    while (cit != commands_staged_.end()) {
-      ZeCommand *cmd = *cit;
-      ZeCommandMetricQuery *cmd_query = *mit;
-
-      if (cmd->event_ != event) {
-        cit++;
-        mit++;
-        continue;
-      }
-
-      // remove from staged lists
-      cit = commands_staged_.erase(cit);
-      mit = metric_queries_staged_.erase(mit);
-
-      commands_free_pool_.push_back(cmd);
-      if (cmd_query != nullptr) {
-        metric_queries_free_pool_.push_back(cmd_query);
-      }
-    }
-  }
-
-  inline ZeCommandMetricQuery *GetCommandMetricQuery(void) {
-    ZeCommandMetricQuery *query;
-
-    if (metric_queries_free_pool_.empty()) {
-      query = new ZeCommandMetricQuery;
-      UniMemory::ExitIfOutOfMemory((void *)(query));
-    }
-    else {
-      query = metric_queries_free_pool_.front();
-      metric_queries_free_pool_.pop_front();
-    }
-
-    query->instance_id_ = 0;
-    query->metric_query_ = nullptr;
-    query->metric_query_event_ = nullptr;
-    query->device_ = nullptr;
-
-    return query;
-  }
-
-  inline void CollectHostFunctionTimeStats(uint32_t id, uint64_t host_time) {
-    auto it = host_time_stats_.find(id);
-    if (it == host_time_stats_.end()){
-      ZeFunctionTime stat;
-      stat.total_time_ = host_time;
-      stat.min_time_ = host_time;
-      stat.max_time_ = host_time;
-      stat.call_count_ = 1;
-      host_time_stats_.insert({id, std::move(stat)});
-    }
-    else {
-      it->second.total_time_ += host_time;
-      if (host_time > it->second.max_time_) {
-        it->second.max_time_ = host_time;
-      }
-      if (host_time < it->second.min_time_) {
-        it->second.min_time_ = host_time;
-      }
-      it->second.call_count_ += 1;
-    }
-  }
-
-  inline void CollectKernelCommandTimeStats(const ZeCommand *command, uint64_t kernel_start, uint64_t kernel_end, int tile) {
-    ZeKernelCommandNameKey key {command->kernel_command_id_, command->mem_size_, tile, command->group_count_};
-    uint64_t kernel_time = kernel_end - kernel_start;
-    auto it = device_time_stats_.find(key);
-    if (it == device_time_stats_.end()){
-      ZeKernelCommandTime stat;
-      stat.append_time_ = command->submit_time_ - command->append_time_;
-      stat.submit_time_ = kernel_start - command->submit_time_;
-      stat.execute_time_ = kernel_time;
-      stat.min_time_ = kernel_time;
-      stat.max_time_ = kernel_time;
-      stat.call_count_ = 1;
-      device_time_stats_.insert({std::move(key), std::move(stat)});
-    }
-    else {
-      it->second.append_time_ += (command->submit_time_ - command->append_time_);
-      it->second.submit_time_ +=  (kernel_start - command->submit_time_);
-      it->second.execute_time_ += kernel_time;
-      if (kernel_time > it->second.max_time_) {
-        it->second.max_time_ = kernel_time;
-      }
-      if (kernel_time < it->second.min_time_) {
-        it->second.min_time_ = kernel_time;
-      }
-      it->second.call_count_ += 1;
-    }
-  }
-
-  inline bool IsFinalized(void) {
-    return finalized_.load(std::memory_order_acquire);
-  }
-
-  inline void Finalize(void) {
-    // caller holds exclusive global_device_submissions_mutex_ lock
-    finalized_.store(true, std::memory_order_release);
-    SweepKernelCommandTimeStats(device_time_stats_);
-    SweepHostFunctionTimeStats(host_time_stats_);
-    SweepKernelProfiles(kernel_profiles_);
-  }
-};
-
-thread_local ZeDeviceSubmissions local_device_submissions_;
-
-struct ZeKernelCommandProperties {
-  uint64_t id_;    // unique identifier
-  uint64_t base_addr_;  // kernel base address
-  ze_device_handle_t device_;
-  int32_t device_id_;
-  uint32_t simd_width_;  // SIMD
-  uint32_t nargs_;  // number of kernel arguments
-  uint32_t nsubgrps_;  // maximal number of subgroups
-  uint32_t slmsize_;  // SLM size
-  uint32_t private_mem_size_;  // private memory size for each thread
-  uint32_t spill_mem_size_;  // spill memory size for each thread
-  ZeKernelGroupSize group_size_;  // group size
-  ZeKernelCommandType type_;
-  uint32_t regsize_;  // GRF size per thread
-  bool aot_;    // AOT or JIT
-  std::string name_;  // kernel or command name
-  bool skip_;  // skip this kernel in the trace
-};
-
-// these will not go away when ZeCollector is destructed
-static std::shared_mutex kernel_command_properties_mutex_;
-static std::map<uint64_t, ZeKernelCommandProperties> *kernel_command_properties_ = nullptr;
-static std::map<ze_kernel_handle_t, ZeKernelCommandProperties> *active_kernel_properties_ = nullptr;
-static std::map<uint64_t, ZeKernelCommandProperties> *active_command_properties_ = nullptr;
-
-struct ZeModule {
-  ze_device_handle_t device_;
-  bool aot_;  // AOT or JIT
-  // From UniModuleId, never 0. Identifies the module within the process and names its
-  // dumped binary (LoggerFactory::GetModuleBinaryFileName). The binary itself is not
-  // kept, so it does not stay resident for the whole run.
-  uint32_t id_;
-};
-
-static std::shared_mutex modules_on_devices_mutex_;
-static std::map<ze_module_handle_t, ZeModule> modules_on_devices_; //module to ZeModule map
-
-enum ZeQueueEngineType {
-  ZE_QUEUE_COMPUTE_ENGINE,
-  ZE_QUEUE_COPY_ENGINE,
-  // Add any new engine type
-  ZE_QUEUE_UNKNOWN_ENGINE
-};
-
-struct ZeDevice {
-  ze_device_handle_t device_;
-  ze_device_handle_t parent_device_;
-  uint64_t host_time_origin_;  // in ns
-  uint64_t device_timer_frequency_;
-  uint64_t device_timer_mask_;
-  double device_ns_per_cycle_;
-  ze_driver_handle_t driver_;
-  ze_context_handle_t context_;
-  zet_metric_group_handle_t metric_group_;
-  int32_t id_;
-  int32_t parent_id_;
-  int32_t subdevice_id_;
-  int32_t num_subdevices_;
-  ze_pci_ext_properties_t pci_properties_;
-  std::string device_name_;
-  std::vector<ZeQueueEngineType> queue_engine_prop_;
-};
-
-// these will not go away when ZeCollector is destructed
-static std::shared_mutex devices_mutex_;
-static std::map<ze_device_handle_t, ZeDevice> *devices_ = nullptr;
-
-struct ZeCommandQueue {
-  ze_command_queue_handle_t queue_;
-  ze_context_handle_t context_;
-  ze_device_handle_t device_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-};
-
-
-constexpr static int number_timestamps_per_slice_ = 128;
-constexpr static int cache_line_size_ = 64;
-
-struct ZeCommandList {
-  ze_command_list_handle_t cmdlist_;
-  ze_context_handle_t context_;
-  ze_device_handle_t device_;
-  uint64_t host_time_origin_;  // in ns
-  uint64_t device_timer_frequency_;
-  uint64_t device_timer_mask_;
-  double device_ns_per_cycle_;
-  uint32_t engine_ordinal_;  // valid if immediate command list
-  uint32_t engine_index_;  // valid if immediate command list
-  bool immediate_;
-  bool implicit_scaling_;
-  bool in_order_;
-  std::vector<ZeCommand *> commands_;  // if non-immediate command list
-  std::vector<ZeCommandMetricQuery *> metric_queries_;  // if non-immediate command list
-  std::vector<ze_kernel_timestamp_result_t *> timestamps_on_event_reset_; // timestamps queried on event reset
-  ze_kernel_timestamp_result_t *timestamps_on_commands_completion_; // timestamps queried on commands completion
-  int num_timestamps_;  // total number of timestamps
-  int num_timestamps_on_event_reset_;  // total number of timestamps queried on event reset
-  std::map<ze_event_handle_t, int> event_to_timestamp_seq_; // map event to timestamp sequence in command list
-  std::vector<int> index_timestamps_on_commands_completion_;  // indices to timestamps_on_commands_completion_ for each command
-  std::vector<int> index_timestamps_on_event_reset_;  // indices to timestamps_on_event_reset_ for each command
-  std::vector<uint64_t *> device_global_timestamps_;  // device timestamps on host
-  int num_device_global_timestamps_;
-  ze_event_handle_t timestamp_event_to_signal_;
-  bool graph_capturing_ = false;
-  ZeGraph* graph_capture_target_ = nullptr;
-  ZeGraph* pending_graph_capture_ = nullptr;  // Heap-allocated for BeginGraphCaptureExp path
-};
-
-typedef void (*OnZeFunctionFinishCallback)(std::vector<uint64_t> *kids, FLOW_DIR flow_dir, API_TRACING_ID api_id, uint64_t started, uint64_t ended);
-
-typedef void (*OnZeKernelFinishCallback)(uint64_t kid, uint64_t tid, uint64_t start, uint64_t end, uint32_t ordinal, uint32_t index, int32_t tile, const ze_device_handle_t device, const uint64_t kernel_command_id, bool implicit_scaling, const ze_group_count_t& group_count, size_t mem_size);
-
-ze_result_t (*ZexKernelGetBaseAddress)(ze_kernel_handle_t hKernel, uint64_t *baseAddress) = nullptr;
-
-inline std::string GetZeKernelCommandName(uint64_t id, const ze_group_count_t& group_count, size_t size, bool detailed = true) {
-  std::string str;
-  kernel_command_properties_mutex_.lock_shared();
-  auto it = kernel_command_properties_->find(id);
-  if (it != kernel_command_properties_->end()) {
-    str = "\"";
-    str += std::move(utils::Demangle(it->second.name_.c_str()));  // quote kernel name which may contain ","
-    if (detailed) {
-      if (it->second.type_ == KERNEL_COMMAND_TYPE_COMPUTE) {
-        if (it->second.simd_width_ > 0) {
-          str += "[SIMD";
-          if (it->second.simd_width_ == 1) {
-            str += "_ANY";
-          } else {
-            str += std::to_string(it->second.simd_width_);
-          }
-        }
-        str = str + " {" +
-          std::to_string(group_count.groupCountX) + "; " +
-          std::to_string(group_count.groupCountY) + "; " +
-          std::to_string(group_count.groupCountZ) + "} {" +
-          std::to_string(it->second.group_size_.x) + "; " +
-          std::to_string(it->second.group_size_.y) + "; " +
-          std::to_string(it->second.group_size_.z) + "}]";
-      }
-      else if ((it->second.type_ == KERNEL_COMMAND_TYPE_MEMORY) && (size > 0)) {
-        str = str + "[" + std::to_string(size) + "]";
-      }
-    }
-    str += "\"";  // quote kernel name
-  }
-
-  kernel_command_properties_mutex_.unlock_shared();
-
-  return str;
-}
-
-inline std::string GetZeKernelCommandName(uint64_t id, ze_group_count_t& group_count, size_t size, bool detailed = true) {
-  const ze_group_count_t& gcount = group_count;
-  return GetZeKernelCommandName(id, gcount, size, detailed);
-}
-
-inline std::string GetZeDeviceName(ze_device_handle_t device) {
-  std::string device_name = "";
-  devices_mutex_.lock_shared();
-  if (devices_ != nullptr) {
-    auto it = devices_->find(device);
-    if (it != devices_->end()) {
-      device_name = it->second.device_name_;
-    }
-  }
-  devices_mutex_.unlock_shared();
-  return device_name;
-}
-
-inline std::string GetZeEngineName(ze_device_handle_t device, uint32_t ordinal) {
-  std::string engine_name = "";
-  devices_mutex_.lock_shared();
-  if (devices_ != nullptr) {
-    auto it = devices_->find(device);
-    if (it != devices_->end()) {
-      if (it->second.queue_engine_prop_[ordinal] == ZE_QUEUE_COMPUTE_ENGINE) {
-        engine_name = "L0 Compute Engine";
-      } else if (it->second.queue_engine_prop_[ordinal] == ZE_QUEUE_COPY_ENGINE) {
-        engine_name = "L0 Copy Engine";
-      } else {
-        engine_name = "L0 Engine";
-      }
-    }
-  }
-  devices_mutex_.unlock_shared();
-  return engine_name;
-}
-
-inline ze_pci_ext_properties_t *GetZeDevicePciPropertiesAndId(ze_device_handle_t device, int32_t *parent_device_id, int32_t *device_id, int32_t *subdevice_id){
-  devices_mutex_.lock_shared();
-  ze_pci_ext_properties_t *props = nullptr;
-
-  if (devices_) {
-    auto it = devices_->find(device);
-    if (it != devices_->end()) {
-      if (parent_device_id) {
-        *parent_device_id = it->second.parent_id_;
-      }
-      if (device_id) {
-        *device_id = it->second.id_;
-      }
-      if (subdevice_id) {
-        *subdevice_id = it->second.subdevice_id_;
-      }
-
-      props = &(it->second.pci_properties_);
-    }
-  }
-  devices_mutex_.unlock_shared();
-
-  return props;
-
-}
-
-// ---------------------------------------------------------------------------
-// Kernel filter lists (--include-kernels[-file], --exclude-kernels[-file])
-// ---------------------------------------------------------------------------
-
-// Splits one line of a kernel filter list into its items and appends them to out.
-//   line  one line of --include-kernels/--exclude-kernels (or of their -file form)
-//   out   receives the items, in order
-// Items are separated by commas. An item in double quotes may contain commas, and
-// \" inside it stands for a quote; an unterminated quoted item runs to the end of
-// the line. Spaces around an item are trimmed and empty items are dropped, so any
-// line, however malformed, yields a (possibly empty) list and never throws.
-inline void SplitFilterLine(const std::string& line, std::vector<std::string>& out) {
-  size_t i = 0;
-  while (i < line.size()) {
-    while (i < line.size() && isspace(static_cast<unsigned char>(line[i]))) ++i;
-    if (i >= line.size()) break;
-    std::string item;
-    if (line[i] == '"') {
-      ++i;
-      while (i < line.size()) {
-        if (line[i] == '"') {
-          ++i;
-          break;
-        }
-        if (line[i] == '\\' && i + 1 < line.size() && line[i + 1] == '"') {
-          item += '"';
-          i += 2;
-          continue;
-        }
-        item += line[i++];
-      }
-    } else {
-      while (i < line.size() && line[i] != ',') {
-        item += line[i++];
-      }
-    }
-    size_t start = 0, end = item.size();
-    while (start < end && isspace(static_cast<unsigned char>(item[start]))) ++start;
-    while (end > start && isspace(static_cast<unsigned char>(item[end - 1]))) --end;
-    if (start < end) out.push_back(item.substr(start, end - start));
-    if (i < line.size() && line[i] == ',') ++i;
-  }
-}
-
-// The kernel names of a filter: every line of file, then the filter string.
-//   file    the opened --include-kernels-file/--exclude-kernels-file, or nullptr
-//   filter  the --include-kernels/--exclude-kernels value, possibly empty
-// Returns the items of all lines, split by SplitFilterLine(). Free of Level Zero,
-// so fuzz_kernel_filter calls it as the collector does (ZeCollector::Create()
-// through ZeCollector::ParseFilterList()).
-inline std::vector<std::string> ParseFilterList(std::istream* file, const std::string& filter) {
-  std::vector<std::string> result;
-  if (file != nullptr) {
-    std::string line;
-    while (std::getline(*file, line)) {
-      SplitFilterLine(line, result);
-    }
-  }
-  if (!filter.empty()) {
-    SplitFilterLine(filter, result);
-  }
-  return result;
-}
-
-// Forward declaration for global collector pointer
-class ZeCollector;
-
-// Global collector pointer for extension API wrappers
-static ZeCollector* s_global_ze_collector_ = nullptr;
-
-// Recursion guard for extension API wrappers.
-// Extension APIs are intercepted via zeDriverGetExtensionFunctionAddress and do
-// not go through the Level Zero tracing layer (zelTracer), so L0's built-in
-// ZE_HANDLE_TRACER_RECURSION guard (tracing_layer::tracingInProgress) does not
-// apply. This flag prevents zelTracer callbacks from re-entering when L0 APIs
-// are called from within extension API wrapper callbacks.
-// This could be replaced by ZE_HANDLE_TRACER_RECURSION if Level Zero exposes
-// access to tracing_layer::tracingInProgress via a public API.
-static thread_local bool s_extension_api_tracing_in_progress_ = false;
-
-static void SetGlobalZeCollector(ZeCollector* collector) {
-  if (collector != nullptr && s_global_ze_collector_ != nullptr) {
-    std::cerr << "[ERROR] SetGlobalZeCollector: global pointer is already set. "
-              << "Only one ZeCollector per process is supported." << std::endl;
-    return;
-  }
-  s_global_ze_collector_ = collector;
-}
-
-class ZeCollector {
- private:
-    // Helpers
-    static bool SampleThisRank() {
-      std::set<int> ranks_to_sample;
-      GetZeRanksToSample(ranks_to_sample);
-
-      // Check if rank is specified for tracing in MPI environment
-      if (ranks_to_sample.size() > 0) {
-        const auto &my_MPI_rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-        if (!my_MPI_rank.empty()) {
-            int my_rank = -1;
-            if (!ToInt(my_MPI_rank, my_rank) || ranks_to_sample.find(my_rank) == ranks_to_sample.end()) {
-              std::cout << "[INFO] MPI rank " << my_rank << " is not enabled for tracing or profiling" << std::endl;
-              return false;
-            }
-        }
-      }
-      return true;
-    }
-
-    static bool SampleThisDevice(ze_driver_handle_t driver) {
-      std::set<int> devices_to_sample;
-      GetZeDevicesToSample(devices_to_sample);
-
-      if (devices_to_sample.size() != 0) {
-        int global_dev_cnt = 0;
-        auto devices = GetDeviceList(driver);
-        for (auto device : devices) {
-          if (!devices_to_sample.empty()) {
-            if (devices_to_sample.find(global_dev_cnt) != devices_to_sample.end()) {
-              break;
-            }
-          }
-          global_dev_cnt++;
-        }
-        if (global_dev_cnt == static_cast<int>(devices.size())) {
-          std::cout << "[INFO] Device or devices visible to process " << utils::GetPid() << " are not enabled for tracing or profiling" << std::endl;
-          return false;
-        }
-      }
-      return true;
-    }
- public: // Interface
-
-  static ZeCollector* Create(
-      CollectorOptions options,
-      OnZeKernelFinishCallback kcallback = nullptr,
-      OnZeFunctionFinishCallback fcallback = nullptr,
-      void* callback_data = nullptr) {
-    ze_api_version_t version = GetZeVersion();
-    UNITRACE_ASSERT(
-        ZE_MAJOR_VERSION(version) >= 1 &&
-        ZE_MINOR_VERSION(version) >= 2);
-
-    if (!SampleThisRank()) {
-      return nullptr;
-    }
-
-    ze_driver_handle_t driver;
-    uint32_t count = 1;
-    if (ZE_FUNC(zeDriverGet)(&count, &driver) == ZE_RESULT_SUCCESS) {
-      if (!SampleThisDevice(driver)) {
-        return nullptr;
-      }
-      if (ZE_FUNC(zeDriverGetExtensionFunctionAddress)(driver, "zexKernelGetBaseAddress", (void **)&ZexKernelGetBaseAddress) != ZE_RESULT_SUCCESS) {
-        ZexKernelGetBaseAddress = nullptr;
-      }
-    }
-    else {
-      std::cerr << "[ERROR] Unable to get Level Zero driver" << std::endl;
-      return nullptr;
-  }
-
-    std::string data_dir_name = utils::GetEnv("UNITRACE_DataDir");
-    bool reset_event_on_device = true;
-    std::string reset_event_env = utils::GetEnv("UNITRACE_ResetEventOnDevice");
-    if (!reset_event_env.empty() && reset_event_env == "0") {
-      reset_event_on_device = false;
-    }
-
-    std::vector<std::string> include_kernels_vec = ParseFilterList(
-        utils::GetEnv("UNITRACE_IncludeKernelsFile"),
-        utils::GetEnv("UNITRACE_IncludeKernels")
-    );
-    std::vector<std::string> exclude_kernels_vec = ParseFilterList(
-        utils::GetEnv("UNITRACE_ExcludeKernelsFile"),
-        utils::GetEnv("UNITRACE_ExcludeKernels")
-    );
-
-    ZeCollector* collector = new ZeCollector(
-      options, kcallback, fcallback, callback_data, data_dir_name, reset_event_on_device, include_kernels_vec, exclude_kernels_vec);
-
-    UniMemory::ExitIfOutOfMemory((void *)(collector));
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    zel_tracer_desc_t tracer_desc = {
-        ZEL_STRUCTURE_TYPE_TRACER_EXP_DESC, nullptr, collector};
-    zel_tracer_handle_t tracer = nullptr;
-    status = ZE_FUNC(zelTracerCreate)(&tracer_desc, &tracer);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[WARNING] Unable to create Level Zero tracer" << std::endl;
-      delete collector;
-      return nullptr;
-    }
-
-    collector->EnableTracing(tracer);
-
-    collector->tracer_ = tracer;
-
-    // Initialize extension API tracing (graph APIs, etc.)
-    SetGlobalZeCollector(collector);
-
-    return collector;
-  }
-
-  ZeCollector(const ZeCollector& that) = delete;
-
-  ZeCollector& operator=(const ZeCollector& that) = delete;
-
-  void FlushData() {
-    ProcessAllCommandsSubmitted(nullptr);
-
-    global_device_submissions_mutex_.lock();
-    if (global_device_submissions_) {
-      for (auto it = global_device_submissions_->begin(); it != global_device_submissions_->end();) {
-        (*it)->Finalize();
-        it = global_device_submissions_->erase(it);
-      }
-    }
-    global_device_submissions_mutex_.unlock();
-
-    DumpKernelProfiles();
-  }
-
-  void Finalize() {
-    FlushData();
-
-#ifndef _WIN32
-    // Not done on Windows: the process randomly dies inside zelTracerDestroy().
-    // Teardown runs from DllMain(DLL_PROCESS_DETACH) at process exit, and the call
-    // intermittently never returns -- it takes the process down before the trace is
-    // closed, silently truncating the output. Only a fraction of runs are affected,
-    // which is what made it look like malformed JSON rather than a crash.
-    // Also skipped in a fork()-without-exec child: the tracing layer waits for
-    // in-flight callbacks copied from the parent's other threads, which never
-    // drain here, so zelTracerDestroy() would spin forever at exit.
-    if (tracer_ != nullptr && !in_forked_child_) {
-      ze_result_t status = ZE_FUNC(zelTracerDestroy)(tracer_);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[WARNING] Failed to destroy tracer (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      }
-    }
-#endif /* _WIN32 */
-
-    // Reset the global collector pointer for extension API tracing
-    SetGlobalZeCollector(nullptr);
-
-    if (options_.metric_query) {
-      for (auto it = metric_activations_.begin(); it != metric_activations_.end(); it++) {
-        auto status = ZE_FUNC(zetContextActivateMetricGroups)(it->first, it->second, 0, nullptr);
-        if (status != ZE_RESULT_SUCCESS) {
-#ifndef _WIN32
-          // on Windows, it is very possible that L0 has been unloaded or is being unloaded at this point and L0 calls may fail safely
-          // so ignore the error
-          std::cerr << "[WARNING] Failed to deactivate metric groups (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-#endif /* _WIN32 */
-        }
-      }
-      metric_activations_.clear();
-      for (auto& context : metric_contexts_) {
-        auto status = ZE_FUNC(zeContextDestroy)(context);
-        if (status != ZE_RESULT_SUCCESS) {
-#ifndef _WIN32
-          // on Windows, it is very possible that L0 has been unloaded or is being unloaded at this point and L0 calls may fail safely
-          // so ignore the error
-          std::cerr << "[WARNING] Failed to destroy context for metrics query (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-#endif /* _WIN32 */
-        }
-      }
-      metric_contexts_.clear();
-
-      for (ZeMetricsManager *mng: metricsManagers_) {
-        delete mng;
-      }
-      metricsManagers_.clear();
-    }
-  }
-
-  uint64_t CalculateTotalKernelTime() const {
-    uint64_t total_time = 0;
-
-    global_device_time_stats_mutex_.lock();
-    if (global_device_time_stats_) {
-      for (auto it = global_device_time_stats_->begin(); it != global_device_time_stats_->end(); it++) {
-        total_time += it->second.execute_time_;
-      }
-    }
-    global_device_time_stats_mutex_.unlock();
-
-    return total_time;
-  }
-
-  void PrintKernelsTable(std::shared_ptr<UniLogger> logger) const {
-    uint64_t total_time = 0;
-    std::vector<std::string> knames;
-    size_t max_name_size = 0;
-    global_device_time_stats_mutex_.lock();
-
-    AggregateDeviceTimeStats();
-
-    std::set<std::pair<ZeKernelCommandNameKey, ZeKernelCommandTime>, utils::Comparator> sorted_list(
-        global_device_time_stats_->begin(), global_device_time_stats_->end());
-
-    for (auto& it : sorted_list) {
-      total_time += it.second.execute_time_;
-      std::string kname;
-      if (it.first.tile_ >= 0) {
-        kname = "Tile #" + std::to_string(it.first.tile_) + ": " + GetZeKernelCommandName(it.first.kernel_command_id_, it.first.group_count_, it.first.mem_size_, options_.verbose);
-      }
-      else {
-        kname = GetZeKernelCommandName(it.first.kernel_command_id_, it.first.group_count_, it.first.mem_size_, options_.verbose);
-      }
-      if (kname.size() > max_name_size) {
-        max_name_size = kname.size();
-      }
-      knames.push_back(kname);
-    }
-
-    if (total_time != 0) {
-      // sizeof("Kernel") is 7, not 6
-      std::string str(std::max(int(max_name_size - sizeof("Kernel") + 1), 0), ' ');
-      str += "Kernel, " +
-      std::string(std::max(int(kCallsLength - sizeof("Calls") + 1), 0), ' ') + "Calls, " +
-      std::string(std::max(int(kTimeLength - sizeof("Time (ns)") + 1), 0), ' ') + "Time (ns), " +
-        "    Time (%), " +
-      std::string(std::max(int(kTimeLength - sizeof("Average (ns)") + 1), 0), ' ') + "Average (ns), " +
-      std::string(std::max(int(kTimeLength - sizeof("Min (ns)") + 1), 0), ' ') + "Min (ns), " +
-      std::string(std::max(int(kTimeLength - sizeof("Max (ns)") + 1), 0), ' ') + "Max (ns)\n";
-      logger->Log(str);
-      int i = 0;
-      for (auto& it : sorted_list) {
-        uint64_t call_count = it.second.call_count_;
-        uint64_t time = it.second.execute_time_;
-        uint64_t avg_time = time / call_count;
-        uint64_t min_time = it.second.min_time_;
-        uint64_t max_time = it.second.max_time_;
-        float percent_time = (100.0f * time / total_time);
-
-        str = std::string(std::max(int(max_name_size - knames[i].length()), 0), ' ');
-        str += knames[i] + ", " +
-        std::string(std::max(int(kCallsLength - std::to_string(call_count).length()), 0), ' ') +  std::to_string(call_count) + ", " +
-        std::string(std::max(int(kTimeLength - std::to_string(time).length()), 0), ' ') + std::to_string(time) + ", " +
-        std::string(std::max(int(sizeof("   Time (%)") - std::to_string(percent_time).length()), 0), ' ') +
-        std::to_string(percent_time) + ", " +
-        std::string(std::max(int(kTimeLength - std::to_string(avg_time).length()), 0), ' ') + std::to_string(avg_time) + ", " +
-        std::string(std::max(int(kTimeLength - std::to_string(min_time).length()), 0), ' ') + std::to_string(min_time) + ", " +
-        std::string(std::max(int(kTimeLength - std::to_string(max_time).length()), 0), ' ') + std::to_string(max_time) + "\n";
-        logger->Log(str);
-        i++;
-      }
-
-      str = "\n\n=== Kernel Properties ===\n\n";
-      str = str + std::string(std::max(int(max_name_size - sizeof("Kernel") + 1), 0), ' ') +
-        "Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread\n";
-      logger->Log(str);
-
-      i = -1;
-      kernel_command_properties_mutex_.lock_shared();
-
-      for (auto& it : sorted_list) {
-        ++i;
-        auto kit = kernel_command_properties_->find(it.first.kernel_command_id_);
-        if (kit == kernel_command_properties_->end()) {
-          continue;
-        }
-        if (kit->second.type_ != KERNEL_COMMAND_TYPE_COMPUTE) {
-          continue;
-        }
-
-        str = std::string(std::max(int(max_name_size - knames[i].length()), 0), ' ');
-        str = str + knames[i] + "," +
-          std::string(sizeof("Compiled") - sizeof("AOT") + 1, ' ') +
-          (kit->second.aot_ ? "AOT" : "JIT") + "," +
-          std::string(std::max(int(sizeof("SIMD") - ((kit->second.simd_width_ != 1) ? std::to_string(kit->second.simd_width_).length() : sizeof("ANY") - 1)), 0), ' ') +
-          ((kit->second.simd_width_ != 1) ? std::to_string(kit->second.simd_width_) : "ANY") + "," +
-          std::string(std::max(int(sizeof("Number of Arguments") - std::to_string(kit->second.nargs_).length()), 0), ' ') +
-          std::to_string(kit->second.nargs_) + "," +
-          std::string(std::max(int(sizeof("SLM Per Work Group") - std::to_string(kit->second.slmsize_).length()), 0), ' ') +
-          std::to_string(kit->second.slmsize_) + "," +
-          std::string(std::max(int(sizeof("Private Memory Per Thread") - std::to_string(kit->second.private_mem_size_).length()), 0), ' ') +
-          std::to_string(kit->second.private_mem_size_) + "," +
-          std::string(std::max(int(sizeof("Spill Memory Per Thread") - std::to_string(kit->second.spill_mem_size_).length()), 0), ' ') +
-          std::to_string(kit->second.spill_mem_size_) + ",";
-        if (kit->second.regsize_) {
-          // report size if size is available
-          str += std::string(std::max(int(sizeof("Register File Size Per Thread") - std::to_string(kit->second.regsize_).length()), 0), ' ') +
-                 std::to_string(kit->second.regsize_) + "\n";
-          }
-        else {
-          // report "unknown" otherwise
-          str += std::string(sizeof("Register File Size Per Thread") - sizeof("unknown") + 1, ' ') +
-                 "unknown\n";
-        }
-        logger->Log(str);
-      }
-      kernel_command_properties_mutex_.unlock_shared();
-    }
-
-    global_device_time_stats_mutex_.unlock();
-
-  }
-
-  void PrintSubmissionTable(std::shared_ptr<UniLogger> logger) const {
-    uint64_t total_submit_time = 0;
-    uint64_t total_append_time = 0;
-    uint64_t total_device_time = 0;
-    std::vector<std::string> knames;
-    size_t max_name_size = 0;
-    global_device_time_stats_mutex_.lock();
-
-    AggregateDeviceTimeStats();
-
-    std::set<std::pair<ZeKernelCommandNameKey, ZeKernelCommandTime>, utils::Comparator> sorted_list(
-        global_device_time_stats_->begin(), global_device_time_stats_->end());
-
-    for (auto& it : sorted_list) {
-      total_device_time += it.second.execute_time_;
-      total_append_time += it.second.append_time_;
-      total_submit_time += it.second.submit_time_;
-      std::string kname;
-      if (it.first.tile_ >= 0) {
-        kname = "Tile #" + std::to_string(it.first.tile_) + ": " + GetZeKernelCommandName(it.first.kernel_command_id_, it.first.group_count_, it.first.mem_size_, options_.verbose);
-      }
-      else {
-        kname = GetZeKernelCommandName(it.first.kernel_command_id_, it.first.group_count_, it.first.mem_size_, options_.verbose);
-      }
-      if (kname.size() > max_name_size) {
-        max_name_size = kname.size();
-      }
-      knames.push_back(std::move(kname));
-    }
-
-    if (total_device_time != 0) {
-
-      //sizeof("Kernel") is 7, not 6
-      std::string str(std::max(int(max_name_size - sizeof("Kernel") + 1), 0), ' ');
-
-      str += "Kernel, " + std::string(std::max(int(kCallsLength - sizeof("Calls") + 1), 0), ' ') +
-             "Calls, " + std::string(std::max(int(kTimeLength - sizeof("Append (ns)") + 1), 0), ' ') +
-             "Append (ns),  Append (%), " +
-             std::string(std::max(int(kTimeLength - sizeof("Submit (ns)") + 1), 0), ' ') +
-             "Submit (ns),  Submit (%), " +
-             std::string(std::max(int(kTimeLength - sizeof("Execute (ns)") + 1), 0), ' ') +
-             "Execute (ns),  Execute (%)\n";
-
-      logger->Log(str);
-
-      int i = 0;
-      for (auto& it : sorted_list) {
-        uint64_t call_count = it.second.call_count_;
-        float append_percent = 100.0f * it.second.append_time_ / total_append_time;
-        float submit_percent = 100.0f * it.second.submit_time_ / total_submit_time;
-        float device_percent = 100.0f * it.second.execute_time_ / total_device_time;
-        str = std::string(std::max(int(max_name_size - knames[i].length()), 0), ' ') + knames[i] + ", ";
-        str += std::string(std::max(int(kCallsLength - std::to_string(call_count).length()), 0), ' ') + std::to_string(call_count) + ", " +
-               std::string(std::max(int(kTimeLength - std::to_string(it.second.append_time_).length()), 0), ' ') +
-               std::to_string(it.second.append_time_) + ", " +
-               std::string(std::max(int(sizeof("Append (%)") - std::to_string(append_percent).length()), 0), ' ') +
-               std::to_string(append_percent) + ", " +
-               std::string(std::max(int(kTimeLength - std::to_string(it.second.submit_time_).length()), 0), ' ') +
-               std::to_string(it.second.submit_time_) + ", " +
-               std::string(std::max(int(sizeof("Submit (%)") - std::to_string(submit_percent).length()), 0), ' ') +
-               std::to_string(submit_percent) + ", " +
-               std::string(std::max(int(kTimeLength - std::to_string(it.second.execute_time_).length()), 0), ' ') +
-               std::to_string(it.second.execute_time_) + ", " +
-               std::string(std::max(int(sizeof("Execute (%)") - std::to_string(device_percent).length()), 0), ' ') +
-               std::to_string(device_percent) + "\n";
-        logger->Log(str);
-        i++;
-      }
-    }
-
-    global_device_time_stats_mutex_.unlock();
-
-  }
-
-#ifndef _WIN32
-  // Called from the atfork child handler (see tracer.cc).
-  void MarkForkedChild() { in_forked_child_ = true; }
-#endif /* _WIN32 */
-
-  void DisableTracing() {
-    // For Windows, level-zero might have been unloaded hence calling zelTracerSetEnabled may have undefined behavior, so skip calling it.
-#ifndef _WIN32
-    ze_result_t status = ZE_FUNC(zelTracerSetEnabled)(tracer_, false);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-#endif /* _WIN32 */
-  }
-
-  uint64_t CalculateTotalFunctionTime() const {
-    global_host_time_stats_mutex_.lock();
-
-    uint64_t total_time = 0;
-    for (auto it = global_host_time_stats_->begin(); it != global_host_time_stats_->end(); it++) {
-      total_time += it->second.total_time_;
-    }
-
-    global_host_time_stats_mutex_.unlock();
-
-    return total_time;
-  }
-
-  void PrintFunctionsTable(std::shared_ptr<UniLogger> logger) const {
-    global_host_time_stats_mutex_.lock();
-    std::set<std::pair<uint32_t, ZeFunctionTime>, utils::Comparator> sorted_list(
-      global_host_time_stats_->begin(), global_host_time_stats_->end());
-
-    uint64_t total_time = 0;
-    size_t max_name_size = 0;
-    for (auto& stat : sorted_list) {
-      total_time += stat.second.total_time_;
-      if (get_symbol(API_TRACING_ID(stat.first)).size() > max_name_size) {
-        max_name_size = get_symbol(API_TRACING_ID(stat.first)).size();
-      }
-    }
-
-    if (total_time != 0) {
-      std::string str(std::max(int(max_name_size - sizeof("Function") + 1), 0), ' ');
-      str += "Function, " + std::string(std::max(int(kCallsLength - sizeof("Calls") + 1), 0), ' ') +
-             "Calls, " + std::string(std::max(int(kTimeLength - sizeof("Time (ns)") + 1), 0), ' ') +
-             "Time (ns),      Time (%), " + std::string(std::max(int(kTimeLength - sizeof("Average (ns)") + 1), 0), ' ') +
-             "Average (ns), " + std::string(std::max(int(kTimeLength - sizeof("Min (ns)") + 1), 0), ' ') +
-             "Min (ns), " + std::string(std::max(int(kTimeLength - sizeof("Max (ns)") + 1), 0), ' ') +
-             "Max (ns)\n";
-      logger->Log(str);
-      for (auto& stat : sorted_list) {
-        const std::string function = get_symbol(API_TRACING_ID(stat.first));
-        uint64_t time = stat.second.total_time_;
-        uint64_t call_count = stat.second.call_count_;
-        uint64_t avg_time = time / call_count;
-        uint64_t min_time = stat.second.min_time_;
-        uint64_t max_time = stat.second.max_time_;
-        float percent_time = 100.0f * time / total_time;
-        str = std::string(std::max(int(max_name_size - function.length()), 0), ' ') + function + ", " +
-              std::string(std::max(int(kCallsLength - std::to_string(call_count).length()), 0), ' ') + std::to_string(call_count) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(time).length()), 0), ' ') + std::to_string(time) + ", " +
-              std::string(std::max(int(sizeof("    Time (%)") - std::to_string(percent_time).length()), 0), ' ') +
-              std::to_string(percent_time) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(avg_time).length()), 0), ' ') + std::to_string(avg_time) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(min_time).length()), 0), ' ') + std::to_string(min_time) + ", " +
-              std::string(std::max(int(kTimeLength - std::to_string(max_time).length()), 0), ' ') + std::to_string(max_time) + "\n";
-        logger->Log(str);
-      }
-    }
-    global_host_time_stats_mutex_.unlock();
-  }
-
-  void ProcessCommandsSubmitted(std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    global_device_submissions_mutex_.lock_shared();
-    auto it = local_device_submissions_.commands_submitted_.begin();
-    while (it != local_device_submissions_.commands_submitted_.end()) {
-      ZeCommand *command = *it;
-
-      bool processed = false;
-      if ((command->device_global_timestamps_ != nullptr) || (command->timestamps_on_event_reset_!= nullptr)) {
-        if (ZE_FUNC(zeEventQueryStatus)(command->timestamp_event_) == ZE_RESULT_SUCCESS) {
-          ProcessCommandSubmitted(local_device_submissions_, command, kids, false);
-          processed = true;
-        }
-      }
-      else {
-        if (ZE_FUNC(zeEventQueryStatus)(command->event_) == ZE_RESULT_SUCCESS) {
-          ProcessCommandSubmitted(local_device_submissions_, command, kids, true);
-          processed = true;
-        }
-      }
-      if (processed) {
-        // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-        local_device_submissions_.commands_free_pool_.push_back(command);
-        it = local_device_submissions_.commands_submitted_.erase(it);
-        continue;
-      }
-      ++it;
-    }
-    if (options_.metric_query) {
-      ProcessCommandMetricQueriesSubmitted();
-    }
-    global_device_submissions_mutex_.unlock_shared();
-  }
-
-  void ProcessAllCommandsSubmitted(std::vector<uint64_t> *kids) {
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    global_device_submissions_mutex_.lock();
-    if (global_device_submissions_) {
-      for (auto s : *global_device_submissions_) {
-        auto& local_submissions = *s;
-        auto it = local_submissions.commands_submitted_.begin();
-        while (it != local_submissions.commands_submitted_.end()) {
-          ZeCommand *command = *it;
-
-          bool processed = false;
-          if ((command->device_global_timestamps_ != nullptr) || (command->timestamps_on_event_reset_ != nullptr)) {
-            if (ZE_FUNC(zeEventQueryStatus)(command->timestamp_event_) == ZE_RESULT_SUCCESS) {
-              ProcessCommandSubmitted(local_submissions, command, kids, false);
-              processed = true;
-            }
-          }
-          else {
-            if (ZE_FUNC(zeEventQueryStatus)(command->event_) == ZE_RESULT_SUCCESS) {
-              ProcessCommandSubmitted(local_submissions, command, kids, true);
-              processed = true;
-            }
-          }
-          if (processed) {
-            // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-            local_submissions.commands_free_pool_.push_back(command);
-            it = local_submissions.commands_submitted_.erase(it);
-            continue;
-          }
-          ++it;
-        }
-        if (options_.metric_query) {
-          ProcessCommandMetricQueriesSubmitted();
-        }
-      }
-    }
-    global_device_submissions_mutex_.unlock();
-  }
-
-  void FinalizeDeviceSubmissions(std::vector<uint64_t> *kids) {
-
-    // Do not acquire any locks!
-    auto it = local_device_submissions_.commands_submitted_.begin();
-    while (it != local_device_submissions_.commands_submitted_.end()) {
-      ZeCommand *command = *it;
-
-      bool processed = false;
-      if ((command->device_global_timestamps_ != nullptr) || (command->timestamps_on_event_reset_ != nullptr)) {
-        if (ZE_FUNC(zeEventQueryStatus)(command->timestamp_event_) == ZE_RESULT_SUCCESS) {
-          ProcessCommandSubmitted(local_device_submissions_, command, kids, false);
-          processed = true;
-        }
-      }
-      else {
-        if (ZE_FUNC(zeEventQueryStatus)(command->event_) == ZE_RESULT_SUCCESS) {
-          ProcessCommandSubmitted(local_device_submissions_, command, kids, true);
-          processed = true;
-        }
-      }
-      if (processed) {
-        // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-        local_device_submissions_.commands_free_pool_.push_back(command);
-        it = local_device_submissions_.commands_submitted_.erase(it);
-        continue;
-      }
-      ++it;
-    }
-    if (options_.metric_query) {
-      ProcessCommandMetricQueriesSubmitted();
-    }
-  }
-
- private: // Implementation
-
-  ZeCollector(
-      CollectorOptions options,
-      OnZeKernelFinishCallback kcallback,
-      OnZeFunctionFinishCallback fcallback,
-      void* /* callback_data */,
-      std::string& data_dir_name,
-      bool reset_event_on_device,
-      const std::vector<std::string>& include_kernels = {},
-      const std::vector<std::string>& exclude_kernels = {})
-      : logger_factory_(LoggerFactory::Create()),
-        options_(options),
-        kcallback_(kcallback),
-        fcallback_(fcallback),
-        reset_event_on_device_(reset_event_on_device),
-        event_cache_(ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP),
-        include_kernels_(include_kernels),
-        exclude_kernels_(exclude_kernels) {
-    data_dir_name_ = data_dir_name;
-    // Create loggers using the factory
-    if (options_.call_logging) {
-      logger_ = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_CALL_LOGGING);
-    }
-    if (options_.device_timeline) {
-      logger_device_timeline_ = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_DEVICE_TIMELINE);
-    }
-    EnumerateAndSetupDevices();
-    InitializeKernelCommandProperties();
-  }
-
-  void InitializeKernelCommandProperties(void) {
-    kernel_command_properties_mutex_.lock();
-    if (active_command_properties_ == nullptr) {
-      active_command_properties_ = new std::map<uint64_t, ZeKernelCommandProperties>;
-      UniMemory::ExitIfOutOfMemory((void *)(active_command_properties_));
-    }
-    if (active_kernel_properties_ == nullptr) {
-      active_kernel_properties_ = new std::map<ze_kernel_handle_t, ZeKernelCommandProperties>;
-      UniMemory::ExitIfOutOfMemory((void *)(active_kernel_properties_));
-    }
-    if (kernel_command_properties_ == nullptr) {
-      kernel_command_properties_ = new std::map<uint64_t, ZeKernelCommandProperties>;
-      UniMemory::ExitIfOutOfMemory((void *)(kernel_command_properties_));
-    }
-
-    for (uint32_t i = 0; i <= uint32_t(ZeDeviceCommandHandle::LastCommand); i++) {
-      ZeKernelCommandProperties desc;
-
-      desc.name_ = device_command_names[i];
-      desc.id_ = UniKernelId::GetKernelId();
-      if (i < uint32_t(ZeDeviceCommandHandle::Barrier)) {
-        desc.type_ = KERNEL_COMMAND_TYPE_MEMORY;
-      }
-      else {
-        desc.type_ = KERNEL_COMMAND_TYPE_COMMAND;
-      }
-
-      ZeKernelCommandProperties desc2;
-      desc2 = desc;
-
-      active_command_properties_->insert({uint64_t(i), std::move(desc)});
-      kernel_command_properties_->insert({desc2.id_, std::move(desc2)});
-    }
-    kernel_command_properties_mutex_.unlock();
-  }
-
-  void EnumerateAndSetupDevices() {
-    if (devices_ == nullptr) {
-      devices_ = new std::map<ze_device_handle_t, ZeDevice>;
-      UniMemory::ExitIfOutOfMemory((void *)(devices_));
-    }
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-    uint32_t num_drivers = 0;
-    status = ZE_FUNC(zeDriverGet)(&num_drivers, nullptr);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Unable to get driver" << std::endl;
-      exit(-1);
-    }
-
-    if (num_drivers > 0) {
-      int32_t did = 0;
-      std::vector<ze_driver_handle_t> drivers(num_drivers);
-      std::vector<ze_context_handle_t> contexts;
-      status = ZE_FUNC(zeDriverGet)(&num_drivers, drivers.data());
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Unable to get driver" << std::endl;
-        exit(-1);
-      }
-
-      for (auto driver : drivers) {
-        ze_context_handle_t context = nullptr;
-        if (options_.metric_query) {
-          ze_context_desc_t cdesc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-          status = ZE_FUNC(zeContextCreate)(driver, &cdesc, &context);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Unable to create context for metrics" << std::endl;
-            exit(-1);
-          }
-          metric_contexts_.push_back(context);
-        }
-
-        uint32_t num_devices = 0;
-        status = ZE_FUNC(zeDeviceGet)(driver, &num_devices, nullptr);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[WARNING] Unable to get device" << std::endl;
-          num_devices = 0;
-        }
-        if (num_devices) {
-          std::vector<ze_device_handle_t> devices(num_devices);
-          status = ZE_FUNC(zeDeviceGet)(driver, &num_devices, devices.data());
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[WARNING] Unable to get device" << std::endl;
-            devices.clear();
-          }
-          for (auto device : devices) {
-            ZeDevice desc;
-
-            desc.device_ = device;
-            desc.id_ = did;
-            desc.parent_id_ = -1;  // no parent
-            desc.parent_device_ = nullptr;
-            desc.subdevice_id_ = -1;  // not a subdevice
-
-            ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2};
-            ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-            UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-            UNITRACE_ASSERT(props.timerResolution != 0);
-
-            desc.device_timer_frequency_ = props.timerResolution;
-            desc.device_timer_mask_ = (props.kernelTimestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)() : ((1ull << props.kernelTimestampValidBits) - 1ull);
-            desc.device_ns_per_cycle_ = static_cast<double>(NSEC_IN_SEC) / static_cast<double>(props.timerResolution);
-
-            ze_pci_ext_properties_t pci_device_properties;
-            status = ZE_FUNC(zeDevicePciGetPropertiesExt)(device, &pci_device_properties);
-            if (status != ZE_RESULT_SUCCESS) {
-              std::cerr << "[WARNING] Unable to get device PCI properties" << std::endl;
-              memset(&pci_device_properties, 0, sizeof(pci_device_properties));  // dummy device properties
-            }
-            desc.pci_properties_ = pci_device_properties;
-
-            desc.driver_ = driver;
-            desc.context_ = context;
-
-            uint32_t num_sub_devices = 0;
-            status = ZE_FUNC(zeDeviceGetSubDevices)(device, &num_sub_devices, nullptr);
-
-            if (status != ZE_RESULT_SUCCESS) {
-              std::cerr << "[WARNING] Unable to get sub-devices" << std::endl;
-              desc.num_subdevices_ = 0;
-            }
-            else {
-              desc.num_subdevices_ = num_sub_devices;
-            }
-
-            if (options_.metric_query) {
-              zet_metric_group_handle_t group = nullptr;
-              ZeMetricsManager* metricsManager = ZeMetricsManager::CreateMetricGroups(device, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED, utils::GetEnv("UNITRACE_MetricConfig"), utils::GetEnv("UNITRACE_MetricGroup"));
-
-              if (metricsManager != nullptr && metricsManager->GetMetricGroups() != nullptr) {
-                group = metricsManager->GetMetricGroups()[0];
-              }
-
-              if (group == nullptr) {
-                std::cerr << "[ERROR] Unable to get metric group. Please make sure the metric group is valid and supported" << std::endl;
-                exit(-1);
-              }
-
-              metricsManagers_.push_back(metricsManager);
-
-              status = ZE_FUNC(zetContextActivateMetricGroups)(context, device, 1, &group);
-              if (status != ZE_RESULT_SUCCESS) {
-                std::cerr << "[ERROR] Unable to activate metric groups" << std::endl;
-                exit(-1);
-              }
-              metric_activations_.insert({context, device});
-
-              desc.metric_group_ = group;
-            }
-            else {
-              desc.metric_group_ = nullptr;
-            }
-
-            uint64_t host_time;
-            uint64_t ticks;
-
-            status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(device, &host_time, &ticks);
-            if (status != ZE_RESULT_SUCCESS) {
-              std::cerr << "[ERROR] Unable to get global timestamps" << std::endl;
-              exit(-1);
-            }
-
-            desc.host_time_origin_ = host_time;
-
-            // Get device name
-            ze_device_properties_t device_properties = {};
-            device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-            status = ZE_FUNC(zeDeviceGetProperties)(device, &device_properties);
-            if (status == ZE_RESULT_SUCCESS) {
-              desc.device_name_ = std::move(std::string(device_properties.name));
-            } else {
-              desc.device_name_ = "";
-              std::cerr << "[WARNING] zeDeviceGetProperties failed with error code : " << status << std::endl;
-            }
-
-            // query group ordinal
-            uint32_t count = 0;
-            status = ZE_FUNC(zeDeviceGetCommandQueueGroupProperties)(device, &count, nullptr);
-            if (status != ZE_RESULT_SUCCESS || count == 0) {
-              std::cerr << "[WARNING] zeDeviceGetCommandQueueGroupProperties failed with error code : " << status << std::endl;
-            } else {
-              std::vector<ze_command_queue_group_properties_t> props(count);
-              status = ZE_FUNC(zeDeviceGetCommandQueueGroupProperties)(device, &count, props.data());
-              if (status != ZE_RESULT_SUCCESS) {
-                std::cerr << "[WARNING] zeDeviceGetCommandQueueGroupProperties failed with error code : " << status << std::endl;
-              } else {
-                desc.queue_engine_prop_.resize(count);
-                for (uint32_t i = 0; i < count; ++i) {
-                  if (props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
-                    desc.queue_engine_prop_[i] = ZE_QUEUE_COMPUTE_ENGINE;
-                  } else if (props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY) {
-                    desc.queue_engine_prop_[i] = ZE_QUEUE_COPY_ENGINE;
-                  } else {
-                    desc.queue_engine_prop_[i] = ZE_QUEUE_UNKNOWN_ENGINE;
-                  }
-                }
-              }
-            }
-
-            devices_->insert({device, std::move(desc)});
-
-            if (num_sub_devices > 0) {
-              std::vector<ze_device_handle_t> sub_devices(num_sub_devices);
-
-              status = ZE_FUNC(zeDeviceGetSubDevices)(device, &num_sub_devices, sub_devices.data());
-              if (status != ZE_RESULT_SUCCESS) {
-                std::cerr << "[WARNING] Unable to get sub-devices" << std::endl;
-                num_sub_devices = 0;
-              }
-
-              for (uint32_t j = 0; j < num_sub_devices; j++) {
-                ZeDevice sub_desc;
-
-                sub_desc.device_ = sub_devices[j];
-                sub_desc.parent_id_ = did;
-                sub_desc.parent_device_ = device;
-                sub_desc.num_subdevices_ = 0;
-                sub_desc.subdevice_id_ = j;
-                sub_desc.id_ = did;  // take parent device's id
-
-                ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2};
-                ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(sub_devices[j], &props);
-                UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-                UNITRACE_ASSERT(props.timerResolution != 0);
-
-                sub_desc.device_timer_frequency_ = props.timerResolution;
-                sub_desc.device_timer_mask_ = (props.kernelTimestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)() : ((1ull << props.kernelTimestampValidBits) - 1ull);
-                sub_desc.device_ns_per_cycle_ = static_cast<double>(NSEC_IN_SEC) / static_cast<double>(props.timerResolution);
-
-                ze_pci_ext_properties_t pci_device_properties;
-                status = ZE_FUNC(zeDevicePciGetPropertiesExt)(sub_devices[j], &pci_device_properties);
-                if (status != ZE_RESULT_SUCCESS) {
-                  std::cerr << "[WARNING] Unable to get device PCI properties" << std::endl;
-                  memset(&pci_device_properties, 0, sizeof(pci_device_properties)); // dummy device properties
-                }
-                sub_desc.pci_properties_ = pci_device_properties;
-
-                uint64_t ticks;
-                uint64_t host_time;
-                status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(sub_devices[j], &host_time, &ticks);
-                if (status != ZE_RESULT_SUCCESS) {
-                  std::cerr << "[ERROR] Unable to get global timestamps" << std::endl;
-                  exit(-1);
-                }
-
-                sub_desc.host_time_origin_ = host_time;
-
-                sub_desc.driver_ = driver;
-                sub_desc.context_ = context;
-
-                sub_desc.metric_group_ = nullptr;
-
-                // Get sub-device name
-                ze_device_properties_t device_properties = {};
-                device_properties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
-                status = ZE_FUNC(zeDeviceGetProperties)(sub_devices[j], &device_properties);
-                if (status == ZE_RESULT_SUCCESS) {
-                  sub_desc.device_name_ = std::move(std::string(device_properties.name));
-                } else {
-                  sub_desc.device_name_ = "";
-                  std::cerr << "[WARNING] zeDeviceGetProperties failed with error code : " << status << std::endl;
-                }
-
-                // query group ordinal
-                count = 0;
-                status = ZE_FUNC(zeDeviceGetCommandQueueGroupProperties)(sub_devices[j], &count, nullptr);
-                if (status != ZE_RESULT_SUCCESS || count == 0) {
-                  std::cerr << "[WARNING] zeDeviceGetCommandQueueGroupProperties failed with error code : " << status << std::endl;
-                } else {
-                  std::vector<ze_command_queue_group_properties_t> props(count);
-                  status = ZE_FUNC(zeDeviceGetCommandQueueGroupProperties)(sub_devices[j], &count, props.data());
-                  if (status != ZE_RESULT_SUCCESS) {
-                    std::cerr << "[WARNING] zeDeviceGetCommandQueueGroupProperties failed with error code : " << status << std::endl;
-                  } else {
-                    sub_desc.queue_engine_prop_.resize(count);
-                    for (uint32_t i = 0; i < count; ++i) {
-                      if (props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) {
-                        sub_desc.queue_engine_prop_[i] = ZE_QUEUE_COMPUTE_ENGINE;
-                      } else if (props[i].flags & ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY) {
-                        sub_desc.queue_engine_prop_[i] = ZE_QUEUE_COPY_ENGINE;
-                      } else {
-                        sub_desc.queue_engine_prop_[i] = ZE_QUEUE_UNKNOWN_ENGINE;
-                      }
-                    }
-                  }
-                }
-
-                devices_->insert({sub_devices[j], std::move(sub_desc)});
-              }
-            }
-            did++;
-          }
-        }
-      }
-    }
-  }
-
-  static std::string PrintTypedValue(const zet_typed_value_t& typed_value) {
-    switch (typed_value.type) {
-      case ZET_VALUE_TYPE_UINT32:
-        return std::to_string(typed_value.value.ui32);
-      case ZET_VALUE_TYPE_UINT64:
-        return std::to_string(typed_value.value.ui64);
-      case ZET_VALUE_TYPE_FLOAT32:
-        return std::to_string(typed_value.value.fp32);
-      case ZET_VALUE_TYPE_FLOAT64:
-        return std::to_string(typed_value.value.fp64);
-      case ZET_VALUE_TYPE_BOOL8:
-        return std::to_string(static_cast<uint32_t>(typed_value.value.b8));
-      default:
-        UNITRACE_ASSERT(0);
-        break;
-    }
-    return "";   //in case of error returns empty string.
-  }
-
-  inline static std::string GetMetricUnits(const char* units) {
-    UNITRACE_ASSERT(units != nullptr);
-
-    std::string result = units;
-    if (result.find("null") != std::string::npos) {
-      result = "";
-    } else if (result.find("percent") != std::string::npos) {
-      result = "%";
-    }
-
-    return result;
-  }
-
-  static uint32_t GetMetricCount(zet_metric_group_handle_t group) {
-    UNITRACE_ASSERT(group != nullptr);
-
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    ze_result_t status = ZE_FUNC(zetMetricGroupGetProperties)(group, &group_props);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Failed to get metric group properties (status = 0x" << std::hex << status << std::dec << ")." << std::endl;
-      exit(-1);
-    }
-
-    return group_props.metricCount;
-  }
-
-  static std::vector<std::string> GetMetricNames(zet_metric_group_handle_t group) {
-    UNITRACE_ASSERT(group != nullptr);
-
-    uint32_t metric_count = GetMetricCount(group);
-    UNITRACE_ASSERT(metric_count > 0);
-
-    std::vector<zet_metric_handle_t> metrics(metric_count);
-    ze_result_t status = ZE_FUNC(zetMetricGet)(group, &metric_count, metrics.data());
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    UNITRACE_ASSERT(metric_count == metrics.size());
-
-    std::vector<std::string> names;
-    for (auto metric : metrics) {
-      zet_metric_properties_t metric_props{
-          ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, };
-      status = ZE_FUNC(zetMetricGetProperties)(metric, &metric_props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::string units = GetMetricUnits(metric_props.resultUnits);
-      std::string name = metric_props.name;
-      if (!units.empty()) {
-        name += "[" + units + "]";
-      }
-      names.push_back(std::move(name));
-    }
-
-    return names;
-  }
-
-  bool QueryKernelCommandMetrics(ZeDeviceSubmissions& submissions, ZeCommandMetricQuery *command_metric_query, bool collect_data) {
-
-    ze_result_t status;
-    if ((status = ZE_FUNC(zeEventQueryStatus)(command_metric_query->metric_query_event_)) == ZE_RESULT_SUCCESS) {
-
-      auto it = submissions.kernel_profiles_.find(command_metric_query->instance_id_);
-      if (it != submissions.kernel_profiles_.end()) {
-        if (collect_data) {
-          size_t size = 0;
-          status = ZE_FUNC(zetMetricQueryGetData)(command_metric_query->metric_query_, &size, nullptr);
-          if ((status == ZE_RESULT_SUCCESS) && (size > 0)) {
-
-            std::vector<uint8_t> *kmetrics = new std::vector<uint8_t>(size);
-            UniMemory::ExitIfOutOfMemory((void *)(kmetrics));
-            size_t size2 = size;
-            status = ZE_FUNC(zetMetricQueryGetData)(command_metric_query->metric_query_, &size2, kmetrics->data());
-            if (size2 == size) {
-              it->second.metrics_ = kmetrics;
-            }
-            else {
-              delete kmetrics;
-            }
-          }
-        }
-      } else {
-        return false;
-      }
-      event_cache_.ResetEvent(command_metric_query->metric_query_event_);
-      query_pools_.ResetQuery(command_metric_query->metric_query_);
-      if (command_metric_query->immediate_) {
-        event_cache_.ReleaseEvent(command_metric_query->metric_query_event_);
-        query_pools_.PutQuery(command_metric_query->metric_query_);
-      }
-      command_metric_query->metric_query_event_ = nullptr;
-      command_metric_query->metric_query_ = nullptr;
-
-      return true;
-    }
-    else {
-      return false;
-    }
-  }
-
-  void ProcessCommandMetricQueriesSubmitted(void) {
-    // This runs while a caller (ProcessAllCommandsSubmitted/ProcessCommandsSubmitted)
-    // holds global_device_submissions_mutex_. Querying the collection state must
-    // not synchronously fire the session-stopped flush here: OnSessionStopped() ->
-    // UniTracer::Flush() -> FlushData() -> ProcessAllCommandsSubmitted() would
-    // re-enter the collector and deadlock on that non-recursive mutex
-    // (std::system_error / EDEADLK). Defer the notification so it fires from a safe
-    // top-level call site (the next OnEnter*Append* callback) instead.
-    bool collect_data = UniController::IsCollectionEnabled(/*defer_callback=*/true);
-    for (auto it = local_device_submissions_.metric_queries_submitted_.begin(); it != local_device_submissions_.metric_queries_submitted_.end();) {
-      if (QueryKernelCommandMetrics(local_device_submissions_, *it, collect_data)) {
-          local_device_submissions_.metric_queries_free_pool_.push_back(*it);
-          it = local_device_submissions_.metric_queries_submitted_.erase(it);
-      }
-      else {
-        it++;
-      }
-    }
-  }
-
-  void DumpKernelProfiles(void) {
-
-    const std::lock_guard<std::mutex> lock(global_kernel_profiles_mutex_);
-    if (global_kernel_profiles_.size() == 0) {
-      return;
-    }
-
-    if (options_.metric_stream) {
-      devices_mutex_.lock_shared();
-      std::map<int32_t, std::vector<ZeKernelProfileRecord *>> device_kprofiles; // kernel profiles by device;
-      for (auto it = global_kernel_profiles_.begin(); it != global_kernel_profiles_.end(); it++) {
-        int32_t device_id = -1;
-        auto dit = devices_->find(it->second.device_);
-        if (dit != devices_->end()) {
-          device_id = dit->second.id_;
-        }
-        if (device_id == -1) {
-          continue;
-        }
-        auto dpit = device_kprofiles.find(device_id);
-        if (dpit == device_kprofiles.end()) {
-          std::vector<ZeKernelProfileRecord *> kprofiles;
-          kprofiles.push_back(&(it->second));
-          device_kprofiles.insert({device_id, std::move(kprofiles)});
-        }
-        else {
-          dpit->second.push_back(&(it->second));
-        }
-      }
-      devices_mutex_.unlock_shared();
-
-      for (auto& profiles : device_kprofiles) {
-        std::shared_ptr<UniLogger> ktime_logger = logger_factory_->GetDeviceLogger(LOGGER_TYPE_KTIME, profiles.first, true, true);
-        if (ktime_logger == nullptr) {
-              std::cerr << "[ERROR] Failed to create kernel times data file" << std::endl;
-              exit(-1);
-        }
-        for (auto& prof : profiles.second) {
-          for (auto& ts : prof->timestamps_) {
-            std::string kname = GetZeKernelCommandName(prof->kernel_command_id_, prof->group_count_, prof->mem_size_);
-            ktime_logger->Log(std::to_string(ts.subdevice_id) + "\n");
-            ktime_logger->Log(std::to_string(prof->instance_id_) + "\n");
-            ktime_logger->Log(std::to_string(ts.metric_start) + "\n");
-            ktime_logger->Log(std::to_string(ts.metric_end) + "\n");
-            ktime_logger->Log(kname + "\n");
-          }
-        }
-        ktime_logger->Flush();
-      }
-
-      return;
-    }
-
-    if (!options_.metric_query) {
-      return;
-    }
-
-    // metric query
-
-#ifdef _WIN32
-    // On Windows, L0 may be unloaded by now, so the metric data is saved to
-    // <data_dir>/.metrics.<pid>.q and computed in the parent process. Each entry: device id
-    // (int32_t), kernel name size (size_t), kernel name, instance id (uint64_t), metric
-    // data size (uint64_t), metric data.
-
-    std::string fpath = logger_factory_->GenerateLogFileName(LOGGER_TYPE_METRICS_QUERY_TEMP);
-    // Append: FlushData() can run more than once (an explicit flush and again
-    // from Finalize()); entries are erased from global_kernel_profiles_ once
-    // written, so appending never duplicates data, while truncation would
-    // discard everything dumped by an earlier flush.
-    std::ofstream mf(fpath, std::ios::binary | std::ios::app);
-
-    if (!mf) {
-        std::cerr << "[ERROR] Failed to create metric data file" << std::endl;
-        exit(-1);
-    }
-
-    while (1) {
-      if (global_kernel_profiles_.empty()) {
-        break;  // done
-      }
-      ze_device_handle_t device = nullptr;
-      int32_t did = -1;
-      for (auto it = global_kernel_profiles_.begin(); it != global_kernel_profiles_.end();) {
-        if ((it->second.metrics_ == nullptr) || it->second.metrics_->empty() || (it->second.device_ == nullptr)) {
-          // skip empty entries
-          it = global_kernel_profiles_.erase(it);
-          continue;
-        }
-
-        if (device == nullptr) {
-          devices_mutex_.lock_shared();
-          auto it2 = devices_->find(it->second.device_);
-
-          if (it2 == devices_->end()) {
-            devices_mutex_.unlock_shared();
-            // should never get here
-            it = global_kernel_profiles_.erase(it);
-            continue;
-          }
-
-          device = it->second.device_;
-          did = it2->second.id_;
-          devices_mutex_.unlock_shared();
-        }
-        else {
-          if (it->second.device_ != device) {
-            it++;  // different device, dump later
-            continue;
-          }
-        }
-
-        std::string kname = GetZeKernelCommandName(it->second.kernel_command_id_, it->second.group_count_, it->second.mem_size_);
-        if (kname.empty()) {
-          // skip invalid kernels; should never get here
-          it = global_kernel_profiles_.erase(it);
-          continue;
-        }
-
-        mf.write(reinterpret_cast<char *>(&did), sizeof(int32_t));
-        size_t kname_size = kname.size();
-        mf.write(reinterpret_cast<char *>(&(kname_size)), sizeof(size_t));
-        mf.write(kname.c_str(), kname_size);
-        mf.write(reinterpret_cast<char *>(&(it->second.instance_id_)), sizeof(uint64_t));
-        uint64_t metrics_size =  it->second.metrics_->size();
-        mf.write(reinterpret_cast<char *>(&(metrics_size)), sizeof(uint64_t));
-        mf.write(reinterpret_cast<char *>(it->second.metrics_->data()), it->second.metrics_->size());
-        it = global_kernel_profiles_.erase(it);
-      }
-    }
-
-    mf.close();
-
-#else /* LINUX */
-
-    std::shared_ptr<UniLogger> metric_logger = nullptr;
-
-    std::cerr << "[INFO] Post-processing metric data is in progress. "
-              << "This may take a while, please do not interrupt." << std::endl;
-    while (1) {
-      if (global_kernel_profiles_.empty()) {
-        break;  // done
-      }
-      ze_device_handle_t device = nullptr;
-      int did = -1;
-      zet_metric_group_handle_t group = nullptr;
-      std::vector<std::string> metric_names;
-      std::string counter_header;
-      for (auto it = global_kernel_profiles_.begin(); it != global_kernel_profiles_.end();) {
-        if ((it->second.metrics_ == nullptr) || it->second.metrics_->empty()) {
-          it = global_kernel_profiles_.erase(it);
-          continue;
-        }
-
-        if (it->second.device_ == nullptr) {
-          // should never get here
-          it = global_kernel_profiles_.erase(it);
-          continue;
-        }
-
-        if (device == nullptr) {
-          devices_mutex_.lock_shared();
-          auto it2 = devices_->find(it->second.device_);
-
-          if (it2 == devices_->end()) {
-            devices_mutex_.unlock_shared();
-            // should never get here
-            it = global_kernel_profiles_.erase(it);
-            continue;
-          }
-
-          device = it->second.device_;
-          did = it2->second.id_;
-          group = it2->second.metric_group_;
-          metric_names = GetMetricNames(it2->second.metric_group_);
-          devices_mutex_.unlock_shared();
-          UNITRACE_ASSERT(!metric_names.empty());
-
-          metric_logger = logger_factory_->GetDeviceLogger(LOGGER_TYPE_METRICS_QUERY, did, true, true);
-          if (metric_logger == nullptr) {
-            std::cerr << "[ERROR] Failed to create metric query data file" << std::endl;
-            exit(-1);
-          }
-
-          if (logger_factory_->IsLegacy()) {
-            metric_logger->Log("\n=== Device #" + std::to_string(did) + " Metrics ===\n");
-          }
-
-          // Query metrics are written as a self-contained section per kernel-instance, the
-          // shape time-based sampling also uses, less the SubDeviceId column:
-          //   Kernel, GlobalInstanceId              <- section label, naming the identity
-          //   "<name>", <instance id>                  the section carries
-          //   [SubDeviceId, ]<counter names...>     <- column header: the sub-device, then
-          //   [<sub-device>, ]<counter values...>      all metrics in metric_names order;
-          //                                            one row per sub-device
-          // SubDeviceId is written only when there is more than one sub-device.
-          // The counter names are the same for every section, so build them once.
-          counter_header.clear();
-          for (size_t i = 0; i < metric_names.size(); i++) {
-            if (i > 0) {
-              counter_header += ", ";
-            }
-            counter_header += metric_names[i];
-          }
-          counter_header += "\n";
-        }
-        else {
-          if (it->second.device_ != device) {
-            it++;  // different device, dump later
-            continue;
-          }
-        }
-
-        std::string kname = GetZeKernelCommandName(it->second.kernel_command_id_, it->second.group_count_, it->second.mem_size_);
-        uint32_t num_samples = 0;
-        uint32_t num_metrics = 0;
-        ze_result_t status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          it->second.metrics_->size(), it->second.metrics_->data(), &num_samples, &num_metrics,
-          nullptr, nullptr);
-
-        if ((status == ZE_RESULT_SUCCESS) && (num_samples > 0) && (num_metrics > 0)) {
-          std::vector<uint32_t> samples(num_samples);
-          std::vector<zet_typed_value_t> metrics(num_metrics);
-
-          status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-            group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-            it->second.metrics_->size(), it->second.metrics_->data(), &num_samples, &num_metrics,
-            samples.data(), metrics.data());
-
-          if (status == ZE_RESULT_SUCCESS) {
-            const bool with_sub_device = (num_samples > 1);
-            // The leading newline puts a blank line before every section.
-            std::string str = "\nKernel, GlobalInstanceId\n" + kname + ", " +
-                              std::to_string(it->second.instance_id_) + "\n" +
-                              (with_sub_device ? "SubDeviceId, " : "") + counter_header;
-            for (uint32_t i = 0; i < num_samples; ++i) {
-              uint32_t size = samples[i];
-              UNITRACE_ASSERT(size == metric_names.size());
-
-              // A sample per sub-device, i being the sub-device
-              if (with_sub_device) {
-                str += std::to_string(i) + ", ";
-              }
-              const zet_typed_value_t *value = metrics.data() + i * size;
-              for (uint32_t j = 0; j < size; ++j) {
-                if (j > 0) {
-                  str += ", ";
-                }
-                str += PrintTypedValue(value[j]);
-              }
-              str += "\n";
-            }
-            metric_logger->Log(str);
-          }
-          else {
-            std::cerr << "[WARNING] Not able to calculate metrics" << std::endl;
-          }
-        }
-        else {
-          std::cerr << "[WARNING] Not able to calculate metrics" << std::endl;
-        }
-        it = global_kernel_profiles_.erase(it);
-        metric_logger->Flush();
-      }
-    }
-    std::cerr << "[INFO] Post-processing metric data is complete." << std::endl;
-
-    if (logger_factory_->IsLegacy() && metric_logger && metric_logger->IsLogToFile()) {
-      std::cerr << "[INFO] Kernel metrics are stored in " << metric_logger->GetLogFileName() << std::endl;
-    }
-#endif /* _WIN32 */
-  }
-
-  void ProcessCommandsSubmittedOnSignaledEvent(ze_event_handle_t event, std::vector<uint64_t> *kids) {
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-    global_device_submissions_mutex_.lock_shared();
-    for (auto it = local_device_submissions_.commands_submitted_.begin(); it != local_device_submissions_.commands_submitted_.end();) {
-      ZeCommand *command = *it;
-
-      if (command->event_ == event || command->in_order_counter_event_ == event) {
-        ProcessCommandSubmitted(local_device_submissions_, command, kids, true);
-        // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-        local_device_submissions_.commands_free_pool_.push_back(command);
-        it = local_device_submissions_.commands_submitted_.erase(it);
-        continue;
-      }
-      else {
-        bool processed = false;
-        if ((command->device_global_timestamps_ != nullptr) || (command->timestamps_on_event_reset_ != nullptr)) {
-          if (ZE_FUNC(zeEventQueryStatus)(command->timestamp_event_) == ZE_RESULT_SUCCESS) {
-            ProcessCommandSubmitted(local_device_submissions_, command, nullptr, false);
-            processed = true;
-          }
-        }
-        else {
-          if (ZE_FUNC(zeEventQueryStatus)(command->event_) == ZE_RESULT_SUCCESS) {
-            ProcessCommandSubmitted(local_device_submissions_, command, nullptr, true);
-            processed = true;
-          }
-        }
-        if (processed) {
-          // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-          local_device_submissions_.commands_free_pool_.push_back(command);
-          it = local_device_submissions_.commands_submitted_.erase(it);
-          continue;
-        }
-      }
-      it++;
-    }
-
-    if (options_.metric_query) {
-      ProcessCommandMetricQueriesSubmitted();
-    }
-    global_device_submissions_mutex_.unlock_shared();
-  }
-
-  void ProcessCommandsSubmittedOnFenceSynchronization(ze_fence_handle_t fence, std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    global_device_submissions_mutex_.lock_shared();
-    for (auto it = local_device_submissions_.commands_submitted_.begin(); it != local_device_submissions_.commands_submitted_.end();) {
-      ZeCommand *command = *it;
-      if ((command->fence_ != nullptr) && (command->fence_ == fence)) {
-        ProcessCommandSubmitted(local_device_submissions_, command, kids, true);
-        // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-        local_device_submissions_.commands_free_pool_.push_back(command);
-        it = local_device_submissions_.commands_submitted_.erase(it);
-        continue;
-      }
-      else {
-        bool processed = false;
-        if ((command->device_global_timestamps_ != nullptr) || (command->timestamps_on_event_reset_ != nullptr)) {
-          if (ZE_FUNC(zeEventQueryStatus)(command->timestamp_event_) == ZE_RESULT_SUCCESS) {
-            ProcessCommandSubmitted(local_device_submissions_, command, nullptr, false);
-            processed = true;
-          }
-        }
-        else {
-          if (ZE_FUNC(zeEventQueryStatus)(command->event_) == ZE_RESULT_SUCCESS) {
-            ProcessCommandSubmitted(local_device_submissions_, command, nullptr, true);
-            processed = true;
-          }
-        }
-        if (processed) {
-          // event_cache_.ReleaseEvent(command->event_) or event_cache_.ResetEvent(command->event_) is already called inside ProcessCommandSubmitted()
-          local_device_submissions_.commands_free_pool_.push_back(command);
-          it = local_device_submissions_.commands_submitted_.erase(it);
-          continue;
-        }
-      }
-      it++;
-    }
-    if (options_.metric_query) {
-      ProcessCommandMetricQueriesSubmitted();
-    }
-    global_device_submissions_mutex_.unlock_shared();
-  }
-
-  inline uint64_t ComputeDuration(uint64_t start, uint64_t end, uint64_t freq, uint64_t mask, double ns_per_cycle) {
-    uint64_t duration = 0;
-    if (start <= end) {
-      duration = static_cast<double>(end - start) * ns_per_cycle;
-    } else { // Timer Overflow
-      duration = static_cast<double>(mask - start + 1 + end) * ns_per_cycle;
-    }
-    return duration;
-  }
-
-  inline void GetHostTime(const ZeCommand *command, const ze_kernel_timestamp_result_t& ts, uint64_t& start, uint64_t& end) {
-    uint64_t device_freq = command->device_timer_frequency_;
-    uint64_t device_mask = command->device_timer_mask_;
-    double ns_per_cycle = command->device_ns_per_cycle_;
-
-    uint64_t device_start = ts.global.kernelStart & device_mask;
-    uint64_t device_end = ts.global.kernelEnd & device_mask;
-
-    uint64_t device_submit_time = (command->submit_time_device_ & device_mask);
-
-    uint64_t time_shift;
-
-    if (device_start > device_submit_time) {
-      time_shift = static_cast<double>(device_start - device_submit_time) * ns_per_cycle;
-    }
-    else {
-      // overflow
-      time_shift = static_cast<double>(device_mask - device_submit_time + 1 + device_start) * ns_per_cycle;
-    }
-
-    uint64_t duration = ComputeDuration(device_start, device_end, device_freq, device_mask, ns_per_cycle);
-
-    start = command->submit_time_ + time_shift;
-    end = start + duration;
-  }
-
-  void PrintCommandCompleted(const ZeCommand *command, uint64_t kernel_start, uint64_t kernel_end) {
-    std::string str("Thread ");
-    str += std::to_string(command->tid_) + " Device " + std::to_string(reinterpret_cast<uintptr_t>(command->device_)) +
-      " : " + GetZeKernelCommandName(command->kernel_command_id_, command->group_count_, command->mem_size_) + " [ns] " +
-      std::to_string(command->append_time_) + " (append) " +
-      std::to_string(command->submit_time_) + " (submit) " +
-      std::to_string(kernel_start) + " (start) " +
-      std::to_string(kernel_end) + " (end)\n";
-    logger_device_timeline_->Log(str);
-  }
-
-  inline void LogCommandCompleted(const ZeCommand *command, const ze_kernel_timestamp_result_t& timestamp, int tile) {
-
-    uint64_t kernel_start = 0, kernel_end = 0;
-    GetHostTime(command, timestamp, kernel_start, kernel_end);
-
-    UNITRACE_ASSERT(kernel_start <= kernel_end);
-
-    if (options_.device_timing || options_.kernel_submission) {
-      local_device_submissions_.CollectKernelCommandTimeStats(command, kernel_start, kernel_end, tile);
-    }
-
-    if (options_.device_timeline) {
-      PrintCommandCompleted(command, kernel_start, kernel_end);
-    }
-
-    if (kcallback_) {
-      bool implicit_scaling = ((tile >= 0) && command->implicit_scaling_);
-
-      kcallback_(command->instance_id_, command->tid_, kernel_start, kernel_end, command->engine_ordinal_, command->engine_index_, tile, command->device_, command->kernel_command_id_, implicit_scaling, command->group_count_, command->mem_size_);
-    }
-  }
-
-  inline void ProcessCommandSubmitted(ZeDeviceSubmissions& submissions, ZeCommand *command, std::vector<uint64_t> *kids, bool on_event) {
-
-    if (kids) {
-        kids->push_back(command->instance_id_);
-    }
-
-    ze_kernel_timestamp_result_t timestamp;
-    if (!on_event) {
-      if (command->device_global_timestamps_) {
-        timestamp.global.kernelStart = command->device_global_timestamps_[0];
-        timestamp.global.kernelEnd = command->device_global_timestamps_[1];
-      }
-      else {
-        if (command->timestamps_on_event_reset_) {
-          int slot = command->index_timestamps_on_commands_completion_->at(command->timestamp_seq_);
-          if (slot == -1) {
-            slot = command->index_timestamps_on_event_reset_->at(command->timestamp_seq_);
-            ze_kernel_timestamp_result_t *ts = command->timestamps_on_event_reset_->at(slot / number_timestamps_per_slice_);
-            timestamp = ts[slot % number_timestamps_per_slice_];
-          }
-          else {
-            timestamp = (*(command->timestamps_on_commands_completion_))[slot];
-          }
-        }
-        else {
-          std::cerr << "[ERROR] Failed to get timestamps on device" << std::endl;
-          return;
-        }
-      }
-      if (timestamp.global.kernelStart == timestamp.global.kernelEnd) {
-        std::cerr << "[WARNING] Kernel starting timestamp and ending timestamp on the device are the same (" << timestamp.global.kernelStart << ")" << std::endl;
-        if (command->event_ != nullptr) {
-          ze_result_t status;
-          status = ZE_FUNC(zeEventQueryStatus)(command->event_);
-          if (status == ZE_RESULT_SUCCESS) {
-            std::cerr << "[WARNING] Trying to query event for timestamps" << std::endl;
-            status = ZE_FUNC(zeEventQueryKernelTimestamp)(command->event_, &timestamp);
-            if (status != ZE_RESULT_SUCCESS) {
-              // do not panic
-              std::cerr << "[WARNING] Unable to query event for timestamps" << std::endl;
-            }
-          }
-        }
-      }
-    }
-    else {
-      if (command->event_ != nullptr) {
-        ze_result_t status = ZE_FUNC(zeEventQueryKernelTimestamp)(command->event_, &timestamp);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Unable to query event for timestamps" << std::endl;
-          return;
-        }
-      }
-    }
-
-    ZeKernelProfileRecord r;
-
-    if (options_.metric_query || options_.metric_stream) {
-      r.device_ = command->device_;
-      r.instance_id_ = command->instance_id_;
-      r.kernel_command_id_ = command->kernel_command_id_;
-      r.group_count_ = command->group_count_;
-      r.mem_size_ = command->mem_size_;
-    }
-
-    if (options_.kernels_per_tile && (command->type_ == KERNEL_COMMAND_TYPE_COMPUTE)) {
-      if (command->implicit_scaling_) { // Implicit Scaling
-        uint32_t count = 0;
-        ze_result_t status = ZE_FUNC(zeEventQueryTimestampsExp)(command->event_, command->device_, &count, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        UNITRACE_ASSERT(count > 0);
-
-        std::vector<ze_kernel_timestamp_result_t> timestamps(count);
-        status = ZE_FUNC(zeEventQueryTimestampsExp)(command->event_, command->device_, &count, timestamps.data());
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        if (options_.metric_query || options_.metric_stream) {
-          for (uint32_t i = 0; i < count; i++) {
-            ZeKernelProfileTimestamps ts;
-
-            ts.subdevice_id = i;
-
-            ts.metric_start = timestamps[i].global.kernelStart;
-            ts.metric_end = timestamps[i].global.kernelEnd;
-
-            r.timestamps_.push_back(std::move(ts));
-          }
-
-          submissions.kernel_profiles_.insert({command->instance_id_, std::move(r)});
-        }
-
-        if (count == 1) { // First tile is used only
-          LogCommandCompleted(command, timestamps[0], 0);
-        } else {
-          for (uint32_t i = 0; i < count; ++i) {
-            LogCommandCompleted(command, timestamps[i], static_cast<int>(i));
-          }
-        }
-      } else { // Explicit Scaling
-        auto it = devices_->find(command->device_);
-        if (it != devices_->end()) {
-          LogCommandCompleted(command, timestamp, -1);
-        }
-
-        if (options_.metric_query || options_.metric_stream) {
-          ZeKernelProfileTimestamps ts;
-
-          ts.metric_start = timestamp.global.kernelStart;
-          ts.metric_end = timestamp.global.kernelEnd;
-
-          ts.subdevice_id = -1;
-
-          r.timestamps_.push_back(std::move(ts));
-
-          submissions.kernel_profiles_.insert({command->instance_id_, std::move(r)});
-        }
-      }
-    } else {
-      if (options_.metric_query || options_.metric_stream) {
-        ZeKernelProfileTimestamps ts;
-
-        ts.metric_start = timestamp.global.kernelStart;
-        ts.metric_end = timestamp.global.kernelEnd;
-
-        ts.subdevice_id = -1;
-        r.timestamps_.push_back(std::move(ts));
-
-        submissions.kernel_profiles_.insert({command->instance_id_, std::move(r)});
-      }
-
-      LogCommandCompleted(command, timestamp, -1);
-    }
-
-    // Graph commands are reused across executions.
-    if (command->immediate_ && !command->graph_command_) {
-      event_cache_.ReleaseEvent(command->event_);
-    } else {
-      event_cache_.ResetEvent(command->event_);
-    }
-    command->event_ = nullptr;
-    command->in_order_counter_event_ = nullptr;
-  }
-
-  void CreateCommandList( ze_command_list_handle_t command_list,
-    ze_context_handle_t context,
-    ze_device_handle_t device,
-    uint32_t ordinal,
-    uint32_t index,
-    bool immediate,
-    bool in_order) {
-
-    ZeCommandList *desc;
-
-    command_lists_mutex_.lock();
-    auto it = command_lists_.find(command_list);
-    if (it != command_lists_.end()) {
-      desc = it->second;
-      command_lists_.erase(it);
-    }
-    else {
-      desc = new ZeCommandList;
-      UniMemory::ExitIfOutOfMemory((void *)(desc));
-    }
-
-    desc->num_timestamps_ = 0;
-    desc->num_timestamps_on_event_reset_ = 0;
-    desc->timestamps_on_commands_completion_ = nullptr;
-    desc->timestamps_on_event_reset_.clear();
-    desc->event_to_timestamp_seq_.clear();
-    desc->index_timestamps_on_commands_completion_.clear();
-    desc->index_timestamps_on_event_reset_.clear();
-    desc->num_device_global_timestamps_ = 0;
-    desc->device_global_timestamps_.clear();
-
-    command_lists_mutex_.unlock();
-
-    desc->cmdlist_ = command_list;
-    desc->context_ = context;
-    desc->device_ = device;
-    desc->immediate_ = immediate;
-    desc->in_order_ = in_order;
-    desc->engine_ordinal_ = ordinal;  // valid if immediate command list
-    desc->engine_index_ = index;;  // valid if immediate command list
-
-    if (immediate == false) {
-      desc->timestamp_event_to_signal_ = event_cache_.GetEvent(context);
-      // set to signal state to unblock first ZE_FUNC(zeCommandQueueExecuteCommandLists)() call
-      auto status = ZE_FUNC(zeEventHostSignal)(desc->timestamp_event_to_signal_);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Failed to signal timestamp event in command list" << std::endl;
-        exit(-1);
-      }
-    }
-    else {
-      desc->timestamp_event_to_signal_ = nullptr;
-    }
-
-    devices_mutex_.lock_shared();
-    auto it2 = devices_->find(device);
-    if (it2 != devices_->end()) {
-      desc->host_time_origin_ = it2->second.host_time_origin_;
-      desc->device_timer_frequency_ = it2->second.device_timer_frequency_;
-      desc->device_timer_mask_ = it2->second.device_timer_mask_;
-      desc->device_ns_per_cycle_ = it2->second.device_ns_per_cycle_;
-      desc->implicit_scaling_ = (it2->second.num_subdevices_ != 0);
-    }
-    devices_mutex_.unlock_shared();
-
-    command_lists_mutex_.lock();
-    command_lists_.insert({command_list, desc});
-    command_lists_mutex_.unlock();
-  }
-
-  void DestroyCommandList(ze_command_list_handle_t command_list) {
-
-    command_lists_mutex_.lock();
-
-    auto it = command_lists_.find(command_list);
-    if (it != command_lists_.end()) {
-      if (!it->second->immediate_) {
-        if (it->second->timestamp_event_to_signal_) {
-          auto status = ZE_FUNC(zeEventHostSynchronize)(it->second->timestamp_event_to_signal_, UINT64_MAX);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Timestamp event is not signaled" << std::endl;
-            command_lists_mutex_.unlock();
-            return;
-          }
-          ProcessAllCommandsSubmitted(nullptr);  // make sure commands submitted already are processed
-        }
-        for (auto& command : it->second->commands_) {
-          if (command->event_) {
-            event_cache_.ReleaseEvent(command->event_);
-          }
-        }
-        it->second->commands_.clear();
-        it->second->event_to_timestamp_seq_.clear();
-        ze_result_t status;
-        for (auto ts : it->second->timestamps_on_event_reset_) {
-          if (ts != nullptr) {
-            status = ZE_FUNC(zeMemFree)(it->second->context_, ts);
-            if (status != ZE_RESULT_SUCCESS) {
-              std::cerr << "[WARNING] Failed to free event timestamp memory (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            }
-          }
-        }
-        it->second->timestamps_on_event_reset_.clear();
-        for (auto ts : it->second->device_global_timestamps_) {
-          if (ts != nullptr) {
-            status = ZE_FUNC(zeMemFree)(it->second->context_, ts);
-            if (status != ZE_RESULT_SUCCESS) {
-              std::cerr << "[WARNING] Failed to free global timestamp memory (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            }
-          }
-        }
-        it->second->device_global_timestamps_.clear();
-        if (it->second->timestamps_on_commands_completion_ != nullptr) {
-          status = ZE_FUNC(zeMemFree)(it->second->context_, it->second->timestamps_on_commands_completion_);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[WARNING] Failed to free command timestamp memory (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          }
-          it->second->timestamps_on_commands_completion_ = nullptr;
-        }
-        it->second->index_timestamps_on_commands_completion_.clear();
-        it->second->index_timestamps_on_event_reset_.clear();
-        event_cache_.ReleaseEvent(it->second->timestamp_event_to_signal_);
-        it->second->timestamp_event_to_signal_ = nullptr;
-      }
-      // Clean up pending graph capture to prevent memory leak
-      if (it->second->pending_graph_capture_ != nullptr) {
-        ReleaseGraphResources(*it->second->pending_graph_capture_);
-        delete it->second->pending_graph_capture_;
-        it->second->pending_graph_capture_ = nullptr;
-      }
-      command_lists_.erase(it);
-    }
-
-    command_lists_mutex_.unlock();
-  }
-
-  void ResetCommandList(ze_command_list_handle_t command_list) {
-
-    command_lists_mutex_.lock();
-
-    auto it = command_lists_.find(command_list);
-    if (it != command_lists_.end()) {
-      if (!it->second->immediate_) {
-        if (it->second->timestamp_event_to_signal_) {
-          auto status = ZE_FUNC(zeEventHostSynchronize)(it->second->timestamp_event_to_signal_, UINT64_MAX);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Timestamp event is not signaled" << std::endl;
-            command_lists_mutex_.unlock();
-            return;
-          }
-          ProcessAllCommandsSubmitted(nullptr);  // make sure commands submitted already are processed
-        }
-        for (auto& command : it->second->commands_) {
-          if (command->event_) {
-            event_cache_.ReleaseEvent(command->event_);
-          }
-        }
-        it->second->commands_.clear();
-        it->second->event_to_timestamp_seq_.clear();
-        it->second->num_timestamps_ = 0;
-        it->second->num_timestamps_on_event_reset_ = 0;
-        it->second->index_timestamps_on_commands_completion_.clear();
-        it->second->index_timestamps_on_event_reset_.clear();
-        if (it->second->timestamps_on_commands_completion_ != nullptr) {
-          ze_result_t status;
-          status = ZE_FUNC(zeMemFree)(it->second->context_, it->second->timestamps_on_commands_completion_);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[WARNING] Failed to free command timestamp memory (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          }
-          it->second->timestamps_on_commands_completion_ = nullptr;
-        }
-        it->second->device_global_timestamps_.clear();
-        it->second->num_device_global_timestamps_ = 0;
-      }
-    }
-
-    command_lists_mutex_.unlock();
-  }
-
-  void PrepareToExecuteCommandLists(
-    ze_command_list_handle_t *cmdlists, uint32_t count, ze_command_queue_handle_t queue, ze_fence_handle_t fence) {
-
-    command_queues_mutex_.lock_shared();
-    auto qit = command_queues_.find(queue);
-    if (qit != command_queues_.end()) {
-      command_lists_mutex_.lock_shared();
-      PrepareToExecuteCommandListsLocked(cmdlists, count, qit->second.device_, qit->second.engine_ordinal_, qit->second.engine_index_, fence);
-      command_lists_mutex_.unlock_shared();
-    }
-    command_queues_mutex_.unlock_shared();
-  }
-
-  void PrepareToExecuteCommandListsLocked(
-    ze_command_list_handle_t *cmdlists, uint32_t count, ze_device_handle_t device,
-    uint32_t engine_ordinal, uint32_t engine_index, ze_fence_handle_t fence) {
-
-    for (uint32_t i = 0; i < count; i++) {
-      ze_command_list_handle_t cmdlist = cmdlists[i];
-
-      auto it = command_lists_.find(cmdlist);
-
-      if (it == command_lists_.end()) {
-        std::cerr << "[ERROR] Command list (" << cmdlist << ") is not found to execute." << std::endl;
-        continue;
-      }
-
-      if (!it->second->immediate_) {
-        if (it->second->timestamp_event_to_signal_) {
-          auto status = ZE_FUNC(zeEventHostSynchronize)(it->second->timestamp_event_to_signal_, UINT64_MAX);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Timestamp event is not signaled" << std::endl;
-            return;
-          }
-          ProcessAllCommandsSubmitted(nullptr);  // make sure commands submitted last time are processed
-          if (ZE_FUNC(zeEventHostReset)(it->second->timestamp_event_to_signal_) != ZE_RESULT_SUCCESS) {    // reset event
-            std::cerr << "[ERROR] Failed to reset timestamp event" << std::endl;
-            return;
-          }
-        }
-      }
-    }
-
-    uint64_t host_timestamp;
-    uint64_t device_timestamp;
-    ze_result_t status;
-
-    status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(device, &host_timestamp, &device_timestamp);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    for (uint32_t i = 0; i < count; i++) {
-      ze_command_list_handle_t cmdlist = cmdlists[i];
-      auto it = command_lists_.find(cmdlist);
-      if (it == command_lists_.end()) {
-        std::cerr << "[ERROR] Command list (" << cmdlist << ") is not found to execute." << std::endl;
-        continue;
-      }
-
-      if (!it->second->immediate_) {
-        for (auto command : it->second->commands_) {
-          ZeCommand *cmd = nullptr;
-          ZeCommandMetricQuery *cmd_query = nullptr;
-
-          cmd = local_device_submissions_.GetKernelCommand();
-
-          if (command->command_metric_query_ != nullptr) {
-            cmd_query = local_device_submissions_.GetCommandMetricQuery();
-          }
-          *cmd = *command;
-
-          cmd->engine_ordinal_ = engine_ordinal;
-          cmd->engine_index_ = engine_index;
-          cmd->submit_time_ = host_timestamp;    //in ns
-          cmd->submit_time_device_ = device_timestamp;  //in ticks
-          cmd->tid_ = utils::GetTid();;
-          cmd->fence_ = fence;
-          // Exit callback will reset cmd->event_ and backfill cmd->instance_id_
-          local_device_submissions_.StageKernelCommand(cmd);
-
-          if (cmd_query) {
-            *cmd_query = *(command->command_metric_query_);
-            // Exit callback will reset cmd_query->metric_query_event_ and backfill cmd_query->instance_id_
-            local_device_submissions_.StageCommandMetricQuery(cmd_query);
-          }
-          else {
-            local_device_submissions_.StageCommandMetricQuery(nullptr);
-          }
-        }
-      }
-    }
-  }
-
-  void CreateImage(ze_image_handle_t image, size_t size) {
-    images_mutex_.lock();
-    if (images_.find(image) != images_.end()) {
-      images_.erase(image);
-    }
-    images_.insert({image, size});
-    images_mutex_.unlock();
-  }
-
-  void DestroyImage(ze_image_handle_t image) {
-    images_mutex_.lock();
-    images_.erase(image);
-    images_mutex_.unlock();
-  }
-
-  size_t GetImageSize(ze_image_handle_t image) {
-    size_t size;
-
-    images_mutex_.lock_shared();
-    auto it = images_.find(image);
-    if (it != images_.end()) {
-      size = it->second;
-    }
-    else {
-      size = 0;
-    }
-    images_mutex_.unlock_shared();
-
-    return size;
-  }
-
- private: // Callbacks
-
-  #include <tracing.gen.types> // Auto-generated types for callbacks
-
-  static void OnEnterEventPoolCreate(ze_event_pool_create_params_t *params, void * /* global_data */, void **instance_data) {
-    const ze_event_pool_desc_t* desc = *(params->pdesc);
-    if (desc == nullptr) {
-      return;
-    }
-    if (desc->flags & ZE_EVENT_POOL_FLAG_IPC) {
-      return;
-    }
-
-    // Do not override flags if counter based pool
-    const void *pNext = desc->pNext;
-    while (pNext) {
-      if (((ze_base_cb_params_t *)pNext)->stype == ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC) {
-        return;
-      }
-      pNext = ((ze_base_cb_params_t *)pNext)->pNext;
-    }
-
-    ze_event_pool_desc_t* profiling_desc = new ze_event_pool_desc_t;
-    UniMemory::ExitIfOutOfMemory((void *)(profiling_desc));
-    UNITRACE_ASSERT(profiling_desc != nullptr);
-    profiling_desc->stype = desc->stype;
-    profiling_desc->pNext = desc->pNext;
-    profiling_desc->flags = desc->flags;
-    profiling_desc->flags |= ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
-    profiling_desc->flags |= ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
-    profiling_desc->count = desc->count;
-
-    *(params->pdesc) = profiling_desc;
-    *instance_data = profiling_desc;
-  }
-
-  static void OnExitEventPoolCreate(ze_event_pool_create_params_t *params,
-                                    ze_result_t result,
-                                    void *global_data,
-                                    void **instance_data) {
-
-    if (result == ZE_RESULT_SUCCESS && params->pphEventPool && *params->pphEventPool) {
-      const ze_event_pool_desc_t* desc = *(params->pdesc);
-      const void *pNext = desc ? desc->pNext : nullptr;
-      while (pNext) {
-        if (((ze_base_cb_params_t *)pNext)->stype == ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC) {
-          ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-          collector->events_mutex_.lock();
-          collector->counter_based_pools_.insert(**params->pphEventPool);
-          collector->events_mutex_.unlock();
-          break;
-        }
-        pNext = ((ze_base_cb_params_t *)pNext)->pNext;
-      }
-    }
-
-    ze_event_pool_desc_t* desc = static_cast<ze_event_pool_desc_t*>(*instance_data);
-    if (desc != nullptr) {
-      delete desc;
-    }
-  }
-
-  static void OnExitEventPoolDestroy(ze_event_pool_destroy_params_t *params,
-                                ze_result_t result,
-                                void* global_data,
-                                void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->events_mutex_.lock();
-      collector->counter_based_pools_.erase(*params->phEventPool);
-      collector->events_mutex_.unlock();
-    }
-  }
-
-  static void OnExitEventCreate(ze_event_create_params_t* params,
-                                ze_result_t result,
-                                void* global_data,
-                                void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS && params->pphEvent && *params->pphEvent) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->events_mutex_.lock();
-      if (collector->counter_based_pools_.find(*params->phEventPool) != collector->counter_based_pools_.end()) {
-        collector->counter_based_events_.insert(**params->pphEvent);
-      }
-      collector->events_mutex_.unlock();
-    }
-  }
-
-  static void OnExitCounterBasedEventCreate2(
-      ze_x_counter_based_event_create2_params_t *params,
-      ze_result_t result,
-      void* global_data,
-      void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS && params->pphEvent && *params->pphEvent) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->events_mutex_.lock();
-      collector->counter_based_events_.insert(**params->pphEvent);
-      collector->events_mutex_.unlock();
-    }
-  }
-
-  static void OnEnterEventDestroy(
-      ze_event_destroy_params_t *params,
-      void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-
-    if (*(params->phEvent) != nullptr) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      if (ZE_FUNC(zeEventQueryStatus)(*(params->phEvent)) == ZE_RESULT_SUCCESS) {
-        collector->ProcessCommandsSubmittedOnSignaledEvent(*(params->phEvent), kids);
-      }
-      else {
-        // Event is not signaled on destroy, removing associated commands
-        global_device_submissions_mutex_.lock_shared();
-        // discard event associated staged commands
-        local_device_submissions_.RevertStagedKernelCommandAndMetricQueriesForEvent(*(params->phEvent));
-        // discard event associated submitted commands
-        auto it_cmd = local_device_submissions_.commands_submitted_.begin();
-        while (it_cmd != local_device_submissions_.commands_submitted_.end()) {
-          ZeCommand *command = *it_cmd;
-          if (command->event_ == *(params->phEvent)) {
-            std::cerr << "[INFO] Remove command from submitted commands on event destroy" << std::endl;
-            local_device_submissions_.commands_free_pool_.push_back(command);
-            it_cmd = local_device_submissions_.commands_submitted_.erase(it_cmd);
-            continue;
-          }
-          ++it_cmd;
-        }
-        global_device_submissions_mutex_.unlock_shared();
-        // Non immediate command list
-        collector->command_lists_mutex_.lock();
-        auto it = collector->command_lists_.begin();
-        while (it != collector->command_lists_.end()) {
-          auto cmd_it = it->second->commands_.begin();
-          while (cmd_it != it->second->commands_.end()) {
-            ZeCommand *command = *cmd_it;
-            if (command->event_ == *(params->phEvent)) {
-              std::cerr << "[INFO] Remove command from command list on event destroy" << std::endl;
-              cmd_it = it->second->commands_.erase(cmd_it);
-              continue;
-            }
-            ++cmd_it;
-          }
-          ++it;
-        }
-        collector->command_lists_mutex_.unlock();
-      }
-    }
-  }
-
-  static void OnExitEventDestroy(
-      ze_event_destroy_params_t *params, ze_result_t result,
-      void *global_data, void ** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->events_mutex_.lock();
-      collector->counter_based_events_.erase(*params->phEvent);
-      collector->events_mutex_.unlock();
-    }
-  }
-
-  static void OnEnterEventHostReset(
-      ze_event_host_reset_params_t *params,
-      void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (*(params->phEvent) != nullptr) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      if (ZE_FUNC(zeEventQueryStatus)(*(params->phEvent)) == ZE_RESULT_SUCCESS) {
-        collector->ProcessCommandsSubmittedOnSignaledEvent(*(params->phEvent), kids);
-      }
-    }
-  }
-
-  static void OnExitEventHostSynchronize(
-      ze_event_host_synchronize_params_t *params,
-      ze_result_t result, void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessCommandsSubmittedOnSignaledEvent(*(params->phEvent), kids);
-    }
-  }
-
-  static void OnExitCommandListHostSynchronize(
-      ze_command_list_host_synchronize_params_t * /* params */,
-      ze_result_t result, void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessAllCommandsSubmitted(kids);
-    }
-  }
-
-  static void OnExitEventQueryStatus(
-      ze_event_query_status_params_t *params,
-      ze_result_t result, void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessCommandsSubmittedOnSignaledEvent(*(params->phEvent), kids);
-    }
-  }
-
-  static void OnExitFenceHostSynchronize(
-      ze_fence_host_synchronize_params_t *params,
-      ze_result_t result, void *global_data, void ** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      UNITRACE_ASSERT(*(params->phFence) != nullptr);
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessCommandsSubmittedOnFenceSynchronization(*(params->phFence), kids);
-    }
-  }
-
-  static void OnExitImageCreate(
-      ze_image_create_params_t *params, ze_result_t result,
-      void *global_data, void ** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-      ze_image_desc_t image_desc = **(params->pdesc);
-      size_t image_size = image_desc.width;
-      switch (image_desc.type) {
-        case ZE_IMAGE_TYPE_2D:
-        case ZE_IMAGE_TYPE_2DARRAY:
-          image_size *= image_desc.height;
-          break;
-        case ZE_IMAGE_TYPE_3D:
-          image_size *= image_desc.height * image_desc.depth;
-          break;
-        default:
-          break;
-      }
-
-      switch (image_desc.format.type) {
-        case ZE_IMAGE_FORMAT_TYPE_UINT:
-        case ZE_IMAGE_FORMAT_TYPE_UNORM:
-        case ZE_IMAGE_FORMAT_TYPE_FORCE_UINT32:
-          image_size *= sizeof(unsigned int);
-          break;
-        case ZE_IMAGE_FORMAT_TYPE_SINT:
-        case ZE_IMAGE_FORMAT_TYPE_SNORM:
-          image_size *= sizeof(int);
-          break;
-        case ZE_IMAGE_FORMAT_TYPE_FLOAT:
-          image_size *= sizeof(float);
-          break;
-      }
-
-      collector->CreateImage(**(params->pphImage), image_size);
-    }
-  }
-
-  static void OnExitImageDestroy(
-      ze_image_destroy_params_t *params, ze_result_t result,
-      void *global_data, void ** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->DestroyImage(*(params->phImage));
-    }
-  }
-
-  static void PrepareToAppendKernelCommand(
-    ZeCollector* collector,
-    ze_event_handle_t& signal_event,
-    ze_command_list_handle_t command_list,
-    bool iskernel,
-    ze_kernel_handle_t kernel = nullptr,
-    uint32_t num_wait_events = 0,
-    ze_event_handle_t* wait_events = nullptr) {
-
-    ze_context_handle_t context = nullptr;
-    ze_device_handle_t device = nullptr;
-    bool in_order = false;
-
-    ze_instance_data.query_ = nullptr;
-    ze_instance_data.in_order_counter_event_ = nullptr;
-    ze_instance_data.instrument_ = true;
-
-    if (iskernel) {
-      if (kernel == nullptr) {
-        std::cerr << "[ERROR] Kernel handle is null for kernel command." << std::endl;
-        ze_instance_data.instrument_ = false;
-        return;
-      }
-      kernel_command_properties_mutex_.lock_shared();
-      auto kit = active_kernel_properties_->find(kernel);
-      if (kit != active_kernel_properties_->end()) {
-          if (kit->second.skip_) {
-            ze_instance_data.instrument_ = false;
-            kernel_command_properties_mutex_.unlock_shared();
-            return;
-          }
-      }
-      kernel_command_properties_mutex_.unlock_shared();
-    }
-
-    collector->command_lists_mutex_.lock_shared();
-
-    auto it = collector->command_lists_.find(command_list);
-    if (it != collector->command_lists_.end()) {
-      context = it->second->context_;
-      device = it->second->device_;
-      in_order = it->second->in_order_;
-    }
-
-    collector->command_lists_mutex_.unlock_shared();
-
-    if ((context == nullptr) || (device == nullptr)) {
-      // should never get here
-      std::cerr << "[ERROR] Command list (" << command_list << ") is not found for appending." << std::endl;
-      ze_instance_data.instrument_ = true;
-      return;
-    }
-
-    // Check if this append triggers a fork transition
-    // (i.e., this cmdlist waits on an event from an active graph capture)
-    if (num_wait_events > 0 && wait_events != nullptr) {
-      collector->CheckAndApplyForkTransition(command_list, num_wait_events, wait_events);
-    }
-
-    if (signal_event == nullptr) {
-      signal_event = collector->event_cache_.GetEvent(context);
-      UNITRACE_ASSERT(signal_event != nullptr);
-    } else {
-      collector->events_mutex_.lock();
-      if (collector->counter_based_events_.find(signal_event) != collector->counter_based_events_.end()) {
-        if (in_order) {
-          ze_instance_data.in_order_counter_event_ = signal_event;
-          signal_event = collector->event_cache_.GetEvent(context);
-        } else {
-          // This is an error that should never happen since counter based events can be
-          // used only in in-order command lists.
-          std::cerr << "[ERROR] Counter based events are used in non immediate command list - command will not be instrumented" << std::endl;
-          ze_instance_data.instrument_ = false;
-          collector->events_mutex_.unlock();
-          return;
-        }
-      }
-      collector->events_mutex_.unlock();
-    }
-
-    ze_result_t status;
-    if (collector->options_.metric_query && iskernel) {
-      devices_mutex_.lock_shared();
-
-      auto it2 = devices_->find(device);
-
-      UNITRACE_ASSERT(it2 != devices_->end());
-      ze_instance_data.query_ = collector->query_pools_.GetQuery(context, device, it2->second.metric_group_);
-
-      devices_mutex_.unlock_shared();
-
-      status = ZE_FUNC(zetCommandListAppendMetricQueryBegin)(command_list, ze_instance_data.query_);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-
-    uint64_t host_timestamp;
-    uint64_t device_timestamp;  // in ticks
-
-    status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(device, &host_timestamp, &device_timestamp);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_instance_data.timestamp_host = host_timestamp;
-    ze_instance_data.timestamp_device = device_timestamp;
-  }
-
-  static void PrepareToAppendKernelCommand(ZeCommandList *cl) {
-    ze_result_t status;
-    uint64_t host_timestamp;
-    uint64_t device_timestamp;  // in ticks
-
-    status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(cl->device_, &host_timestamp, &device_timestamp);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_instance_data.timestamp_host = host_timestamp;
-    ze_instance_data.timestamp_device = device_timestamp;
-  }
-
-  void AppendLaunchKernel(
-    ze_kernel_handle_t kernel,
-    const ze_group_count_t *group_count,
-    ze_event_handle_t& event_to_signal,
-    zet_metric_query_handle_t& query,
-    ze_command_list_handle_t command_list,
-    std::vector<uint64_t> *kids) {
-
-    uint64_t kernel_id;
-    ZeKernelGroupSize group_size;
-    bool found = false;
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_kernel_properties_->find(kernel);
-    if (kit != active_kernel_properties_->end()) {
-      kernel_id = kit->second.id_;
-      group_size = kit->second.group_size_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    if (!found) {
-      std::cerr << "[ERROR] Kernel (" << kernel << ") is not found." << std::endl;
-      return;
-    }
-
-    command_lists_mutex_.lock_shared();
-
-    auto it = command_lists_.find(command_list);
-
-    if (it != command_lists_.end()) {
-      ZeCommand *desc = nullptr;
-      ZeCommandMetricQuery *desc_query = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_COMPUTE;
-      desc->kernel_command_id_ = kernel_id;
-      desc->group_size_ = group_size;
-      desc->group_count_ = *group_count;
-      desc->engine_ordinal_ = it->second->engine_ordinal_;
-      desc->engine_index_ = it->second->engine_index_;
-      desc->host_time_origin_ = it->second->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = it->second->device_timer_frequency_;
-      desc->device_timer_mask_ = it->second->device_timer_mask_;
-      desc->device_ns_per_cycle_ = it->second->device_ns_per_cycle_;
-      desc->implicit_scaling_ = it->second->implicit_scaling_;
-      desc->device_ = it->second->device_;
-      ze_context_handle_t context = it->second->context_;
-
-      desc->mem_size_ = 0;
-      desc->event_ = event_to_signal;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->command_list_ = command_list;
-      desc->queue_ = nullptr;
-      desc->tid_ = utils::GetTid();
-
-      desc->device_global_timestamps_ = nullptr;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->timestamp_event_ = nullptr;
-      desc->timestamp_seq_ = -1;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      // Read graph capture state before releasing the lock
-      bool graph_capturing = it->second->graph_capturing_;
-
-      command_lists_mutex_.unlock_shared();
-
-      if (ze_instance_data.in_order_counter_event_ && it->second->in_order_) {
-        ze_result_t status = ZE_FUNC(zeCommandListAppendSignalEvent)(command_list, ze_instance_data.in_order_counter_event_);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      if (query != nullptr) {
-        desc_query = local_device_submissions_.GetCommandMetricQuery();
-
-        ze_event_handle_t metric_query_event = event_cache_.GetEvent(context);
-        ze_result_t status = ZE_FUNC(zetCommandListAppendMetricQueryEnd)(command_list, query, metric_query_event, 0, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc_query->metric_query_event_ = metric_query_event;
-        desc_query->metric_query_ = query;
-        desc_query->device_ = it->second->device_;
-      }
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-
-      // In graph capture mode the command goes into the capture target; the
-      // target is re-read under the locks in StoreCommandInGraph (capture may
-      // have ended since graph_capturing was read).
-      if (graph_capturing && StoreCommandInGraph(command_list, desc, desc_query, host_timestamp, event_to_signal)) {
-      } else if (it->second->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;    // don't care metric query in case of immediate command list
-        local_device_submissions_.SubmitKernelCommand(desc);
-        kids->push_back(desc->instance_id_);
-
-        if (query != nullptr) {
-          desc_query->instance_id_ = desc->instance_id_;
-          desc_query->immediate_ = true;
-          local_device_submissions_.SubmitCommandMetricQuery(desc_query);
-        }
-      }
-      else {
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = desc_query;  // need metric query upon submission
-
-        command_lists_mutex_.lock();
-
-        if (reset_event_on_device_) {
-          int seq = it->second->num_timestamps_++;
-          it->second->index_timestamps_on_commands_completion_.push_back(-1);
-          it->second->index_timestamps_on_event_reset_.push_back(-1);
-          it->second->event_to_timestamp_seq_.insert({event_to_signal, seq});
-
-          desc->timestamp_seq_ = seq;
-          desc->timestamps_on_event_reset_ = &(it->second->timestamps_on_event_reset_);
-          desc->timestamps_on_commands_completion_ = &(it->second->timestamps_on_commands_completion_);
-          desc->index_timestamps_on_commands_completion_ = &(it->second->index_timestamps_on_commands_completion_);
-          desc->index_timestamps_on_event_reset_ = &(it->second->index_timestamps_on_event_reset_);
-        }
-
-        desc->timestamp_event_ = it->second->timestamp_event_to_signal_;
-
-        it->second->commands_.push_back(desc);
-        if (query != nullptr) {
-          desc_query->immediate_ = false;
-          it->second->metric_queries_.push_back(desc_query);
-        }
-
-        command_lists_mutex_.unlock();
-      }
-    }
-    else {
-      command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  void AppendMemoryCommand(
-    ZeDeviceCommandHandle handle,
-    size_t size,
-    const void* src,
-    const void* dst,
-    ze_event_handle_t& event_to_signal,
-    zet_metric_query_handle_t& query,
-    ze_command_list_handle_t command_list,
-    std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    ze_context_handle_t context = nullptr;
-    command_lists_mutex_.lock_shared();
-    auto it = command_lists_.find(command_list);
-    if (it != command_lists_.end()) {
-      context = it->second->context_;
-    }
-
-    int mtype = GetMemoryTransferType(context, src, context, dst);
-    if (mtype != -1) {
-      handle = ZeDeviceCommandHandle(int(handle) + mtype);
-    }
-
-    uint64_t command_id;
-    bool found = false;
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_command_properties_->find(handle);
-    if (kit != active_command_properties_->end()) {
-      command_id = kit->second.id_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    if (found && (it != command_lists_.end())) {
-      ZeCommand *desc = nullptr;
-      ZeCommandMetricQuery *desc_query = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_MEMORY;
-      desc->kernel_command_id_ = command_id;;
-      desc->engine_ordinal_ = it->second->engine_ordinal_;
-      desc->engine_index_ = it->second->engine_index_;
-      desc->host_time_origin_ = it->second->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = it->second->device_timer_frequency_;
-      desc->device_timer_mask_ = it->second->device_timer_mask_;
-      desc->device_ns_per_cycle_ = it->second->device_ns_per_cycle_;
-      desc->event_ = event_to_signal;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->device_ = it->second->device_;
-      ze_context_handle_t context = it->second->context_;
-
-      // Read graph capture state before releasing the lock
-      bool graph_capturing = it->second->graph_capturing_;
-
-      command_lists_mutex_.unlock_shared();
-
-      desc->group_count_ = {0, 0, 0};
-      desc->command_list_ = command_list;
-      desc->queue_ = nullptr;
-      desc->mem_size_ = size;
-      desc->tid_ = utils::GetTid();
-
-      desc->device_global_timestamps_ = nullptr;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->timestamp_event_ = nullptr;
-      desc->timestamp_seq_ = -1;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      if (ze_instance_data.in_order_counter_event_ && it->second->in_order_) {
-        ze_result_t status = ZE_FUNC(zeCommandListAppendSignalEvent)(command_list, ze_instance_data.in_order_counter_event_);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      if (query != nullptr) {
-        desc_query = local_device_submissions_.GetCommandMetricQuery();
-
-        ze_event_handle_t metric_query_event = event_cache_.GetEvent(context);
-        ze_result_t status = ZE_FUNC(zetCommandListAppendMetricQueryEnd)(command_list, query, metric_query_event, 0, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc_query->metric_query_event_ = metric_query_event;
-        desc_query->metric_query_ = query;
-        desc_query->device_ = it->second->device_;
-      }
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-
-      // In graph capture mode the command goes into the capture target; the
-      // target is re-read under the locks in StoreCommandInGraph (capture may
-      // have ended since graph_capturing was read).
-      if (graph_capturing && StoreCommandInGraph(command_list, desc, desc_query, host_timestamp, event_to_signal)) {
-      } else if (it->second->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;  // do not care metric query in case of immediate command list
-
-        local_device_submissions_.SubmitKernelCommand(desc);
-
-        kids->push_back(desc->instance_id_);
-
-        if (query != nullptr) {
-          desc_query->instance_id_ = desc->instance_id_;
-          desc_query->immediate_ = true;
-          local_device_submissions_.SubmitCommandMetricQuery(desc_query);
-        }
-      }
-      else {
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = desc_query;
-
-        command_lists_mutex_.lock();
-
-        it->second->commands_.push_back(desc);
-        if (query != nullptr) {
-          desc_query->immediate_ = false;
-          it->second->metric_queries_.push_back(desc_query);
-        }
-
-        command_lists_mutex_.unlock();
-      }
-    }
-    else {
-      command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  void AppendMemoryCommandContext(
-      ZeDeviceCommandHandle handle,
-      size_t size,
-      ze_context_handle_t src_context,
-      const void* src,
-      ze_context_handle_t dst_context,
-      const void* dst,
-      ze_event_handle_t& event_to_signal,
-      zet_metric_query_handle_t& query,
-      ze_command_list_handle_t command_list,
-      std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    command_lists_mutex_.lock_shared();
-    auto it = command_lists_.find(command_list);
-
-    int mtype = GetMemoryTransferType(src_context, src, dst_context, dst);
-    if (mtype != -1) {
-      handle = ZeDeviceCommandHandle(int(handle) + mtype);
-    }
-
-    uint64_t command_id;
-    bool found = false;
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_command_properties_->find(handle);
-    if (kit != active_command_properties_->end()) {
-      command_id = kit->second.id_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    if (found && (it != command_lists_.end())) {
-      ZeCommand *desc = nullptr;
-      ZeCommandMetricQuery *desc_query = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_MEMORY;
-      desc->kernel_command_id_ = command_id;;
-      desc->engine_ordinal_ = it->second->engine_ordinal_;
-      desc->engine_index_ = it->second->engine_index_;
-      desc->host_time_origin_ = it->second->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = it->second->device_timer_frequency_;
-      desc->device_timer_mask_ = it->second->device_timer_mask_;
-      desc->device_ns_per_cycle_ = it->second->device_ns_per_cycle_;
-      desc->event_ = event_to_signal;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->device_ = it->second->device_;
-      ze_context_handle_t context = it->second->context_;
-
-      // Read graph capture state before releasing the lock
-      bool graph_capturing = it->second->graph_capturing_;
-
-      command_lists_mutex_.unlock_shared();
-
-      desc->group_count_ = {0, 0, 0};
-      desc->command_list_ = command_list;
-      desc->queue_ = nullptr;
-      desc->mem_size_ = size;
-      desc->tid_ = utils::GetTid();
-
-      desc->device_global_timestamps_ = nullptr;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->timestamp_event_ = nullptr;
-      desc->timestamp_seq_ = -1;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      if (ze_instance_data.in_order_counter_event_ && it->second->in_order_) {
-        ze_result_t status = ZE_FUNC(zeCommandListAppendSignalEvent)(command_list, ze_instance_data.in_order_counter_event_);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      if (query != nullptr) {
-        desc_query = local_device_submissions_.GetCommandMetricQuery();
-
-        ze_event_handle_t metric_query_event = event_cache_.GetEvent(context);
-        ze_result_t status = ZE_FUNC(zetCommandListAppendMetricQueryEnd)(command_list, query, metric_query_event, 0, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc_query->metric_query_ = query;
-        desc_query->metric_query_event_ = metric_query_event;
-      }
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-
-      // In graph capture mode the command goes into the capture target; the
-      // target is re-read under the locks in StoreCommandInGraph (capture may
-      // have ended since graph_capturing was read).
-      if (graph_capturing && StoreCommandInGraph(command_list, desc, desc_query, host_timestamp, event_to_signal)) {
-      } else if (it->second->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;
-
-        local_device_submissions_.SubmitKernelCommand(desc);
-
-        kids->push_back(desc->instance_id_);
-        if (query != nullptr) {
-          desc_query->instance_id_ = desc->instance_id_;
-          desc_query->immediate_ = true;
-          local_device_submissions_.SubmitCommandMetricQuery(desc_query);
-        }
-      }
-      else {
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = desc_query;
-
-        command_lists_mutex_.lock();
-
-        it->second->commands_.push_back(desc);
-        if (query != nullptr) {
-          desc_query->immediate_ = false;
-          it->second->metric_queries_.push_back(desc_query);
-        }
-
-        command_lists_mutex_.unlock();
-      }
-    }
-    else {
-      command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  void AppendImageMemoryCopyCommand(
-    ZeDeviceCommandHandle handle,
-    ze_image_handle_t image,
-    const void* src,
-    const void* dst,
-    ze_event_handle_t& event_to_signal,
-    zet_metric_query_handle_t& query,
-    ze_command_list_handle_t command_list,
-    std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    ze_context_handle_t context = nullptr;
-    command_lists_mutex_.lock_shared();
-    auto it = command_lists_.find(command_list);
-    if (it != command_lists_.end()) {
-      context = it->second->context_;
-    }
-
-    int mtype = GetMemoryTransferType(context, src, context, dst);
-    if (mtype != -1) {
-      handle = ZeDeviceCommandHandle(int(handle) + mtype);
-    }
-
-    size_t size = GetImageSize(image);
-
-    uint64_t command_id;
-    bool found = false;
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_command_properties_->find(handle);
-    if (kit != active_command_properties_->end()) {
-      command_id = kit->second.id_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    if (found && (it != command_lists_.end())) {
-      ZeCommand *desc = nullptr;
-      ZeCommandMetricQuery *desc_query = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_MEMORY;
-      desc->kernel_command_id_ = command_id;;
-      desc->engine_ordinal_ = it->second->engine_ordinal_;
-      desc->engine_index_ = it->second->engine_index_;
-      desc->host_time_origin_ = it->second->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = it->second->device_timer_frequency_;
-      desc->device_timer_mask_ = it->second->device_timer_mask_;
-      desc->device_ns_per_cycle_ = it->second->device_ns_per_cycle_;
-      desc->device_ = it->second->device_;
-      ze_context_handle_t context = it->second->context_;
-
-      // Read graph capture state before releasing the lock
-      bool graph_capturing = it->second->graph_capturing_;
-
-      command_lists_mutex_.unlock_shared();
-
-      desc->group_count_ = {0, 0, 0};
-      desc->event_ = event_to_signal;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->command_list_ = command_list;
-      desc->mem_size_ = size;
-      desc->queue_ = nullptr;
-      desc->tid_ = utils::GetTid();
-
-      desc->device_global_timestamps_ = nullptr;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->timestamp_event_ = nullptr;
-      desc->timestamp_seq_ = -1;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      if (ze_instance_data.in_order_counter_event_ && it->second->in_order_) {
-        ze_result_t status = ZE_FUNC(zeCommandListAppendSignalEvent)(command_list, ze_instance_data.in_order_counter_event_);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      if (query != nullptr) {
-        desc_query = local_device_submissions_.GetCommandMetricQuery();
-
-        ze_event_handle_t metric_query_event = event_cache_.GetEvent(context);
-        ze_result_t status = ZE_FUNC(zetCommandListAppendMetricQueryEnd)(command_list, query, metric_query_event, 0, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc_query->metric_query_ = query;
-        desc_query->metric_query_event_ = metric_query_event;
-      }
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-
-      // In graph capture mode the command goes into the capture target; the
-      // target is re-read under the locks in StoreCommandInGraph (capture may
-      // have ended since graph_capturing was read).
-      if (graph_capturing && StoreCommandInGraph(command_list, desc, desc_query, host_timestamp, event_to_signal)) {
-      } else if (it->second->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;
-
-        local_device_submissions_.SubmitKernelCommand(desc);
-
-        kids->push_back(desc->instance_id_);
-        if (query != nullptr) {
-          desc_query->instance_id_ = desc->instance_id_;
-          desc_query->immediate_ = true;
-          local_device_submissions_.SubmitCommandMetricQuery(desc_query);
-        }
-      }
-      else {
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = desc_query;
-
-        command_lists_mutex_.lock();
-
-        it->second->commands_.push_back(desc);
-        if (query != nullptr) {
-          desc_query->immediate_ = false;
-          it->second->metric_queries_.push_back(desc_query);
-        }
-
-        command_lists_mutex_.unlock();
-      }
-    }
-    else {
-      command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  void AppendCommand(
-      ZeDeviceCommandHandle handle,
-      ze_event_handle_t& event_to_signal,
-      zet_metric_query_handle_t& query,
-      ze_command_list_handle_t command_list,
-      std::vector<uint64_t> *kids) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    command_lists_mutex_.lock_shared();
-
-    uint64_t command_id;
-    bool found = false;
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_command_properties_->find(handle);
-    if (kit != active_command_properties_->end()) {
-      command_id = kit->second.id_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    auto it = command_lists_.find(command_list);
-    if (found && (it != command_lists_.end())) {
-      ZeCommand *desc = nullptr;
-      ZeCommandMetricQuery *desc_query = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_COMMAND;
-      desc->kernel_command_id_ = command_id;;
-      desc->engine_ordinal_ = it->second->engine_ordinal_;
-      desc->engine_index_ = it->second->engine_index_;
-      desc->host_time_origin_ = it->second->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = it->second->device_timer_frequency_;
-      desc->device_timer_mask_ = it->second->device_timer_mask_;
-      desc->device_ns_per_cycle_ = it->second->device_ns_per_cycle_;
-      desc->device_ = it->second->device_;
-      ze_context_handle_t context = it->second->context_;
-
-      // Read graph capture state before releasing the lock
-      bool graph_capturing = it->second->graph_capturing_;
-
-      command_lists_mutex_.unlock_shared();
-
-      desc->group_count_ = {0, 0, 0};
-      desc->mem_size_ = 0;
-      desc->event_ = event_to_signal;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->command_list_ = command_list;
-      desc->queue_ = nullptr;
-      desc->tid_ = utils::GetTid();
-
-      desc->device_global_timestamps_ = nullptr;
-      desc->timestamp_seq_ = -1;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->timestamp_event_ = nullptr;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      if (ze_instance_data.in_order_counter_event_ && it->second->in_order_) {
-        ze_result_t status = ZE_FUNC(zeCommandListAppendSignalEvent)(command_list, ze_instance_data.in_order_counter_event_);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      if (query != nullptr) {
-        desc_query = local_device_submissions_.GetCommandMetricQuery();
-
-        ze_event_handle_t metric_query_event = event_cache_.GetEvent(context);
-        desc_query->metric_query_ = query;
-        desc_query->metric_query_event_ = metric_query_event;
-        ze_result_t status = ZE_FUNC(zetCommandListAppendMetricQueryEnd)(command_list, query, metric_query_event, 0, nullptr);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-
-      // In graph capture mode the command goes into the capture target; the
-      // target is re-read under the locks in StoreCommandInGraph (capture may
-      // have ended since graph_capturing was read).
-      if (graph_capturing && StoreCommandInGraph(command_list, desc, desc_query, host_timestamp, event_to_signal)) {
-      } else if (it->second->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;
-
-        local_device_submissions_.SubmitKernelCommand(desc);
-        kids->push_back(desc->instance_id_);
-        if (query != nullptr) {
-          desc_query->instance_id_ = desc->instance_id_;
-          desc_query->immediate_ = true;
-          local_device_submissions_.SubmitCommandMetricQuery(desc_query);
-        }
-      }
-      else {
-        // TODO: what happens if an event associated with a barrier gets reset?
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = desc_query;
-
-        command_lists_mutex_.lock();
-
-        it->second->commands_.push_back(desc);
-        if (query != nullptr) {
-          desc_query->immediate_ = false;
-          it->second->metric_queries_.push_back(desc_query);
-        }
-
-        command_lists_mutex_.unlock();
-      }
-    }
-    else {
-      command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  void AppendCommand(ZeDeviceCommandHandle handle, ZeCommandList *cl, std::vector<uint64_t> *kids, uint64_t *dts) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    if (dts == nullptr) {
-      std::cerr << "[WARNING] Invalid timestamp slot" << std::endl;
-      return;  // ignore this command
-    }
-
-    uint64_t command_id;
-    bool found = false;
-
-    kernel_command_properties_mutex_.lock_shared();
-    auto kit = active_command_properties_->find(handle);
-    if (kit != active_command_properties_->end()) {
-      command_id = kit->second.id_;
-      found = true;
-    }
-    kernel_command_properties_mutex_.unlock_shared();
-
-    if (found) {
-      ZeCommand *desc = nullptr;
-
-      desc = local_device_submissions_.GetKernelCommand();
-
-      desc->type_ = KERNEL_COMMAND_TYPE_COMMAND;
-      desc->kernel_command_id_ = command_id;;
-      desc->engine_ordinal_ = cl->engine_ordinal_;
-      desc->engine_index_ = cl->engine_index_;
-      desc->host_time_origin_ = cl->host_time_origin_;  // in ns
-      desc->device_timer_frequency_ = cl->device_timer_frequency_;
-      desc->device_timer_mask_ = cl->device_timer_mask_;
-      desc->device_ns_per_cycle_ = cl->device_ns_per_cycle_;
-      desc->device_ = cl->device_;
-
-      desc->group_count_ = {0, 0, 0};
-      desc->mem_size_ = 0;
-      desc->event_ = nullptr;
-      desc->in_order_counter_event_ = ze_instance_data.in_order_counter_event_;
-      desc->command_list_ = cl->cmdlist_;
-      desc->queue_ = nullptr;
-      desc->tid_ = utils::GetTid();
-
-      desc->timestamp_seq_ = -1;
-      desc->timestamps_on_event_reset_ = nullptr;
-      desc->timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_commands_completion_ = nullptr;
-      desc->index_timestamps_on_event_reset_ = nullptr;
-
-      // dts points to end timestamp but we need start timestamp too which is immediately followed by end timestamp
-      // hence dts - 1
-      desc->device_global_timestamps_ = dts - 1;  // dts points to end timestamp but start timestamp is needed also which immediately
-      desc->timestamp_event_ = cl->timestamp_event_to_signal_;
-
-      uint64_t host_timestamp = ze_instance_data.timestamp_host;
-      if (cl->immediate_) {
-        desc->immediate_ = true;
-        desc->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-        desc->append_time_ = host_timestamp;
-        desc->submit_time_ = host_timestamp;
-        desc->submit_time_device_ = ze_instance_data.timestamp_device;  // append time and submit time are the same
-        desc->command_metric_query_ = nullptr;
-
-        local_device_submissions_.SubmitKernelCommand(desc);
-        kids->push_back(desc->instance_id_);
-      }
-      else {
-        desc->append_time_ = host_timestamp;
-        desc->immediate_ = false;
-        desc->command_metric_query_ = nullptr;
-        cl->commands_.push_back(desc);
-      }
-    }
-  }
-
-  // Stores a command into the graph that command_list is capturing into and
-  // tracks the signal event. The capture target is read here, under
-  // command_lists_mutex_ (shared) and graphs_mutex_ (graph contents, always taken
-  // after command_lists_mutex_), so it cannot change or be destroyed between the
-  // check and the store. Returns false if the command list is no longer
-  // capturing; the caller then handles the command as a regular one.
-  bool StoreCommandInGraph(ze_command_list_handle_t command_list, ZeCommand* desc,
-                           ZeCommandMetricQuery* desc_query, uint64_t host_timestamp,
-                           ze_event_handle_t signal_event) {
-    std::shared_lock<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-    auto it = command_lists_.find(command_list);
-    if (it == command_lists_.end() || !it->second->graph_capturing_ ||
-        it->second->graph_capture_target_ == nullptr) {
-      return false;
-    }
-    ZeGraph* graph = it->second->graph_capture_target_;
-
-    desc->immediate_ = true;
-    desc->graph_command_ = true;
-    desc->append_time_ = host_timestamp;
-    desc->command_metric_query_ = desc_query;
-
-    graph->commands_.push_back(desc);
-    if (desc_query != nullptr) {
-      desc_query->immediate_ = false;
-      graph->metric_queries_.push_back(desc_query);
-    }
-
-    // Track signal event for fork detection and join handling
-    if (signal_event != nullptr) {
-      graph->event_to_cmdlist_[signal_event] = command_list;
-    }
-    return true;
-  }
-
-  // Detects fork and join transitions during graph capture.
-  //
-  // Fork: when a non-capturing cmdlist waits on an event signaled during an
-  //   active graph capture, it auto-transitions into capture mode.
-  // Join: when the primary cmdlist waits on an event signaled by a forked
-  //   cmdlist, capture ends on that fork. Per spec each fork must join back
-  //   to the primary cmdlist (no nested forks).
-  void CheckAndApplyForkTransition(
-      ze_command_list_handle_t command_list,
-      uint32_t num_wait_events, ze_event_handle_t* wait_events) {
-    if (wait_events == nullptr || num_wait_events == 0) return;
-
-    // Cheap shared-lock pass first; the common case is no match
-    ZeGraph* target = FindForkSourceGraph(num_wait_events, wait_events);
-    if (target == nullptr) return;
-
-    // Decide and apply under both exclusive locks: the search above released
-    // its locks, so re-check that the graph is still tracked and still matches
-    // a wait event, and read the command list state here.
-    std::lock_guard<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-    auto clit = command_lists_.find(command_list);
-    if (clit == command_lists_.end()) {
-      return;
-    }
-    const bool already_capturing = clit->second->graph_capturing_;
-    ZeGraph* const existing_target = clit->second->graph_capture_target_;
-    bool target_matches = false;
-    for (auto& [gh, ginfo] : graphs_) {
-      if (ginfo == target) {
-        for (uint32_t i = 0; i < num_wait_events; ++i) {
-          if (target->event_to_cmdlist_.count(wait_events[i])) {
-            target_matches = true;
-            break;
-          }
-        }
-        break;
-      }
-    }
-    if (!target_matches) return;
-
-    // --- Join: primary waits on fork events → end capture on those forks ---
-    if (already_capturing && command_list == target->primary_command_list_) {
-      for (uint32_t i = 0; i < num_wait_events; ++i) {
-        auto evt_it = target->event_to_cmdlist_.find(wait_events[i]);
-        if (evt_it == target->event_to_cmdlist_.end()) continue;
-        ze_command_list_handle_t fork_cl = evt_it->second;
-        if (fork_cl == target->primary_command_list_) continue;
-        auto fit = command_lists_.find(fork_cl);
-        if (fit != command_lists_.end() && fit->second->graph_capturing_) {
-          fit->second->graph_capturing_ = false;
-          fit->second->graph_capture_target_ = nullptr;
-        }
-        target->forked_command_lists_.erase(fork_cl);
-      }
-      return;
-    }
-
-    // Already capturing into the same graph — nothing to do
-    if (already_capturing && existing_target == target) return;
-
-    // Cross-graph merge prevention
-    if (already_capturing && existing_target != nullptr && existing_target != target) {
-      std::cerr << "[ERROR] Cross-graph merge detected: command list " << command_list
-                << " is already capturing into a different graph." << std::endl;
-      return;
-    }
-
-    // --- Fork: auto-transition this cmdlist into capture mode ---
-    if (!already_capturing) {
-      clit->second->graph_capturing_ = true;
-      clit->second->graph_capture_target_ = target;
-    }
-    target->forked_command_lists_.insert(command_list);
-  }
-
-  // Called when zeGraphDestroyExp succeeds - cleanup graph tracking
-  void OnGraphDestroy(ze_graph_handle_t graph) {
-    std::lock_guard<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-    auto git = graphs_.find(graph);
-    if (git != graphs_.end()) {
-      ZeGraph* g = git->second;
-      if (g != nullptr) {
-        // Reset any command lists still referencing this graph
-        for (auto& [cl_handle, cl] : command_lists_) {
-          if (cl->graph_capture_target_ == g) {
-            cl->graph_capturing_ = false;
-            cl->graph_capture_target_ = nullptr;
-            cl->pending_graph_capture_ = nullptr;
-          }
-        }
-        ReleaseGraphResources(*g);
-        delete g;
-      }
-      graphs_.erase(git);
-    }
-  }
-
-  // True if the cmdlist is currently inside a graph capture. Used so the
-  // append callbacks keep capturing into the graph even when collection is
-  // paused.
-  bool IsCommandListGraphCapturing(ze_command_list_handle_t command_list) {
-    std::shared_lock<std::shared_mutex> lock(command_lists_mutex_);
-    auto it = command_lists_.find(command_list);
-    return (it != command_lists_.end() && it->second->graph_capturing_);
-  }
-
-  // True if any wait event is a fork-signal of an active graph capture.
-  // Lets the very first append on a fork cmdlist through while collection
-  // is paused, before its graph_capturing_ flag has been flipped.
-  bool WouldTriggerGraphCapture(uint32_t num_wait_events,
-                                ze_event_handle_t* wait_events) {
-    return FindForkSourceGraph(num_wait_events, wait_events) != nullptr;
-  }
-
-  // Returns the graph whose captured signal events include one of the wait
-  // events, or nullptr. Takes the same locks, in the same order, as the
-  // writers of event_to_cmdlist_ (command_lists_mutex_, then graphs_mutex_),
-  // both shared. The result is only a hint: callers that act on it must
-  // re-check under the exclusive locks.
-  ZeGraph* FindForkSourceGraph(uint32_t num_wait_events,
-                               ze_event_handle_t* wait_events) {
-    if (wait_events == nullptr || num_wait_events == 0) return nullptr;
-    std::shared_lock<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::shared_lock<std::shared_mutex> graph_lock(graphs_mutex_);
-    for (auto& [gh, ginfo] : graphs_) {
-      for (uint32_t i = 0; i < num_wait_events; ++i) {
-        if (ginfo->event_to_cmdlist_.count(wait_events[i])) {
-          return ginfo;
-        }
-      }
-    }
-    return nullptr;
-  }
-
-  // Whether an append on this command list should be instrumented. Always
-  // true when collection is enabled; while paused, still true if the list is
-  // mid graph-capture, so the captured graph is populated for later replay.
-  bool ShouldCaptureAppend(ze_command_list_handle_t command_list,
-                           uint32_t num_wait_events,
-                           ze_event_handle_t* wait_events) {
-    return UniController::IsCollectionEnabled() ||
-           IsCommandListGraphCapturing(command_list) ||
-           WouldTriggerGraphCapture(num_wait_events, wait_events);
-  }
-
-  // Release all resources owned by a ZeGraph (events, metric queries, commands)
-  void ReleaseGraphResources(ZeGraph& graph_info) {
-    for (auto* cmd : graph_info.commands_) {
-      if (cmd != nullptr) {
-        if (cmd->event_ != nullptr) {
-          event_cache_.ReleaseEvent(cmd->event_);
-          cmd->event_ = nullptr;
-        }
-        delete cmd;
-      }
-    }
-    for (auto* mq : graph_info.metric_queries_) {
-      if (mq != nullptr) {
-        if (mq->metric_query_event_ != nullptr) {
-          event_cache_.ReleaseEvent(mq->metric_query_event_);
-          mq->metric_query_event_ = nullptr;
-        }
-        if (mq->metric_query_ != nullptr) {
-          query_pools_.PutQuery(mq->metric_query_);
-          mq->metric_query_ = nullptr;
-        }
-        delete mq;
-      }
-    }
-    graph_info.commands_.clear();
-    graph_info.metric_queries_.clear();
-  }
-
-  // Called when zeExecutableGraphDestroyExp succeeds - cleanup executable graph mapping
-  void OnExecutableGraphDestroy(ze_executable_graph_handle_t exec_graph) {
-    std::lock_guard<std::shared_mutex> lock(executable_graphs_mutex_);
-    executable_to_source_graph_.erase(exec_graph);
-  }
-
-  // Called when zeCommandListBeginGraphCaptureExp succeeds (no graph handle yet).
-  // Allocates a temporary ZeGraph so that Append* methods can capture commands
-  // into it.  OnEndGraphCapture will adopt this into graphs_ under the real handle.
-  void OnBeginGraphCaptureNoGraph(ze_command_list_handle_t command_list) {
-    std::lock_guard<std::shared_mutex> lock(command_lists_mutex_);
-    // The new graph becomes reachable through graph_capture_target_; its
-    // contents are guarded by graphs_mutex_ like every other graph's.
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-    auto it = command_lists_.find(command_list);
-    if (it == command_lists_.end()) {
-      return;
-    }
-
-    // Allocate a temporary graph info to accumulate captured commands
-    ZeGraph* pending = new ZeGraph();
-    pending->primary_command_list_ = command_list;
-
-    it->second->graph_capturing_ = true;
-    it->second->graph_capture_target_ = pending;
-    it->second->pending_graph_capture_ = pending;  // Ownership tracked here
-  }
-
-  // Called when zeCommandListBeginCaptureIntoGraphExp succeeds - start tracking captures
-  void OnBeginGraphCapture(ze_command_list_handle_t command_list, ze_graph_handle_t graph) {
-    // One critical section, so the command list cannot go away and the graph
-    // cannot be reset or destroyed between the check and the update.
-    std::lock_guard<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-    auto it = command_lists_.find(command_list);
-    if (it == command_lists_.end()) {
-      return;
-    }
-
-    // Create or update the graph entry and reset capture state
-    auto git = graphs_.try_emplace(graph, nullptr).first;
-    if (git->second == nullptr) {
-      git->second = new ZeGraph();
-    }
-    ZeGraph* graph_info = git->second;
-    graph_info->commands_.clear();
-    graph_info->metric_queries_.clear();
-    graph_info->primary_command_list_ = command_list;
-    graph_info->forked_command_lists_.clear();
-    graph_info->event_to_cmdlist_.clear();
-
-    // Mark command list as in graph capture mode with pointer to graph in graphs_ map
-    it->second->graph_capturing_ = true;
-    it->second->graph_capture_target_ = graph_info;
-  }
-
-  // Called when zeCommandListEndGraphCaptureExp succeeds - stop tracking captures
-  void OnEndGraphCapture(ze_command_list_handle_t command_list, ze_graph_handle_t graph) {
-    // Get pending capture (if any) and reset capture state on command list
-    ZeGraph* pending = nullptr;
-
-    // One critical section: the target graph's fork and event sets are graph
-    // contents (graphs_mutex_), and the pending graph is adopted atomically.
-    std::lock_guard<std::shared_mutex> cmd_lock(command_lists_mutex_);
-    std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-
-    // Reset capture state on primary and all forked command lists
-    {
-      auto it = command_lists_.find(command_list);
-      if (it != command_lists_.end()) {
-        pending = it->second->pending_graph_capture_;
-        ZeGraph* target = it->second->graph_capture_target_;
-        it->second->graph_capturing_ = false;
-        it->second->graph_capture_target_ = nullptr;
-        it->second->pending_graph_capture_ = nullptr;
-
-        // End capture on all forked command lists
-        if (target != nullptr) {
-          for (auto forked_cl : target->forked_command_lists_) {
-            auto fit = command_lists_.find(forked_cl);
-            if (fit != command_lists_.end()) {
-              fit->second->graph_capturing_ = false;
-              fit->second->graph_capture_target_ = nullptr;
-            }
-          }
-          // Clear event tracking data now that capture is complete.
-          // Prevents stale events from triggering false fork matches
-          // in CheckAndApplyForkTransition during a later capture.
-          target->event_to_cmdlist_.clear();
-          target->forked_command_lists_.clear();
-        }
-      }
-    }
-
-    {
-      auto git = graphs_.find(graph);
-      if (git == graphs_.end()) {
-        // BeginGraphCaptureExp path: adopt the pending capture into graphs_
-        if (pending != nullptr) {
-          graphs_.insert({graph, pending});
-        }
-      } else {
-        // BeginCaptureIntoGraphExp path: graph already exists with captured commands.
-        // If there was somehow a pending capture, clean it up.
-        if (pending != nullptr) {
-          ReleaseGraphResources(*pending);
-          delete pending;
-        }
-      }
-    }
-  }
-
-  // Called when zeCommandListInstantiateGraphExp succeeds - map executable to source graph
-  void OnInstantiateGraph(ze_graph_handle_t graph, ze_executable_graph_handle_t exec_graph) {
-    // Map executable graph directly to source graph's ZeGraph
-    ZeGraph* graph_info = nullptr;
-    {
-      // Same lock order as every other graphs_ access.
-      std::shared_lock<std::shared_mutex> cmd_lock(command_lists_mutex_);
-      std::shared_lock<std::shared_mutex> lock(graphs_mutex_);
-      auto git = graphs_.find(graph);
-      if (git != graphs_.end()) {
-        graph_info = git->second;
-      }
-    }
-
-    if (graph_info != nullptr) {
-      std::lock_guard<std::shared_mutex> lock(executable_graphs_mutex_);
-      executable_to_source_graph_.insert({exec_graph, graph_info});
-    }
-  }
-
-  // Called from Enter callback for zeCommandListAppendGraphExp.
-  // Prepares timing entries for all captured kernels in the graph.
-  // Mirrors the pattern in OnEnterCommandListImmediateAppendCommandListsExp.
-  void PrepareGraphExecution(
-      ze_command_list_handle_t command_list,
-      ze_executable_graph_handle_t exec_graph) {
-
-    if (local_device_submissions_.IsFinalized()) {
-      return;
-    }
-
-    // Look up source graph info directly from executable graph
-    ZeGraph* graph_info = nullptr;
-    executable_graphs_mutex_.lock_shared();
-    auto eit = executable_to_source_graph_.find(exec_graph);
-    if (eit != executable_to_source_graph_.end()) {
-      graph_info = eit->second;
-    }
-    executable_graphs_mutex_.unlock_shared();
-
-    if (graph_info == nullptr) {
-      return;  // Graph not tracked
-    }
-
-    // Get command list info for execution context
-    ze_device_handle_t device = nullptr;
-    uint32_t engine_ordinal = 0;
-    uint32_t engine_index = 0;
-
-    command_lists_mutex_.lock_shared();
-    auto clit = command_lists_.find(command_list);
-    if (clit != command_lists_.end()) {
-      device = clit->second->device_;
-      engine_ordinal = clit->second->engine_ordinal_;
-      engine_index = clit->second->engine_index_;
-    }
-    command_lists_mutex_.unlock_shared();
-
-    if (device == nullptr) {
-      return;
-    }
-
-    // The graph's captured commands reuse the same physical events on every
-    // replay. If a previous replay's clones are still in flight, this replay
-    // would reset those events before their timestamps are read, dropping the
-    // prior replay's records. A previous replay may have been appended to a
-    // different command list, so wait on every command list that currently
-    // has an in-flight clone carrying one of this graph's events,
-    // then process the drained commands before staging this replay.
-    {
-      std::set<ze_event_handle_t> graph_events;
-      graphs_mutex_.lock_shared();
-      for (auto cmd : graph_info->commands_) {
-        if (cmd->event_ != nullptr) {
-          graph_events.insert(cmd->event_);
-        }
-      }
-      graphs_mutex_.unlock_shared();
-
-      std::set<ze_command_list_handle_t> lists_to_wait;
-      global_device_submissions_mutex_.lock_shared();
-      for (auto cmd : local_device_submissions_.commands_submitted_) {
-        if (cmd->command_list_ != nullptr && graph_events.count(cmd->event_)) {
-          lists_to_wait.insert(cmd->command_list_);
-        }
-      }
-      global_device_submissions_mutex_.unlock_shared();
-
-      for (auto list : lists_to_wait) {
-        ZE_FUNC(zeCommandListHostSynchronize)(list, UINT64_MAX);
-      }
-    }
-    ProcessAllCommandsSubmitted(nullptr);
-
-    // Get timestamp for submit time
-    uint64_t host_timestamp = 0;
-    uint64_t device_timestamp = 0;
-
-    ze_result_t status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(device, &host_timestamp, &device_timestamp);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    // Get graph captured commands and clone them for this execution
-    graphs_mutex_.lock_shared();
-    if (graph_info->commands_.empty()) {
-      graphs_mutex_.unlock_shared();
-      return;
-    }
-
-    // Clone each captured command for this execution (similar to PrepareToExecuteCommandListsLocked)
-    for (auto command : graph_info->commands_) {
-      ZeCommand* cmd = local_device_submissions_.GetKernelCommand();
-      ZeCommandMetricQuery* cmd_query = nullptr;
-
-      if (command->command_metric_query_ != nullptr) {
-        cmd_query = local_device_submissions_.GetCommandMetricQuery();
-      }
-      *cmd = *command;
-
-      cmd->instance_id_ = UniKernelInstanceId::GetKernelInstanceId();
-      cmd->engine_ordinal_ = engine_ordinal;
-      cmd->engine_index_ = engine_index;
-      cmd->submit_time_ = host_timestamp;		//in ns
-      cmd->submit_time_device_ = device_timestamp;	//in ticks
-      cmd->tid_ = utils::GetTid();
-      // Record the command list this replay runs on, so a later replay can
-      // host-synchronize on it before reusing the shared captured events.
-      cmd->command_list_ = command_list;
-
-      local_device_submissions_.StageKernelCommand(cmd);
-
-      if (cmd_query) {
-        *cmd_query = *(command->command_metric_query_);
-        cmd_query->instance_id_ = cmd->instance_id_;
-        local_device_submissions_.StageCommandMetricQuery(cmd_query);
-      }
-      else {
-        local_device_submissions_.StageCommandMetricQuery(nullptr);
-      }
-    }
-
-    graphs_mutex_.unlock_shared();
-  }
-
-  static void OnEnterCommandListAppendLaunchKernel(
-      ze_command_list_append_launch_kernel_params_t* params,
-      void* global_data, void** instance_data) {
-    // Snapshot the collection-enabled decision here, at enter, into the
-    // thread-local instance state so the matching OnExit acts on this snapshot.
-    // If OnExit instead re-checked UniController::IsCollectionEnabled() and a
-    // session was stopped between enter and exit, it would destroy the
-    // profiling event already appended into the command list and corrupt the
-    // in-flight GPU submission (seen as UR_RESULT_ERROR_UNKNOWN on queue wait).
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), true, *(params->phKernel),
-          *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-    else {
-      *instance_data = nullptr;
-    }
-  }
-
-  static void OnExitCommandListAppendLaunchKernel(
-    ze_command_list_append_launch_kernel_params_t* params,
-    ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    // Act on the enter-time snapshot (ze_instance_data.instrument_), not a
-    // fresh IsCollectionEnabled() check: if the session was stopped between
-    // enter and exit, re-checking here would release (zeEventDestroy) the
-    // profiling event already queued on the GPU and crash the app's wait.
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendLaunchKernel(
-        *(params->phKernel),
-        *(params->ppLaunchFuncArgs),
-        *(params->phSignalEvent),
-        ze_instance_data.query_,
-        *(params->phCommandList),
-        kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelWithArguments(
-      ze_command_list_append_launch_kernel_with_arguments_params_t* params,
-      void* global_data, void** instance_data) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), true, *(params->phKernel),
-          *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-    else {
-      *instance_data = nullptr;
-    }
-  }
-
-  static void OnExitCommandListAppendLaunchKernelWithArguments(
-      ze_command_list_append_launch_kernel_with_arguments_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-        collector->AppendLaunchKernel(
-          *(params->phKernel),
-          params->pgroupCounts,
-          *(params->phSignalEvent),
-          ze_instance_data.query_,
-          *(params->phCommandList),
-          kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelWithParameters(
-      ze_command_list_append_launch_kernel_with_parameters_params_t* params,
-      void* global_data, void** instance_data) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), true, *(params->phKernel),
-          *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-    else {
-      *instance_data = nullptr;
-    }
-  }
-
-  static void OnExitCommandListAppendLaunchKernelWithParameters(
-      ze_command_list_append_launch_kernel_with_parameters_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-        collector->AppendLaunchKernel(
-          *(params->phKernel),
-          *(params->ppGroupCounts),
-          *(params->phSignalEvent),
-          ze_instance_data.query_,
-          *(params->phCommandList),
-          kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchCooperativeKernel(
-      ze_command_list_append_launch_cooperative_kernel_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), true, *(params->phKernel),
-          *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendLaunchCooperativeKernel(
-      ze_command_list_append_launch_cooperative_kernel_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-        collector->AppendLaunchKernel(
-          *(params->phKernel),
-          *(params->ppLaunchFuncArgs),
-          *(params->phSignalEvent),
-          ze_instance_data.query_,
-          *(params->phCommandList),
-          kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendLaunchKernelIndirect(
-      ze_command_list_append_launch_kernel_indirect_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), true, *(params->phKernel),
-          *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendLaunchKernelIndirect(
-      ze_command_list_append_launch_kernel_indirect_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-        collector->AppendLaunchKernel(
-          *(params->phKernel),
-          *(params->ppLaunchArgumentsBuffer),
-          *(params->phSignalEvent),
-          ze_instance_data.query_,
-          *(params->phCommandList),
-          kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  int GetMemoryTransferType(ze_context_handle_t src_context, const void *src) {
-
-    int stype = -1;
-
-    if (src_context != nullptr && src != nullptr) {
-      ze_memory_allocation_properties_t props{ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES,};
-      ze_result_t status = ZE_FUNC(zeMemGetAllocProperties)(src_context, src, &props, nullptr);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      switch (props.type) {
-        case ZE_MEMORY_TYPE_HOST:
-          stype = 0;
-          break;
-        case ZE_MEMORY_TYPE_DEVICE:
-          stype = 1;
-          break;
-        case ZE_MEMORY_TYPE_UNKNOWN:
-          stype = 2;
-          break;
-        case ZE_MEMORY_TYPE_SHARED:
-          stype = 3;
-          break;
-        case ZE_MEMORY_TYPE_HOST_IMPORTED:
-          stype = 0;
-          break;
-        default:
-          break;
-      }
-    }
-    return stype;
-  }
-
-  int GetMemoryTransferType(ze_context_handle_t src_context, const void *src, ze_context_handle_t dst_context, const void *dst) {
-
-    int stype = -1;
-    int dtype = -1;
-
-    if (src_context != nullptr && src != nullptr) {
-      ze_memory_allocation_properties_t props{ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES,};
-      ze_result_t status = ZE_FUNC(zeMemGetAllocProperties)(src_context, src, &props, nullptr);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      switch (props.type) {
-        case ZE_MEMORY_TYPE_HOST:
-          stype = 0;
-          break;
-        case ZE_MEMORY_TYPE_DEVICE:
-          stype = 1;
-          break;
-        case ZE_MEMORY_TYPE_UNKNOWN:
-          stype = 2;
-          break;
-        case ZE_MEMORY_TYPE_SHARED:
-          stype = 3;
-          break;
-        case ZE_MEMORY_TYPE_HOST_IMPORTED:
-          stype = 0;
-          break;
-        default:
-          break;
-      }
-    }
-
-    if (dst_context != nullptr && dst != nullptr) {
-      ze_memory_allocation_properties_t props{ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES,};
-      ze_result_t status = ZE_FUNC(zeMemGetAllocProperties)(dst_context, dst, &props, nullptr);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      switch (props.type) {
-        case ZE_MEMORY_TYPE_HOST:
-          dtype = 0;
-          break;
-        case ZE_MEMORY_TYPE_DEVICE:
-          dtype = 1;
-          break;
-        case ZE_MEMORY_TYPE_UNKNOWN:
-          dtype = 2;
-          break;
-        case ZE_MEMORY_TYPE_SHARED:
-          dtype = 3;
-          break;
-        case ZE_MEMORY_TYPE_HOST_IMPORTED:
-          dtype = 0;
-          break;
-        default:
-          break;
-      }
-    }
-
-    if ((stype != -1) && (dtype != -1)) {
-      return (stype << 2 | dtype);
-    }
-    else {
-      return stype;
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryCopy(
-      ze_command_list_append_memory_copy_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendMemoryCopy(
-      ze_command_list_append_memory_copy_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendMemoryCommand(MemoryCopy, *(params->psize),
-          *(params->psrcptr), *(params->pdstptr), *(params->phSignalEvent), ze_instance_data.query_,
-          *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryFill(
-      ze_command_list_append_memory_fill_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendMemoryFill(
-      ze_command_list_append_memory_fill_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendMemoryCommand(MemoryFill, *(params->psize),
-          *(params->pptr), nullptr, *(params->phSignalEvent), ze_instance_data.query_,
-          *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendBarrier(
-      ze_command_list_append_barrier_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendBarrier(
-      ze_command_list_append_barrier_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendCommand(Barrier, *(params->phSignalEvent), ze_instance_data.query_,
-          *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryRangesBarrier(
-      ze_command_list_append_memory_ranges_barrier_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendMemoryRangesBarrier(
-      ze_command_list_append_memory_ranges_barrier_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendCommand(MemoryRangesBarrier, *(params->phSignalEvent), ze_instance_data.query_,
-          *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryCopyRegion(
-      ze_command_list_append_memory_copy_region_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendMemoryCopyRegion(
-      ze_command_list_append_memory_copy_region_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      size_t bytes_transferred = 0;
-      const ze_copy_region_t* region = *(params->psrcRegion);
-
-      if (region != nullptr) {
-        if (region->depth != 0) {
-          bytes_transferred *= region->depth;
-        }
-      }
-
-      collector->AppendMemoryCommand(MemoryCopyRegion, bytes_transferred,
-        *(params->psrcptr), *(params->pdstptr), *(params->phSignalEvent), ze_instance_data.query_,
-         *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendMemoryCopyFromContext(
-      ze_command_list_append_memory_copy_from_context_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendMemoryCopyFromContext(
-      ze_command_list_append_memory_copy_from_context_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      ze_context_handle_t src_context = *(params->phContextSrc);
-      collector->AppendMemoryCommandContext(MemoryCopyFromContext, *(params->psize),
-        src_context, *(params->psrcptr), nullptr, *(params->pdstptr), *(params->phSignalEvent), ze_instance_data.query_,
-        *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopy(
-      ze_command_list_append_image_copy_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendImageCopy(
-      ze_command_list_append_image_copy_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendImageMemoryCopyCommand(ImageCopy, *(params->phSrcImage),
-        nullptr, nullptr, *(params->phSignalEvent), ze_instance_data.query_,
-        *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyRegion(
-      ze_command_list_append_image_copy_region_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendImageCopyRegion(
-      ze_command_list_append_image_copy_region_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendImageMemoryCopyCommand(ImageCopyRegion, *(params->phSrcImage),
-        nullptr, nullptr, *(params->phSignalEvent), ze_instance_data.query_,
-        *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyToMemory(
-      ze_command_list_append_image_copy_to_memory_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendImageCopyToMemory(
-      ze_command_list_append_image_copy_to_memory_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      collector->AppendImageMemoryCopyCommand(ImageCopyToMemory, *(params->phSrcImage),
-        nullptr, *(params->pdstptr), *(params->phSignalEvent), ze_instance_data.query_,
-        *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendImageCopyFromMemory(
-      ze_command_list_append_image_copy_from_memory_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ze_instance_data.instrument_ = false;
-    ze_instance_data.query_ = nullptr;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumWaitEvents),
-                                       *(params->pphWaitEvents))) {
-      PrepareToAppendKernelCommand(collector, *(params->phSignalEvent), *(params->phCommandList), false,
-          nullptr, *(params->pnumWaitEvents), *(params->pphWaitEvents));
-    }
-  }
-
-  static void OnExitCommandListAppendImageCopyFromMemory(
-      ze_command_list_append_image_copy_from_memory_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if ((result == ZE_RESULT_SUCCESS) && ze_instance_data.instrument_) {
-      size_t bytes_transferred = 0;
-      const ze_image_region_t* region = *(params->ppDstRegion);
-
-      if (region != nullptr) {
-        bytes_transferred = region->width * region->height;
-        if (region->depth != 0) {
-          bytes_transferred *= region->depth;
-        }
-      }
-
-      collector->AppendMemoryCommand(ImageCopyFromMemory, bytes_transferred,
-        *(params->psrcptr), nullptr, *(params->phSignalEvent), ze_instance_data.query_,
-        *(params->phCommandList), kids);
-    }
-    else {
-      collector->query_pools_.PutQuery(ze_instance_data.query_);
-      collector->event_cache_.ReleaseEvent(*(params->phSignalEvent));
-    }
-  }
-
-  static void OnEnterCommandListAppendEventReset(ze_command_list_append_event_reset_params_t* params, void* global_data, void** instance_data) {
-
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    if (!(collector->reset_event_on_device_)) {
-      return;
-    }
-
-    collector->command_lists_mutex_.lock();
-    auto it = collector->command_lists_.find(*(params->phCommandList));
-    if (it != collector->command_lists_.end()) {
-      if (it->second->immediate_) {
-        if (!it->second->in_order_) {
-          std::cerr << "[WARNING] Event reset in out-of-order immediate command list" << std::endl;
-        }
-        // handle immediate command list
-        global_device_submissions_mutex_.lock_shared();
-        auto it_cmd = local_device_submissions_.commands_submitted_.begin();
-        bool process_commands = false;
-        while (it_cmd != local_device_submissions_.commands_submitted_.end()) {
-          ZeCommand *command = *it_cmd;
-          if (command->command_list_ == *(params->phCommandList)) {
-            // check if reset event is associated with any command
-            if (command->event_ == *(params->phEvent)) {
-                // found a command associated with this event
-                // wait for the event to be signaled before processing commands
-                auto status = ZE_FUNC(zeEventHostSynchronize)(command->event_, UINT64_MAX);
-                if (status != ZE_RESULT_SUCCESS) {
-                  process_commands = false;
-                  std::cerr << "[ERROR] Failed to synchronize event when tracing event reset on device" << std::endl;
-                  break;
-                }
-                process_commands = true;
-            }
-          }
-          ++it_cmd;
-        }
-        if (process_commands) {
-          // Associated commands found for immediate command list, process them
-          collector->ProcessCommandsSubmitted(nullptr);
-        }
-        global_device_submissions_mutex_.unlock_shared();
-      }
-    }
-
-    if ((it != collector->command_lists_.end()) && !(it->second->immediate_)) {
-      auto it2 = it->second->event_to_timestamp_seq_.find(*(params->phEvent));
-      if (it2 != it->second->event_to_timestamp_seq_.end()) {
-        int slot = it->second->num_timestamps_on_event_reset_++;
-        it->second->index_timestamps_on_event_reset_[it2->second] = slot;
-        ze_kernel_timestamp_result_t *ts = nullptr;
-        size_t slice = slot / number_timestamps_per_slice_;
-        if (it->second->timestamps_on_event_reset_.size() <= slice) {
-          ze_host_mem_alloc_desc_t host_alloc_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr, 0};
-          auto status = ZE_FUNC(zeMemAllocHost)(it->second->context_, &host_alloc_desc, number_timestamps_per_slice_ * sizeof(ze_kernel_timestamp_result_t), cache_line_size_, (void **)&ts);
-          UniMemory::ExitIfOutOfMemory((void *)(ts));
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Failed to allocate host memory for timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            exit(-1);
-          }
-          it->second->timestamps_on_event_reset_.push_back(ts);
-        }
-        else {
-          ts = it->second->timestamps_on_event_reset_[slice];
-        }
-        int idx = slot % number_timestamps_per_slice_;
-        auto status = ZE_FUNC(zeCommandListAppendQueryKernelTimestamps)(*(params->phCommandList), 1, (ze_event_handle_t *)(params->phEvent), (void *)&(ts[idx]), nullptr, nullptr, 1, (ze_event_handle_t *)(params->phEvent));
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to get kernel timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          exit(-1);
-        }
-        it->second->event_to_timestamp_seq_.erase(it2);
-      }
-
-      if (UniController::IsCollectionEnabled()) {
-        // each command or kernel needs two slots: one for start and one for end
-        uint64_t *dts = nullptr;
-        size_t slice = it->second->num_device_global_timestamps_ / (2 * number_timestamps_per_slice_);
-        if (it->second->device_global_timestamps_.size() <= slice) {
-          ze_host_mem_alloc_desc_t host_alloc_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr, 0};
-          auto status = ZE_FUNC(zeMemAllocHost)(it->second->context_, &host_alloc_desc, number_timestamps_per_slice_ * sizeof(uint64_t) * 2, cache_line_size_, (void **)&dts);
-          UniMemory::ExitIfOutOfMemory((void *)(dts));
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Failed to allocate host memory for timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            exit(-1);
-          }
-          it->second->device_global_timestamps_.push_back(dts);
-        }
-        else {
-          dts = it->second->device_global_timestamps_.at(slice);
-        }
-        int idx = it->second->num_device_global_timestamps_ % (2 * number_timestamps_per_slice_);
-        auto status = ZE_FUNC(zeCommandListAppendWriteGlobalTimestamp)(*(params->phCommandList), (uint64_t *)&(dts[idx]), nullptr, 0, nullptr);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to get device global timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          exit(-1);
-        }
-
-        collector->PrepareToAppendKernelCommand(it->second);
-
-        *instance_data = reinterpret_cast<void *>(&(dts[idx]) + 1);
-        it->second->num_device_global_timestamps_ += 2; // start timestamp and end timestamp
-      }
-      else {
-        *instance_data = nullptr;
-      }
-    }
-    collector->command_lists_mutex_.unlock();
-  }
-
-  static void OnExitCommandListAppendEventReset(
-      ze_command_list_append_event_reset_params_t* params, ze_result_t result, void* global_data,
-      void** instance_data, std::vector<uint64_t> *kids) {
-
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-      if (!(collector->reset_event_on_device_)) {
-        return;
-      }
-
-      collector->command_lists_mutex_.lock();
-      auto it = collector->command_lists_.find(*(params->phCommandList));
-      if ((it != collector->command_lists_.end()) && !(it->second->immediate_)) {
-        // TODO: handle immediate command list?
-        uint64_t *dts = (*((uint64_t **)instance_data));
-        if (dts != nullptr) {
-          auto status = ZE_FUNC(zeCommandListAppendWriteGlobalTimestamp)(*(params->phCommandList), (uint64_t *)(dts), nullptr, 0, nullptr);
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Failed to get device global timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-            exit(-1);
-          }
-          collector->AppendCommand(EventReset, it->second, kids, dts);
-        }
-      }
-      collector->command_lists_mutex_.unlock();
-    }
-  }
-
-  static void OnExitCommandListAppendSignalEvent(
-      ze_command_list_append_signal_event_params_t* params,
-      ze_result_t /* result */, void* global_data, void** /* instance_data */) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (UniController::IsCollectionEnabled() ||
-        collector->IsCommandListGraphCapturing(*(params->phCommandList))) {
-      // Track this as a potential fork signal event during graph capture
-      std::shared_lock<std::shared_mutex> lock(collector->command_lists_mutex_);
-      auto it = collector->command_lists_.find(*(params->phCommandList));
-      if (it != collector->command_lists_.end() && it->second->graph_capturing_) {
-        // The capture target is read under graphs_mutex_ like everywhere else
-        std::lock_guard<std::shared_mutex> graph_lock(graphs_mutex_);
-        ZeGraph* graph = it->second->graph_capture_target_;
-        if (graph != nullptr) {
-          graph->event_to_cmdlist_[*(params->phEvent)] = *(params->phCommandList);
-        }
-      }
-    }
-  }
-
-  static void OnEnterCommandListAppendWaitOnEvents(
-      ze_command_list_append_wait_on_events_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    if (collector->ShouldCaptureAppend(*(params->phCommandList),
-                                       *(params->pnumEvents),
-                                       *(params->pphEvents))) {
-      // Check for fork/join transitions based on wait events
-      collector->CheckAndApplyForkTransition(
-          *(params->phCommandList),
-          *(params->pnumEvents),
-          *(params->pphEvents));
-    }
-  }
-
-  static void OnExitCommandListCreate(
-      ze_command_list_create_params_t* params,
-      ze_result_t result,
-      void* global_data,
-      void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-      // dummy engine ordinal and index
-      bool in_order = ((*(params->pdesc))->flags & ZE_COMMAND_LIST_FLAG_IN_ORDER) != 0;
-      collector->CreateCommandList( **(params->pphCommandList), *(params->phContext), *(params->phDevice), -1, -1, false, in_order);
-    }
-  }
-
-  static void OnExitCommandListCreateImmediate(
-      ze_command_list_create_immediate_params_t* params,
-      ze_result_t result,
-      void* global_data,
-      void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      UNITRACE_ASSERT(**params->pphCommandList != nullptr);
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      ze_device_handle_t* hDevice = params->phDevice;
-      if (hDevice == nullptr) {
-        return;
-      }
-
-      const ze_command_queue_desc_t* clq_desc = *params->paltdesc;
-      if (clq_desc == nullptr) {
-        return;
-      }
-
-      ze_command_list_handle_t*  command_list = *params->pphCommandList;
-      if (command_list == nullptr) {
-        return;
-      }
-
-      bool in_order = ((*(params->paltdesc))->flags & ZE_COMMAND_QUEUE_FLAG_IN_ORDER) != 0;
-      collector->CreateCommandList(**(params->pphCommandList), *(params->phContext), *(params->phDevice), clq_desc->ordinal, clq_desc->index, true, in_order);
-    }
-  }
-
-  static void OnExitCommandListDestroy(
-    ze_command_list_destroy_params_t* params,
-    ze_result_t result, void* global_data, void** /* instance_data */) {
-
-    if (result == ZE_RESULT_SUCCESS) {
-      UNITRACE_ASSERT(*params->phCommandList != nullptr);
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessCommandsSubmitted(nullptr);
-      collector->DestroyCommandList(*params->phCommandList);
-    }
-  }
-
-  static void OnEnterCommandListClose(ze_command_list_close_params_t* params, void* global_data, void** /* instance_data */) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    collector->command_lists_mutex_.lock();
-    auto it = collector->command_lists_.find(*(params->phCommandList));
-    if (it != collector->command_lists_.end()) {
-      int num_events = it->second->event_to_timestamp_seq_.size();
-      if (num_events) {
-        std::vector<ze_event_handle_t> events(num_events);
-
-        int i = 0;
-        for (auto it2 = it->second->event_to_timestamp_seq_.begin(); it2 != it->second->event_to_timestamp_seq_.end(); it2++, i++) {
-          events[i] = it2->first;
-          it->second->index_timestamps_on_commands_completion_[it2->second] = i;
-        }
-
-        ze_kernel_timestamp_result_t *ts = nullptr;
-
-        ze_host_mem_alloc_desc_t host_alloc_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr, 0};
-        auto status = ZE_FUNC(zeMemAllocHost)(it->second->context_, &host_alloc_desc, i * sizeof(ze_kernel_timestamp_result_t), cache_line_size_, (void **)&ts);
-        UniMemory::ExitIfOutOfMemory((void *)(ts));
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] Failed to allocate host memory for timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        }
-        it->second->timestamps_on_commands_completion_ = ts;
-
-        if (it->second->in_order_) {
-          // WA for driver bug. If command list is in order avoid signaling event
-          // in zeCommandListAppendQueryKernelTimestamps.
-          status = ZE_FUNC(zeCommandListAppendQueryKernelTimestamps)(*(params->phCommandList), num_events, events.data(), (void *)it->second->timestamps_on_commands_completion_, nullptr, nullptr, num_events, events.data());
-          if (status == ZE_RESULT_SUCCESS)
-            status = ZE_FUNC(zeCommandListAppendSignalEvent)(*(params->phCommandList), it->second->timestamp_event_to_signal_);
-        } else {
-          status = ZE_FUNC(zeCommandListAppendQueryKernelTimestamps)(*(params->phCommandList), num_events, events.data(), (void *)it->second->timestamps_on_commands_completion_, nullptr, it->second->timestamp_event_to_signal_, num_events, events.data());
-        }
-
-        if (status != ZE_RESULT_SUCCESS){
-          std::cerr << "[ERROR] Failed to get kernel timestamps (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        }
-      }
-      else {
-        // signal event if events were reset earlier
-        auto status = ZE_FUNC(zeCommandListAppendSignalEvent)(*(params->phCommandList), it->second->timestamp_event_to_signal_);
-        if (status != ZE_RESULT_SUCCESS){
-          std::cerr << "[ERROR] Failed to signal command list timestamps event (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        }
-      }
-
-      if (!it->second->event_to_timestamp_seq_.empty()) {
-        it->second->event_to_timestamp_seq_.clear();
-      }
-    }
-    collector->command_lists_mutex_.unlock();
-  }
-
-  static void OnExitCommandListReset(ze_command_list_reset_params_t* params, ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      UNITRACE_ASSERT(*params->phCommandList != nullptr);
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessCommandsSubmitted(nullptr);
-      collector->ResetCommandList(*params->phCommandList);
-    }
-  }
-
-  static void OnEnterCommandQueueExecuteCommandLists(
-      ze_command_queue_execute_command_lists_params_t* params,
-      void* global_data, void** /* instance_data */) {
-
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    if (UniController::IsCollectionEnabled()) {
-      uint32_t count = *params->pnumCommandLists;
-      if (count == 0) {
-        return;
-      }
-
-      ze_command_list_handle_t* cmdlists = *params->pphCommandLists;
-      if (cmdlists == nullptr) {
-        return;
-      }
-
-      if (local_device_submissions_.IsFinalized()) {
-        return;
-      }
-
-      ze_command_queue_handle_t queue = *(params->phCommandQueue);
-      collector->PrepareToExecuteCommandLists(cmdlists, count, queue, *(params->phFence));
-    }
-  }
-
-  static void OnExitCommandQueueExecuteCommandLists(
-      ze_command_queue_execute_command_lists_params_t* /* params */,
-      ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-      if (UniController::IsCollectionEnabled()) {
-        local_device_submissions_.SubmitStagedKernelCommandAndMetricQueries(collector->event_cache_, kids);
-      }
-    }
-    else {
-      local_device_submissions_.RevertStagedKernelCommandAndMetricQueries();
-    }
-  }
-
-  static void OnExitCommandQueueSynchronize(
-    ze_command_queue_synchronize_params_t* /* params */,
-    ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessAllCommandsSubmitted(kids);
-    }
-  }
-
-  static void OnExitDeviceSynchronize(
-    ze_device_synchronize_params_t* /* params */,
-    ze_result_t result, void* global_data, void** /* instance_data */, std::vector<uint64_t> *kids) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessAllCommandsSubmitted(kids);
-    }
-  }
-
-  static void OnExitCommandQueueCreate(ze_command_queue_create_params_t* params, ze_result_t /* result */, void* global_data, void** /* instance_data */) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    ze_device_handle_t* device = params->phDevice;
-    if (device == nullptr) {
-      return;
-    }
-    const ze_command_queue_desc_t* queue_desc = *params->pdesc;
-    if (queue_desc == nullptr) {
-      return;
-    }
-    ze_command_queue_handle_t*  command_queue = *params->pphCommandQueue;
-    if (command_queue == nullptr) {
-      return;
-    }
-
-    ZeCommandQueue desc;
-    desc.queue_ = *command_queue;
-    desc.context_ = *(params->phContext);
-    desc.device_ = *device;
-    desc.engine_ordinal_ = queue_desc->ordinal;
-    desc.engine_index_ = queue_desc->index;;
-
-    collector->command_queues_mutex_.lock();
-    collector->command_queues_.erase(*command_queue);
-    collector->command_queues_.insert({*command_queue, std::move(desc)});
-    collector->command_queues_mutex_.unlock();
-  }
-
-  static void OnExitCommandQueueDestroy(ze_command_queue_destroy_params_t* params, ze_result_t result,
-    void* global_data, void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessAllCommandsSubmitted(nullptr);
-      collector->command_queues_mutex_.lock();
-      collector->command_queues_.erase(*params->phCommandQueue);
-      collector->command_queues_mutex_.unlock();
-    }
-  }
-
-  static void OnExitModuleCreate(ze_module_create_params_t* params, ze_result_t result, void* global_data, void** /* instance_user_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      ze_module_handle_t mod = **(params->pphModule);
-      ze_device_handle_t device = *(params->phDevice);
-
-      ZeModule m;
-
-      m.device_ = device;
-      m.aot_ = (*(params->pdesc))->format;
-      // Every module gets an id, stall sampling or not; the binary below is named by it.
-      m.id_ = UniModuleId::GetModuleId();
-
-      // For stall sampling, write out the module's native binary now, for disassembly after
-      // the run; the module handle is gone by then. It is written rather than kept, so no
-      // binary stays resident, and not decoded, since only the reader knows which kernels
-      // were sampled. No lock is held across the I/O.
-      if (collector->options_.stall_sampling) {
-        size_t binary_size = 0;
-        if ((ZE_FUNC(zeModuleGetNativeBinary)(mod, &binary_size, nullptr) == ZE_RESULT_SUCCESS) &&
-            (binary_size > 0)) {
-          std::vector<uint8_t> native_binary(binary_size);
-          if (ZE_FUNC(zeModuleGetNativeBinary)(mod, &binary_size, native_binary.data()) ==
-              ZE_RESULT_SUCCESS) {
-            // A failed write is not recorded: the reader finds no binary, and the
-            // module's kernels match no sample.
-            WriteOutModuleNativeBinary(collector->logger_factory_, collector->data_dir_name_,
-                                       m.id_, native_binary.data(), native_binary.size());
-          } else {
-            std::cerr << "[WARNING] Unable to get native binary of module " << m.id_
-                      << ", its kernels will not be disassembled" << std::endl;
-          }
-        }
-      }
-
-      modules_on_devices_mutex_.lock();
-      modules_on_devices_.insert({mod, std::move(m)});
-      modules_on_devices_mutex_.unlock();
-    }
-  }
-
-  static void OnEnterModuleDestroy(ze_module_destroy_params_t* params, void* /* global_data */, void** /* instance_user_data */) {
-    ze_module_handle_t mod = *(params->phModule);
-    modules_on_devices_mutex_.lock();
-    modules_on_devices_.erase(mod);
-    modules_on_devices_mutex_.unlock();
-  }
-
-  static void OnEnterCommandListImmediateAppendCommandListsExp(
-      ze_command_list_immediate_append_command_lists_exp_params_t* params,
-      void* global_data, void** /* instance_data */) {
-
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    if (UniController::IsCollectionEnabled()) {
-      collector->command_lists_mutex_.lock_shared();
-
-      auto it = collector->command_lists_.find(*(params->phCommandListImmediate));
-      if (it != collector->command_lists_.end()) {
-        collector->PrepareToExecuteCommandListsLocked(*(params->pphCommandLists), *(params->pnumCommandLists),
-                                                it->second->device_, it->second->engine_ordinal_, it->second->engine_index_, nullptr);
-      }
-      collector->command_lists_mutex_.unlock_shared();
-    }
-  }
-
-  static void OnExitCommandListImmediateAppendCommandListsExp(
-    ze_command_list_immediate_append_command_lists_exp_params_t* /* params */,
-    ze_result_t result,
-    void* global_data,
-    void** /* instance_data */, std::vector<uint64_t> *kids) {
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-
-    if (UniController::IsCollectionEnabled()) {
-        if (result == ZE_RESULT_SUCCESS) {
-           local_device_submissions_.SubmitStagedKernelCommandAndMetricQueries(collector->event_cache_, kids);
-        }
-        else {
-           local_device_submissions_.RevertStagedKernelCommandAndMetricQueries();
-        }
-    }
-  }
-
-#if !defined(ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP)
-
-#define ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP (ze_structure_type_t)0x00030012
-typedef struct _zex_kernel_register_file_size_exp_t {
-    ze_structure_type_t stype = ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP; ///< [in] type of this structure
-    const void *pNext = nullptr;                                             ///< [in, out][optional] pointer to extension-specific structure
-    uint32_t registerFileSize;                                               ///< [out] Register file size used in kernel
-} zex_kernel_register_file_size_exp_t;
-
-#endif /* !defined(ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP) */
-
-  static void OnExitKernelCreate(ze_kernel_create_params_t *params, ze_result_t result, void* global_data, void** /* instance_user_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      ze_kernel_handle_t kernel = **(params->pphKernel);
-
-      ze_module_handle_t mod = *(params->phModule);
-      ze_device_handle_t device = nullptr;
-      bool aot = false;
-      // Id of the kernel's module; 0 if the module was created before tracing started.
-      uint32_t module = 0;
-      modules_on_devices_mutex_.lock_shared();
-      auto mit = modules_on_devices_.find(mod);
-      if (mit != modules_on_devices_.end()) {
-        device = mit->second.device_;
-        aot = mit->second.aot_;
-        module = mit->second.id_;
-      }
-      modules_on_devices_mutex_.unlock_shared();
-
-      int did = -1;
-      if (device != nullptr) {
-        devices_mutex_.lock_shared();
-        auto dit = devices_->find(device);
-        if (dit != devices_->end()) {
-          did = dit->second.id_;
-        }
-        devices_mutex_.unlock_shared();
-      }
-      kernel_command_properties_mutex_.lock();
-
-      auto it = active_kernel_properties_->find(kernel);
-      if (it != active_kernel_properties_->end()) {
-        active_kernel_properties_->erase(it);
-      }
-
-      ZeKernelCommandProperties desc;
-
-      desc.type_ = KERNEL_COMMAND_TYPE_COMPUTE;
-      desc.aot_ = aot;
-
-      ze_result_t status;
-
-      desc.id_ = UniKernelId::GetKernelId();
-
-      if ((*(params->pdesc) != nullptr) && ((*(params->pdesc))->pKernelName != nullptr)) {
-        desc.name_ = std::string((*(params->pdesc))->pKernelName);
-      }
-      else {
-        // try one more time
-        size_t kname_size = 0;
-        status = ZE_FUNC(zeKernelGetName)(kernel, &kname_size, nullptr);
-        if ((status == ZE_RESULT_SUCCESS) && (kname_size > 0)) {
-          char* kname = (char*) malloc(kname_size);
-          if (kname != nullptr) {
-            status = ZE_FUNC(zeKernelGetName)(kernel, &kname_size, kname);
-            UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-            desc.name_ = std::string(kname, strnlen(kname, kname_size));  // the driver may not terminate it
-            free(kname);
-          }
-          else {
-            desc.name_ = "UnknownKernel";
-          }
-        }
-        else {
-          desc.name_ = "UnknownKernel";
-        }
-      }
-
-      desc.device_id_ = did;
-      desc.device_ = device;
-
-      ze_kernel_properties_t kprops{};
-
-      zex_kernel_register_file_size_exp_t regsize{ZEX_STRUCTURE_KERNEL_REGISTER_FILE_SIZE_EXP, nullptr, 0};
-      kprops.pNext = (void *)&regsize;
-
-      status = ZE_FUNC(zeKernelGetProperties)(kernel, &kprops);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      desc.simd_width_ = kprops.maxSubgroupSize;
-      desc.nargs_ = kprops.numKernelArgs;
-      desc.nsubgrps_ = kprops.maxNumSubgroups;
-      desc.slmsize_ = kprops.localMemSize;
-      desc.private_mem_size_ = kprops.privateMemSize;
-      desc.spill_mem_size_ = kprops.spillMemSize;
-      ZeKernelGroupSize group_size{kprops.requiredGroupSizeX, kprops.requiredGroupSizeY, kprops.requiredGroupSizeZ};
-      desc.group_size_ = group_size;
-      desc.regsize_ = regsize.registerFileSize;
-
-      // for stall sampling
-      uint64_t base_addr = 0;
-      if (collector->options_.stall_sampling && (ZexKernelGetBaseAddress != nullptr)) {
-        if (ZexKernelGetBaseAddress(kernel, &base_addr) != ZE_RESULT_SUCCESS) {
-          // Should we warn here?
-          base_addr = 0;
-        }
-      }
-
-      desc.base_addr_ = base_addr;
-
-      // First, check include_kernels_ to see if the kernel should be included (if any match, skip=false).
-      // Then, check exclude_kernels_ to see if the kernel should be excluded (if any match, skip=true).
-      desc.skip_ = false;
-      if (!collector->include_kernels_.empty() || !collector->exclude_kernels_.empty()) {
-        std::string demangled_name = utils::Demangle(desc.name_.c_str());
-        if (!collector->include_kernels_.empty()) {
-          desc.skip_ = true;
-          for (const auto& filter : collector->include_kernels_) {
-            if (!filter.empty() && demangled_name.find(filter) != std::string::npos) {
-              desc.skip_ = false;
-              break;
-            }
-          }
-        }
-
-        if (!collector->exclude_kernels_.empty() && desc.skip_ == false) {
-          for (const auto& filter : collector->exclude_kernels_) {
-            if (!filter.empty() && demangled_name.find(filter) != std::string::npos) {
-              desc.skip_ = true;
-              break;
-            }
-          }
-        }
-      }
-
-      // For stall sampling, write the kernel's record now: it is final here, so repeated
-      // flushes need no special handling. The reader derives the rest from the module
-      // binary (ZeMetricProfiler::ReadModuleAndKernelProps). Kernels skipped by
-      // --include-kernels/--exclude-kernels get no record, so their samples are attributed
-      // to no known kernel. A kernel created repeatedly writes identical records, which
-      // the reader merges.
-      if (collector->options_.stall_sampling && base_addr != 0 && !desc.skip_) {
-        // Not lock-free: concurrent zeKernelCreate calls would splice records. Lazy flush:
-        // an abnormal exit loses at most a partial last record, which the reader drops.
-        std::shared_ptr<UniLogger> kprops_logger =
-            collector->logger_factory_->GetDeviceLogger(LOGGER_TYPE_KPROPS, did, true, false);
-        if (kprops_logger) {
-          // One line each: quoted mangled name (which has no quote or newline to escape),
-          // base address, kernel command id and module id. The pid is in the file name.
-          kprops_logger->Log("\"" + desc.name_ + "\"\n" + std::to_string(base_addr) + "\n" +
-                             std::to_string(desc.id_) + "\n" + std::to_string(module) + "\n");
-          kprops_logger->Flush();
-        } else {
-          std::cerr << "[ERROR] Failed to create kernel properties data file, samples of kernel "
-                    << desc.name_ << " will not be attributed" << std::endl;
-        }
-      }
-
-      ZeKernelCommandProperties desc2 = desc;
-      active_kernel_properties_->insert({kernel, std::move(desc)});
-      kernel_command_properties_->insert({desc2.id_, std::move(desc2)});
-
-      kernel_command_properties_mutex_.unlock();
-    }
-  }
-
-  static void OnExitKernelSetGroupSize(ze_kernel_set_group_size_params_t* params, ze_result_t result,
-    void* /* global_data */, void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      if (UniController::IsCollectionEnabled()) {
-        ZeKernelGroupSize group_size{*(params->pgroupSizeX), *(params->pgroupSizeY), *(params->pgroupSizeZ)};
-        kernel_command_properties_mutex_.lock();
-
-        auto it = active_kernel_properties_->find(*(params->phKernel));
-        UNITRACE_ASSERT(it != active_kernel_properties_->end());
-        if ((it->second.group_size_.x != group_size.x) || (it->second.group_size_.y != group_size.y) ||
-          (it->second.group_size_.z != group_size.z)) {
-          // new group size
-          it->second.group_size_ = group_size;
-          auto it2 = kernel_command_properties_->find(it->second.id_);
-          if ((it2 != kernel_command_properties_->end()) &&
-            (it2->second.group_size_.x == group_size.x) &&
-            (it2->second.group_size_.y == group_size.y) &&
-            (it2->second.group_size_.z == group_size.z)) {
-            // group size was used before
-            it->second.id_ = it2->second.id_;
-          }
-          else {
-            // first time use the group size
-            it->second.id_ = UniKernelId::GetKernelId();
-            ZeKernelCommandProperties desc2 = it->second;
-            kernel_command_properties_->insert({desc2.id_, std::move(desc2)});
-          }
-        }
-        else {
-          // do nothing
-        }
-
-        kernel_command_properties_mutex_.unlock();
-      }
-    }
-  }
-
-  static void OnExitKernelDestroy(ze_kernel_destroy_params_t* params, ze_result_t result, void* /* global_data */, void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      kernel_command_properties_mutex_.lock();
-      active_kernel_properties_->erase(*(params->phKernel));
-      kernel_command_properties_mutex_.unlock();
-    }
-  }
-
-  static void OnExitContextDestroy(ze_context_destroy_params_t* params, ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result == ZE_RESULT_SUCCESS) {
-      ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-      collector->ProcessAllCommandsSubmitted(nullptr);
-      collector->event_cache_.ReleaseContext(*(params->phContext));
-    }
-  }
-
-  static void OnExitGraphCreateExp(
-      ze_graph_create_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    // Graph tracking entry is created lazily in OnBeginGraphCapture.
-  }
-
-  static void OnExitGraphDestroyExp(
-      ze_graph_destroy_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnGraphDestroy(*(params->phGraph));
-  }
-
-  static void OnExitExecutableGraphDestroyExp(
-      ze_executable_graph_destroy_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnExecutableGraphDestroy(*(params->phGraph));
-  }
-
-  static void OnExitCommandListBeginGraphCaptureExp(
-      ze_command_list_begin_graph_capture_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnBeginGraphCaptureNoGraph(*(params->phCommandList));
-  }
-
-  static void OnExitCommandListBeginCaptureIntoGraphExp(
-      ze_command_list_begin_capture_into_graph_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnBeginGraphCapture(*(params->phCommandList), *(params->phGraph));
-  }
-
-  static void OnExitCommandListEndGraphCaptureExp(
-      ze_command_list_end_graph_capture_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnEndGraphCapture(*(params->phCommandList), **(params->pphGraph));
-  }
-
-  static void OnExitCommandListInstantiateGraphExp(
-      ze_command_list_instantiate_graph_exp_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnInstantiateGraph(*(params->phGraph), **(params->pphExecutableGraph));
-  }
-
-  // Bodies shared by the Exp and Ext variants of zeCommandListAppendGraph.
-  static void StageGraphExecution(void* global_data, ze_command_list_handle_t command_list,
-                                  ze_executable_graph_handle_t graph) {
-    if (!UniController::IsCollectionEnabled()) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->PrepareGraphExecution(command_list, graph);
-  }
-
-  static void SubmitGraphExecution(ze_result_t result, void* global_data,
-                                   std::vector<uint64_t> *kids) {
-    if (result != ZE_RESULT_SUCCESS || !UniController::IsCollectionEnabled()) {
-      local_device_submissions_.RevertStagedKernelCommandAndMetricQueries();
-      return;
-    }
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    // kids let the host-side flow callback emit FLOW_H2D to each replayed kernel.
-    local_device_submissions_.SubmitStagedKernelCommandAndMetricQueries(collector->event_cache_, kids);
-  }
-
-  static void OnEnterCommandListAppendGraphExp(
-      ze_command_list_append_graph_exp_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    StageGraphExecution(global_data, *(params->phCommandList), *(params->phGraph));
-  }
-
-  static void OnExitCommandListAppendGraphExp(
-      ze_command_list_append_graph_exp_params_t* /* params */,
-      ze_result_t result, void* global_data, void** /* instance_data */,
-      std::vector<uint64_t> *kids) {
-    SubmitGraphExecution(result, global_data, kids);
-  }
-
-  // Stable (Ext) graph APIs, which SYCL uses when the driver reports them. They
-  // carry the same handles as the Exp ones, so they feed the same bookkeeping.
-
-  static void OnExitCommandListBeginGraphCaptureExt(
-      ze_command_list_begin_graph_capture_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnBeginGraphCaptureNoGraph(*(params->phCommandList));
-  }
-
-  static void OnExitCommandListBeginCaptureIntoGraphExt(
-      ze_command_list_begin_capture_into_graph_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnBeginGraphCapture(*(params->phCommandList), *(params->phGraph));
-  }
-
-  static void OnExitCommandListEndGraphCaptureExt(
-      ze_command_list_end_graph_capture_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnEndGraphCapture(*(params->phCommandList), **(params->pphGraph));
-  }
-
-  static void OnExitGraphInstantiateExt(
-      ze_graph_instantiate_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnInstantiateGraph(*(params->phGraph), **(params->pphExecutableGraph));
-  }
-
-  static void OnExitGraphDestroyExt(
-      ze_graph_destroy_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnGraphDestroy(*(params->phGraph));
-  }
-
-  static void OnExitExecutableGraphDestroyExt(
-      ze_executable_graph_destroy_ext_params_t* params,
-      ze_result_t result, void* global_data, void** /* instance_data */) {
-    if (result != ZE_RESULT_SUCCESS) return;
-    ZeCollector* collector = reinterpret_cast<ZeCollector*>(global_data);
-    collector->OnExecutableGraphDestroy(*(params->phGraph));
-  }
-
-  static void OnEnterCommandListAppendGraphExt(
-      ze_command_list_append_graph_ext_params_t* params,
-      void* global_data, void** /* instance_data */) {
-    StageGraphExecution(global_data, *(params->phCommandList), *(params->phGraph));
-  }
-
-  static void OnExitCommandListAppendGraphExt(
-      ze_command_list_append_graph_ext_params_t* /* params */,
-      ze_result_t result, void* global_data, void** /* instance_data */,
-      std::vector<uint64_t> *kids) {
-    SubmitGraphExecution(result, global_data, kids);
-  }
-
-  #include <tracing.gen> // Auto-generated callbacks
-
-  void CollectHostFunctionTimeStats(uint32_t id, uint64_t time) {
-    local_device_submissions_.CollectHostFunctionTimeStats(id, time);
-  }
-
-  void AggregateDeviceTimeStats() const {
-    // do not acquire global_device_time_stats_mutex_. caller does it.
-    for (auto it = global_device_time_stats_->begin(); it != global_device_time_stats_->end(); it++) {
-      std::string kname;
-      if (it->first.tile_ >= 0) {
-        kname = "Tile #" + std::to_string(it->first.tile_) + ": " + GetZeKernelCommandName(it->first.kernel_command_id_, it->first.group_count_, it->first.mem_size_, options_.verbose);
-      }
-      else {
-        kname = GetZeKernelCommandName(it->first.kernel_command_id_, it->first.group_count_, it->first.mem_size_, options_.verbose);
-      }
-
-      auto it2 = it;
-      it2++;
-
-      for (; it2 != global_device_time_stats_->end();) {
-        std::string kname2;
-        if (it2->first.tile_ >= 0) {
-          kname2 = "Tile #" + std::to_string(it2->first.tile_) + ": " + GetZeKernelCommandName(it2->first.kernel_command_id_, it2->first.group_count_, it2->first.mem_size_, options_.verbose);
-        }
-        else {
-          kname2 = GetZeKernelCommandName(it2->first.kernel_command_id_, it2->first.group_count_, it2->first.mem_size_, options_.verbose);
-        }
-
-        if (kname2 == kname) {
-          it->second.append_time_ += it2->second.append_time_;
-          it->second.submit_time_ += it2->second.submit_time_;
-          it->second.execute_time_ += it2->second.execute_time_;
-          if (it->second.min_time_ > it2->second.min_time_) {
-            it->second.min_time_ = it2->second.min_time_;
-          }
-          if (it->second.max_time_ < it2->second.max_time_) {
-            it->second.max_time_ = it2->second.max_time_;
-          }
-          it->second.call_count_ += it2->second.call_count_;
-          it2 = global_device_time_stats_->erase(it2);
-        }
-        else {
-          it2++;
-        }
-      }
-    }
-  }
-
-  // The kernel names of a filter given by path: opens file (if not empty and
-  // readable) and hands it with filter to ::ParseFilterList(). A file that cannot be
-  // opened is ignored, as before, so only filter is used.
-  static std::vector<std::string> ParseFilterList(const std::string& file, const std::string& filter) {
-    std::ifstream fin;
-    if (!file.empty()) {
-      fin.open(file);
-    }
-    return ::ParseFilterList((fin.is_open() && fin.good()) ? &fin : nullptr, filter);
-  }
-
- private: // Data
-  LoggerFactory* logger_factory_;
-  std::shared_ptr<UniLogger> logger_;
-  std::shared_ptr<UniLogger> logger_device_timeline_;
-  CollectorOptions options_;
-  OnZeKernelFinishCallback kcallback_ = nullptr;
-  OnZeFunctionFinishCallback fcallback_ = nullptr;
-  bool reset_event_on_device_; // support event reset on device
-  ZeEventCache event_cache_;
-
-  zel_tracer_handle_t tracer_ = nullptr;
-  bool in_forked_child_ = false;  // set by the atfork child handler
-
-  mutable std::shared_mutex images_mutex_;
-  std::map<ze_image_handle_t, size_t> images_;
-
-
-  mutable std::shared_mutex command_queues_mutex_;
-  std::map<ze_command_queue_handle_t, ZeCommandQueue> command_queues_;
-
-  mutable std::shared_mutex command_lists_mutex_;
-  std::map<ze_command_list_handle_t, ZeCommandList *> command_lists_;
-
-  std::set<std::pair<ze_context_handle_t, ze_device_handle_t>> metric_activations_;
-
-  ZeMetricQueryPools query_pools_;
-
-  std::vector<ze_context_handle_t> metric_contexts_;
-  std::vector<ZeMetricsManager*> metricsManagers_;
-
-  mutable std::shared_mutex events_mutex_;
-  std::set<ze_event_pool_handle_t> counter_based_pools_;
-  std::set<ze_event_handle_t> counter_based_events_;
-
-  constexpr static size_t kCallsLength = 12;
-  constexpr static size_t kTimeLength = 20;
-
-  std::string data_dir_name_;
-  std::vector<std::string> include_kernels_;
-  std::vector<std::string> exclude_kernels_;
-
-  // Module ids come from UniModuleId (unikernel.h), shared with the OpenCL collector,
-  // whose module binaries go to the same directory under the same naming.
-};
-
-#endif // PTI_TOOLS_UNITRACE_LEVEL_ZERO_COLLECTOR_H_
diff --git a/tools/unitrace/src/levelzero/ze_event_cache.h b/tools/unitrace/src/levelzero/ze_event_cache.h
deleted file mode 100644
index 8bb8a967..00000000
--- a/tools/unitrace/src/levelzero/ze_event_cache.h
+++ /dev/null
@@ -1,243 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
-#define PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
-
-#include <map>
-#include <mutex>
-#include <vector>
-
-#include "ze_loader.h"
-
-#define EVENT_POOL_SIZE  1024
-
-struct ZeEventInfo {
-  ze_event_pool_handle_t pool;
-  ze_context_handle_t context;
-};
-
-class ZeEventCache {
- public:
-  ZeEventCache(ze_event_pool_flags_t flags) : flags_(flags) {}
-
-  ZeEventCache(const ZeEventCache& that) = delete;
-
-  ZeEventCache& operator=(const ZeEventCache& that) = delete;
-
-  ~ZeEventCache() {
-#ifdef _WIN32
-    // on Windows, it is very possible that L0 has been unloaded or is being unloaded at this point and L0 calls may have undefined behavior
-    // hence skipping all destroy calls and returning early.
-    return;
-#else /* _WIN32 */
-    bool destroyed = true;
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-
-    for (auto& value : event_map_) {
-      for (auto event : value.second) {
-        ze_result_t status = ZE_RESULT_SUCCESS;
-        status = ZE_FUNC(zeEventDestroy)(event);
-        if (status != ZE_RESULT_SUCCESS) {
-          destroyed = false;
-        }
-      }
-    }
-    if (!destroyed) {
-      std::cerr << "[WARNING] Event in event cache is not destroyed" << std::endl;
-    }
-    destroyed = true;
-    for (auto& value : event_pools_) {
-      for (auto pool : value.second) {
-        ze_result_t status = ZE_FUNC(zeEventPoolDestroy)(pool);
-        if (status != ZE_RESULT_SUCCESS) {
-          destroyed = false;
-        }
-      }
-    }
-    if (!destroyed) {
-      std::cerr << "[WARNING] Event pool in event cache is not destroyed" << std::endl;
-    }
-#endif /* _WIN32 */
-  }
-
-  bool QueryEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return false;
-    }
-
-    lock_.lock_shared();
-    auto info = event_info_map_.find(event);
-    if (info == event_info_map_.end()) {
-      return false;
-    }
-    lock_.unlock_shared();
-
-    return true;
-  }
-
-
-  ze_event_handle_t GetEvent(ze_context_handle_t context) {
-    if (context == nullptr) {
-      return nullptr;
-    }
-
-    ze_event_handle_t event = nullptr;
-
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-
-    auto result = event_map_.find(context);
-    if (result == event_map_.end()) {
-      result = event_map_.emplace(
-          std::make_pair(context, std::vector<ze_event_handle_t>())).first;
-    }
-
-    if (result->second.empty()) {
-      ze_result_t status = ZE_RESULT_SUCCESS;
-
-      ze_event_pool_flags_t flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | flags_;
-      ze_event_pool_desc_t pool_desc = {
-          ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
-          nullptr, flags, EVENT_POOL_SIZE};
-      ze_event_pool_handle_t pool = nullptr;
-      status = ZE_FUNC(zeEventPoolCreate)(context, &pool_desc, 0, nullptr, &pool);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      auto pool_iter = event_pools_.find(context);
-      if (pool_iter == event_pools_.end()) {
-        pool_iter = event_pools_.emplace(std::make_pair(context, std::vector<ze_event_pool_handle_t>())).first;
-      }
-      pool_iter->second.push_back(pool);
-
-      for (uint32_t i = 0; i < EVENT_POOL_SIZE; i++) {
-        ze_event_desc_t event_desc = {
-            ZE_STRUCTURE_TYPE_EVENT_DESC,
-            nullptr,
-            i,
-            ZE_EVENT_SCOPE_FLAG_HOST,
-            ZE_EVENT_SCOPE_FLAG_HOST};
-        status = ZE_FUNC(zeEventCreate)(pool, &event_desc, &event);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        UNITRACE_ASSERT(event_info_map_.count(event) == 0);
-        event_info_map_.insert({event, std::make_pair(context, i)});
-        result->second.push_back(event);
-      }
-    }
-
-    event = result->second.back();
-    result->second.pop_back();
-
-    //UNITRACE_ASSERT(ZE_FUNC(zeEventQueryStatus)(event) == ZE_RESULT_NOT_READY);
-
-    return event;
-  }
-
-  void ResetEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-
-    auto info = event_info_map_.find(event);
-    if (info != event_info_map_.end()) {
-      ze_result_t status = ZE_FUNC(zeEventHostReset)(event);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-  }
-
-  void ReleaseEvent(ze_event_handle_t event) {
-    if (event == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-
-    auto info = event_info_map_.find(event);
-    if (info == event_info_map_.end()) {
-      return;
-    }
-
-    auto result = event_map_.find(info->second.first);
-    UNITRACE_ASSERT(result != event_map_.end());
-    if (result != event_map_.end()) {
-      // Workaround to cover L0 bug related to V2 adaptor. Tracking ID: https://github.com/intel-innersource/applications.analyzers.profilingtoolsinterfaces.sdk/issues/700
-      // Idea is to create new event from same event pool at same index. Destroy the old event and update the map.
-
-      // Find event pool and index where old event was create
-      uint32_t event_pool_index = info->second.second;
-      auto context = info->second.first;
-
-      ze_event_pool_handle_t pool;
-      auto status = ZE_FUNC(zeEventGetEventPool)(event, &pool);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      // destroy old event
-      status = ZE_FUNC(zeEventDestroy)(event);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      // create new event
-      ze_event_handle_t new_event;
-      ze_event_desc_t event_desc = {
-          ZE_STRUCTURE_TYPE_EVENT_DESC,
-          nullptr,
-          event_pool_index,
-          ZE_EVENT_SCOPE_FLAG_HOST,
-          ZE_EVENT_SCOPE_FLAG_HOST};
-      status = ZE_FUNC(zeEventCreate)(pool, &event_desc, &new_event);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      // Update event info map
-      event_info_map_.erase(event);
-      event_info_map_.insert({new_event,std::make_pair(context, event_pool_index)});
-      result->second.push_back(new_event);
-    }
-  }
-
-  void ReleaseContext(ze_context_handle_t context) {
-    if (context == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::shared_mutex> lock(lock_);
-
-    // all events in the context should already be released
-    auto result = event_map_.find(context);
-    if (result != event_map_.end()) {
-      auto iter = event_pools_.find(context);
-      if (iter != event_pools_.end()) {
-        if (result->second.size() == (EVENT_POOL_SIZE * iter->second.size())) {
-          for (auto event : result->second) {
-            ze_result_t status = ZE_RESULT_SUCCESS;
-            status = ZE_FUNC(zeEventDestroy)(event);
-            UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-            event_info_map_.erase(event);
-          }
-
-          event_map_.erase(result);
-
-          for (auto pool: iter->second) {
-            ze_result_t status = ZE_RESULT_SUCCESS;
-            status = ZE_FUNC(zeEventPoolDestroy)(pool);
-            UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-          }
-          event_pools_.erase(iter);
-        }
-      }
-    }
-  }
-
-
- private:
-  ze_event_pool_flags_t flags_ = 0;
-  std::map<ze_context_handle_t, std::vector<ze_event_handle_t> > event_map_;
-  std::map<ze_event_handle_t, std::pair<ze_context_handle_t, uint32_t>> event_info_map_;
-  std::map<ze_context_handle_t, std::vector<ze_event_pool_handle_t> > event_pools_;
-  std::shared_mutex lock_;
-};
-
-#endif // PTI_TOOLS_ZE_TRACER_ZE_EVENT_CACHE_H_
diff --git a/tools/unitrace/src/levelzero/ze_loader.h b/tools/unitrace/src/levelzero/ze_loader.h
deleted file mode 100644
index e758f3fc..00000000
--- a/tools/unitrace/src/levelzero/ze_loader.h
+++ /dev/null
@@ -1,65 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-#ifndef PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_
-#define PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_
-
-#include <iostream>
-#include <memory>
-
-#include "utils/library_loader.h"
-#include <level_zero/layers/zel_tracing_register_cb.h>
-#include <level_zero/ze_api.h>
-#include <level_zero/zer_api.h>
-#include <level_zero/zes_api.h>
-#include <level_zero/zet_api.h>
-#include <level_zero/layers/zel_tracing_api.h>
-
-// Include all Level Zero driver_experimental headers
-#include <level_zero/driver_experimental/zex_api.h>
-
-class ZeLoader {
- public:
-  static auto& get() {
-    static ZeLoader instance{};
-    return instance;
-  }
-
-  void Unload() { lib_.reset(nullptr); }
-
-  bool Loaded() const { return lib_ != nullptr; }
-
- private:
-  ZeLoader() {
-    #if defined(_WIN32)
-    static constexpr const char* const kLevelZeroLoaderName = "ze_loader.dll";
-    #else
-    static constexpr const char* const kLevelZeroLoaderName = "libze_loader.so.1";
-    #endif
-
-    try {
-      lib_ = std::make_unique<LibraryLoader>(kLevelZeroLoaderName);
-    } catch (const std::exception& e) {
-      std::cerr << "[ERROR] Failed to load " << kLevelZeroLoaderName
-                << " Reason: " << e.what() << std::endl;
-      lib_ = nullptr;
-      return;
-    }
-
-    init();
-  }
-
-  std::unique_ptr<LibraryLoader> lib_ = nullptr;
-
-  #define LEVEL_ZERO_LOADER_GET_SYMBOL(X) \
-    this->X##_ = lib_->GetSymbol<decltype(&X)>(#X)  // NOLINT
-  #include <l0_loader.gen>               // Auto-generated callbacks
-  #undef LEVEL_ZERO_LOADER_GET_SYMBOL
-};
-
-#define ZE_FUNC(X) ZeLoader::get().X##_
-#define ZE_HAVE_FUNC(X) (ZeLoader::get().X##_ != nullptr)
-
-#endif  // PTI_TOOLS_UNITRACE_LEVEL_ZERO_LEADER_H_
diff --git a/tools/unitrace/src/levelzero/ze_metrics.h b/tools/unitrace/src/levelzero/ze_metrics.h
deleted file mode 100644
index aab9e84a..00000000
--- a/tools/unitrace/src/levelzero/ze_metrics.h
+++ /dev/null
@@ -1,2081 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_LEVEL_ZERO_METRICS_H_
-#define PTI_TOOLS_UNITRACE_LEVEL_ZERO_METRICS_H_
-
-
-#include <string.h>
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include <level_zero/layers/zel_tracing_api.h>
-#include "ze_loader.h"
-
-#include <algorithm>
-#include <array>
-#include <cmath>
-#include <cstdint>
-#include <iomanip>
-#include <iostream>
-#include <map>
-#include <memory>
-#include <set>
-#include <tuple>
-#include <vector>
-#include <atomic>
-#include <thread>
-
-#include "utils/unilogger.h"
-#include "unimemory.h"
-#include "utils/utils.h"
-#include "utils_ze.h"
-#include "utils/unitrace_assert.h"
-#include "logger_factory.h"
-#include "unicontrol.h"
-#include "kernel_disassembler.h"
-#include "kernel_extractor.h"
-#include "source_resolver.h"
-#include <inttypes.h>
-#include "ze_metrics_config.h"
-
-constexpr static uint64_t min_dummy_instance_id = 1024 * 1024;  // offset of idle-sampling instance ids
-constexpr static uint32_t max_metric_samples = 32768;
-// Default UNITRACE_SamplingInterval in us; single source for both the numeric and string forms
-#define DEFAULT_SAMPLING_INTERVAL_US 50
-#define DEFAULT_SAMPLING_INTERVAL_US_STR_(x) #x
-#define DEFAULT_SAMPLING_INTERVAL_US_STR_X_(x) DEFAULT_SAMPLING_INTERVAL_US_STR_(x)
-#define DEFAULT_SAMPLING_INTERVAL_US_STR DEFAULT_SAMPLING_INTERVAL_US_STR_X_(DEFAULT_SAMPLING_INTERVAL_US)
-constexpr static double default_sampling_interval_us = DEFAULT_SAMPLING_INTERVAL_US;
-
-#define MAX_METRIC_BUFFER  (8ULL * 1024ULL * 1024ULL)
-
-inline void PrintDeviceList() {
-  if (!InitializeL0()) {
-    return;
-  }
-
-  auto device_list = GetDeviceList();
-  if (device_list.empty()) {
-    std::cout << "[WARNING] No Level Zero devices found" << std::endl;
-    return;
-  }
-
-  for (size_t i = 0; i < device_list.size(); ++i) {
-    auto device = device_list[i];
-    ze_device_properties_t device_properties{
-        ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-    auto status = ZE_FUNC(zeDeviceGetProperties)(device, &device_properties);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_pci_ext_properties_t pci_props;
-    pci_props.pNext = nullptr;
-    pci_props.stype = ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
-    status = ZE_FUNC(zeDevicePciGetPropertiesExt)(device, &pci_props);
-
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    std::cout << "Device #" << i << ": [" << std::hex <<
-      pci_props.address.domain << ":" <<
-      pci_props.address.bus << ":" <<
-      pci_props.address.device << "." <<
-      pci_props.address.function << "] " <<
-      device_properties.name << std::dec << std::endl;
-  }
-}
-
-inline std::string GetMetricUnits(const char* units) {
-  UNITRACE_ASSERT(units != nullptr);
-
-  std::string result = units;
-  if (result.find("null") != std::string::npos) {
-    result = "";
-  } else if (result.find("percent") != std::string::npos) {
-    result = "%";
-  }
-
-  return result;
-}
-
-// Prints the metric groups and metrics of a device (--metric-list).
-//   device_id  index of the device, from UNITRACE_DeviceId
-// Returns false if device_id names no device; true otherwise, also when there is
-// nothing to print.
-inline bool PrintMetricList(uint32_t device_id) {
-  if (!InitializeL0()) {
-    return true;
-  }
-
-  auto device_list = GetDeviceList();
-  if (device_list.empty()) {
-    std::cout << "[WARNING] No Level Zero devices found" << std::endl;
-    return true;
-  }
-
-  if (device_id >= device_list.size()) {
-    std::cerr << "[ERROR] Device id (" << device_id << ") is out of range, " << device_list.size() << " device(s) found" << std::endl;
-    return false;
-  }
-  ze_device_handle_t device = device_list[device_id];
-
-  uint32_t group_count = 0;
-  auto status = ZE_FUNC(zetMetricGroupGet)(device, &group_count, nullptr);
-  if (status != ZE_RESULT_SUCCESS || group_count == 0) {
-    std::cerr << "[WARNING] No metrics found (status = 0x" << std::hex << status << std::dec << ") group_count = " << group_count << std::endl;
-    std::cerr << "[INFO] Please make sure the intel-metrics-discovery and intel-metrics-library packages are installed." << std::endl;
-    return true;
-  }
-
-  std::vector<zet_metric_group_handle_t> group_list(group_count, nullptr);
-  status = ZE_FUNC(zetMetricGroupGet)(device, &group_count, group_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  uint32_t group_id = 0;
-  for (uint32_t i = 0; i < group_count; ++i) {
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    status = ZE_FUNC(zetMetricGroupGetProperties)(group_list[i], &group_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    bool is_ebs = (group_props.samplingType &
-                  ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
-    bool is_tbs = (group_props.samplingType &
-                   ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
-    UNITRACE_ASSERT(is_ebs || is_tbs);
-    if (is_ebs) {
-      continue;
-    }
-
-    std::cout << "Group " << group_id << ": " << group_props.name << " (" <<
-      group_props.description << ")" << std::endl;
-    ++group_id;
-
-    uint32_t metric_count = group_props.metricCount;
-    std::vector<zet_metric_handle_t> metric_list(metric_count, nullptr);
-    status = ZE_FUNC(zetMetricGet)(group_list[i], &metric_count, metric_list.data());
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    UNITRACE_ASSERT(metric_count == group_props.metricCount);
-
-    for (uint32_t j = 0; j < metric_count; ++j) {
-      zet_metric_properties_t metric_props{};
-      metric_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
-      status = ZE_FUNC(zetMetricGetProperties)(metric_list[j], &metric_props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::cout << "\tMetric " << j << ": "  << metric_props.name;
-      std::string units = GetMetricUnits(metric_props.resultUnits);
-      if (!units.empty()) {
-        std::cout << "[" << units << "]";
-      }
-      std::cout << " (" << metric_props.description << ") [" <<
-        GetResultType(metric_props.resultType) << ", " <<
-        GetMetricType(metric_props.metricType) << ", " <<
-        group_props.name << "]" << std::endl;
-    }
-  }
-  return true;
-}
-// Returns false if the metric configuration template could not be generated.
-inline bool GenMetricConfig(uint32_t device_id, const char* config_filename) {
-  ze_result_t status = ZE_FUNC(zeInit)(ZE_INIT_FLAG_GPU_ONLY);
-  if (status != ZE_RESULT_SUCCESS) {
-    std::cerr << "[ERROR] Failed to initialize Level Zero runtime" << std::endl;
-#ifndef _WIN32
-    std::cerr << "[INFO] Please ensure that either /proc/sys/dev/i915/perf_stream_paranoid or /proc/sys/dev/xe/observation_paranoid is set to 0." << std::endl;
-#endif /* _WIN32 */
-    return false;
-  }
-
-  std::vector<ze_device_handle_t> device_list = GetDeviceList();
-  if (device_list.empty()) {
-    std::cerr << "[ERROR] No devices found" << std::endl;
-    return false;
-  }
-
-  if (device_id >= device_list.size()) {
-    std::cerr << "[ERROR] Device " << device_id << " does not exist" << std::endl;
-    return false;
-  }
-  ze_device_handle_t device = device_list[device_id];
-
-  if (!ZeMetricsManager::GenerateAllMetricConfig(device, config_filename)) {
-    std::cerr << "[ERROR] Failed to generate config file: " << config_filename << std::endl;
-    return false;
-  }
-  std::cerr << "[INFO] Metric configuration template is stored in " << config_filename << std::endl;
-  return true;
-}
-
-inline uint32_t GetMetricId(const std::vector<std::string>& metric_list, const std::string& metric_name) {
-  UNITRACE_ASSERT(!metric_list.empty());
-  UNITRACE_ASSERT(!metric_name.empty());
-
-  for (size_t i = 0; i < metric_list.size(); ++i) {
-    if (metric_list[i].find(metric_name) == 0) {
-      return i;
-    }
-  }
-
-  return metric_list.size();
-}
-
-enum ZeProfilerState {
-  PROFILER_DISABLED = 0,
-  PROFILER_ENABLED = 1
-};
-
-struct ZeDeviceDescriptor {
-  ze_device_handle_t device_;
-  ze_device_handle_t parent_device_;
-  uint64_t device_timer_frequency_;
-  uint64_t device_timer_mask_;
-  uint64_t metric_timer_frequency_;
-  uint64_t metric_timer_mask_;
-  ze_driver_handle_t driver_;
-  ze_context_handle_t context_;
-  int32_t device_id_;
-  int32_t subdevice_id_;
-  int32_t num_sub_devices_;
-  ZeMetricsManager* metricsManager_;
-  zet_metric_group_handle_t metric_group_;
-  ze_pci_ext_properties_t pci_properties_;
-  std::thread *profiling_thread_;
-  std::atomic<ZeProfilerState> profiling_state_;
-  std::string metric_file_name_;
-  std::ofstream metric_file_stream_;
-  bool stall_sampling_;
-  uint32_t stall_sampling_ip_shift;
-  uint64_t stall_sampling_ip_mask;
-};
-
-// ---------------------------------------------------------------------------
-// Intermediate metric query file (.q)
-//   [int32 device][size_t kname_size][kname][uint64 instance_id][uint64 data_size][data]
-// ---------------------------------------------------------------------------
-
-// One record of the intermediate metric query file (.metrics.<pid>.q) the
-// collector writes for each profiled kernel instance (-q/--metric-query):
-//   device_       index of the device in the profiler's device list
-//   kernel_name_  the kernel name as GetZeKernelCommandName() wrote it
-//   instance_id_  global kernel instance id
-//   data_         the raw metric query result, for
-//                 zetMetricGroupCalculateMultipleMetricValuesExp()
-struct MetricQueryRecord {
-  int32_t device_ = 0;
-  std::string kernel_name_;
-  uint64_t instance_id_ = 0;
-  std::vector<uint8_t> data_;
-};
-
-// Upper bounds on the sizes a .q record may claim, so a corrupt file cannot drive an
-// allocation of whatever its length fields say. A kernel name is far below 64 KB,
-// and a query result never exceeds the profiler's own MAX_METRIC_BUFFER.
-constexpr uint64_t kMaxKernelNameSize = 64 * 1024;
-constexpr uint64_t kMaxMetricRecordSize = 8ULL * 1024ULL * 1024ULL;  // MAX_METRIC_BUFFER
-
-// Reads the next record of a .q file into record.
-//   in      the .q file, opened in binary mode
-//   record  receives the record; its buffers are reused from call to call
-// Returns true for a complete record; false at the end of the file, on a short
-// (truncated) record, or when the kernel name or data size exceeds
-// kMaxKernelNameSize or kMaxMetricRecordSize (a warning is printed). The caller
-// still has to check record.device_ against its own device list.
-inline bool ReadMetricQueryRecord(std::istream& in, MetricQueryRecord& record) {
-  size_t kname_size = 0;
-  uint64_t data_size = 0;
-
-  in.read(reinterpret_cast<char*>(&record.device_), sizeof(int32_t));
-  if (in.gcount() != sizeof(int32_t)) {
-    return false;
-  }
-  in.read(reinterpret_cast<char*>(&kname_size), sizeof(size_t));
-  if (in.gcount() != sizeof(size_t)) {
-    return false;
-  }
-  if (kname_size > kMaxKernelNameSize) {
-    std::cerr << "[WARNING] Intermediate metrics file is invalid. Kernel name size " << kname_size << " is too large. Output likely to be incomplete." << std::endl;
-    return false;
-  }
-  record.kernel_name_.resize(kname_size);
-  in.read(&record.kernel_name_[0], kname_size);
-  if (static_cast<size_t>(in.gcount()) != kname_size) {
-    return false;
-  }
-  in.read(reinterpret_cast<char*>(&record.instance_id_), sizeof(uint64_t));
-  if (in.gcount() != sizeof(uint64_t)) {
-    return false;
-  }
-  in.read(reinterpret_cast<char*>(&data_size), sizeof(uint64_t));
-  if (in.gcount() != sizeof(uint64_t)) {
-    return false;
-  }
-  if (data_size > kMaxMetricRecordSize) {
-    std::cerr << "[WARNING] Intermediate metrics file is invalid. Metric data size " << data_size << " is too large. Output likely to be incomplete." << std::endl;
-    return false;
-  }
-  record.data_.resize(data_size);
-  in.read(reinterpret_cast<char*>(record.data_.data()), data_size);
-  if (static_cast<uint64_t>(in.gcount()) != data_size) {
-    return false;
-  }
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// Intermediate metric sampling file (.t): [uint64 data_size][data] ...
-// ---------------------------------------------------------------------------
-
-// What ReadMetricSegment() found: kOk a complete segment, kEnd the end of the file
-// (no segment started), kInvalid a size it cannot take or a truncated segment.
-enum class SegmentStatus { kOk, kEnd, kInvalid };
-
-// Reads the next segment of a metric sampling file (.t): a uint64 byte count, then
-// that many bytes of raw stream data.
-//   in        the .t file, opened in binary mode
-//   buffer    receives the data; must hold capacity bytes
-//   capacity  the size of buffer (MAX_METRIC_BUFFER)
-//   out_size  set to the number of bytes read
-// Returns kOk for a complete segment, kEnd at the end of the file, kInvalid (with a
-// warning) for a size larger than capacity or a truncated size or segment. Never
-// writes past buffer + capacity.
-inline SegmentStatus ReadMetricSegment(std::istream& in, uint8_t* buffer, uint64_t capacity,
-                                       size_t& out_size) {
-  out_size = 0;
-  uint64_t data_size = 0;
-  in.read(reinterpret_cast<char*>(&data_size), sizeof(data_size));
-  if (in.eof()) {
-    return SegmentStatus::kEnd;
-  }
-  if (in.gcount() != sizeof(data_size)) {
-    std::cerr << "[WARNING] Intermediate metrics file is invalid. Cannot find the size of the next data segment. Output likely to be incomplete." << std::endl;
-    return SegmentStatus::kInvalid;
-  }
-  if (data_size > capacity) {
-    std::cerr << "[WARNING] Intermediate metrics file is invalid. Next chunk cannot be larger than the allocated buffer. Output likely to be incomplete." << std::endl;
-    return SegmentStatus::kInvalid;
-  }
-  in.read(reinterpret_cast<char*>(buffer), data_size);
-  out_size = static_cast<size_t>(in.gcount());
-  if (out_size < data_size) {
-    std::cerr << "[WARNING] Intermediate metrics file is incomplete. Expecting " << data_size << " bytes but only " << out_size << " bytes were found. Output likely to be incomplete." << std::endl;
-    return SegmentStatus::kInvalid;
-  }
-  return SegmentStatus::kOk;
-}
-
-// ---------------------------------------------------------------------------
-// Kernel properties (.kprops): one field per line, quoted name, base address,
-// kernel command id, module id
-// ---------------------------------------------------------------------------
-
-// One record of a kernel properties file (.kprops), one field per line, as the
-// Level Zero and OpenCL collectors write them for the metric profiler:
-//   name_       the kernel name, without the quotes it is written with
-//   base_addr_  the kernel's GPU base address
-//   kernel_id_  the kernel command id
-//   module_id_  the module the kernel belongs to (0: no binary available)
-struct KernelPropsRecord {
-  std::string name_;
-  uint64_t base_addr_ = 0;
-  uint64_t kernel_id_ = 0;
-  uint32_t module_id_ = 0;
-};
-
-// Reads the next record of a .kprops file into record.
-//   in      the .kprops file
-//   record  receives the record
-// Returns true for a complete record of four lines; false at the end of the file or
-// on a truncated last record (an abnormal exit of the application), which is
-// dropped while the records before it are kept. Numbers that do not parse read as
-// 0 (strtoull), as the collectors only ever write numbers there.
-inline bool ReadKernelPropsRecord(std::istream& in, KernelPropsRecord& record) {
-  std::string field[4];
-  for (std::string& line : field) {
-    if (!std::getline(in, line)) {
-      return false;
-    }
-  }
-  record.name_ = field[0];
-  if (record.name_.size() >= 2 && record.name_.front() == '"' && record.name_.back() == '"') {
-    record.name_ = record.name_.substr(1, record.name_.size() - 2);
-  }
-  // strtoull: an address needs 64 bits, and long is 32-bit on Windows.
-  record.base_addr_ = std::strtoull(field[1].c_str(), nullptr, 0);
-  record.kernel_id_ = std::strtoull(field[2].c_str(), nullptr, 0);
-  record.module_id_ = static_cast<uint32_t>(std::strtoul(field[3].c_str(), nullptr, 0));
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// Kernel times (.ktime): sub-device, global instance id, metric start, metric end
-// ---------------------------------------------------------------------------
-
-// One record of a kernel time file (.ktime), one field per line: the sub-device
-// (-1: the whole device), the global kernel instance id, and the metric sampling
-// timestamps at which the kernel started and ended.
-struct KernelTimeRecord {
-  int32_t subdevice_id_ = 0;
-  uint64_t global_instance_id_ = 0;
-  uint64_t metric_start_ = 0;
-  uint64_t metric_end_ = 0;
-};
-
-// Reads the next record of a .ktime file into record.
-//   in      the .ktime file
-//   record  receives the record
-// Returns true for a complete record of four lines, with or without a newline after
-// the last one; false at the end of the file, including a truncated last record. Numbers that do not parse read as 0.
-inline bool ReadKernelTimeRecord(std::istream& in, KernelTimeRecord& record) {
-  std::string field[4];
-  for (std::string& line : field) {
-    if (!std::getline(in, line)) {
-      return false;
-    }
-  }
-  record.subdevice_id_ = std::strtol(field[0].c_str(), nullptr, 0);
-  record.global_instance_id_ = std::strtoll(field[1].c_str(), nullptr, 0);
-  record.metric_start_ = std::strtoll(field[2].c_str(), nullptr, 0);
-  record.metric_end_ = std::strtoll(field[3].c_str(), nullptr, 0);
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// Metric values calculated by the driver
-// ---------------------------------------------------------------------------
-
-// Checks the counts zetMetricGroupCalculateMultipleMetricValuesExp() returned with
-// the values it calculated, before they are read: num_samples sets, set i holding
-// samples[i] of the num_values values.
-//   samples, samples_capacity  the per-set counts and the entries the caller passed
-//   num_samples                the number of sets the driver reported
-//   num_values                 the number of values the driver reported
-//   values_capacity            the values the caller passed room for
-//   row_size                   values per row (metrics per sample); must not be 0
-// Returns true if every count fits the buffers passed to the driver, so the sets
-// can be read row by row without reading past the values.
-inline bool CalculatedSamplesFit(const uint32_t* samples, uint32_t num_samples, size_t samples_capacity,
-                                 uint32_t num_values, size_t values_capacity, size_t row_size) {
-  if (row_size == 0 || num_samples > samples_capacity || num_values > values_capacity) {
-    return false;
-  }
-  uint64_t total = 0;
-  for (uint32_t i = 0; i < num_samples; ++i) {
-    total += samples[i];
-  }
-  return total <= num_values;
-}
-
-// Undoes the wrap of a sampling timestamp counter: moves ts on by whole spans (the
-// counter's period) until it is not before previous, the last unwrapped timestamp,
-// as the loop it replaces (while (previous > ts) ts += span) did.
-//   ts        the timestamp of the current sample, as read
-//   previous  the unwrapped timestamp of the previous sample
-//   span      the time between counter resets; 0 leaves ts as it is
-// Returns the unwrapped timestamp, never before previous. A ts equal to previous is
-// not moved: consecutive samples can share a timestamp. Computed in one step, so a
-// span of 1 against a large gap cannot loop for minutes; if the result does not fit
-// a uint64_t (only for corrupt timestamps), previous.
-inline uint64_t UnwrapTimestamp(uint64_t ts, uint64_t previous, uint64_t span) {
-  if (span == 0 || previous <= ts) {
-    return ts;
-  }
-  const uint64_t spans = (previous - ts - 1) / span + 1;
-  if (spans > (UINT64_MAX - ts) / span) {
-    return previous;
-  }
-  return ts + spans * span;
-}
-
-class ZeMetricProfiler {
- public:
-  static ZeMetricProfiler* Create(uint32_t app_pid, char *dir, std::string& logfilename, bool idle_sampling, std::string devices_to_sample) {
-    ZeMetricProfiler* profiler = new ZeMetricProfiler(app_pid, dir, logfilename, idle_sampling, devices_to_sample);
-    UniMemory::ExitIfOutOfMemory((void *)(profiler));
-
-    profiler->StartProfilingMetrics();
-
-    return profiler;
-  }
-
-  ~ZeMetricProfiler() {
-    StopProfilingMetrics();
-    ComputeMetricsSampled();
-
-    // Created metrics now can be destroyed
-    for (auto [handle, device] : device_descriptors_) {
-      delete device->metricsManager_;
-      device->metricsManager_ = nullptr;
-    }
-  }
-
-  ZeMetricProfiler(const ZeMetricProfiler& that) = delete;
-  ZeMetricProfiler& operator=(const ZeMetricProfiler& that) = delete;
-
-#ifdef _WIN32
-  static void ComputeMetricsQueried(uint32_t pid) {
-
-    std::string metric_group_name = utils::GetEnv("UNITRACE_MetricGroup");
-    std::string metric_config = utils::GetEnv("UNITRACE_MetricConfig");
-    // One entry per device, nullptr if no group could be created; freed on every return path.
-    std::vector<std::unique_ptr<ZeMetricsManager>> metricsManagers;
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    // initialize L0, then get the metric group of each device
-    if (ZE_FUNC(zeInit)(ZE_INIT_FLAG_GPU_ONLY) != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Failed to initialize Level Zero runtime" << std::endl;
-      return;
-    }
-
-    uint32_t num_drivers = 0;
-    status = ZE_FUNC(zeDriverGet)(&num_drivers, nullptr);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Unable to get driver" << std::endl;
-      return;
-    }
-
-    if (num_drivers > 0) {
-      std::vector<ze_driver_handle_t> drivers(num_drivers);
-      status = ZE_FUNC(zeDriverGet)(&num_drivers, drivers.data());
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Unable to get driver" << std::endl;
-        return;
-      }
-
-      for (auto driver : drivers) {
-        uint32_t num_devices = 0;
-        status = ZE_FUNC(zeDeviceGet)(driver, &num_devices, nullptr);
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[WARNING] Unable to get device" << std::endl;
-          return;
-        }
-        if (num_devices) {
-          std::vector<ze_device_handle_t> devices(num_devices);
-          status = ZE_FUNC(zeDeviceGet)(driver, &num_devices, devices.data());
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[WARNING] Unable to get device" << std::endl;
-            return;
-          }
-          for (auto device : devices) {
-            metricsManagers.emplace_back(ZeMetricsManager::CreateMetricGroups(device, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED, metric_config, metric_group_name));
-          }
-        }
-      }
-    }
-
-    LoggerFactory* logger_factory = LoggerFactory::Create();
-    std::pair<std::string, std::string> metrics_files = logger_factory->SearchRawMetricFiles(pid);
-    std::string metrics_file_name = metrics_files.first;
-    std::shared_ptr<UniLogger> metrics_logger = std::make_shared<UniLogger>(metrics_files.second);
-    if (metrics_logger == nullptr) {
-      std::cerr << "[ERROR] Failed to create metric data file" << std::endl;
-    }
-
-    // raw metrics are in <UNITRACE_DataDir>/.metrics.<pid>.q
-    std::ifstream mf(metrics_file_name, std::ios::binary);
-    if (!mf) {
-      std::cerr << "[ERROR] Could not open the metric data file" << std::endl;
-      return;
-    }
-    std::cerr << "[INFO] Post-processing metric data is in progress. "
-              << "This may take a while, please do not interrupt." << std::endl;
-    int did = -1;
-    zet_metric_group_handle_t group = nullptr;
-    std::vector<std::string> metric_names;
-    std::string counter_header;
-    MetricQueryRecord record;
-    while (ReadMetricQueryRecord(mf, record)) {
-      const int32_t device = record.device_;
-      // The device index comes from the file, so it must name a device of this run.
-      // A bad record is skipped; the records after it may still be good.
-      if (device < 0 || static_cast<size_t>(device) >= metricsManagers.size() || metricsManagers[device] == nullptr) {
-        std::cerr << "[WARNING] Intermediate metrics file is invalid. Device " << device << " is unknown. Output likely to be incomplete." << std::endl;
-        continue;
-      }
-      const std::string& kname = record.kernel_name_;
-      const uint64_t instance_id = record.instance_id_;
-      const uint64_t data_size = record.data_.size();
-      std::vector<uint8_t>& metrics_data = record.data_;
-
-      if (device != did) {
-        did = device;
-        group = metricsManagers[device]->GetMetricGroups()[0];
-
-        if (group != nullptr) {
-          metric_names = GetMetricNames(group);
-          UNITRACE_ASSERT(!metric_names.empty());
-
-          if (logger_factory->IsLegacy()) {
-             metrics_logger->Log("\n=== Device #" + std::to_string(did) + " Metrics ===\n");
-          }
-
-          // Query metrics are written as a self-contained section per kernel-instance, the
-          // shape stall and time-based sampling also use:
-          //   Kernel, GlobalInstanceId              <- section label, naming the identity
-          //   "<name>", <instance id>                  the section carries
-          //   [SubDeviceId, ]<counter names...>     <- column header: the sub-device, then
-          //   [<sub-device>, ]<counter values...>      all metrics in metric_names order;
-          //                                            one row per sub-device
-          // SubDeviceId is written only when there is more than one sub-device.
-          // The counter names are the same for every section of a device, so build them
-          // once per device change.
-          counter_header.clear();
-          for (size_t i = 0; i < metric_names.size(); i++) {
-            if (i > 0) {
-              counter_header += ", ";
-            }
-            counter_header += metric_names[i];
-          }
-          counter_header += "\n";
-        }
-      }
-
-      if (group == nullptr)
-        continue;
-
-      // compute metrics
-      uint32_t num_samples = 0;
-      uint32_t num_metrics = 0;
-      ze_result_t status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-        group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-        data_size, metrics_data.data(), &num_samples, &num_metrics,
-        nullptr, nullptr);
-
-      if ((status == ZE_RESULT_SUCCESS) && (num_samples > 0) && (num_metrics > 0)) {
-        std::vector<uint32_t> samples(num_samples);
-        std::vector<zet_typed_value_t> computed_metrics(num_metrics);
-
-        status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          group, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          data_size, metrics_data.data(), &num_samples, &num_metrics,
-          samples.data(), computed_metrics.data());
-
-        if (status == ZE_RESULT_SUCCESS) {
-          const bool with_sub_device = (num_samples > 1);
-          // The leading newline puts a blank line before every section.
-          std::string str = "\nKernel, GlobalInstanceId\n" + kname + ", " +
-                            std::to_string(instance_id) + "\n" +
-                            (with_sub_device ? "SubDeviceId, " : "") + counter_header;
-          for (uint32_t i = 0; i < num_samples; ++i) {
-            uint32_t size = samples[i];
-
-            // A sample per sub-device, i being the sub-device
-            if (with_sub_device) {
-              str += std::to_string(i) + ", ";
-            }
-            const zet_typed_value_t *value = computed_metrics.data() + i * size;
-            for (uint32_t j = 0; j < size; ++j) {
-              if (j > 0) {
-                str += ", ";
-              }
-              str += PrintTypedValue(value[j]);
-            }
-            str += "\n";
-          }
-          metrics_logger->Log(str);
-        }
-        else {
-          std::cerr << "[WARNING] Not able to calculate metrics" << std::endl;
-        }
-      }
-      else {
-        std::cerr << "[WARNING] Not able to calculate metrics" << std::endl;
-      }
-    }
-    std::cerr << "[INFO] Post-processing metric data is complete." << std::endl;
-
-    if (logger_factory->IsLegacy() && !metrics_logger->GetLogFileName().empty()) {
-      std::cerr << "[INFO] Kernel metrics are stored in " << metrics_logger->GetLogFileName() << std::endl;
-    }
-  }
-#endif /* _WIN32 */
-
- private:
-  std::set<int> devices_to_sample_;
-
-  ZeMetricProfiler(uint32_t app_pid, char *dir, std::string& logfile, bool idle_sampling, std::string &devices_to_sample) {
-    data_dir_name_ = std::string(dir);
-
-    idle_sampling_ = idle_sampling;
-    logger_factory_ = LoggerFactory::Create(app_pid);
-
-    GetZeDevicesStringToSet(devices_to_sample_, devices_to_sample);
-
-    EnumerateDevices(app_pid, dir);
-  }
-
-  void GetStallSamplingIPMask(uint32_t vendorId, uint32_t ipVersion, uint64_t &mask, uint32_t &shift) {
-    if (vendorId != 0x8086) {
-      mask = UINT64_MAX;
-      shift = 0;
-      return;
-    }
-
-    shift = 3;
-
-    if (ipVersion >= 0x8c2c000) {
-      mask = UINT64_MAX;
-    }
-    else if (ipVersion >= 0x8c28000) {
-      mask = (uint64_t(1) << 48) - 1;
-    }
-    else {
-        mask = UINT32_MAX;
-    }
-  }
-
-  void EnumerateDevices(uint32_t app_pid, char *dir) {
-
-    std::string metric_group = utils::GetEnv("UNITRACE_MetricGroup");
-    std::string output_dir = utils::GetEnv("UNITRACE_TraceOutputDir");
-    std::string metric_config = utils::GetEnv("UNITRACE_MetricConfig");
-
-    bool stall_sampling = false;
-    if (metric_group == "EuStallSampling") {
-      stall_sampling = true;
-    }
-
-    int32_t global_dev_cnt = -1;
-    auto drivers = GetDriverList();
-    for (auto driver : drivers) {
-      ze_context_handle_t context = nullptr;
-      ze_context_desc_t cdesc = {ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-      auto status = ZE_FUNC(zeContextCreate)(driver, &cdesc, &context);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      metric_contexts_.push_back(context);
-
-      auto devices = GetDeviceList(driver);
-      for (auto device : devices) {
-        global_dev_cnt++;
-
-        // Skip devices not found in the list, whenever the list is given
-        if (!devices_to_sample_.empty()) {
-          if (devices_to_sample_.find(global_dev_cnt) == devices_to_sample_.end()) {
-            continue;
-          }
-        }
-
-        auto sub_devices = GetSubDeviceList(device);
-
-        ZeDeviceDescriptor *desc = new ZeDeviceDescriptor;
-        UniMemory::ExitIfOutOfMemory((void *)(desc));
-
-        desc->stall_sampling_ = stall_sampling;
-
-        desc->device_ = device;
-        desc->device_id_ = global_dev_cnt;
-        desc->parent_device_ = nullptr;
-        desc->subdevice_id_ = -1;     // not a subdevice
-        desc->num_sub_devices_ = sub_devices.size();
-
-        ze_device_ip_version_ext_t ip_version{ZE_STRUCTURE_TYPE_DEVICE_IP_VERSION_EXT, nullptr};
-        ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, &ip_version};
-        ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        UNITRACE_ASSERT(props.timerResolution != 0);
-        UNITRACE_ASSERT(props.kernelTimestampValidBits != 0);
-
-        if (stall_sampling) {
-          GetStallSamplingIPMask(props.vendorId, ip_version.ipVersion,
-			         desc->stall_sampling_ip_mask,
-			         desc->stall_sampling_ip_shift);
-        }
-
-        desc->device_timer_frequency_ = props.timerResolution;
-        desc->device_timer_mask_ = (props.kernelTimestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)() : ((1ull << props.kernelTimestampValidBits) - 1ull);
-
-        ze_pci_ext_properties_t pci_device_properties;
-        status = ZE_FUNC(zeDevicePciGetPropertiesExt)(device, &pci_device_properties);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        desc->pci_properties_ = pci_device_properties;
-
-        desc->metricsManager_ = ZeMetricsManager::CreateMetricGroups(device, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED, metric_config, metric_group);
-        zet_metric_group_handle_t group = nullptr;
-
-        if (desc->metricsManager_ != nullptr && desc->metricsManager_->GetMetricGroups() != nullptr) {
-          group = desc->metricsManager_->GetMetricGroups()[0];
-        }
-
-        if (group == nullptr) {
-          std::cerr << "[WARNING] Metric group " << metric_group << " is not found on device : " << desc->device_id_ << std::endl;
-          continue;
-        }
-
-        zet_metric_group_properties_t metric_group_prop;
-        metric_group_prop.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-        metric_group_prop.pNext = nullptr;
-
-        zet_metric_global_timestamps_resolution_exp_t metrics_ts_prop;
-        metrics_ts_prop.stype = ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP;
-        metrics_ts_prop.pNext = nullptr;
-        metric_group_prop.pNext = &metrics_ts_prop;
-        status = ZE_FUNC(zetMetricGroupGetProperties)(group, &metric_group_prop);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-        UNITRACE_ASSERT(metrics_ts_prop.timerResolution != 0);
-        UNITRACE_ASSERT(metrics_ts_prop.timestampValidBits != 0);
-
-        desc->metric_timer_frequency_ = metrics_ts_prop.timerResolution;
-        // special handling for certain older devices
-        uint32_t device_gen = (props.deviceId & 0xFF00);
-        if (device_gen == 0x0B00) {
-          if (desc->metric_timer_frequency_ > desc->device_timer_frequency_) {
-            desc->metric_timer_frequency_ = desc->device_timer_frequency_;
-          }
-
-          if (metrics_ts_prop.timestampValidBits == props.kernelTimestampValidBits) {
-            metrics_ts_prop.timestampValidBits = metrics_ts_prop.timestampValidBits - 1;
-          }
-        }
-        desc->metric_timer_mask_ = (metrics_ts_prop.timestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)() : ((1ull << metrics_ts_prop.timestampValidBits) - 1ull);
-
-        desc->driver_ = driver;
-        desc->context_ = context;
-        desc->metric_group_ = group;
-
-        desc->profiling_thread_ = nullptr;
-        desc->profiling_state_.store(PROFILER_DISABLED, std::memory_order_release);
-
-        desc->metric_file_name_ = logger_factory_->GenerateLogFileName(LOGGER_TYPE_METRICS_SAMPLING_TEMP, global_dev_cnt);
-
-        desc->metric_file_stream_ = std::ofstream(desc->metric_file_name_, std::ios::out | std::ios::trunc | std::ios::binary);
-
-        device_descriptors_.insert({device, desc});
-
-        for (size_t j = 0; j < sub_devices.size(); j++) {
-          ZeDeviceDescriptor *sub_desc = new ZeDeviceDescriptor;
-          UniMemory::ExitIfOutOfMemory((void *)(sub_desc));
-
-          sub_desc->stall_sampling_ = stall_sampling;
-          sub_desc->stall_sampling_ip_mask = desc->stall_sampling_ip_mask;
-          sub_desc->stall_sampling_ip_shift = desc->stall_sampling_ip_shift;
-
-          sub_desc->device_ = sub_devices[j];
-          sub_desc->device_id_ = global_dev_cnt;           // subdevice
-          sub_desc->parent_device_ = device;
-          sub_desc->subdevice_id_ = j;                     // a subdevice
-          sub_desc->num_sub_devices_ = 0;
-
-          sub_desc->driver_ = driver;
-          sub_desc->context_ = context;
-          sub_desc->metric_group_ = group;
-
-          sub_desc->device_timer_frequency_ = desc->device_timer_frequency_;
-          sub_desc->device_timer_mask_ = desc->device_timer_mask_;
-
-          sub_desc->metric_timer_frequency_ = desc->metric_timer_frequency_;
-          sub_desc->metric_timer_mask_ = desc->metric_timer_mask_;
-
-          ze_pci_ext_properties_t pci_device_properties;
-          ze_result_t status = ZE_FUNC(zeDevicePciGetPropertiesExt)(sub_devices[j], &pci_device_properties);
-          UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-          sub_desc->pci_properties_ = pci_device_properties;
-
-          sub_desc->driver_ = driver;
-          sub_desc->context_ = context;
-          sub_desc->metric_group_ = group;
-
-          sub_desc->profiling_thread_ = nullptr;
-          sub_desc->profiling_state_.store(PROFILER_DISABLED, std::memory_order_release);
-          sub_desc->metricsManager_ = nullptr;
-
-#if 0
-          sub_desc->metric_file_name_ = std::string(dir) + "/." + std::to_string(global_dev_cnt) + "." + std::to_string(j) + "." + metric_group + "." + std::to_string(app_pid) + ".t";
-          sub_desc->metric_file_stream_ = std::ofstream(sub_desc->metric_file_name_, std::ios::out | std::ios::trunc | std::ios::binary);
-#endif /* 0 */
-
-          device_descriptors_.insert({sub_devices[j], sub_desc});
-        } // subdevices list
-      } // devices list
-    } // drivers list
-    if (device_descriptors_.empty()) {
-      std::cerr << "[ERROR] No supported device found for the metric group " << metric_group << std::endl;;
-      exit(-1);
-    }
-  }
-
-  int GetDeviceId(ze_device_handle_t sub_device) const {
-    if (auto it = device_descriptors_.find(sub_device); it != device_descriptors_.end()) {
-      return it->second->device_id_;
-    }
-    return -1;
-  }
-
-  int GetSubDeviceId(ze_device_handle_t sub_device) const {
-    if (auto it = device_descriptors_.find(sub_device); it != device_descriptors_.end()) {
-      return it->second->subdevice_id_;
-    }
-    return -1;
-  }
-
-  ze_device_handle_t GetParentDevice(ze_device_handle_t sub_device) const {
-    if (auto it = device_descriptors_.find(sub_device); it != device_descriptors_.end()) {
-      return it->second->parent_device_;
-    }
-    return nullptr;
-  }
-
-  void StartProfilingMetrics(void) {
-
-    for (auto [handle, device] : device_descriptors_) {
-      if (device->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      device->profiling_thread_ = new std::thread(MetricProfilingThread, device);
-      while (device->profiling_state_.load(std::memory_order_acquire) != PROFILER_ENABLED) {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
-      }
-    }
-  }
-
-  void StopProfilingMetrics() {
-    for (auto [handle, device] : device_descriptors_) {
-      if (device->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-      UNITRACE_ASSERT(device->profiling_thread_ != nullptr);
-      UNITRACE_ASSERT(device->profiling_state_ == PROFILER_ENABLED);
-      device->profiling_state_.store(PROFILER_DISABLED, std::memory_order_release);
-      device->profiling_thread_->join();
-      delete device->profiling_thread_;
-      device->profiling_thread_ = nullptr;
-      device->metric_file_stream_.close();
-    }
-  }
-
-  struct ZeKernelInfo {
-    int32_t subdevice_id;
-    uint64_t global_instance_id;
-    uint64_t metric_start;
-    uint64_t metric_end;
-    std::string kernel_name;
-  };
-
-  static bool CompareInterval(ZeKernelInfo& iv1, ZeKernelInfo& iv2) {
-    return (iv1.metric_start < iv2.metric_start);
-  }
-
-  // 0: mangled name, which names the kernel's ".text.<mangled name>" section
-  // 1: kernel command id
-  // 2: code size (extent) of the section, 0 until the section is found
-  // 3: assembly listing
-  // 4: source locations of the instructions
-  // 5: view of the kernel's bytes in ModuleProps::native_binary_
-  // 6: defs and uses read from the listing
-  // 7: IGA refused to disassemble the kernel, so it is not retried
-  // 2 and 5 are filled when the search first reaches the kernel, 3, 4 and 6 when a sample
-  // is first attributed to it.
-  using KernelProps = std::tuple<std::string, uint64_t, uint64_t, std::string,
-                                 std::vector<SourceLocation>, KernelBinaryView, DefsAndUses,
-                                 bool>;
-
-  // native_binary_ is read once, when a kernel of the module first needs it, and shared by
-  // all its kernels. native_binary_loaded_ records that it was read, since a missing binary
-  // also reads back empty.
-  struct ModuleProps {
-    bool native_binary_loaded_ = false;
-    std::vector<uint8_t> native_binary_;
-    std::map<uint64_t, KernelProps> kernels_;
-  };
-
-  // One device's modules, keyed by (module id, pid): ids are only unique within a process,
-  // and the ranks of an MPI run share the data directory.
-  using DeviceModuleProps = std::map<std::pair<uint32_t, uint32_t>, ModuleProps>;
-
-  // Reads every .kprops file of the device (one per traced process) into modules. A
-  // duplicate base address within one (module, pid) keeps the first record.
-  //
-  // The collectors (ze_collector.h at zeKernelCreate, cl_collector.h) write one record per
-  // kernel to .kprops.<device_id>.<pid>.txt, and one binary per module. A record holds only
-  // what the application alone knows: mangled name, base address, command id and module
-  // id. Everything else is derived here from the module binary. The files are
-  // intermediates under UNITRACE_DataDir, removed at exit, so they carry no version.
-  DeviceModuleProps ReadModuleAndKernelProps(int32_t device_id) const {
-    DeviceModuleProps props;
-    // enumerate all kernel property files
-    std::vector<std::string> props_file_paths = logger_factory_->SearchFilesByType(LOGGER_TYPE_KPROPS, device_id);
-    for (const auto& props_file: props_file_paths) {
-      // kernel properties file path: <data_dir>/.kprops.<device_id>.<pid>.txt
-      std::ifstream kpf = std::ifstream(props_file);
-      if (!kpf.is_open()) {
-        continue;
-      }
-
-      // The pid of the process that wrote the file, from its name (logger_factory.h).
-      const uint32_t pid = LoggerFactory::GetFileNamePid(props_file);
-
-      // A truncated last record (abnormal exit) is dropped; the ones before it are kept.
-      KernelPropsRecord record;
-      while (ReadKernelPropsRecord(kpf, record)) {
-        std::string& kname = record.name_;
-        const uint64_t base_addr = record.base_addr_;
-        const uint64_t kernel_id = record.kernel_id_;
-        const uint32_t mod = record.module_id_;
-
-        // Module 0 means the collector has no binary for the kernel (e.g. an OpenCL kernel,
-        // or a module created before tracing started). No sample can be attributed to it,
-        // so it is dropped.
-        if (mod == 0) {
-          std::cerr << "[ERROR] No module binary for kernel "
-                    << utils::Demangle(kname.c_str()) << " of process " << pid
-                    << ": its stall samples cannot be reported" << std::endl;
-          continue;
-        }
-
-        // Everything but the name and id is filled in from the module binary during the
-        // walk, for the kernels samples land in.
-        props[{mod, pid}].kernels_.insert(
-            {base_addr, std::make_tuple(std::move(kname), kernel_id, uint64_t{0}, std::string(),
-                                        std::vector<SourceLocation>(), KernelBinaryView(),
-                                        DefsAndUses(), false)});
-      }
-      kpf.close();
-    }
-
-    return props;
-  }
-
-  // The module's binary, read from the data directory on first use and cached in the
-  // entry. Empty if the file is missing or truncated (an abnormal exit).
-  const std::vector<uint8_t>& GetModuleBinary(
-      DeviceModuleProps::value_type& entry) const {
-    ModuleProps& module = entry.second;
-    if (module.native_binary_loaded_) {
-      return module.native_binary_;
-    }
-
-    // Named as WriteOutModuleNativeBinary() (utils_ze.h) wrote it, with the traced
-    // process's pid.
-    const std::string path =
-        data_dir_name_ + "/" +
-        logger_factory_->GetModuleBinaryFileName(/* pid = */ entry.first.second,
-                                                 /* module_id = */ entry.first.first);
-    if (!ReadBackModuleNativeBinary(path, module.native_binary_)) {
-      // Discard a partial read.
-      module.native_binary_.clear();
-    }
-
-    // Set even on failure, so a missing binary is not looked for again.
-    module.native_binary_loaded_ = true;
-    return module.native_binary_;
-  }
-
-  // A CSV string cell (RFC 4180): quoted, with embedded quotes doubled. Every string cell
-  // needs it, since instruction text and demangled names contain commas.
-  static std::string Quote(const std::string& value) {
-    std::string cell("\"");
-    for (const char c : value) {
-      if (c == '"') {
-        cell += '"';
-      }
-      cell += c;
-    }
-    cell += '"';
-    return cell;
-  }
-
-  // The Source cell: "<file>:<line>[:<column>]", or "NA" for no location, no file or
-  // line 0 (no statement). Unquoted; the caller applies Quote().
-  static std::string FormatSourceLocation(const SourceLocation* location) {
-    if (location == nullptr || location->file_path_.empty() || location->line_ == 0) {
-      return "NA";
-    }
-
-    std::string cell = location->file_path_ + ":" + std::to_string(location->line_);
-    if (location->column_ != 0) {
-      cell += ":" + std::to_string(location->column_);
-    }
-    return cell;
-  }
-
-  // The Dependency cell: the instructions producing the values this one reads, each as
-  // "<offset> (<source>)[: <instruction>]", joined by " | ", or "NA" if none. Live-ins and
-  // defs with no instruction offset are skipped. Consumers split on " (", ")" and ": ".
-  // Unquoted; the caller applies Quote().
-  std::string FormatDependencies(const DefsAndUses& defs,
-                                 const std::vector<SourceLocation>& locations,
-                                 const UsedBy* instruction) const {
-    if (instruction == nullptr) {
-      return "NA";
-    }
-
-    std::string cell;
-    for (const DefinedBy& def : instruction->defs_) {
-      if (def.live_in_ || def.offset_ == kNoInstructionOffset) {
-        continue;
-      }
-      if (!cell.empty()) {
-        cell += " | ";
-      }
-      cell += HexOffset(def.offset_) + " (" +
-              FormatSourceLocation(FindSourceLocation(locations, def.offset_)) + ")";
-
-      // The producer's text, if the listing has a line for it.
-      const UsedBy* producer = defs.FindByOffset(def.offset_);
-      if (producer != nullptr && !producer->text_.empty()) {
-        cell += ": " + producer->text_;
-      }
-    }
-    return cell.empty() ? "NA" : cell;
-  }
-
-  // Writes <device>.<pid>.<kernel id>.asm to disasm_dir: the IGA listing, the source
-  // locations and the defs of one disassembled kernel. A plain stream, since a per-kernel
-  // file does not fit a UniLogger's (type, device) naming.
-  bool WriteOutKernelAssembly(const std::string& disasm_dir, int32_t device_id, uint32_t pid,
-                              uint64_t kernel_id, const std::string& kname,
-                              const std::string& disassembly,
-                              const std::vector<SourceLocation>& locations,
-                              const KernelBinaryView& isa, const DefsAndUses& defs) const {
-    const std::string path =
-        logger_factory_->GetDisasmFileName(disasm_dir, device_id, pid, kernel_id, "asm");
-    std::ofstream file(path, std::ios::out | std::ios::trunc);
-    if (!file.is_open()) {
-      std::cerr << "[ERROR] Failed to open file for writing: " << path << std::endl;
-      return false;
-    }
-
-    file << "// Kernel: " << utils::Demangle(kname.c_str()) << "\n";
-    file << "// Mangled name: " << kname << "\n";
-    file << "// Device #" << device_id << ", pid " << pid << ", kernel id " << kernel_id
-         << "\n";
-    file << "// ISA: " << isa.size_ << " bytes of code in section " << isa.section_name_
-         << "\n\n";
-
-    // Empty when IGA refused the kernel, which it has already said.
-    file << "// Assembly\n";
-    if (disassembly.empty()) {
-      file << "// None\n";
-    } else {
-      file << disassembly;
-      if (disassembly.back() != '\n') {
-        file << "\n";
-      }
-    }
-
-    // By kernel offset, matching the report's Offset column. None without -g.
-    file << "\n// Source locations, by offset in the kernel:\n";
-    if (locations.empty()) {
-      file << "// None\n";
-    }
-    for (const SourceLocation& location : locations) {
-      // Line 0 (no statement) prints as NA; a column of 0 is omitted.
-      file << "// " << std::hex << location.range_offset_ << "-"
-           << (location.range_offset_ + location.range_size_) << std::dec << " "
-           << (location.file_path_.empty() ? "NA" : location.file_path_) << ":";
-      if (location.line_ == 0) {
-        file << "NA";
-      } else {
-        file << location.line_;
-      }
-      if (location.column_ != 0) {
-        file << ":" << location.column_;
-      }
-      if (!location.is_statement_) {
-        file << " [not a statement]";
-      }
-      file << "\n";
-    }
-
-    // "<offset> #<id> <- <offset> #<id>{<registers>}, ...": each instruction, then the
-    // producers of the values it reads. A live-in is "IN", a producer with no offset "NA".
-    // The listing's own def comments show the same; this is what the tool parsed.
-    file << "\n// Defs, by offset in the kernel:\n";
-    if (defs.Empty()) {
-      file << "// None\n";
-    }
-    for (const UsedBy& instruction : defs.instructions_) {
-      file << "// " << std::hex << instruction.offset_ << std::dec << " #" << instruction.id_;
-      const char* separator = " <- ";
-      for (const DefinedBy& def : instruction.defs_) {
-        file << separator;
-        separator = ", ";
-        if (def.live_in_) {
-          file << "IN";
-        } else if (def.offset_ == kNoInstructionOffset) {
-          file << "NA #" << def.id_;
-        } else {
-          file << std::hex << def.offset_ << std::dec << " #" << def.id_;
-        }
-        file << "{" << def.registers_ << "}";
-      }
-      file << "\n";
-    }
-
-    // Checked after close(), which flushes, so write errors such as a full disk show.
-    file.close();
-    if (!file.good()) {
-      std::cerr << "[ERROR] Error writing disassembly to: " << path << std::endl;
-      return false;
-    }
-
-    return true;
-  }
-
-  // The stall-sampling half of ComputeMetricsSampled: correlate one device's EU stall
-  // samples with the kernels the collector recorded and write the report. raw_metrics is
-  // the caller's buffer, reused across devices. Returns false when the run cannot be
-  // continued at all, as opposed to this device having nothing to report.
-  bool ComputeStallMetrics(const ZeDeviceDescriptor* device,
-                           const std::shared_ptr<UniLogger>& metric_logger,
-                           uint8_t* raw_metrics) {
-    DeviceModuleProps modules = ReadModuleAndKernelProps(device->device_id_);
-    if (modules.size() == 0) {
-      return true;
-    }
-
-    std::vector<std::string> metric_list;
-    metric_list = GetMetricList(device->metric_group_);
-    UNITRACE_ASSERT(!metric_list.empty());
-
-    uint32_t ip_idx = GetMetricId(metric_list, "IP");
-    if (ip_idx >= metric_list.size()) {
-      std::cerr << "[WARNING] Metric group has no IP metric, no stall report for device "
-                << device->device_id_ << std::endl;
-      return true;
-    }
-
-    constexpr uint32_t max_num_of_stall_types = 16;  // should be enough for all current platforms
-
-    if ((metric_list.size() - 1) > max_num_of_stall_types) { // metric_list.size() includes IP
-      std::cerr << "[ERROR] Number of stall types exceeds supported limit of " << max_num_of_stall_types << std::endl;
-      return false;
-    }
-
-    std::ifstream inf = std::ifstream(device->metric_file_name_, std::ios::in | std::ios::binary);
-    if (!inf.is_open()) {
-      std::cerr << "[WARNING] Failed to open stall sampling data file "
-                << device->metric_file_name_ << std::endl;
-      return true;
-    }
-
-    std::map<uint64_t, std::array<uint64_t, max_num_of_stall_types>> eustalls;
-
-    while (!inf.eof()) {
-      // each segment is its size in bytes, then the data
-      size_t raw_size = 0;
-      if (ReadMetricSegment(inf, raw_metrics, MAX_METRIC_BUFFER, raw_size) !=
-          SegmentStatus::kOk) {
-        break;
-      }
-      if (raw_size > 0) {
-        uint32_t num_samples = 0;
-        uint32_t num_metrics = 0;
-        auto status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          device->metric_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          raw_size, raw_metrics, &num_samples, &num_metrics,
-          nullptr, nullptr);
-        if ((status != ZE_RESULT_SUCCESS) || (num_samples == 0) || (num_metrics == 0)) {
-          std::cerr << "[WARNING] Unable to calculate metrics (status = 0x" << std::hex << status << std::dec << ") num_samples = " << num_samples << " num_metrics = " << num_metrics << std::endl;
-          continue;
-        }
-
-        std::vector<uint32_t> samples(num_samples);
-        std::vector<zet_typed_value_t> metrics(num_metrics);
-
-        status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          device->metric_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          raw_size, raw_metrics, &num_samples, &num_metrics,
-          samples.data(), metrics.data());
-
-        if ((status != ZE_RESULT_SUCCESS) && (status != ZE_RESULT_WARNING_DROPPED_DATA)) {
-          std::cerr << "[WARNING] Unable to calculate metrics (status = 0x" << std::hex << status << std::dec << ") num_samples = " << num_samples << " num_metrics = " << num_metrics << std::endl;
-          continue;
-        }
-        if (!CalculatedSamplesFit(samples.data(), num_samples, samples.size(), num_metrics,
-                                                 metrics.size(), metric_list.size())) {
-          std::cerr << "[WARNING] Metric values calculated by the driver are inconsistent (num_samples = " << num_samples << " num_metrics = " << num_metrics << "), skipped" << std::endl;
-          continue;
-        }
-
-        const zet_typed_value_t *value = metrics.data();
-        for (uint32_t i = 0; i < num_samples; ++i) {
-          uint32_t size = samples[i];
-          for (uint32_t j = 0; j + metric_list.size() <= size; j += metric_list.size()) {
-            uint64_t ip;
-            ip = (value[j + 0].value.ui64 << device->stall_sampling_ip_shift) &
-                 device->stall_sampling_ip_mask;
-            if (ip == 0) {
-              continue;
-            }
-
-            std::array<uint64_t, max_num_of_stall_types> stall;
-
-            // value[j] is the IP; the (metric_list.size() - 1) stall counts follow
-            for (uint32_t k = 0; k <  (metric_list.size() - 1); k++) {
-              stall[k] = value[j + k + 1].value.ui64;
-            }
-            if (auto eit = eustalls.find(ip); eit != eustalls.end()) {
-              for (uint32_t k = 0; k <  (metric_list.size() - 1); k++) {
-                eit->second[k] += stall[k];
-              }
-            }
-            else {
-              eustalls.insert({ip, std::move(stall)});
-            }
-          }
-          value += samples[i];
-        }
-      }
-    }
-    inf.close();
-
-    if (eustalls.size() == 0) {
-      return true;
-    }
-
-    if (logger_factory_->IsLegacy()) {
-      std::string banner("\n=== Device #");
-      banner += std::to_string(device->device_id_) + " Metrics ===\n";
-      metric_logger->Log(banner);
-    }
-
-    // The column header repeated in every kernel section. metric_list[0] is the IP
-    // (reported as Offset); the rest are the stall types, in row order.
-    std::string column_header("Source,Offset,Instruction,Dependency");
-    for (size_t i = 1; i < metric_list.size(); i++) {
-      column_header += "," + metric_list[i];
-    }
-    column_header += "\n";
-
-    // Fetched on the first .asm file, since fetching it creates the directory.
-    std::string disasm_dir;
-
-    // The kernel the walk is on and its module. No kernel is current while current_props
-    // is null; current_module and current_base are only valid otherwise. A base address
-    // and a KernelProps pointer are kept instead of a map iterator so there is no
-    // singular iterator to misuse (std::map nodes are pointer-stable). (CID 802278)
-    DeviceModuleProps::iterator current_module = modules.end();
-    uint64_t current_base = 0;
-    KernelProps* current_props = nullptr;
-
-    // The last source location found in the current kernel's locations, or null.
-    const SourceLocation* current_source_location = nullptr;
-
-    for (auto [ip, stall] : eustalls) {
-      // Samples come in ascending IP order, so most fall in the current kernel. Search only
-      // when there is none or the IP is outside it; an IP below the base wraps and fails
-      // the unsigned test.
-      if ((current_props == nullptr) ||
-          ((ip - current_base) >= std::get<2>(*current_props))) {
-        bool attributed = false;
-
-        // Modules interleave in the address space, so every module is searched; the first
-        // kernel containing the IP wins.
-        for (auto mod = modules.begin(); mod != modules.end(); ++mod) {
-          std::map<uint64_t, KernelProps>& kernels = mod->second.kernels_;
-
-          // Highest base address first: within a module, kernels do not overlap, so the
-          // nearest kernel at or below the IP is the only candidate.
-          for (auto it = kernels.rbegin(); it != kernels.rend(); ++it) {
-            // mask the base address to only bits available in ip in metrics result
-            const uint64_t base_addr = (it->first &  device->stall_sampling_ip_mask);
-            KernelProps& props = it->second;
-
-            if (base_addr > ip) {
-              continue;
-            }
-
-            // The extent is the code size of the kernel's section in the module binary. If
-            // there is no binary, no section or no code it stays 0, the kernel matches no
-            // sample, and the lookup is repeated each time the search reaches it.
-            if (!std::get<2>(props)) {
-              const std::vector<uint8_t>& binary = GetModuleBinary(*mod);
-              if (!binary.empty() &&
-                  GetKernelBinary(binary.data(), binary.size(), std::get<0>(props),
-                                  std::get<5>(props))) {
-                std::get<2>(props) = std::get<5>(props).Size();
-              }
-            }
-
-            // Past this kernel's end: try the rest. An extent of 0 matches nothing, so a
-            // found kernel always has its ISA.
-            if ((ip - base_addr) >= std::get<2>(props)) {
-              continue;
-            }
-
-            // Found: make it current, and drop the previous kernel's source location.
-            current_module = mod;
-            current_base = base_addr;
-            current_props = &props;
-            current_source_location = nullptr;
-
-            attributed = true;
-            break;
-          }
-
-          if (attributed) {
-            break;
-          }
-        }
-
-        // No row for a sample in no known kernel.
-        if (!attributed) {
-          continue;
-        }
-
-        KernelProps& props = *current_props;
-
-        // First time this kernel is found: resolve its source and disassemble it, unless
-        // IGA already refused.
-        if (std::get<3>(props).empty() && !std::get<7>(props)) {
-          // Source locations from the module's line information; none without -g. Needs
-          // no disassembly, so a kernel IGA refuses still has them.
-          const std::vector<uint8_t>& binary = GetModuleBinary(*current_module);
-          if (!ResolveAllKernelInstructions(binary.data(), binary.size(),
-                                            std::get<0>(props), std::get<4>(props))) {
-            std::get<4>(props).clear();
-          }
-
-          // With defs (each instruction names the instructions producing its inputs),
-          // without register-level deps; see DisassembleKernelInstructions() for costs.
-          if (DisassembleKernelInstructions(std::get<5>(props), std::get<3>(props),
-                                            /* with_deps = */ false,
-                                            /* with_defs = */ true)) {
-            // Parse the listing's defs into records looked up by offset.
-            ConstructDefsAndUses(std::get<3>(props), std::get<6>(props));
-          } else {
-            // Drop any partial listing and mark the kernel so it is not retried. Its rows
-            // report source and counts only.
-            std::get<3>(props).clear();
-            std::get<7>(props) = true;
-            std::cerr << "[ERROR] Unable to disassemble kernel "
-                      << utils::Demangle(std::get<0>(props).c_str()) << " of process "
-                      << current_module->first.second << std::endl;
-          }
-
-          // Write the kernel's .asm file, creating the directory on the first one.
-          if (disasm_dir.empty()) {
-            disasm_dir = logger_factory_->GetDisasmDirPath();
-          }
-          WriteOutKernelAssembly(disasm_dir, device->device_id_,
-                                 current_module->first.second,
-                                 std::get<1>(props), std::get<0>(props),
-                                 std::get<3>(props), std::get<4>(props),
-                                 std::get<5>(props), std::get<6>(props));
-        }
-
-        // Open a self-contained section for the new kernel: its demangled name, pid and
-        // kernel id (which also name its .asm file), then the column header.
-        std::string header("\nKernel,Pid,KernelId\n");
-        header += Quote(utils::Demangle(std::get<0>(props).c_str())) + "," +
-                  std::to_string(current_module->first.second) + "," +
-                  std::to_string(std::get<1>(props)) + "\n";
-        header += column_header;
-        metric_logger->Log(header);
-      }
-
-      const uint64_t base_addr = current_base;
-      KernelProps& props = *current_props;
-
-      const uint64_t offset = ip - base_addr;
-
-      // Null for a kernel that could not be disassembled; the row still has its source
-      // and counts.
-      const UsedBy* instruction = std::get<6>(props).FindByOffset(offset);
-      const std::string text =
-          (instruction != nullptr && !instruction->text_.empty()) ? instruction->text_
-                                                                 : "unknown";
-
-      // Reuse the current source location while it covers the offset, else look it up.
-      if (current_source_location == nullptr ||
-          offset - current_source_location->range_offset_ >=
-              current_source_location->range_size_) {
-        current_source_location = FindSourceLocation(std::get<4>(props), offset);
-      }
-
-      std::string row = Quote(FormatSourceLocation(current_source_location)) + "," +
-                        HexOffset(offset) + "," + Quote(text) + "," +
-                        Quote(FormatDependencies(std::get<6>(props), std::get<4>(props),
-                                                 instruction));
-
-      // One count per stall type, in header order.
-      for (size_t k = 0; k < (metric_list.size() - 1); k++) {
-        row += "," + std::to_string(stall[k]);
-      }
-      row += "\n";
-      metric_logger->Log(row);
-    }
-
-    return true;
-  }
-
-  // The time-based half of ComputeMetricsSampled: line one device's metric samples up
-  // against the intervals the kernels ran in and write the report. raw_metrics is the
-  // caller's buffer, reused across devices.
-  void ComputeTimedMetrics(const ZeDeviceDescriptor* device,
-                           const std::shared_ptr<UniLogger>& metric_logger,
-                           uint8_t* raw_metrics) {
-    std::vector<ZeKernelInfo> kinfo;
-    uint64_t max_global_instance_id = 0;
-    double device_ns_per_cycle = (static_cast<double>(NSEC_IN_SEC) / static_cast<double>(device->device_timer_frequency_));
-    double metric_ns_per_cycle = (static_cast<double>(NSEC_IN_SEC) / static_cast<double>(device->metric_timer_frequency_));
-
-    // enumerate all kernel time files
-    std::vector<std::string> ktime_file_paths = logger_factory_->SearchFilesByType(LOGGER_TYPE_KTIME, device->device_id_);
-    for (const auto& ktime_path: ktime_file_paths) {
-      std::ifstream kf = std::ifstream(ktime_path);
-      if (!kf.is_open()) {
-        continue;
-      }
-
-      KernelTimeRecord record;
-      while (ReadKernelTimeRecord(kf, record)) {
-        ZeKernelInfo info;
-        info.subdevice_id = record.subdevice_id_;
-        info.global_instance_id = record.global_instance_id_;
-        if (info.global_instance_id > max_global_instance_id) {
-          max_global_instance_id = info.global_instance_id;
-        }
-        info.metric_start = record.metric_start_;
-        info.metric_end = record.metric_end_;
-
-        uint64_t kstart;
-        uint64_t kend;
-        uint64_t elapsed;
-
-        kstart = info.metric_start & device->device_timer_mask_;
-        kstart = static_cast<double>(kstart) * device_ns_per_cycle;
-
-        kend = info.metric_end & device->device_timer_mask_;
-        kend = static_cast<double>(kend) * device_ns_per_cycle;
-
-        while (kend <= kstart) {
-          kend += static_cast<double>(device->device_timer_mask_ + 1UL) * device_ns_per_cycle;
-        }
-        elapsed = kend - kstart;
-
-        info.metric_start = info.metric_start & device->metric_timer_mask_;
-        info.metric_start = static_cast<double>(info.metric_start) * metric_ns_per_cycle;
-
-        info.metric_end = info.metric_start + elapsed;
-
-        std::getline(kf, info.kernel_name);
-        if ((info.metric_start != 0) && (info.metric_end != 0) && (!info.kernel_name.empty())) {
-          kinfo.push_back(std::move(info));
-        }
-      }
-      kf.close();
-    }
-
-    if (kinfo.empty()) {
-      return;
-    }
-    std::sort(kinfo.begin(), kinfo.end(), CompareInterval);
-
-    auto metric_list = GetMetricList(device->metric_group_);
-    UNITRACE_ASSERT(!metric_list.empty());
-
-    uint32_t ts_idx = GetMetricId(metric_list, "QueryBeginTime");
-    if (ts_idx >= metric_list.size()) {
-      // no QueryBeginTime metric
-      return;
-    }
-
-    //TODO: handle subdevices in case of implicit scaling
-    uint64_t time_span_between_clock_resets = static_cast<double>(device->metric_timer_mask_ + 1ull) * metric_ns_per_cycle;
-
-    std::ifstream inf = std::ifstream(device->metric_file_name_, std::ios::in | std::ios::binary);
-    if (!inf.is_open()) {
-      return;
-    }
-
-    std::string header;
-    if (logger_factory_->IsLegacy()) {
-      header = "\n=== Device #";
-      header += std::to_string(device->device_id_) + " Metrics ===\n";
-      metric_logger->Log(header);
-    }
-
-    // Time-based sampling is written as a self-contained section per kernel-instance:
-    //   Kernel, GlobalInstanceId          <- section label (distinguishes this format
-    //   "<name>", <global_instance_id>       from the stall one, "Kernel,Pid,KernelId")
-    //   <counter names...>                <- column header: all metrics, in metric_list order
-    //   <counter values...>               <- one row per time sample
-    // The counter column header is the same for every section, so build it once.
-    std::string counter_header;
-    for (size_t i = 0; i < metric_list.size(); i++) {
-      if (i != 0) {
-        counter_header += ", ";
-      }
-      counter_header += metric_list[i];
-    }
-    counter_header += "\n";
-
-    uint64_t current_instance = (std::numeric_limits<uint64_t>::max)();
-    auto WriteOutInstanceHeader = [&metric_logger, &counter_header]
-                                  (const std::string& kernel_name, uint64_t id) {
-      // The leading newline puts a blank line before every instance.
-      metric_logger->Log("\nKernel, GlobalInstanceId\n" + kernel_name + ", " +
-                         std::to_string(id) + "\n");
-      metric_logger->Log(counter_header);
-    };
-
-    uint64_t dummy_global_instance_id = max_global_instance_id + min_dummy_instance_id;  // for idle samples
-
-    uint64_t cur_sampling_ts = 0;
-    auto kit = kinfo.begin();
-    while (!inf.eof() && kit != kinfo.end()) {
-      // each segment is its size in bytes, then the data
-      size_t raw_size = 0;
-      if (ReadMetricSegment(inf, raw_metrics, MAX_METRIC_BUFFER, raw_size) !=
-          SegmentStatus::kOk) {
-        break;
-      }
-      if (raw_size > 0) {
-        uint32_t num_samples = 0;
-        uint32_t num_metrics = 0;
-        auto status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          device->metric_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          raw_size, raw_metrics, &num_samples, &num_metrics,
-          nullptr, nullptr);
-        if ((status != ZE_RESULT_SUCCESS) || (num_samples == 0) || (num_metrics == 0)) {
-          std::cerr << "[WARNING] Unable to calculate metrics (status = 0x" << std::hex << status << std::dec << ") num_samples = " << num_samples << " num_metrics = " << num_metrics << std::endl;
-          continue;
-        }
-
-        std::vector<uint32_t> samples(num_samples);
-        std::vector<zet_typed_value_t> metrics(num_metrics);
-
-        status = ZE_FUNC(zetMetricGroupCalculateMultipleMetricValuesExp)(
-          device->metric_group_, ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES,
-          raw_size, raw_metrics, &num_samples, &num_metrics,
-          samples.data(), metrics.data());
-        if ((status != ZE_RESULT_SUCCESS) && (status != ZE_RESULT_WARNING_DROPPED_DATA)) {
-          std::cerr << "[WARNING] Unable to calculate metrics (status = 0x" << std::hex << status << std::dec << ") num_samples = " << num_samples << " num_metrics = " << num_metrics << std::endl;
-          continue;
-        }
-        if (!CalculatedSamplesFit(samples.data(), num_samples, samples.size(), num_metrics,
-                                                 metrics.size(), metric_list.size())) {
-          std::cerr << "[WARNING] Metric values calculated by the driver are inconsistent (num_samples = " << num_samples << " num_metrics = " << num_metrics << "), skipped" << std::endl;
-          continue;
-        }
-
-        const zet_typed_value_t *value = metrics.data();
-        for (uint32_t i = 0; i < num_samples && kit != kinfo.end(); ++i) {
-          uint32_t size = samples[i];
-
-          for (uint32_t j = 0; j < (size / metric_list.size()); ) {
-            std::string str;
-            const zet_typed_value_t *v = value + j * metric_list.size();
-            uint64_t ts = v[ts_idx].value.ui64;
-            if (cur_sampling_ts != 0) {  // clock overflow
-              ts = UnwrapTimestamp(ts, cur_sampling_ts, time_span_between_clock_resets);
-            }
-            cur_sampling_ts = ts;
-            if ((ts >= kit->metric_start) && (ts <= kit->metric_end)) {
-              if (current_instance != kit->global_instance_id) {
-                WriteOutInstanceHeader(kit->kernel_name, kit->global_instance_id);
-                current_instance = kit->global_instance_id;
-              }
-
-              for (size_t k = 0; k < metric_list.size(); k++) {
-                if (k != 0) {
-                  str += ", ";
-                }
-                if (k == ts_idx) {
-                  str += std::to_string(ts);
-                }
-                else{
-                  str += PrintTypedValue(v[k]);
-                }
-              }
-              str += "\n";
-              metric_logger->Log(str);
-              ++j; // move to next sample
-            }
-            else {
-              if (ts > kit->metric_end) {
-                kit++;  // move to next kernel
-                dummy_global_instance_id++;
-                if (kit == kinfo.end()) {
-                  break;  // we are done
-                }
-              }
-              else { // ts < kit->metric_start
-                ++j; // move to next sample
-                // does not belong to any kernel/command
-                if (idle_sampling_) {
-                  // one idle section per gap: dummy_global_instance_id advances with kit,
-                  // so each gap preceding a different kernel becomes its own section
-                  if (current_instance != dummy_global_instance_id) {
-                    auto sz = kit->kernel_name.size();
-                    std::string idle_name;
-                    if (sz > 2) {
-                      idle_name = "\"NoKernel(Before " + kit->kernel_name.substr(1, sz - 2)  + ")\"";
-                    }
-                    else {
-                      idle_name = "\"NoKernel\"";
-                    }
-                    WriteOutInstanceHeader(idle_name, dummy_global_instance_id);
-                    current_instance = dummy_global_instance_id;
-                  }
-
-                  // sample row: counter values only
-                  for (size_t k = 0; k < metric_list.size(); k++) {
-                    if (k != 0) {
-                      str += ", ";
-                    }
-                    if (k == ts_idx) {
-                      str += std::to_string(ts);
-                    }
-                    else{
-                      str += PrintTypedValue(v[k]);
-                    }
-                  }
-                  str += "\n";
-                  metric_logger->Log(str);
-                }
-              }
-            }
-          }
-          value += samples[i];
-        }
-      }
-    }
-    inf.close();
-  }
-
-  void ComputeMetricsSampled() {
-    // The .kprops/.ktime files and metric blobs read below are written by the child
-    // processes when their tracing stops. The caller must make sure they are ready.
-    auto *raw_metrics = static_cast<uint8_t*>(malloc(sizeof(uint8_t)*MAX_METRIC_BUFFER));
-    UniMemory::ExitIfOutOfMemory((void *)raw_metrics);
-
-    std::shared_ptr<UniLogger> metric_logger = nullptr;
-
-    // Post-processing can take long on large workloads; say so once, for all devices.
-    std::cerr << "[INFO] Post-processing metric data is in progress. "
-              << "This may take a while, please do not interrupt." << std::endl;
-
-    for (auto [handle, device] : device_descriptors_) {
-      if (device->parent_device_ != nullptr) {
-        // subdevice
-        continue;
-      }
-
-      metric_logger = logger_factory_->GetDeviceLogger(LOGGER_TYPE_METRICS_SAMPLING, device->device_id_, true, true);
-      if (device->stall_sampling_) {
-        ComputeStallMetrics(device, metric_logger, raw_metrics);
-      }
-      else {
-        ComputeTimedMetrics(device, metric_logger, raw_metrics);
-      }
-      metric_logger->Flush();
-    }
-    free (raw_metrics);
-    std::cerr << "[INFO] Post-processing metric data is complete." << std::endl;
-    if (logger_factory_->IsLegacy() && metric_logger && !metric_logger->GetLogFileName().empty()) {
-      std::cerr << "[INFO] Device metrics are stored in " << metric_logger->GetLogFileName() << std::endl;
-    }
-  }
-
-  static std::vector<std::string> GetMetricNames(zet_metric_group_handle_t group) {
-    UNITRACE_ASSERT(group != nullptr);
-
-    uint32_t metric_count = GetMetricCount(group);
-    UNITRACE_ASSERT(metric_count > 0);
-
-    std::vector<zet_metric_handle_t> metrics(metric_count);
-    ze_result_t status = ZE_FUNC(zetMetricGet)(group, &metric_count, metrics.data());
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    UNITRACE_ASSERT(metric_count == metrics.size());
-
-    std::vector<std::string> names;
-    for (auto metric : metrics) {
-      zet_metric_properties_t metric_props{
-          ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, };
-      status = ZE_FUNC(zetMetricGetProperties)(metric, &metric_props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::string units = GetMetricUnits(metric_props.resultUnits);
-      std::string name = metric_props.name;
-      if (!units.empty()) {
-        name += "[" + units + "]";
-      }
-      names.push_back(std::move(name));
-    }
-
-    return names;
-  }
-
- private:
-
-    static std::string PrintTypedValue(const zet_typed_value_t& typed_value) {
-    switch (typed_value.type) {
-      case ZET_VALUE_TYPE_UINT32:
-        return std::to_string(typed_value.value.ui32);
-      case ZET_VALUE_TYPE_UINT64:
-        return std::to_string(typed_value.value.ui64);
-      case ZET_VALUE_TYPE_FLOAT32:
-        return std::to_string(typed_value.value.fp32);
-      case ZET_VALUE_TYPE_FLOAT64:
-        return std::to_string(typed_value.value.fp64);
-      case ZET_VALUE_TYPE_BOOL8:
-        return std::to_string(static_cast<uint32_t>(typed_value.value.b8));
-      default:
-        UNITRACE_ASSERT(0);
-        break;
-    }
-    return "";  // in case of error returns empty string.
-  }
-
-  inline static std::string GetMetricUnits(const char* units) {
-    UNITRACE_ASSERT(units != nullptr);
-
-    std::string result = units;
-    if (result.find("null") != std::string::npos) {
-      result = "";
-    } else if (result.find("percent") != std::string::npos) {
-      result = "%";
-    }
-
-    return result;
-  }
-
-  static uint32_t GetMetricCount(zet_metric_group_handle_t group) {
-    UNITRACE_ASSERT(group != nullptr);
-
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    ze_result_t status = ZE_FUNC(zetMetricGroupGetProperties)(group, &group_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    return group_props.metricCount;
-  }
-
-  static std::vector<std::string> GetMetricList(zet_metric_group_handle_t group) {
-    UNITRACE_ASSERT(group != nullptr);
-
-    uint32_t metric_count = GetMetricCount(group);
-    UNITRACE_ASSERT(metric_count > 0);
-
-    std::vector<zet_metric_handle_t> metric_list(metric_count);
-    ze_result_t status = ZE_FUNC(zetMetricGet)(group, &metric_count, metric_list.data());
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    UNITRACE_ASSERT(metric_count == metric_list.size());
-
-    std::vector<std::string> name_list;
-    for (auto metric : metric_list) {
-      zet_metric_properties_t metric_props{
-          ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, };
-      status = ZE_FUNC(zetMetricGetProperties)(metric, &metric_props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::string units = GetMetricUnits(metric_props.resultUnits);
-      std::string name = metric_props.name;
-      if (!units.empty()) {
-        name += "[" + units + "]";
-      }
-      name_list.push_back(std::move(name));
-    }
-
-    return name_list;
-  }
-
-  static uint64_t ReadMetrics(zet_metric_streamer_handle_t streamer, uint8_t* storage, size_t ssize) {
-      ze_result_t status = ZE_RESULT_SUCCESS;
-      size_t data_size = ssize;
-      status = ZE_FUNC(zetMetricStreamerReadData)(streamer, UINT32_MAX, &data_size, storage);
-      if (status == ZE_RESULT_WARNING_DROPPED_DATA) {
-          std::cerr << "[WARNING] Metric samples dropped." << std::endl;
-      }
-      else if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[ERROR] zetMetricStreamerReadData failed with error code: "
-              << static_cast<std::size_t>(status) << std::endl;
-          UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-      return data_size;
-  }
-
-  static uint64_t EventBasedReadMetrics(ze_event_handle_t event, zet_metric_streamer_handle_t  streamer, uint8_t *storage, size_t ssize) {
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    //status = ZE_FUNC(zeEventHostSynchronize)(event, 0);
-    status = ZE_FUNC(zeEventQueryStatus)(event);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS || status == ZE_RESULT_NOT_READY);
-    if (status == ZE_RESULT_SUCCESS) {
-      status = ZE_FUNC(zeEventHostReset)(event);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-    else {
-      // if (status == ZE_RESULT_NOT_READY)
-      return 0;
-    }
-
-    return ReadMetrics(streamer, storage, ssize);
-  }
-
-  static void MetricProfilingThread(ZeDeviceDescriptor *desc) {
-
-    ze_result_t status = ZE_RESULT_SUCCESS;
-
-    ze_context_handle_t context = desc->context_;
-    ze_device_handle_t device = desc->device_;
-    zet_metric_group_handle_t group = desc->metric_group_;
-
-    status = ZE_FUNC(zetContextActivateMetricGroups)(context, device, 1, &group);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_event_pool_handle_t event_pool = nullptr;
-    ze_event_pool_desc_t event_pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr, ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-    status = ZE_FUNC(zeEventPoolCreate)(context, &event_pool_desc, 1, &device, &event_pool);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    ze_event_handle_t event = nullptr;
-    ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0, ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-    status = ZE_FUNC(zeEventCreate)(event_pool, &event_desc, &event);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    zet_metric_streamer_handle_t streamer = nullptr;
-    // UNITRACE_SamplingInterval is in us and may be fractional (e.g. "0.5")
-    double interval_us = default_sampling_interval_us;
-    try {
-      interval_us = std::stod(utils::GetEnv("UNITRACE_SamplingInterval"));
-    } catch (...) {
-      std::cerr << "[WARNING] Invalid sampling interval \"" << utils::GetEnv("UNITRACE_SamplingInterval") << "\", using default " << default_sampling_interval_us << " us" << std::endl;
-    }
-    if (!(interval_us > 0.0) || interval_us * 1000.0 > double(UINT32_MAX)) {
-      std::cerr << "[WARNING] Sampling interval " << interval_us << " us is out of range, using default " << default_sampling_interval_us << " us" << std::endl;
-      interval_us = default_sampling_interval_us;
-    }
-    uint32_t interval = static_cast<uint32_t>(std::llround(interval_us * 1000.0));  // convert us to ns
-    if (interval == 0) {
-      interval = 1;
-    }
-
-    // Work around a driver bug: zetMetricStreamerOpen fails if the sample count is out of
-    // the HW-supported range, so retry with fewer samples.
-    uint32_t metric_sample_sz = max_metric_samples;
-    while (1) {
-      zet_metric_streamer_desc_t streamer_desc = {ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC, nullptr, metric_sample_sz, interval};
-      status = ZE_FUNC(zetMetricStreamerOpen)(context, device, group, &streamer_desc, event, &streamer);
-      if (status == ZE_RESULT_SUCCESS) {
-        break;
-      } else {
-        metric_sample_sz = metric_sample_sz >> 2;
-        if (metric_sample_sz < 1024) {
-          break;
-        }
-      }
-    }
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[WARNING] Unable to open metric streamer for sampling (status = 0x" << std::hex << status << std::dec << "). The sampling interval might be too small or another sampling instance is active." << std::endl;
-#ifndef _WIN32
-      std::cerr << "[INFO] Please also make sure /proc/sys/dev/i915/perf_stream_paranoid or /proc/sys/dev/xe/observation_paranoid is set to 0." << std::endl;
-#endif /* _WIN32 */
-
-      status = ZE_FUNC(zeEventDestroy)(event);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      status = ZE_FUNC(zeEventPoolDestroy)(event_pool);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      // Deactivate like the normal exit path: groups created from programmable metrics
-      // are destroyed later with the metrics manager and must not be active then.
-      status = ZE_FUNC(zetContextActivateMetricGroups)(context, device, 0, &group);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      // set state to enabled to let the parent thread continue
-      desc->profiling_state_.store(PROFILER_ENABLED, std::memory_order_release);
-      return;
-    }
-
-    std::vector<std::string> metrics_list;
-    metrics_list = GetMetricList(group);
-    UNITRACE_ASSERT(!metrics_list.empty());
-
-    auto *raw_metrics = static_cast<uint8_t*>(malloc(sizeof(uint8_t)*MAX_METRIC_BUFFER));
-    UniMemory::ExitIfOutOfMemory((void *)raw_metrics);
-
-    auto dump_metrics = [](uint8_t *buffer, uint64_t size, std::ofstream *f) -> bool {
-      // write the size in bytes, then the data
-      if (f->good()) {
-        f->write(reinterpret_cast<char*>(&size), sizeof(size));
-      }
-      if (f->good()) {
-        f->write(reinterpret_cast<char*>(buffer), size);
-      }
-      return f->good();
-    };
-
-    // Drain the stream; dump the data only if save is true.
-    auto drain_metrics = [&](uint64_t size, bool save) -> bool {
-      while (size > 0) {
-        if (save && !dump_metrics (raw_metrics, size, &desc->metric_file_stream_)) {
-          std::cerr << "[ERROR] Failed to write to sampling metrics file " << desc->metric_file_name_ << std::endl;
-          return false;
-        }
-        //
-        // If less data than requested was read, we can assume that we have reached the end of the stream and
-        // can exit the loop however, it might be that less data was read because there was no space available in the buffer
-        // and not because we reached the end of the stream. To be safe, we will read again and if we get less than half of the
-        // buffer size, we will assume that we have reached the end of the stream.
-        //
-        if (size < MAX_METRIC_BUFFER / 2)
-          break;
-        size = ReadMetrics(streamer, raw_metrics, MAX_METRIC_BUFFER);
-      }
-      return true;
-    };
-
-    // One save decision per full drain, covering data since the previous drain.
-    MetricSamplingWindow sampling_window = UniController::BeginMetricSamplingWindow();
-
-    // Windows MetricsDiscovery returns no values until it sees the counters-programmed report
-    // at the start of the stream, so keep the first drain even while paused.
-    bool keep_stream_start = true;
-    auto should_save = [&sampling_window, &keep_stream_start]() -> bool {
-      bool save = UniController::IsMetricSamplingEnabled(sampling_window);
-#ifdef _WIN32
-      save = save || keep_stream_start;
-#endif
-      keep_stream_start = false;
-      return save;
-    };
-
-    desc->profiling_state_.store(PROFILER_ENABLED, std::memory_order_release);
-    while (desc->profiling_state_.load(std::memory_order_acquire) != PROFILER_DISABLED) {
-      auto size = EventBasedReadMetrics(event, streamer, raw_metrics, MAX_METRIC_BUFFER);
-      if (size > 0) {
-        if (!drain_metrics(size, should_save())) {
-          break;
-        }
-      }
-    }
-
-    // flush the remaining metrics
-    auto size = ReadMetrics(streamer, raw_metrics, MAX_METRIC_BUFFER);
-    if (size > 0) {
-      drain_metrics(size, should_save());
-    }
-    free (raw_metrics);
-
-    status = ZE_FUNC(zetMetricStreamerClose)(streamer);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    status = ZE_FUNC(zeEventDestroy)(event);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    status = ZE_FUNC(zeEventPoolDestroy)(event_pool);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    status = ZE_FUNC(zetContextActivateMetricGroups)(context, device, 0, &group);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  }
-
- private: // Data
-
-  std::vector<ze_context_handle_t> metric_contexts_;
-  std::map<ze_device_handle_t, ZeDeviceDescriptor *> device_descriptors_;
-  std::string data_dir_name_;
-  LoggerFactory* logger_factory_;
-  bool idle_sampling_;
-};
-
-#endif // PTI_TOOLS_UNITRACE_LEVEL_ZERO_METRICS_H_
diff --git a/tools/unitrace/src/levelzero/ze_metrics_config.h b/tools/unitrace/src/levelzero/ze_metrics_config.h
deleted file mode 100644
index 30410811..00000000
--- a/tools/unitrace/src/levelzero/ze_metrics_config.h
+++ /dev/null
@@ -1,1055 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_METRICS_CONFIG_H_
-#define PTI_TOOLS_UNITRACE_METRICS_CONFIG_H_
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zes_api.h>
-#include <level_zero/zet_api.h>
-#include "ze_loader.h"
-
-#include <string>
-#include <functional>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <map>
-#include <sstream>
-#include <type_traits>
-#include <string>
-#include <vector>
-#include <unordered_map>
-
-#include "utils/unitrace_assert.h"
-#include "config_node.h"
-#include "metric_config_validator.h"
-
-
-// Formats a sorted list of valid parameter values compactly for the "Valid values"
-// comments of a generated config template. Each run of three or more values with a
-// common step is printed as "first:last" (step 1) or "first:last:step"; shorter
-// runs are printed as individual values. E.g. 0,1,2,3,8,10,12 -> "0:3,8:12:2".
-template <class T>
-class RangeStringify {
-public:
-  RangeStringify() = default;
-  void add(T value) {
-    if (values_.size() < 2 || (value - values_.back() == (values_[1] - values_[0]))) {
-      values_.push_back(value);
-      return;
-    }
-    flush();
-    values_.push_back(value);
-  }
-
-  std::string str() {
-   flush();
-   return str_;
-  }
-
-private:
-  void flush() {
-    if (values_.size() == 0) {
-      return;
-    }
-    if (str_.size() > 0) {
-      str_ += ",";
-    }
-    if (values_.size() > 2) {
-      str_ += ToString(values_[0]) + ":" + ToString(values_.back());
-      if (values_[1] - values_[0] != (T)1) {
-        str_ += ":" + ToString(values_[1] - values_[0]);
-      }
-    } else {
-      for (auto &val: values_) {
-        if (&val != &values_[0]) str_ += ",";
-        str_ += ToString(val);
-      }
-    }
-    values_.clear();
-  }
-
-  static std::string ToString(T value) {
-    if constexpr (std::is_floating_point_v<T>) {
-      return config_node_detail::FormatDouble(value);
-    } else {
-      return std::to_string(value);
-    }
-  }
-
-  std::vector<T> values_;  // current run, flushed when the step changes
-  std::string str_;
-};
-
-// Builds the single metric group unitrace activates on a device, from the -g
-// group name(s) and/or the --metric-config file, for one sampling type
-// (event-based for -q, time-based for -k/--stall-sampling).
-//
-// Two kinds of groups can be selected:
-//  - predefined groups, enumerated and owned by the driver;
-//  - programmable metrics: each enabled "programmable" entry creates one or more
-//    metrics from a driver programmable with the configured parameter values;
-//    all created metrics are then combined into new metric groups. The created
-//    metrics and groups are owned by this object and destroyed with it, so it
-//    must outlive any activation or calculation that uses its groups.
-//
-// It also generates a config template listing everything the device supports
-// (GenerateAllMetricConfig).
-class ZeMetricsManager {
- public:
-  ZeMetricsManager(ze_device_handle_t device, zet_metric_group_sampling_type_flag_t samplingType) :
-                    m_device_(device),
-                    m_samplingType_(samplingType),
-                    m_prog_groups_start_(0) {
-    InitPredefined();
-    InitProgrammables();
-  }
-
-  // Owns driver handles that are destroyed exactly once in the destructor.
-  ZeMetricsManager(const ZeMetricsManager&) = delete;
-  ZeMetricsManager& operator=(const ZeMetricsManager&) = delete;
-
-  // Selects the groups in groups_list (comma separated predefined names, may be
-  // empty) plus the enabled groups and programmables of the metric_config file
-  // (may be empty). Exactly one group must result: returns nullptr (after
-  // printing the reason) if none or more than one does, or on any config error.
-  // On success the caller owns the returned object and must delete it after the
-  // group is no longer used.
-  static ZeMetricsManager* CreateMetricGroups(ze_device_handle_t device, zet_metric_group_sampling_type_flag_t samplingType, const std::string &metric_config, const std::string &groups_list) {
-    ConfigNodePtr conf;
-    if (!metric_config.empty()) {
-      std::string error;
-      conf = metric_config::Load(metric_config, metric_config::CountGroups(groups_list), error);
-      if (conf == nullptr) {
-        std::cerr << "[ERROR] Invalid metric configuration file: " << error << std::endl;
-        return nullptr;
-      }
-    }
-
-    ZeMetricsManager* metricsManager = new ZeMetricsManager(device, samplingType);
-
-    // Add predefined metric groups based on comma separated groups_list if it's not empty.
-    if (!groups_list.empty()) {
-      std::istringstream ss(groups_list);
-      std::string group_name;
-      while (std::getline(ss, group_name, ',')) {
-        if (!metricsManager->addPredefinedMetricGroup(group_name)) {
-          delete metricsManager;
-          return nullptr;
-        }
-      }
-    }
-
-    // Add groups and metrics from the (already validated) config file if provided.
-    if (conf) {
-      // Predefined metric groups
-      auto cpredef = conf->findChildByName("predefined");
-      if (cpredef != nullptr) {
-        for (auto cgroup : cpredef->getChildren()) {
-          if (!IsNodeEnabled(cgroup)) {
-            continue;
-          }
-
-          if (!metricsManager->addPredefinedMetricGroup(cgroup->getName())) {
-            delete metricsManager;
-            return nullptr;
-          }
-        }
-      }
-
-      // Programmable metric groups
-      auto cprog = conf->findChildByName("programmable");
-      if (cprog != nullptr) {
-        for (auto cmetric : cprog->getChildren()) {
-          if (!metricsManager->createProgramMetrics(cmetric)) {
-            delete metricsManager;
-            return nullptr;
-          }
-        }
-        metricsManager->createProgMetricGroups();
-      }
-    }
-
-    if (metricsManager->getMetricGroupsCount() == 0) {
-      std::cerr << "[ERROR] No valid metric groups found based on the provided configuration." << std::endl;
-      delete metricsManager;
-      return nullptr;
-    } else if (metricsManager->getMetricGroupsCount() > 1) {
-      std::cerr << "[ERROR] Only one metric group can be collected, but " << metricsManager->getMetricGroupsCount()
-                << " were selected on this device: " << metricsManager->DescribeMetricGroups()
-                << ". Enable a single predefined group, or programmable metrics only (without -g)." << std::endl;
-      delete metricsManager;
-      return nullptr;
-    }
-
-    return metricsManager;
-  }
-
-  static bool GenerateAllMetricConfig(ze_device_handle_t device, const std::string &metric_config) {
-    ConfigNodePtr conf = std::make_shared<ConfigNode>("");
-    // Predefined metric groups
-    ConfigNodePtr cpredef = std::make_shared<ConfigNode>("predefined");
-    conf->addChild(cpredef);
-    if (!fillAllPredefinedMetricGroup(device, cpredef)) {
-      return false;
-    }
-
-    // Programmable metric groups
-    ConfigNodePtr cprog = std::make_shared<ConfigNode>("programmable");
-    conf->addChild(cprog);
-    if (!fillAllProgrammables(device, cprog)) {
-      return false;
-    }
-
-    return ConfigNode::save(conf, metric_config);
-  }
-
-  const zet_metric_group_handle_t* GetMetricGroups() {
-    if( m_metric_groups_.size() == 0) {
-      return nullptr;
-    }
-    return m_metric_groups_.data();
-  }
-
-  // Builds, for each parameter, the "Valid values" text written to the template:
-  //  - enumerated integer/float values: compressed by RangeStringify, e.g. "0:19";
-  //  - UINT64_RANGE / FLOAT64_RANGE: the reported intervals as "min:max,...";
-  //  - BOOL8: the reported values, or "false,true" if none are reported.
-  static void buildParamValuesRangeDesc(zet_metric_programmable_exp_handle_t prog,
-                                        const std::vector<zet_metric_programmable_param_info_exp_t> &params,
-                                        std::vector<std::string> &paramsValuesRangeDesc) {
-
-    auto to_ui64 = [](zet_value_info_exp_t &vinfo, zet_value_info_type_exp_t vtype) {
-      switch(vtype) {
-      case ZET_VALUE_INFO_TYPE_EXP_UINT32:
-        return (uint64_t)vinfo.ui32;
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64:
-        return (uint64_t)vinfo.ui64;
-      case ZET_VALUE_INFO_TYPE_EXP_UINT8:
-        return (uint64_t)vinfo.ui8;
-      case ZET_VALUE_INFO_TYPE_EXP_UINT16:
-        return (uint64_t)vinfo.ui16;
-      default:
-        UNITRACE_ASSERT(false && "Invalid value type for uint64 conversion");
-      }
-      return UINT64_MAX;
-    };
-
-    auto to_double = [](zet_value_info_exp_t &vinfo, zet_value_info_type_exp_t vtype) {
-      switch(vtype) {
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT32:
-        return (double)vinfo.fp32;
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT64:
-        return (double)vinfo.fp64;
-      default:
-        UNITRACE_ASSERT(false && "Invalid value type for float64 conversion");
-      }
-      return std::numeric_limits<double>::max();
-    };
-
-    for (uint32_t i = 0; i < params.size(); i++) {
-      uint32_t val_num = params[i].valueInfoCount;
-      std::vector<zet_metric_programmable_param_value_info_exp_t> val_info(val_num);
-      ze_result_t status = ZE_FUNC(zetMetricProgrammableGetParamValueInfoExp)(prog, i, &val_num, val_info.data());
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::string str;
-
-      if (params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE) {
-        for (uint32_t j = 0; j < val_num; j++) {
-          str += std::to_string(val_info[j].valueInfo.ui64Range.ui64Min) + ":" +
-                 std::to_string(val_info[j].valueInfo.ui64Range.ui64Max);
-            if (j != val_num - 1) {
-                str += ",";
-            }
-        }
-      } else if (params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE) {
-        for (uint32_t j = 0; j < val_num; j++) {
-          str += config_node_detail::FormatDouble(val_info[j].valueInfo.fp64Range.fp64Min) + ":" +
-                 config_node_detail::FormatDouble(val_info[j].valueInfo.fp64Range.fp64Max);
-            if (j != val_num - 1) {
-                str += ",";
-            }
-        }
-      } else if (params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_UINT32 ||
-               params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_UINT64 ||
-               params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_UINT8 ||
-               params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_UINT16) {
-        RangeStringify<uint64_t> range_ui64;
-        for (uint32_t j = 0; j < val_num; j++) {
-          range_ui64.add(to_ui64(val_info[j].valueInfo, params[i].valueInfoType));
-        }
-        str = range_ui64.str();
-      } else if (params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_FLOAT32 ||
-               params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_FLOAT64) {
-        RangeStringify<double> range_fp64;
-        for (uint32_t j = 0; j < val_num; j++) {
-          range_fp64.add(to_double(val_info[j].valueInfo, params[i].valueInfoType));
-        }
-        str = range_fp64.str();
-      } else if (params[i].valueInfoType == ZET_VALUE_INFO_TYPE_EXP_BOOL8) {
-        if (val_num > 0) {
-          for (uint32_t j = 0; j < val_num; j++) {
-              str += (val_info[j].valueInfo.b8 != 0) ? "true" : "false";
-              if (j != val_num - 1) {
-                  str += ",";
-              }
-          }
-        } else {
-            str = "false,true";
-        }
-      } else {
-          UNITRACE_ASSERT(false && "Unsupported value info type for range description");
-      }
-
-      paramsValuesRangeDesc.push_back(str);
-    }
-  }
-
-  // Adds a disabled entry per predefined group to the template. The driver reports
-  // a group once per sampling type, so groups are merged by name and the comment
-  // lists all sampling types the name supports.
-  static bool fillAllPredefinedMetricGroup(ze_device_handle_t device, ConfigNodePtr cpredef_metric) {
-    uint32_t num_groups = 0;
-    ze_result_t status = ZE_FUNC(zetMetricGroupGet)(device, &num_groups, nullptr);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    if (num_groups > 0) {
-      std::vector<zet_metric_group_handle_t> groups(num_groups, nullptr);
-      status = ZE_FUNC(zetMetricGroupGet)(device, &num_groups, groups.data());
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      std::vector<std::pair<std::string, zet_metric_group_sampling_type_flags_t>> groups_vec;
-      std::unordered_map<std::string, uint32_t> group_idx;
-
-      for (uint32_t i = 0; i < num_groups; ++i) {
-        zet_metric_group_properties_t group_props{};
-        group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-        status = ZE_FUNC(zetMetricGroupGetProperties)(groups[i], &group_props);
-        if (status != ZE_RESULT_SUCCESS) {
-          UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-          return false;
-        }
-
-        auto it = group_idx.find(group_props.name);
-        if (it != group_idx.end()) {
-          groups_vec[it->second].second |= group_props.samplingType;
-        } else {
-          group_idx[group_props.name] = groups_vec.size();
-          groups_vec.emplace_back(group_props.name, group_props.samplingType);
-        }
-      }
-
-      for (auto &[name, samplingTypes] : groups_vec) {
-        if ((samplingTypes & kCollectableSamplingTypes) == 0) {
-          continue;
-        }
-        std::string desc = getSupportedSamplingTypesDesc(samplingTypes);
-
-        ConfigNodePtr groupNode = std::make_shared<ConfigNode>(name);
-        groupNode->addAttribute(std::make_shared<BoolAttribute>("enable", false, desc));
-        cpredef_metric->addChild(groupNode);
-      }
-    }
-    return true;
-  }
-
-  // A programmable as it appears in the config file. Programmables sharing a name
-  // but differing in their parameter set get the key "<name>_<params hash>"; the
-  // first one keeps the plain name. Programmables with the same name and parameter
-  // set (e.g. one per sampling type) share one key.
-  struct ProgrammableEntry {
-    std::string key;
-    std::string name;
-    zet_metric_programmable_exp_handle_t handle;
-    zet_metric_group_sampling_type_flags_t samplingType;
-    uint32_t parameterCount;
-    std::string params_signature;  // full description of the parameter set, see ParamsSignature
-    std::size_t params_hash;       // hash of params_signature, used in "<name>_<hash>" keys
-    std::vector<zet_metric_programmable_param_info_exp_t> params;
-    std::vector<std::string> paramsValuesRangeDesc;
-  };
-
-  // Enumerates the programmables of a device and assigns their config keys.
-  // Parameter details are fetched for every programmable when with_params is true,
-  // otherwise only for names that are shared, where they are needed for the key.
-  // The hash is not stable across builds, so a config file using "<name>_<hash>"
-  // keys must be generated by the same unitrace build.
-  static std::vector<ProgrammableEntry> EnumerateProgrammables(ze_device_handle_t device, bool with_params) {
-    std::vector<ProgrammableEntry> entries;
-
-    uint32_t num_progs = 0;
-    ze_result_t status = ZE_FUNC(zetMetricProgrammableGetExp)(device, &num_progs, nullptr);
-    if (status != ZE_RESULT_SUCCESS || num_progs == 0) {
-      return entries;
-    }
-    std::vector<zet_metric_programmable_exp_handle_t> progs(num_progs, nullptr);
-    status = ZE_FUNC(zetMetricProgrammableGetExp)(device, &num_progs, progs.data());
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[WARNING] Unable to get programmable metrics (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      return entries;
-    }
-
-    std::vector<std::string> names;
-    std::unordered_map<std::string, uint32_t> name_count;
-    for (uint32_t i = 0; i < num_progs; ++i) {
-      zet_metric_programmable_exp_properties_t prog_props{};
-      prog_props.stype = ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES;
-      status = ZE_FUNC(zetMetricProgrammableGetPropertiesExp)(progs[i], &prog_props);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[WARNING] Unable to get properties of programmable metric #" << i << " (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        continue;
-      }
-      ProgrammableEntry entry{};
-      entry.key = prog_props.name;
-      entry.name = prog_props.name;
-      entry.handle = progs[i];
-      entry.samplingType = prog_props.samplingType;
-      entry.parameterCount = prog_props.parameterCount;
-      ++name_count[entry.key];
-      entries.push_back(std::move(entry));
-    }
-
-    std::vector<ProgrammableEntry> result;
-    std::unordered_map<std::string, std::string> key_signature;  // assigned key -> params signature
-    for (auto& entry : entries) {
-      const std::string& name = entry.name;
-      const bool shared_name = name_count[name] > 1;
-      if (with_params || shared_name) {
-        uint32_t num_params = entry.parameterCount;
-        entry.params.resize(num_params);
-        status = ZE_FUNC(zetMetricProgrammableGetParamInfoExp)(entry.handle, &num_params, entry.params.data());
-        if (status != ZE_RESULT_SUCCESS) {
-          std::cerr << "[WARNING] Unable to get parameters of programmable metric " << name << " (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-          continue;
-        }
-        entry.params.resize(num_params);
-        buildParamValuesRangeDesc(entry.handle, entry.params, entry.paramsValuesRangeDesc);
-        entry.params_signature = ParamsSignature(entry.params, entry.paramsValuesRangeDesc);
-        entry.params_hash = std::hash<std::string>{}(entry.params_signature);
-      }
-
-      if (shared_name) {
-        auto it = key_signature.find(name);
-        if (it != key_signature.end() && it->second != entry.params_signature) {
-          entry.key = name + "_" + std::to_string(entry.params_hash);
-        }
-      }
-      key_signature.insert({entry.key, entry.params_signature});
-      result.push_back(std::move(entry));
-    }
-    return result;
-  }
-
-  static bool fillAllProgrammables(ze_device_handle_t device, ConfigNodePtr cprog_metric) {
-    //
-    // Programmables sharing a key (same name and parameter set) are represented by
-    // one config entry with combined supported sampling types.
-    //
-    struct ProgInfo {
-      std::string name;
-      zet_metric_group_sampling_type_flags_t samplingTypes;
-      std::string params_signature;
-    };
-
-    std::vector<ProgInfo> progs_vec;
-    std::unordered_map<std::string, uint32_t> prog_idx;
-    // Programmables with identical parameter sets (names, types, defaults, valid values) share one node.
-    std::map<std::string, ConfigNodePtr> param_nodes;
-
-    for (const auto& entry : EnumerateProgrammables(device, true)) {
-      auto it = prog_idx.find(entry.key);
-      if (it != prog_idx.end()) {
-        progs_vec[it->second].samplingTypes |= entry.samplingType;
-        continue;
-      }
-
-      if (param_nodes.find(entry.params_signature) == param_nodes.end()) {
-        ConfigNodePtr param_node = std::make_shared<ConfigNode>("parameters");
-        for (size_t j = 0; j < entry.params.size(); ++j) {
-          std::string desc = !entry.paramsValuesRangeDesc[j].empty() ? "Valid values: " + entry.paramsValuesRangeDesc[j] : "";
-          addParam(entry.params[j], param_node, desc);
-        }
-        param_nodes[entry.params_signature] = param_node;
-      }
-
-      prog_idx[entry.key] = progs_vec.size();
-      progs_vec.push_back({entry.key, entry.samplingType, entry.params_signature});
-    }
-
-    for (auto &pinfo : progs_vec) {
-      if ((pinfo.samplingTypes & kCollectableSamplingTypes) == 0) {
-        continue;
-      }
-      std::string desc = getSupportedSamplingTypesDesc(pinfo.samplingTypes);
-
-      ConfigNodePtr progNode = std::make_shared<ConfigNode>(pinfo.name);
-      progNode->addAttribute(std::make_shared<BoolAttribute>("enable", false, desc));
-      progNode->addChild(param_nodes[pinfo.params_signature]);
-      cprog_metric->addChild(progNode);
-    }
-
-    return true;
-  }
-
-  std::size_t getMetricGroupsCount() {
-    return m_metric_groups_.size();
-  }
-
-  // Comma-separated names of the selected groups; groups created from
-  // programmable metrics are named by the driver.
-  std::string DescribeMetricGroups() const {
-    std::string names;
-    for (auto group : m_metric_groups_) {
-      zet_metric_group_properties_t props{};
-      props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-      if (!names.empty()) {
-        names += ", ";
-      }
-      names += (ZE_FUNC(zetMetricGroupGetProperties)(group, &props) == ZE_RESULT_SUCCESS) ? props.name : "<unknown>";
-    }
-    return names;
-  }
-
-  // Created groups must be destroyed before the metrics they contain.
-  ~ZeMetricsManager() {
-    for (uint32_t i = m_prog_groups_start_; i < m_metric_groups_.size(); ++i) {
-      ze_result_t status = ZE_FUNC(zetMetricGroupDestroyExp)(m_metric_groups_[i]);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-
-    for (auto metric : m_all_progs_metrics_) {
-      ze_result_t status = ZE_FUNC(zetMetricDestroyExp)(metric);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    }
-  }
-
- protected:
-  void InitPredefined() {
-    uint32_t num_groups = 0;
-    ze_result_t status = ZE_FUNC(zetMetricGroupGet)(m_device_, &num_groups, nullptr);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-    if (num_groups > 0) {
-      std::vector<zet_metric_group_handle_t> groups(num_groups, nullptr);
-      status = ZE_FUNC(zetMetricGroupGet)(m_device_, &num_groups, groups.data());
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      for (uint32_t i = 0; i < num_groups; ++i) {
-        zet_metric_group_properties_t group_props{};
-        group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-        status = ZE_FUNC(zetMetricGroupGetProperties)(groups[i], &group_props);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-        if ((group_props.samplingType & m_samplingType_) != 0) {
-          m_predef_groups_.insert({std::string(group_props.name), groups[i]});
-        }
-      }
-    }
-  }
-
-  void InitProgrammables() {
-    for (const auto& entry : EnumerateProgrammables(m_device_, false)) {
-      if ((entry.samplingType & m_samplingType_) != 0) {
-        m_programmables_.insert({entry.key, {entry.handle, entry.parameterCount, entry.name}});
-      }
-    }
-  }
-
-  // Unknown names (or names without the requested sampling type) only warn, so one
-  // config can be shared by devices and sampling modes; an empty result is
-  // reported by CreateMetricGroups.
-  bool addPredefinedMetricGroup(const std::string &name) {
-    if(name.empty()) {
-      std::cerr << "[ERROR] Predefined metric without name." << std::endl;
-      return false;
-     }
-    auto mgroup = m_predef_groups_.find(name);
-    if (mgroup == m_predef_groups_.end()) {
-      std::cerr << "[WARNING] Predefined metric(" << name << ") not found." << std::endl;
-      return true;
-    }
-
-    // Keep predefined groups before the created ones (see m_prog_groups_start_).
-    m_metric_groups_.insert(std::next(m_metric_groups_.begin(), m_prog_groups_start_), mgroup->second);
-    ++m_prog_groups_start_;
-    return true;
-  }
-
-  // Creates the metrics of one "programmable" config entry and appends them to
-  // m_all_progs_metrics_:
-  //  1. start from the driver default of every parameter;
-  //  2. override the parameters listed under "parameters", validating each value
-  //     against the values the driver reports as valid;
-  //  3. at most one parameter may be a range list ([0,2,4:8]); the programmable is
-  //     instantiated once per value of that list, otherwise once.
-  // One instantiation can yield several metrics (e.g. per disaggregation level).
-  // Disabled or unknown entries are skipped; returns false on config errors.
-  bool createProgramMetrics(ConfigNodePtr cprogram_metric) {
-    auto cname = cprogram_metric->getName();
-    if (cname.empty()) {
-      std::cerr << "[ERROR] Programmable without \"name\"." << std::endl;
-      return false;
-    }
-
-    if (!IsNodeEnabled(cprogram_metric)) {
-      return true;
-    }
-
-    auto prog = m_programmables_.find(cname);
-    if (prog == m_programmables_.end()) {
-      std::cerr << "[WARNING] Programmable(" << cname << ") not found." << std::endl;
-      return true;
-    }
-
-    // The config key may carry a "_<hash>" suffix; created metrics use the programmable's own name.
-    const char* prog_name = prog->second.name.c_str();
-    zet_metric_programmable_exp_handle_t programmable = prog->second.handle;
-    uint32_t num_params = prog->second.parameterCount;
-
-    std::vector<zet_metric_programmable_param_info_exp_t> params(num_params);
-    std::vector<zet_metric_programmable_param_value_exp_t> vals(num_params);
-    ze_result_t status = ZE_FUNC(zetMetricProgrammableGetParamInfoExp)(programmable, &num_params, params.data());
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Unable to get parameters of programmable(" << cname << ") (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      return false;
-    }
-    params.resize(num_params);
-    vals.resize(num_params);
-
-    FillDefaultVals(params, vals);
-
-    struct RangeParamIterator {
-      uint32_t index;
-      const U64RangeListAttribute *range_attr;
-      uint64_t current;
-    };
-    std::vector<RangeParamIterator> range_params;
-
-    auto cparams = cprogram_metric->findChildByName("parameters");
-    if (cparams != nullptr) {
-      for (const auto& aparam : cparams->getAttributes()) {
-        auto apname = aparam->getKey();
-        if (apname.empty()) {
-          std::cerr << "[ERROR] Parameter of programmable(" << cname << ") without \"name\"." << std::endl;
-          return false;
-        }
-
-        uint32_t i;
-        for (i = 0; i < num_params; ++i) {
-          if (apname.compare(params[i].name) != 0) {
-            continue;
-          }
-
-          uint32_t val_num = params[i].valueInfoCount;
-          std::vector<zet_metric_programmable_param_value_info_exp_t> val_info(val_num);
-          status = ZE_FUNC(zetMetricProgrammableGetParamValueInfoExp)(programmable, i, &val_num, val_info.data());
-          if (status != ZE_RESULT_SUCCESS) {
-            std::cerr << "[ERROR] Unable to get valid values of Parameter(" << apname << ") of programmable(" << cname << ")" << std::endl;
-            return false;
-          }
-          val_info.resize(val_num);
-
-          if (aparam->getType() == AttributeType::UNSIGNED_64_RANGE_LIST) {
-            if (!IsUintValueType(params[i].valueInfoType)) {
-              std::cerr << "[ERROR] Parameter(" << apname << ") of programmable(" << cname << ") cannot be set to uint values." << std::endl;
-              return false;
-            }
-            if (!range_params.empty()) {
-              std::cerr << "[ERROR] Multiple range parameters for programmable(" << cname << ") are not supported yet." << std::endl;
-              return false;
-            }
-            const U64RangeListAttribute *range_attr = dynamic_cast<const U64RangeListAttribute*>(aparam.get());
-            if (range_attr == nullptr) {
-              std::cerr << "[ERROR] Parameter(" << apname << ") of programmable(" << cname << ") has invalid value type." << std::endl;
-              return false;
-            }
-
-            // Validate every value up front so that an invalid value is reported, not passed to the driver.
-            uint64_t value = range_attr->getMin();
-            uint32_t value_count = 0;
-            do {
-              if (++value_count > max_range_values) {
-                std::cerr << "[ERROR] Parameter(" << apname << ") of programmable(" << cname << ") has more than " << max_range_values << " values." << std::endl;
-                return false;
-              }
-              if (!IsUintValueValid(params[i].valueInfoType, val_info, value)) {
-                std::cerr << "[ERROR] Value " << value << " of Parameter(" << apname << ") of programmable(" << cname << ") is not valid." << std::endl;
-                return false;
-              }
-            } while (range_attr->getNext(value, value));
-
-            SetUintValue(params[i].valueInfoType, range_attr->getMin(), vals[i]);
-            range_params.push_back({i, range_attr, range_attr->getMin()});
-            break;
-          }
-
-          std::string reason = SetParamValue(aparam, params[i], val_info, vals[i]);
-          if (!reason.empty()) {
-            std::cerr << "[ERROR] Parameter(" << apname << ") of programmable(" << cname << "): " << reason << std::endl;
-            return false;
-          }
-          break;
-        }
-        if (i == num_params) {
-          std::cerr << "[ERROR] Parameter(" << apname << ") of programmable(" << cname << ") not found." << std::endl;
-          return false;
-        }
-      }
-    }
-
-    // Create metrics for every value of the (at most one) range parameter.
-    while (true) {
-      uint32_t num_metrics = 0;
-      status = ZE_FUNC(zetMetricCreateFromProgrammableExp2)(programmable, num_params, vals.data(), prog_name, "prog description", &num_metrics, nullptr);
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Unable to create metrics from programmable(" << cname << ") (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        return false;
-      }
-      if (num_metrics == 0) {
-        std::cerr << "[WARNING] No metric was created for programmable(" << cname << ")." << std::endl;
-        return false;
-      }
-      size_t offset = m_all_progs_metrics_.size();
-      m_all_progs_metrics_.resize(offset + num_metrics);
-      status = ZE_FUNC(zetMetricCreateFromProgrammableExp2)(programmable, num_params, vals.data(), prog_name, "prog description", &num_metrics, m_all_progs_metrics_.data() + offset);
-      if (status != ZE_RESULT_SUCCESS) {
-        m_all_progs_metrics_.resize(offset);
-        std::cerr << "[ERROR] Unable to create metrics from programmable(" << cname << ") (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        return false;
-      }
-      m_all_progs_metrics_.resize(offset + num_metrics);
-
-      if (range_params.empty()) {
-        break;
-      }
-      uint64_t next = 0;
-      if (!range_params[0].range_attr->getNext(range_params[0].current, next)) {
-        break;
-      }
-      range_params[0].current = next;
-      SetUintValue(params[range_params[0].index].valueInfoType, next, vals[range_params[0].index]);
-    }
-
-    return true;
-  }
-
-  // Combines all created metrics into metric groups. The driver puts metrics whose
-  // hardware resources do not overlap into the same group, so conflicting metrics
-  // yield several groups, which CreateMetricGroups then rejects.
-  void createProgMetricGroups() {
-    std::vector<zet_metric_group_handle_t> groups_to_create;
-    if (m_all_progs_metrics_.size() == 0) {
-      return;
-    }
-    uint32_t num_metric_groups = 0;
-    ze_result_t status = ZE_FUNC(zetDeviceCreateMetricGroupsFromMetricsExp)(m_device_, m_all_progs_metrics_.size(), m_all_progs_metrics_.data(), "Progs_", "_Disposable", &num_metric_groups, nullptr);
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cerr << "[ERROR] Unable to create metric groups from programmable metrics (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-      return;
-    }
-    if (num_metric_groups != 0) {
-      groups_to_create.resize(num_metric_groups);
-      status = ZE_FUNC(zetDeviceCreateMetricGroupsFromMetricsExp)(m_device_, m_all_progs_metrics_.size(), m_all_progs_metrics_.data(), "Progs_", "_Disposable", &num_metric_groups, groups_to_create.data());
-      if (status != ZE_RESULT_SUCCESS) {
-        std::cerr << "[ERROR] Unable to create metric groups from programmable metrics (status = 0x" << std::hex << status << std::dec << ")" << std::endl;
-        return;
-      }
-      // Actual number of groups may be less than what previously reported for allocation purposes.
-      groups_to_create.resize(num_metric_groups);
-    }
-
-    for (auto group : groups_to_create) {
-      zet_metric_group_properties_t metric_group_props{};
-      metric_group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-      status = ZE_FUNC(zetMetricGroupGetProperties)(group, &metric_group_props);
-      // A group may support more than one sampling type; keep it if it supports the requested one.
-      if (status == ZE_RESULT_SUCCESS && (metric_group_props.samplingType & m_samplingType_) != 0) {
-        m_metric_groups_.push_back(group);
-      } else {
-        status = ZE_FUNC(zetMetricGroupDestroyExp)(group);
-        UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      }
-    }
-
-  }
-
- private:
-  // Upper bound on the values of a range parameter, i.e. on metrics created per programmable.
-  static constexpr uint32_t max_range_values = 4096;
-
-  // Default value of a parameter as config text. The default is a zet_value_t,
-  // which has no 8/16-bit members: those defaults are held in ui32.
-  static std::string DefaultValueString(const zet_metric_programmable_param_info_exp_t &param) {
-    const auto &v = param.defaultValue;
-    switch (param.valueInfoType) {
-      case ZET_VALUE_INFO_TYPE_EXP_UINT8:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT16:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT32:        return std::to_string(v.ui32);
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE:  return std::to_string(v.ui64);
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT32:       return config_node_detail::FormatDouble(v.fp32);
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT64:
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE: return config_node_detail::FormatDouble(v.fp64);
-      case ZET_VALUE_INFO_TYPE_EXP_BOOL8:         return v.b8 ? "true" : "false";
-      default:                                    return "?";
-    }
-  }
-
-  // Everything that makes up the "parameters" node of a template entry: name, type,
-  // default value and valid values of every parameter. Two programmables can share
-  // a node, or a config key, only if their signatures are equal.
-  static std::string ParamsSignature(const std::vector<zet_metric_programmable_param_info_exp_t> &params,
-                                     const std::vector<std::string> &descs) {
-    std::string sig;
-    for (size_t i = 0; i < params.size(); ++i) {
-      sig += std::string(params[i].name) + '\x1f' + std::to_string(params[i].valueInfoType) + '\x1f' +
-             std::to_string(params[i].valueInfoCount) + '\x1f' + DefaultValueString(params[i]) + '\x1f' +
-             (i < descs.size() ? descs[i] : std::string()) + '\x1e';
-    }
-    return sig;
-  }
-
-  static bool IsFloatValueType(zet_value_info_type_exp_t type) {
-    return type == ZET_VALUE_INFO_TYPE_EXP_FLOAT32 || type == ZET_VALUE_INFO_TYPE_EXP_FLOAT64 ||
-           type == ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE;
-  }
-
-  // An empty val_info means the driver did not report valid values; leave validation to the driver.
-  static bool IsFloatValueValid(zet_value_info_type_exp_t type,
-                                const std::vector<zet_metric_programmable_param_value_info_exp_t> &val_info,
-                                double value) {
-    if (val_info.empty()) {
-      return true;
-    }
-    for (const auto &vi : val_info) {
-      switch (type) {
-        case ZET_VALUE_INFO_TYPE_EXP_FLOAT32:
-          // compare in the parameter's precision: 0.1 in the file is 0.1f for a FLOAT32 parameter
-          if (vi.valueInfo.fp32 == static_cast<float>(value)) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_FLOAT64:
-          if (vi.valueInfo.fp64 == value) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE:
-          if (vi.valueInfo.fp64Range.fp64Min <= value && value <= vi.valueInfo.fp64Range.fp64Max) return true;
-          break;
-        default:
-          return false;
-      }
-    }
-    return false;
-  }
-
-  static bool IsUintValueType(zet_value_info_type_exp_t type) {
-    return type == ZET_VALUE_INFO_TYPE_EXP_UINT8 || type == ZET_VALUE_INFO_TYPE_EXP_UINT16 ||
-           type == ZET_VALUE_INFO_TYPE_EXP_UINT32 || type == ZET_VALUE_INFO_TYPE_EXP_UINT64 ||
-           type == ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE;
-  }
-
-  // An empty val_info means the driver did not report valid values; leave validation to the driver.
-  static bool IsUintValueValid(zet_value_info_type_exp_t type,
-                               const std::vector<zet_metric_programmable_param_value_info_exp_t> &val_info,
-                               uint64_t value) {
-    if ((type == ZET_VALUE_INFO_TYPE_EXP_UINT8 && value > UINT8_MAX) ||
-        (type == ZET_VALUE_INFO_TYPE_EXP_UINT16 && value > UINT16_MAX) ||
-        (type == ZET_VALUE_INFO_TYPE_EXP_UINT32 && value > UINT32_MAX)) {
-      return false;
-    }
-    if (val_info.empty()) {
-      return true;
-    }
-    for (const auto &vi : val_info) {
-      switch (type) {
-        case ZET_VALUE_INFO_TYPE_EXP_UINT8:
-          if (vi.valueInfo.ui8 == value) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_UINT16:
-          if (vi.valueInfo.ui16 == value) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_UINT32:
-          if (vi.valueInfo.ui32 == value) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_UINT64:
-          if (vi.valueInfo.ui64 == value) return true;
-          break;
-        case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE:
-          if (vi.valueInfo.ui64Range.ui64Min <= value && value <= vi.valueInfo.ui64Range.ui64Max) return true;
-          break;
-        default:
-          return false;
-      }
-    }
-    return false;
-  }
-
-  static void SetUintValue(zet_value_info_type_exp_t type, uint64_t value, zet_metric_programmable_param_value_exp_t &val) {
-    switch (type) {
-      case ZET_VALUE_INFO_TYPE_EXP_UINT8:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT16:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT32:
-        val.value.ui32 = static_cast<uint32_t>(value);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE:
-        val.value.ui64 = value;
-        break;
-      default:
-        UNITRACE_ASSERT(false && "Invalid value type for uint parameter");
-    }
-  }
-
-  static inline void addParam(const zet_metric_programmable_param_info_exp_t& param, ConfigNodePtr params_set, const std::string &value_range_desc = "") {
-    AttributePtr ap ;
-    switch (param.valueInfoType) {
-      case ZET_VALUE_INFO_TYPE_EXP_UINT8:   // zet_value_t holds 8/16-bit defaults in ui32
-      case ZET_VALUE_INFO_TYPE_EXP_UINT16:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT32:
-        ap = std::make_shared<UInt64Attribute>(param.name, param.defaultValue.ui32, value_range_desc);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64:
-      case ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE:
-        ap = std::make_shared<UInt64Attribute>(param.name, param.defaultValue.ui64, value_range_desc);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT32:
-          ap = std::make_shared<DoubleAttribute>(param.name, param.defaultValue.fp32, value_range_desc);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT64:
-      case ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE:
-        ap = std::make_shared<DoubleAttribute>(param.name, param.defaultValue.fp64, value_range_desc);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_BOOL8:
-        ap = std::make_shared<BoolAttribute>(param.name, param.defaultValue.b8 != 0, value_range_desc);
-        break;
-      case ZET_VALUE_INFO_TYPE_EXP_FORCE_UINT32:
-      default:
-        UNITRACE_ASSERT(!"Not supported value type");
-        return;
-    }
-    params_set->addAttribute(ap);
-  }
-
-  // The sampling types unitrace collects: event based (-q) and time based (-k).
-  // Entries supporting neither are left out of the template.
-  static constexpr zet_metric_group_sampling_type_flags_t kCollectableSamplingTypes =
-      ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED |
-      ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
-
-  static std::string getSupportedSamplingTypesDesc(zet_metric_group_sampling_type_flags_t samplingTypes) {
-    std::string str;
-
-    if (samplingTypes & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED) {
-      str += "event_based,";
-    }
-    if (samplingTypes & ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED) {
-      str += "time_based,";
-    }
-
-    UNITRACE_ASSERT(!str.empty());
-    str.pop_back(); // remove trailing comma
-    return "Supported sampling types: " + str;
-  }
-
-  // An entry is enabled only if it has "enable=true"; a missing attribute means disabled.
-  static inline bool IsNodeEnabled(const ConfigNodePtr cnode) {
-    auto attribute_enable = cnode->findAttributeByKey("enable");
-    if (attribute_enable != nullptr) {
-       BoolAttribute* bool_attr = dynamic_cast<BoolAttribute*>(attribute_enable.get());
-      if(bool_attr == nullptr) {
-        std::cerr << "[ERROR] Metric(" << cnode->getName() << ") has invalid \"enable\" attribute." << std::endl;
-        return false;
-      }
-
-      return bool_attr->getTypedValue();
-    }
-    return false;
-  }
-
-  // Sets val from a scalar config value. Returns "" on success, otherwise the reason.
-  // Integer parameters take unsigned integers, decimal parameters take decimals or
-  // unsigned integers, BOOL8 parameters take true/false. The value must be one of
-  // the reported valid values, or inside one of the reported intervals for *_RANGE
-  // types; if the driver reports no valid values, any value of the right type is
-  // passed on and the driver validates it. BOOL8 values are not checked against
-  // the reported values.
-  static std::string SetParamValue(const AttributePtr &aparam, const zet_metric_programmable_param_info_exp_t &info,
-                                   const std::vector<zet_metric_programmable_param_value_info_exp_t> &val_info,
-                                   zet_metric_programmable_param_value_exp_t &val) {
-    const zet_value_info_type_exp_t type = info.valueInfoType;
-
-    if (IsUintValueType(type)) {
-      auto attr = std::dynamic_pointer_cast<UInt64Attribute>(aparam);
-      if (attr == nullptr) {
-        return "expected an unsigned integer, found '" + aparam->getValue() + "'";
-      }
-      if (!IsUintValueValid(type, val_info, attr->getTypedValue())) {
-        return "value " + aparam->getValue() + " is not valid";
-      }
-      SetUintValue(type, attr->getTypedValue(), val);
-      return "";
-    }
-
-    if (IsFloatValueType(type)) {
-      double value = 0.0;
-      if (auto dattr = std::dynamic_pointer_cast<DoubleAttribute>(aparam)) {
-        value = dattr->getTypedValue();
-      } else if (auto uattr = std::dynamic_pointer_cast<UInt64Attribute>(aparam)) {
-        value = static_cast<double>(uattr->getTypedValue());
-      } else {
-        return "expected a decimal number, found '" + aparam->getValue() + "'";
-      }
-      if (!IsFloatValueValid(type, val_info, value)) {
-        return "value " + aparam->getValue() + " is not valid";
-      }
-      if (type == ZET_VALUE_INFO_TYPE_EXP_FLOAT32) {
-        val.value.fp32 = static_cast<float>(value);
-      } else {
-        val.value.fp64 = value;
-      }
-      return "";
-    }
-
-    if (type == ZET_VALUE_INFO_TYPE_EXP_BOOL8) {
-      auto battr = std::dynamic_pointer_cast<BoolAttribute>(aparam);
-      if (battr == nullptr) {
-        return "expected true or false, found '" + aparam->getValue() + "'";
-      }
-      val.value.b8 = battr->getTypedValue();
-      return "";
-    }
-
-    return "unsupported parameter type " + std::to_string(type);
-  }
-
-  static inline void FillDefaultVals(std::vector<zet_metric_programmable_param_info_exp_t> &params, std::vector<zet_metric_programmable_param_value_exp_t> &vals) {
-    UNITRACE_ASSERT(params.size() == vals.size());
-
-    for (uint32_t i = 0; i < params.size(); ++i) {
-      // no need to check the type, since union is copied to the same union
-      vals[i].value = params[i].defaultValue;
-    }
-  }
-
- private: //data
-  ze_device_handle_t m_device_;
-  zet_metric_group_sampling_type_flag_t m_samplingType_;
-  std::unordered_map<std::string, zet_metric_group_handle_t> m_predef_groups_;
-  struct ProgrammableRef {
-    zet_metric_programmable_exp_handle_t handle;
-    uint32_t parameterCount;
-    std::string name;
-  };
-  std::unordered_map<std::string, ProgrammableRef> m_programmables_;  // keyed by config key
-  std::vector<zet_metric_handle_t> m_all_progs_metrics_;  // created metrics, owned
-  // Selected groups: [0, m_prog_groups_start_) are predefined groups owned by the
-  // driver; [m_prog_groups_start_, end) are created groups owned by this object.
-  // The destructor relies on this order to destroy only the created groups.
-  std::vector<zet_metric_group_handle_t> m_metric_groups_;
-  uint32_t m_prog_groups_start_;
-}; //class ZeMetricsManager
-
-#endif // PTI_TOOLS_UNITRACE_METRICS_CONFIG_H_
-
diff --git a/tools/unitrace/src/mpi/mpi.c b/tools/unitrace/src/mpi/mpi.c
deleted file mode 100644
index 0b8ba36e..00000000
--- a/tools/unitrace/src/mpi/mpi.c
+++ /dev/null
@@ -1,1141 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <ittnotify.h>
-#include <mpi.h>
-#include <stdlib.h>
-
-enum {
-    MPI_TASK_SEND,
-    MPI_TASK_RECV,
-    MPI_TASK_ISEND,
-    MPI_TASK_IRECV,
-    MPI_TASK_WAIT,
-    MPI_TASK_TEST,
-    MPI_TASK_WAITANY,
-    MPI_TASK_TESTANY,
-    MPI_TASK_WAITALL,
-    MPI_TASK_TESTALL,
-    MPI_TASK_WAITSOME,
-    MPI_TASK_TESTSOME,
-    MPI_TASK_IPROBE,
-    MPI_TASK_PROBE,
-    MPI_TASK_SENDRECV,
-    MPI_TASK_SENDRECV_REPLACE,
-    MPI_TASK_INIT,
-    MPI_TASK_INIT_THREAD,
-    MPI_TASK_FINALIZE,
-    MPI_TASK_BARRIER,
-    MPI_TASK_BCAST,
-    MPI_TASK_GATHER,
-    MPI_TASK_GATHERV,
-    MPI_TASK_SCATTER,
-    MPI_TASK_SCATTERV,
-    MPI_TASK_ALLGATHER,
-    MPI_TASK_ALLGATHERV,
-    MPI_TASK_ALLTOALL,
-    MPI_TASK_ALLTOALLV,
-    MPI_TASK_REDUCE,
-    MPI_TASK_ALLREDUCE,
-    MPI_TASK_REDUCE_SCATTER,
-    MPI_TASK_GET,
-    MPI_TASK_PUT,
-    MPI_TASK_IALLGATHERV,
-    MPI_TASK_IALLREDUCE,
-    MPI_TASK_IALLTOALL,
-    MPI_TASK_IALLTOALLV,
-    MPI_TASK_IBARRIER,
-    MPI_TASK_IBCAST,
-    MPI_TASK_IREDUCE,
-    MPI_TASK_IREDUCE_SCATTER_BLOCK,
-    MPI_TASK_WIN_CREATE,
-    MPI_TASK_WIN_FENCE,
-    MPI_TASK_WIN_FREE,
-    MPI_TASK_WIN_LOCK,
-    MPI_TASK_WIN_UNLOCK,
-    MPI_TASK_WIN_LOCK_ALL,
-    MPI_TASK_WIN_UNLOCK_ALL,
-    MPI_TASK_WIN_FLUSH,
-    MPI_TASK_WIN_FLUSH_ALL,
-    MPI_TASK_WIN_FLUSH_LOCAL,
-    MPI_TASK_WIN_FLUSH_LOCAL_ALL,
-    MPI_TASK_WIN_SYNC,
-    MPI_TASK_CANCEL,
-    MPI_TASK_COMM_CREATE_GROUP,
-    MPI_TASK_COMM_FREE,
-    MPI_TASK_COMM_GET_ATTR,
-    MPI_TASK_COMM_GET_INFO,
-    MPI_TASK_COMM_GROUP,
-    MPI_TASK_COMM_RANK,
-    MPI_TASK_COMM_SET_INFO,
-    MPI_TASK_COMM_SIZE,
-    MPI_TASK_COMM_SPLIT,
-    MPI_TASK_COMM_SPLIT_TYPE,
-    MPI_TASK_ERROR_STRING,
-    MPI_TASK_FINALIZED,
-    MPI_TASK_GET_COUNT,
-    MPI_TASK_GET_LIBRARY_VERSION,
-    MPI_TASK_GROUP_INCL,
-    MPI_TASK_INFO_CREATE,
-    MPI_TASK_INFO_FREE,
-    MPI_TASK_INFO_GET,
-    MPI_TASK_INFO_SET,
-    MPI_TASK_INITIALIZED,
-    MPI_TASK_OP_CREATE,
-    MPI_TASK_OP_FREE,
-    MPI_TASK_QUERY_THREAD,
-    MPI_TASK_REDUCE_SCATTER_BLOCK,
-    MPI_TASK_TYPE_COMMIT,
-    MPI_TASK_TYPE_CONTIGUOUS,
-    MPI_TASK_TYPE_FREE,
-    MPI_TASK_INTERNAL,
-    MPI_TASK_NUM
-};
-
-const char *mpi_task_names[MPI_TASK_NUM] = {
-    "MPI_Send",
-    "MPI_Recv",
-    "MPI_Isend",
-    "MPI_Irecv",
-    "MPI_Wait",
-    "MPI_Test",
-    "MPI_Waitany",
-    "MPI_Testany",
-    "MPI_Waitall",
-    "MPI_Testall",
-    "MPI_Waitsome",
-    "MPI_Testsome",
-    "MPI_Iprobe",
-    "MPI_Probe",
-    "MPI_Sendrecv",
-    "MPI_Sendrecv_replace",
-    "MPI_Init",
-    "MPI_Init_thread",
-    "MPI_Finalize",
-    "MPI_Barrier",
-    "MPI_Bcast",
-    "MPI_Gather",
-    "MPI_Gatherv",
-    "MPI_Scatter",
-    "MPI_Scatterv",
-    "MPI_Allgather",
-    "MPI_Allgatherv",
-    "MPI_Alltoall",
-    "MPI_Alltoallv",
-    "MPI_Reduce",
-    "MPI_Allreduce",
-    "MPI_Reeduce_scatter",
-    "MPI_Get",
-    "MPI_Put",
-    "MPI_Iallgatherv",
-    "MPI_Iallreduce",
-    "MPI_Ialltoall",
-    "MPI_Ialltoallv",
-    "MPI_Ibarrier",
-    "MPI_Ibcast",
-    "MPI_Ireduce",
-    "MPI_Ireduce_scatter_block",
-    "MPI_Win_create",
-    "MPI_Win_fence",
-    "MPI_Win_free",
-    "MPI_Win_lock",
-    "MPI_Win_unlock",
-    "MPI_Win_lock_all",
-    "MPI_Win_unlock_all",
-    "MPI_Win_flush",
-    "MPI_Win_flush_all",
-    "MPI_Win_flush_local",
-    "MPI_Win_flush_local_all",
-    "MPI_Win_sync",
-    "MPI_Cancel",
-    "MPI_Comm_create_group",
-    "MPI_Comm_free",
-    "MPI_Comm_get_attr",
-    "MPI_Comm_get_info",
-    "MPI_Comm_group",
-    "MPI_Comm_rank",
-    "MPI_Comm_set_info",
-    "MPI_Comm_size",
-    "MPI_Comm_split",
-    "MPI_Comm_split_type",
-    "MPI_Error_string",
-    "MPI_Finalized",
-    "MPI_Get_count",
-    "MPI_Get_library_version",
-    "MPI_Group_incl",
-    "MPI_Info_create",
-    "MPI_Info_free",
-    "MPI_Info_get",
-    "MPI_Info_set",
-    "MPI_Initialized",
-    "MPI_Op_create",
-    "MPI_Op_free",
-    "MPI_Query_thread",
-    "MPI_Reduce_scatter_block",
-    "MPI_Type_commit",
-    "MPI_Type_contiguous",
-    "MPI_Type_free",
-    "MPI_Internal_operation"
-};
-
-__itt_domain *mpi_domain = NULL;
-__itt_string_handle *mpi_task_handles[MPI_TASK_NUM] = { 0 };
-
-#define INTERNAL_SIZE_INITIAL 16
-struct _MPI_Internal_operation {
-    int size;
-    int current;
-    __itt_string_handle **handle;
-};
-
-struct _MPI_Internal_operation internal_operations = { 0, 0, NULL };
-
-extern void __itt_task_end_internal_ex_info(const __itt_domain *domain,
-                                     size_t src_size, int src_location, int src_tag,
-                                     size_t dst_size, int dst_location, int dst_tag);
-
-extern void __itt_task_end_internal_callback_info(const __itt_domain *domain,
-                                     int64_t mpi_counter,  size_t src_size, size_t dst_size);
-
-#define ITT_BEGIN(_MPI_ID) { \
-	__itt_task_begin(mpi_domain, __itt_null, __itt_null, mpi_task_handles[_MPI_ID]); \
-	}
-
-#define ITT_END(_MPI_ID) { \
-	__itt_task_end(mpi_domain); \
-	}
-
-#define ITT_END_MPI_EX_INFO(_MPI_ID, data_size1, location1 , tag1, data_size2, location2 , tag2){\
-    __itt_task_end_internal_ex_info(mpi_domain, data_size1, location1 , tag1, data_size2, location2 , tag2); \
-}
-
-
-#define ITT_BEGIN_MPI_INTERNAL(_MPI_ID_INTERNAL) { \
-    __itt_string_handle *h =  mpi_task_handles[MPI_TASK_INTERNAL]; \
-    if ((_MPI_ID_INTERNAL < internal_operations.current) && (_MPI_ID_INTERNAL >= 0)) { \
-        h = internal_operations.handle[_MPI_ID_INTERNAL]; \
-    } \
-    __itt_task_begin(mpi_domain, __itt_null, __itt_null, h); \
-}
-
-#define ITT_END_MPI_INTERNAL(operation, mpi_counter, src_size, dst_size){ \
-    __itt_task_end_internal_callback_info(mpi_domain, mpi_counter, src_size, dst_size); \
-}
-
-int  _MPI_Internal_register_operation_name(const char*name) __attribute__((visibility ("default")));
-void _MPI_Internal_task_start_hook(int operation) __attribute__((visibility ("default")));
-void _MPI_Internal_task_stop_hook(int operation, int64_t mpi_counter, size_t src_size, size_t dst_szie) __attribute__((visibility ("default")));
-
-void _MPI_Internal_task_start_hook(int operation)
-{
-    ITT_BEGIN_MPI_INTERNAL(operation);
-}
-
-void _MPI_Internal_task_stop_hook(int operation, int64_t mpi_counter, size_t src_size, size_t dst_szie)
-{
-    ITT_END_MPI_INTERNAL(operation, mpi_counter, src_size, dst_szie);
-}
-
-int _MPI_Internal_register_operation_name(const char *name)
-{
-    if (internal_operations.size == 0) {
-        internal_operations.size = INTERNAL_SIZE_INITIAL;
-        internal_operations.handle = ( __itt_string_handle **)malloc(internal_operations.size * sizeof(__itt_string_handle *));
-    } else if (internal_operations.current == internal_operations.size) {
-        internal_operations.size *= 2;
-        internal_operations.handle = ( __itt_string_handle **)realloc(internal_operations.handle, internal_operations.size * sizeof(__itt_string_handle *));
-    }
-    internal_operations.handle[internal_operations.current] = __itt_string_handle_create(name);
-    internal_operations.current++;
-    return internal_operations.current - 1;
-}
-
-
-int MPI_Send(const void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_SEND);
-    result = PMPI_Send(buf, count, datatype, dest, tag, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_SEND, 0, -1 , -1, count*sizeof(datatype), dest, tag);
-    return result;
-}
-
-int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source, int tag,
-             MPI_Comm comm, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_RECV);
-    result = PMPI_Recv(buf, count, datatype, source, tag, comm, status);
-    ITT_END_MPI_EX_INFO(MPI_TASK_RECV, count*sizeof(datatype), source, tag, 0, -1 , -1 );
-    return result;
-}
-
-int MPI_Isend(const void *buf, int count, MPI_Datatype datatype, int dest, int tag,
-              MPI_Comm comm, MPI_Request * request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ISEND);
-    result = PMPI_Isend(buf, count, datatype, dest, tag, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ISEND,  0, -1 , -1, count*sizeof(datatype), dest, tag);
-    return result;
-}
-
-int MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag,
-              MPI_Comm comm, MPI_Request * request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IRECV);
-    result = PMPI_Irecv(buf, count, datatype, source, tag, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IRECV, count*sizeof(datatype), source, tag, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Wait(MPI_Request * request, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WAIT);
-    result = PMPI_Wait(request, status);
-    ITT_END(MPI_TASK_WAIT);
-    return result;
-}
-
-int MPI_Test(MPI_Request * request, int *flag, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TEST);
-    result = PMPI_Test(request, flag, status);
-    ITT_END(MPI_TASK_TEST);
-    return result;
-}
-
-int MPI_Waitany(int count, MPI_Request array_of_requests[], int *indx, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WAITANY);
-    result = PMPI_Waitany(count, array_of_requests, indx, status);
-    ITT_END(MPI_TASK_WAITANY);
-    return result;
-}
-
-int MPI_Testany(int count, MPI_Request array_of_requests[], int *indx, int *flag,
-                MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TESTANY);
-    result = PMPI_Testany(count, array_of_requests, indx, flag, status);
-    ITT_END(MPI_TASK_TESTANY);
-    return result;
-}
-
-int MPI_Waitall(int count, MPI_Request array_of_requests[], MPI_Status array_of_statuses[])
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WAITALL);
-    result = PMPI_Waitall(count, array_of_requests, array_of_statuses);
-    ITT_END(MPI_TASK_WAITALL);
-    return result;
-}
-
-int MPI_Testall(int count, MPI_Request array_of_requests[], int *flag,
-                MPI_Status array_of_statuses[])
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TESTALL);
-    result = PMPI_Testall(count, array_of_requests, flag, array_of_statuses);
-    ITT_END(MPI_TASK_TESTALL);
-    return result;
-}
-
-int MPI_Waitsome(int incount, MPI_Request array_of_requests[], int *outcount,
-                 int array_of_indices[], MPI_Status array_of_statuses[])
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WAITSOME);
-    result =
-        PMPI_Waitsome(incount, array_of_requests, outcount, array_of_indices, array_of_statuses);
-    ITT_END(MPI_TASK_WAITSOME);
-    return result;
-}
-
-int MPI_Testsome(int incount, MPI_Request array_of_requests[], int *outcount,
-                 int array_of_indices[], MPI_Status array_of_statuses[])
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TESTSOME);
-    result = PMPI_Testsome(incount, array_of_requests, outcount,
-                           array_of_indices, array_of_statuses);
-    ITT_END(MPI_TASK_TESTSOME);
-    return result;
-}
-
-int MPI_Iprobe(int source, int tag, MPI_Comm comm, int *flag, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IPROBE);
-    result = PMPI_Iprobe(source, tag, comm, flag, status);
-    ITT_END(MPI_TASK_IPROBE);
-    return result;
-}
-
-int MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_PROBE);
-    result = PMPI_Probe(source, tag, comm, status);
-    ITT_END(MPI_TASK_PROBE);
-    return result;
-}
-
-int MPI_Sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype, int dest,
-                 int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype,
-                 int source, int recvtag, MPI_Comm comm, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_SENDRECV);
-    result = PMPI_Sendrecv(sendbuf, sendcount, sendtype, dest,
-                           sendtag, recvbuf, recvcount, recvtype, source, recvtag, comm, status);
-    ITT_END_MPI_EX_INFO(MPI_TASK_SENDRECV, sendcount*sizeof(sendtype), dest, sendtag, recvcount*sizeof(recvtype), source, recvtag );
-    return result;
-}
-
-int MPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dest,
-                         int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status * status)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_SENDRECV_REPLACE);
-    result = PMPI_Sendrecv_replace(buf, count, datatype, dest,
-                                   sendtag, source, recvtag, comm, status);
-    ITT_END_MPI_EX_INFO(MPI_TASK_SENDRECV_REPLACE, 0, source, recvtag, count*sizeof(datatype), dest, sendtag);
-    return result;
-}
-
-int MPI_Init(int *argc, char ***argv)
-{
-    int result = 0;
-
-    mpi_domain = __itt_domain_create("MPI");
-
-    int i = 0;
-
-    for (i = 0; i < MPI_TASK_NUM; i++) {
-        mpi_task_handles[i] = __itt_string_handle_create(mpi_task_names[i]);
-    }
-
-    ITT_BEGIN(MPI_TASK_INIT);
-    result = PMPI_Init(argc, argv);
-    ITT_END(MPI_TASK_INIT);
-    return result;
-}
-
-int MPI_Init_thread(int *argc, char ***argv, int required, int *provided)
-{
-    int result = 0;
-
-    mpi_domain = __itt_domain_create("MPI");
-
-    int i = 0;
-
-    for (i = 0; i < MPI_TASK_NUM; i++) {
-        mpi_task_handles[i] = __itt_string_handle_create(mpi_task_names[i]);
-    }
-
-    ITT_BEGIN(MPI_TASK_INIT_THREAD);
-    result = PMPI_Init_thread(argc, argv, required, provided);
-    ITT_END(MPI_TASK_INIT_TRHEAD);
-    return result;
-}
-
-int MPI_Finalize(void)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_FINALIZE);
-    result = PMPI_Finalize();
-    ITT_END(MPI_TASK_FINALIZE);
-    return result;
-}
-
-int MPI_Barrier(MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_BARRIER);
-    result = PMPI_Barrier(comm);
-    ITT_END(MPI_TASK_BARRIER);
-    return result;
-}
-
-int MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_BCAST);
-    result = PMPI_Bcast(buffer, count, datatype, root, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_BCAST, count*sizeof(datatype), root , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Gather(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-               int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GATHER);
-    result = PMPI_Gather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    if(curr_rank == root) {
-        int size;
-        PMPI_Comm_size(comm, &size);
-        ITT_END_MPI_EX_INFO(MPI_TASK_GATHER, sendcount*sizeof(sendtype), -1, -1, recvcount*sizeof(recvtype)*size, root, -1);
-    } else {
-        ITT_END_MPI_EX_INFO(MPI_TASK_GATHER, sendcount*sizeof(sendtype), root, -1, 0, -1, -1);
-    }
-    return result;
-}
-
-int MPI_Gatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                const int *recvcounts, const int *displs, MPI_Datatype recvtype, int root,
-                MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GATHERV);
-    result = PMPI_Gatherv(sendbuf, sendcount, sendtype, recvbuf,
-                          recvcounts, displs, recvtype, root, comm);
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    if(curr_rank == root) {
-        int no_of_element = 0;
-        int size = 0;
-        PMPI_Comm_size(comm, &size);
-        for (int i=0; i<size; ++i) {
-            no_of_element += recvcounts[i];
-        }
-        ITT_END_MPI_EX_INFO(MPI_TASK_GATHER, sendcount*sizeof(sendtype), -1, -1, no_of_element*sizeof(recvtype), root, -1);
-    } else {
-        ITT_END_MPI_EX_INFO(MPI_TASK_GATHER, sendcount*sizeof(sendtype), root, -1, 0, -1, -1);
-    }
-    return result;
-}
-
-int MPI_Scatter(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_SCATTER);
-    result = PMPI_Scatter(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, root, comm);
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    if(curr_rank != root) {
-        ITT_END_MPI_EX_INFO(MPI_TASK_SCATTER, 0, -1, -1, recvcount*sizeof(recvtype), root, -1);
-    } else {
-        int size;
-        PMPI_Comm_size(comm, &size);
-        ITT_END_MPI_EX_INFO(MPI_TASK_SCATTER, sendcount*sizeof(sendtype)*size, root, -1, recvcount*sizeof(recvtype), -1, -1);
-    }
-    return result;
-}
-
-int MPI_Scatterv(const void *sendbuf, const int *sendcounts, const int *displs,
-                 MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype,
-                 int root, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_SCATTERV);
-    result = PMPI_Scatterv(sendbuf, sendcounts, displs,
-                           sendtype, recvbuf, recvcount, recvtype, root, comm);
-
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    if (curr_rank != root){
-        ITT_END_MPI_EX_INFO(MPI_TASK_SCATTERV, 0, -1, -1, recvcount*sizeof(recvtype), root, -1);
-    }else {
-        int no_of_element = 0;
-        int size = 0;
-        PMPI_Comm_size(comm, &size);
-        for (int i=0; i<size; ++i) {
-            no_of_element += sendcounts[i];
-        }
-        ITT_END_MPI_EX_INFO(MPI_TASK_SCATTERV, no_of_element*sizeof(sendtype), curr_rank, -1, recvcount*sizeof(recvtype), curr_rank, -1);
-    }
-    return result;
-}
-
-int MPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                  int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ALLGATHER);
-    result = PMPI_Allgather(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ALLGATHER, sendcount*sizeof(sendtype), -1, -1, recvcount*sizeof(recvtype), -1, -1);
-    return result;
-}
-
-int MPI_Allgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                   const int *recvcounts, const int *displs, MPI_Datatype recvtype, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ALLGATHERV);
-    result = PMPI_Allgatherv(sendbuf, sendcount, sendtype, recvbuf,
-                             recvcounts, displs, recvtype, comm);
-
-    int no_of_element = 0;
-    int size = 0;
-    PMPI_Comm_size(comm, &size);
-    for (int i=0; i<size; ++i) {
-        no_of_element += recvcounts[i];
-    }
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ALLGATHERV, sendcount*sizeof(sendtype), curr_rank, -1, no_of_element*sizeof(recvtype), curr_rank, -1);
-    return result;
-}
-
-int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
-                 void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ALLTOALL);
-    result = PMPI_Alltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ALLTOALL, sendcount*sizeof(sendtype), -1, -1, recvcount*sizeof(recvtype), -1, -1);
-    return result;
-}
-
-int MPI_Alltoallv(const void *sendbuf, const int *sendcounts,
-                  const int *sdispls, MPI_Datatype sendtype, void *recvbuf,
-                  const int *recvcounts, const int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ALLTOALLV);
-    result = PMPI_Alltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf,
-                            recvcounts, rdispls, recvtype, comm);
-    int no_of_recv_element = 0;
-    int no_of_send_element = 0;
-    int size = 0;
-    PMPI_Comm_size(comm, &size);
-    for (int i=0; i<size; ++i) {
-        no_of_recv_element += recvcounts[i];
-        no_of_send_element += sendcounts[i];
-    }
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ALLTOALLV, no_of_send_element*sizeof(sendtype), curr_rank, -1, no_of_recv_element*sizeof(recvtype), curr_rank, -1);
-    return result;
-}
-
-int MPI_Reduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
-               MPI_Op op, int root, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_REDUCE);
-    result = PMPI_Reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_REDUCE, count*sizeof(datatype), root , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Allreduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype,
-                  MPI_Op op, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ALLREDUCE);
-    result = PMPI_Allreduce(sendbuf, recvbuf, count, datatype, op, comm);
-    ITT_END_MPI_EX_INFO(MPI_TASK_ALLREDUCE, count*sizeof(datatype), -1 , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Reduce_scatter(const void *sendbuf, void *recvbuf, const int recvcounts[],
-                       MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_REDUCE_SCATTER);
-    result = PMPI_Reduce_scatter(sendbuf, recvbuf, recvcounts, datatype, op, comm);
-    ITT_END(MPI_TASK_REDUCE_SCATTER);
-    return result;
-}
-
-int MPI_Get(void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
-            int target_rank, MPI_Aint target_disp, int target_count,
-            MPI_Datatype target_datatype, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GET);
-    result = PMPI_Get(origin_addr, origin_count, origin_datatype,
-                      target_rank, target_disp, target_count, target_datatype, win);
-    ITT_END_MPI_EX_INFO(MPI_TASK_GET, origin_count*sizeof(origin_datatype), target_rank, -1, target_count*sizeof(target_datatype), -1, -1);
-    return result;
-}
-
-int MPI_Put(const void *origin_addr, int origin_count, MPI_Datatype origin_datatype,
-            int target_rank, MPI_Aint target_disp, int target_count,
-            MPI_Datatype target_datatype, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_PUT);
-    result = PMPI_Put(origin_addr, origin_count, origin_datatype,
-                      target_rank, target_disp, target_count, target_datatype, win);
-    ITT_END_MPI_EX_INFO(MPI_TASK_PUT, origin_count*sizeof(origin_datatype), target_rank, -1, target_count*sizeof(target_datatype), -1, -1);
-    return result;
-}
-
-int MPI_Iallgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                    const int recvcounts[], const int displs[], MPI_Datatype recvtype,
-                    MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IALLGATHERV);
-    result = PMPI_Iallgatherv(sendbuf, sendcount, sendtype, recvbuf,
-                    recvcounts, displs, recvtype, comm, request);
-    int no_of_recv_element = 0;
-    int size = 0;
-    PMPI_Comm_size(comm, &size);
-    for (int i=0; i<size; ++i) {
-        no_of_recv_element += recvcounts[i];
-    }
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IALLGATHERV, sendcount*sizeof(sendtype), curr_rank, -1, no_of_recv_element*sizeof(recvtype), curr_rank, -1);
-    return result;
-}
-
-int MPI_Iallreduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
-                   MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IALLREDUCE);
-    result = PMPI_Iallreduce(sendbuf, recvbuf, count, datatype, op, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IALLREDUCE, count*sizeof(datatype), -1 , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Ialltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf,
-                  int recvcount, MPI_Datatype recvtype, MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IALLTOALL);
-    result = PMPI_Ialltoall(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IALLTOALL, sendcount*sizeof(sendtype), -1, -1, recvcount*sizeof(recvtype), -1, -1);
-    return result;
-}
-
-int MPI_Ialltoallv(const void *sendbuf, const int sendcounts[], const int sdispls[],
-                   MPI_Datatype sendtype, void *recvbuf, const int recvcounts[],
-                   const int rdispls[], MPI_Datatype recvtype, MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IALLTOALLV);
-    result = PMPI_Ialltoallv(sendbuf, sendcounts, sdispls, sendtype, recvbuf,
-                            recvcounts, rdispls, recvtype, comm, request);
-
-    int no_of_recv_element = 0;
-    int no_of_send_element = 0;
-    int size = 0;
-    PMPI_Comm_size(comm, &size);
-    for (int i=0; i<size; ++i) {
-        no_of_recv_element += recvcounts[i];
-        no_of_send_element += sendcounts[i];
-    }
-    int curr_rank;
-    PMPI_Comm_rank(comm, &curr_rank);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IALLTOALLV, no_of_send_element*sizeof(sendtype), curr_rank, -1, no_of_recv_element*sizeof(recvtype), curr_rank, -1);
-    return result;
-}
-
-int MPI_Ibarrier(MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IBARRIER);
-    result = PMPI_Ibarrier(comm, request);
-    ITT_END(MPI_TASK_IBARRIER);
-    return result;
-}
-
-int MPI_Ibcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm,
-               MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IBCAST);
-    result = PMPI_Ibcast(buffer, count, datatype, root, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IBCAST, count*sizeof(datatype), root , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Ireduce(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op,
-                int root, MPI_Comm comm, MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IREDUCE);
-    result = PMPI_Ireduce(sendbuf, recvbuf, count, datatype, op, root, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IREDUCE, count*sizeof(datatype), root , -1, 0, -1 , -1);
-    return result;
-}
-
-int MPI_Ireduce_scatter_block(const void *sendbuf, void *recvbuf, int recvcount,
-                              MPI_Datatype datatype, MPI_Op op, MPI_Comm comm,
-                              MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_IREDUCE_SCATTER_BLOCK);
-    result = PMPI_Ireduce_scatter_block(sendbuf, recvbuf, recvcount, datatype, op, comm, request);
-    ITT_END_MPI_EX_INFO(MPI_TASK_IREDUCE_SCATTER_BLOCK, 0, -1, -1, recvcount*sizeof(datatype), -1 , -1);
-    return result;
-}
-
-int MPI_Win_create(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm,
-                   MPI_Win * win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_CREATE);
-    result = PMPI_Win_create(base, size, disp_unit, info, comm, win);
-    ITT_END(MPI_TASK_WIN_CREATE);
-    return result;
-}
-
-int MPI_Win_fence(int assert, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FENCE);
-    result = PMPI_Win_fence(assert, win);
-    ITT_END(MPI_TASK_WIN_FENCE);
-    return result;
-}
-
-int MPI_Win_free(MPI_Win * win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FREE);
-    result = PMPI_Win_free(win);
-    ITT_END(MPI_TASK_WIN_FREE);
-    return result;
-}
-
-int MPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_LOCK);
-    result = PMPI_Win_lock(lock_type, rank, assert, win);
-    ITT_END(MPI_TASK_WIN_LOCK);
-    return result;
-}
-
-int MPI_Win_unlock(int rank, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_UNLOCK);
-    result = PMPI_Win_unlock(rank, win);
-    ITT_END(MPI_TASK_WIN_UNLOCK);
-    return result;
-}
-
-int MPI_Win_lock_all(int assert, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_LOCK_ALL);
-    result = PMPI_Win_lock_all(assert, win);
-    ITT_END(MPI_TASK_WIN_LOCK_ALL);
-    return result;
-}
-
-int MPI_Win_unlock_all(MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_UNLOCK_ALL);
-    result = PMPI_Win_unlock_all(win);
-    ITT_END(MPI_TASK_WIN_UNLOCK_ALL);
-    return result;
-}
-
-int MPI_Win_flush(int rank, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FLUSH);
-    result = PMPI_Win_flush(rank, win);
-    ITT_END(MPI_TASK_WIN_FLUSH);
-    return result;
-}
-
-int MPI_Win_flush_all(MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FLUSH_ALL);
-    result = PMPI_Win_flush_all(win);
-    ITT_END(MPI_TASK_WIN_FLUSH_ALL);
-    return result;
-}
-
-int MPI_Win_flush_local(int rank, MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FLUSH_LOCAL);
-    result = PMPI_Win_flush_local(rank, win);
-    ITT_END(MPI_TASK_WIN_FLUSH_LOCAL);
-    return result;
-}
-
-int MPI_Win_flush_local_all(MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_FLUSH_LOCAL_ALL);
-    result = PMPI_Win_flush_local_all(win);
-    ITT_END(MPI_TASK_WIN_FLUSH_LOCAL_ALL);
-    return result;
-}
-
-int MPI_Win_sync(MPI_Win win)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_WIN_SYNC);
-    result = PMPI_Win_sync(win);
-    ITT_END(MPI_TASK_WIN_SYNC);
-    return result;
-}
-
-int MPI_Cancel(MPI_Request *request)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_CANCEL);
-    result = PMPI_Cancel(request);
-    ITT_END(MPI_TASK_CANCEL);
-    return result;
-}
-
-int MPI_Comm_create_group(MPI_Comm comm, MPI_Group group, int tag, MPI_Comm * newcomm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_CREATE_GROUP);
-    result = PMPI_Comm_create_group(comm, group, tag, newcomm);
-    ITT_END(MPI_TASK_COMM_CREATE_GROUP);
-    return result;
-}
-
-int MPI_Comm_free(MPI_Comm *comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_FREE);
-    result = PMPI_Comm_free(comm);
-    ITT_END(MPI_TASK_COMM_FREE);
-    return result;
-}
-
-int MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_GET_ATTR);
-    result = PMPI_Comm_get_attr(comm, comm_keyval, attribute_val, flag);
-    ITT_END(MPI_TASK_COMM_GET_ATTR);
-    return result;
-}
-
-int MPI_Comm_get_info(MPI_Comm comm, MPI_Info * info_used)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_GET_INFO);
-    result = PMPI_Comm_get_info(comm, info_used);
-    ITT_END(MPI_TASK_COMM_GET_INFO);
-    return result;
-}
-
-int MPI_Comm_group(MPI_Comm comm, MPI_Group * group)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_GROUP);
-    result = PMPI_Comm_group(comm, group);
-    ITT_END(MPI_TASK_COMM_GROUP);
-    return result;
-}
-
-int MPI_Comm_rank(MPI_Comm comm, int *rank)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_RANK);
-    result = PMPI_Comm_rank(comm, rank);
-    ITT_END(MPI_TASK_COMM_RANK);
-    return result;
-}
-
-int MPI_Comm_set_info(MPI_Comm comm, MPI_Info info)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_SET_INFO);
-    result = PMPI_Comm_set_info(comm, info);
-    ITT_END(MPI_TASK_COMM_SET_INFO);
-    return result;
-}
-
-int MPI_Comm_size(MPI_Comm comm, int *size)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_SIZE);
-    result = PMPI_Comm_size(comm, size);
-    ITT_END(MPI_TASK_COMM_SIZE);
-    return result;
-}
-
-int MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm * newcomm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_SPLIT);
-    result = PMPI_Comm_split(comm, color, key, newcomm);
-    ITT_END(MPI_TASK_COMM_SPLIT);
-    return result;
-}
-
-int MPI_Comm_split_type(MPI_Comm comm, int split_type, int key, MPI_Info info, MPI_Comm * newcomm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_COMM_SPLIT_TYPE);
-    result = PMPI_Comm_split_type(comm, split_type, key, info, newcomm);
-    ITT_END(MPI_TASK_COMM_SPLIT_TYPE);
-    return result;
-}
-
-int MPI_Error_string(int errorcode, char *string, int *resultlen)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_ERROR_STRING);
-    result = PMPI_Error_string(errorcode, string, resultlen);
-    ITT_END(MPI_TASK_ERROR_STRING);
-    return result;
-}
-
-int MPI_Finalized(int *flag)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_FINALIZED);
-    result = PMPI_Finalized(flag);
-    ITT_END(MPI_TASK_FIANLIZED);
-    return result;
-}
-
-int MPI_Get_count(const MPI_Status *status, MPI_Datatype datatype, int *count)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GET_COUNT);
-    result = PMPI_Get_count(status, datatype, count);
-    ITT_END(MPI_TASK_GET_COUNT);
-    return result;
-}
-
-int MPI_Get_library_version(char *version, int *resultlen)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GET_LIBRARY_VERSION);
-    result = PMPI_Get_library_version(version, resultlen);
-    ITT_END(MPI_TASK_GET_LIBRARY_VERSION);
-    return result;
-}
-
-int MPI_Group_incl(MPI_Group group, int n, const int ranks[], MPI_Group *newgroup)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_GROUP_INCL);
-    result = PMPI_Group_incl(group, n, ranks, newgroup);
-    ITT_END(MPI_TASK_GROUP_INCL);
-    return result;
-}
-
-int MPI_Info_create(MPI_Info *info)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_INFO_CREATE);
-    result = PMPI_Info_create(info);
-    ITT_END(MPI_TASK_INFO_CREATE);
-    return result;
-}
-
-int MPI_Info_free(MPI_Info *info)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_INFO_FREE);
-    result = PMPI_Info_free(info);
-    ITT_END(MPI_TASK_INFO_FREE);
-    return result;
-}
-
-int MPI_Info_get(MPI_Info info, const char *key, int valuelen, char *value, int *flag)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_INFO_GET);
-    result = PMPI_Info_get(info, key, valuelen, value, flag);
-    ITT_END(MPI_TASK_INFO_GET);
-    return result;
-}
-
-int MPI_Info_set(MPI_Info info, const char *key, const char *value)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_INFO_SET);
-    result = PMPI_Info_set(info, key, value);
-    ITT_END(MPI_TASK_INFO_SET);
-    return result;
-}
-
-int MPI_Initialized(int *flag)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_INITIALIZED);
-    result = PMPI_Initialized(flag);
-    ITT_END(MPI_TASK_INITIALIZED);
-    return result;
-}
-
-int MPI_Op_create(MPI_User_function *user_fn, int commute, MPI_Op *op)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_OP_CREATE);
-    result = PMPI_Op_create(user_fn, commute, op);
-    ITT_END(MPI_TASK_OP_CREATE);
-    return result;
-}
-
-int MPI_Op_free(MPI_Op * op)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_OP_FREE);
-    result = PMPI_Op_free(op);
-    ITT_END(MPI_TASK_OP_FREE);
-    return result;
-}
-
-int MPI_Query_thread(int *provided)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_QUERY_THREAD);
-    result = PMPI_Query_thread(provided);
-    ITT_END(MPI_TASK_QUERY_THREAD);
-    return result;
-}
-
-int MPI_Reduce_scatter_block(const void *sendbuf, void *recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_REDUCE_SCATTER_BLOCK);
-    result = PMPI_Reduce_scatter_block(sendbuf, recvbuf, recvcount, datatype, op, comm);
-    ITT_END(MPI_TASK_REDUCE_SCATTER_BLOCK);
-    return result;
-}
-
-int MPI_Type_commit(MPI_Datatype *datatype)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TYPE_COMMIT);
-    result = PMPI_Type_commit(datatype);
-    ITT_END(MPI_TASK_TYPE_COMMIT);
-    return result;
-}
-
-int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype * newtype)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TYPE_CONTIGUOUS);
-    result = PMPI_Type_contiguous(count, oldtype, newtype);
-    ITT_END(MPI_TASK_TYPE_CONTIGUOUS);
-    return result;
-}
-
-int MPI_Type_free(MPI_Datatype *datatype)
-{
-    int result = 0;
-    ITT_BEGIN(MPI_TASK_TYPE_FREE);
-    result = PMPI_Type_free(datatype);
-    ITT_END(MPI_TASK_TYPE_FREE);
-    return result;
-}
diff --git a/tools/unitrace/src/omp/ompt_collector.h b/tools/unitrace/src/omp/ompt_collector.h
deleted file mode 100644
index f6c60056..00000000
--- a/tools/unitrace/src/omp/ompt_collector.h
+++ /dev/null
@@ -1,702 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_OMPT_COLLECTOR_H_
-#define PTI_TOOLS_UNITRACE_OMPT_COLLECTOR_H_
-
-#include <cstdint>
-#include <stack>
-#include <string>
-#include <omp-tools.h>
-#include "unievent.h"
-
-#define UNI_OMPT_CHECK_COLLECTOR() do { if (!ompt_collector) return; } while (0)
-
-#define UNI_OMPT_FOREACH_ENTRY(macro)                                          \
-  macro(ompt_set_callback)              macro(ompt_get_callback)               \
-  macro(ompt_get_state)                 macro(ompt_get_task_info)              \
-  macro(ompt_get_task_memory)           macro(ompt_get_thread_data)            \
-  macro(ompt_get_parallel_info)         macro(ompt_get_unique_id)              \
-  macro(ompt_finalize_tool)             macro(ompt_get_num_procs)              \
-  macro(ompt_get_num_places)            macro(ompt_get_place_proc_ids)         \
-  macro(ompt_get_place_num)             macro(ompt_get_partition_place_nums)   \
-  macro(ompt_get_proc_id)               macro(ompt_enumerate_states)           \
-  macro(ompt_enumerate_mutex_impls)
-
-// OMPT routines initialized by the look-up function.
-// Use these routines to access more information maintained by the runtime.
-#define UNI_OMPT_ENTRY_DECL(name) static name##_t name;
-UNI_OMPT_FOREACH_ENTRY(UNI_OMPT_ENTRY_DECL)
-
-// Initialize OMPT entries that can be used to query OpenMP information
-static void init_ompt_entries(ompt_function_lookup_t lookup) {
-  #define UNI_OMPT_ENTRY_SET(name)                                             \
-    name = reinterpret_cast<name##_t>(lookup(#name));
-  UNI_OMPT_FOREACH_ENTRY(UNI_OMPT_ENTRY_SET)
-}
-
-// Event offset or ID used to map an event ID to its corresponding string.
-enum class OmptEventID {
-  // Offset and flag value can be used to identify an individual event for 0--87
-  SyncRegion = 0,
-  Work = 16,
-  MutexHold = 32,
-  MutexWait = 40,
-  MutexInit = 48,
-  MutexDestroy = 56,
-  Dispatch = 64,
-  Cancel = 72,
-  // Individual names are required starting from 88
-  // Other events
-  ParallelRegion = 88,
-  TeamsRegion,
-  ImplicitTask,
-  NestLockOwned,
-  Masked,
-  Flush,
-  TaskGeneration,
-  TaskRegion,
-  TaskDependence,
-};
-
-static const char *GetOmptEventName(uint32_t event_id) {
-  // Maintain ID-to-string map for all OMP events
-  static const char *all_ompt_events[] = {
-    // OmptEventID::SyncRegion + 0
-    "",
-    "OMP::sync_region_barrier",
-    "OMP::sync_region_barrier_implicit",
-    "OMP::sync_region_barrier_explicit",
-    "OMP::sync_region_barrier_implementation",
-    "OMP::sync_region_taskwait",
-    "OMP::sync_region_taskgroup",
-    "OMP::sync_region_reduction",
-    "OMP::sync_region_barrier_implicit_workshare",
-    "OMP::sync_region_barrier_implicit_parallel",
-    "OMP::sync_region_barrier_teams",
-    "", "", "", "", "",
-    // OmptEventID::Work + 0
-    "",
-    "OMP::work_loop",
-    "OMP::work_sections",
-    "OMP::work_single_executor",
-    "OMP::work_single_other",
-    "OMP::work_workshare",
-    "OMP::work_distribute",
-    "OMP::work_taskloop",
-    "OMP::work_scope",
-    "", // + 9
-    "OMP::work_loop_static",
-    "OMP::work_loop_dynamic",
-    "OMP::work_loop_guided",
-    "OMP::work_loop_other",
-    "", "",
-    // OmptEventID::MutexHold + 0
-    "",
-    "OMP::lock_hold",
-    "OMP::test_lock_hold",
-    "OMP::nest_lock_hold",
-    "OMP::test_nest_lock_hold",
-    "OMP::critical_hold",
-    "OMP::atomic_hold",
-    "OMP::ordered_hold",
-    // OmptEventID::MutexWait + 0
-    "",
-    "OMP::lock_wait",
-    "OMP::test_lock_wait",
-    "OMP::nest_lock_wait",
-    "OMP::test_nest_lock_wait",
-    "OMP::critical_wait",
-    "OMP::atomic_wait",
-    "OMP::ordered_wait",
-    // OmptEventID::MutexInit + 0
-    "",
-    "OMP::lock_init",
-    "OMP::test_lock_init",
-    "OMP::nest_lock_init",
-    "OMP::test_nest_lock_init",
-    "OMP::critical_init",
-    "OMP::atomic_init",
-    "OMP::ordered_init",
-    // OmptEventID::MutexDestroy + 0
-    "",
-    "OMP::lock_destroy",
-    "OMP::test_lock_destroy",
-    "OMP::nest_lock_destroy",
-    "OMP::test_nest_lock_destroy",
-    "OMP::critical_destroy",
-    "OMP::atomic_destroy",
-    "OMP::ordered_destroy",
-    // OmptEventID::Dispatch + 0
-    "",
-    "OMP::dispatch_iteration",
-    "OMP::dispatch_section",
-    "OMP::dispatch_ws_loop_chunk",
-    "OMP::dispatch_task_loop_chunk",
-    "OMP::dispatch_distribute_chunk",
-    "", "",
-    // OmptEventID::Cancel + 0
-    "OMP::cancel_parallel_activated",
-    "OMP::cancel_parallel_detected",
-    "OMP::cancel_parallel_discarded_task",
-    "OMP::cancel_parallel",
-    "OMP::cancel_sections_activated",
-    "OMP::cancel_sections_detected",
-    "OMP::cancel_sections_discarded_task",
-    "OMP::cancel_sections",
-    "OMP::cancel_loop_activated",
-    "OMP::cancel_loop_detected",
-    "OMP::cancel_loop_discarded_task",
-    "OMP::cancel_loop",
-    "OMP::cancel_taskgroup_activated",
-    "OMP::cancel_taskgroup_detected",
-    "OMP::cancel_taskgroup_discarded_task",
-    "OMP::cancel_taskgroup",
-    // OmptEventID::ParallelRegion
-    "OMP::parallel_region",
-    "OMP::teams_region",
-    "OMP::implicit_task",
-    "OMP::nest_lock_owned",
-    "OMP::masked",
-    "OMP::flush",
-    "OMP::task_generation",
-    "OMP::task_region",
-    "OMP::task_dependence",
-  };
-  return all_ompt_events[event_id];
-}
-
-class OmptCollector {
-  using OmptLoggingCallback =
-      void (*)(uint64_t, uint64_t, uint64_t, EVENT_TYPE, OmpArgs *);
-  /// Chrome logging callback
-  OmptLoggingCallback callback_ = nullptr;
-public:
-  /// Create and return a new OMPT collector
-  static OmptCollector *Create(OmptLoggingCallback callback = nullptr) {
-    auto *collector = new OmptCollector(callback);
-    if (!collector)
-      std::cerr << "[WARNING] Unable to create OpenMP tracer" << std::endl;
-    return collector;
-  }
-  /// Get thread-private stack of OMPT records
-  static std::stack<ompt_record_ompt_t> &GetRecords() {
-    static thread_local std::stack<ompt_record_ompt_t> records{};
-    return records;
-  }
-  /// Construct with the specified logger callback
-  OmptCollector(OmptLoggingCallback callback) : callback_(callback) {}
-  /// Log the specified information
-  void Log(uint64_t event_id, uint64_t start_ts, uint64_t end_ts,
-           OmpArgs *args = nullptr) {
-    if (callback_)
-      callback_(event_id, start_ts, end_ts, EVENT_COMPLETE, args);
-  }
-  /// Log with start time and current time, and pop the current record.
-  void Log(uint64_t event_id, uint64_t start_ts, OmpArgs *args = nullptr) {
-    if (callback_) {
-      callback_(event_id, start_ts, UniTimer::GetHostTimestamp(),
-                EVENT_COMPLETE, args);
-      GetRecords().pop();
-    }
-  }
-  /// Mark an event without endpoints
-  void Mark(uint64_t event_id, OmpArgs *args = nullptr) {
-    if (callback_) {
-      uint64_t now = UniTimer::GetHostTimestamp();
-      callback_(event_id, now, now, EVENT_MARK, args);
-    }
-  }
-  /// Push the OMPT record to the thread-private stack
-  void Push(ompt_record_ompt_t &record) { GetRecords().push(record); }
-  /// Pop the OMPT record from the stack
-  void Pop() { GetRecords().pop(); }
-  /// Read the most recent OMPT record pushed to the stack
-  ompt_record_ompt_t &Top() { return GetRecords().top(); }
-};
-
-OmptCollector *ompt_collector = nullptr;
-
-// Callback for parallel region begin
-static void on_ompt_callback_parallel_begin(
-    // ompt_data_t arguments represent data reserved for tool use. Tool can use
-    // this place to attach information to the specific OpenMP instance (e.g.,
-    // parallel region, task, thread).
-    // tool data attached to the encountering task
-    ompt_data_t *encountering_task_data,
-    // procedure frame information for the encountering task
-    const ompt_frame_t *encountering_task_frame,
-    // tool data location to be used by the tool for the region
-    ompt_data_t *parallel_data,
-    // number of threads or teams requested by the user
-    unsigned int requested_parallelism,
-    // flag that indicates if the region is for a team (parallel region) or
-    // a league (teams region)
-    int flags,
-    // return address of the routine that implements the region
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  ompt_record_ompt_t omptrec;
-  omptrec.type = ompt_callback_parallel_begin;
-  omptrec.time = UniTimer::GetHostTimestamp();
-  auto &parbegin = omptrec.record.parallel_begin;
-  parbegin.requested_parallelism = requested_parallelism;
-  parbegin.flags = flags;
-  parbegin.codeptr_ra = codeptr_ra;
-  ompt_collector->Push(omptrec);
-}
-
-// Callback for parallel region end
-static void on_ompt_callback_parallel_end(
-    ompt_data_t *parallel_data,
-    ompt_data_t *encountering_task_data,
-    int flags,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto &omptrec = ompt_collector->Top();
-  if (omptrec.type != ompt_callback_parallel_begin) {
-    std::cerr << "[WARNING] Unexpected OMPT record\n";
-    return;
-  }
-  auto &parbegin = omptrec.record.parallel_begin;
-  bool is_team = parbegin.flags & ompt_parallel_team;
-  auto event_id = static_cast<uint64_t>(is_team ? OmptEventID::ParallelRegion
-                                                : OmptEventID::TeamsRegion);
-  ompt_collector->Log(event_id, omptrec.time);
-}
-
-// Callback for synchronization regions
-static void on_ompt_callback_sync_region(
-    // type of the synchronizing resgion
-    ompt_sync_region_t kind,
-    ompt_scope_endpoint_t endpoint,
-    // tool data from the enclosing parallel/teams region
-    ompt_data_t *parallel_data,
-    // tool data from the current task
-    ompt_data_t *task_data,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  if (endpoint == ompt_scope_begin) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_sync_region;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    auto &syncbegin = omptrec.record.sync_region;
-    syncbegin.kind = kind;
-    syncbegin.endpoint = endpoint;
-    syncbegin.codeptr_ra = codeptr_ra;
-    ompt_collector->Push(omptrec);
-  } else {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_sync_region ||
-        omptrec.record.sync_region.endpoint != ompt_scope_begin) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::SyncRegion) + kind;
-    ompt_collector->Log(event_id, omptrec.time);
-  }
-}
-
-// Callback for sync region due to reduction activity
-static void on_ompt_callback_reduction(
-    ompt_sync_region_t kind,
-    ompt_scope_endpoint_t endpoint,
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    const void *codeptr_ra) {
-  on_ompt_callback_sync_region(kind, endpoint, parallel_data, task_data,
-                               codeptr_ra);
-}
-
-// Callback for work sharing constructs
-static void on_ompt_callback_work(
-    ompt_work_t work_type,
-    ompt_scope_endpoint_t endpoint,
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    uint64_t count,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  if (endpoint == ompt_scope_begin) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_work;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    auto &workbegin = omptrec.record.work;
-    workbegin.work_type = work_type;
-    workbegin.endpoint = endpoint;
-    workbegin.count = count;
-    workbegin.codeptr_ra = codeptr_ra;
-    ompt_collector->Push(omptrec);
-  } else {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_work ||
-        omptrec.record.work.endpoint != ompt_scope_begin) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::Work) + work_type;
-    ompt_collector->Log(event_id, omptrec.time);
-  }
-}
-
-// Callback for mutex operations
-static void on_ompt_callback_mutex_acquire(
-    // type of the associated OpenMP activity
-    ompt_mutex_t kind,
-    // synchronization hint provided when the mutex was initialized
-    unsigned int hint,
-    // mutex implementation type
-    unsigned int impl,
-    // identifier for the associated mutex
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  ompt_record_ompt_t omptrec;
-  omptrec.type = ompt_callback_mutex_acquire;
-  omptrec.time = UniTimer::GetHostTimestamp();
-  omptrec.record.mutex_acquire.kind = kind;
-  omptrec.record.mutex_acquire.hint = hint;
-  omptrec.record.mutex_acquire.impl = impl;
-  omptrec.record.mutex_acquire.wait_id = wait_id;
-  omptrec.record.mutex_acquire.codeptr_ra = codeptr_ra;
-  ompt_collector->Push(omptrec);
-}
-
-static void on_ompt_callback_mutex_acquired(
-    ompt_mutex_t kind,
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto &omptrec = ompt_collector->Top();
-  if (omptrec.type != ompt_callback_mutex_acquire) {
-    std::cerr << "[WARNING] Unexpected OMPT record\n";
-    return;
-  }
-  uint64_t now = UniTimer::GetHostTimestamp();
-  auto event_id = static_cast<uint64_t>(OmptEventID::MutexWait) + kind;
-  ompt_collector->Log(event_id, omptrec.time, now);
-  // Reuse existing record while only updating the timestamp.
-  omptrec.time = now;
-}
-
-static void on_ompt_callback_mutex_released(
-    ompt_mutex_t kind,
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto &omptrec = ompt_collector->Top();
-  if (omptrec.type != ompt_callback_mutex_acquire) {
-    std::cerr << "[WARNING] Unexpected OMPT record\n";
-    return;
-  }
-  auto event_id = static_cast<uint64_t>(OmptEventID::MutexHold) + kind;
-  ompt_collector->Log(event_id, omptrec.time);
-}
-
-static void on_ompt_callback_lock_init(
-    ompt_mutex_t kind,
-    unsigned int hint,
-    unsigned int impl,
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto event_id = static_cast<uint64_t>(OmptEventID::MutexInit) + kind;
-  ompt_collector->Mark(event_id);
-}
-
-static void on_ompt_callback_lock_destroy(
-    ompt_mutex_t kind,
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto event_id = static_cast<uint64_t>(OmptEventID::MutexDestroy) + kind;
-  ompt_collector->Mark(event_id);
-}
-
-static void on_ompt_callback_nest_lock(
-    ompt_scope_endpoint_t endpoint,
-    ompt_wait_id_t wait_id,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  // Region for nest-lock-owned event
-  if (endpoint == ompt_scope_begin) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_nest_lock;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    omptrec.record.nest_lock.endpoint = endpoint;
-    omptrec.record.nest_lock.wait_id = wait_id;
-    omptrec.record.nest_lock.codeptr_ra = codeptr_ra;
-  } else {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_nest_lock ||
-        omptrec.record.nest_lock.endpoint != ompt_scope_begin) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::NestLockOwned);
-    ompt_collector->Log(event_id, omptrec.time);
-  }
-}
-
-// Callback for implicit task
-static void on_ompt_callback_implicit_task(
-    ompt_scope_endpoint_t endpoint,
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    // number of threads (parallel region) or number of teams (teams region)
-    unsigned int actual_parallelism,
-    // thread number or the team number of the current thread
-    unsigned int index,
-    // flag that indicates if the task is an initial task or implicit task
-    int flags) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  if (endpoint == ompt_scope_begin) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_implicit_task;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    omptrec.record.implicit_task.endpoint = endpoint;
-    omptrec.record.implicit_task.actual_parallelism = actual_parallelism;
-    omptrec.record.implicit_task.index = index;
-    omptrec.record.implicit_task.flags = flags;
-    ompt_collector->Push(omptrec);
-  } else {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_implicit_task ||
-        omptrec.record.implicit_task.endpoint != ompt_scope_begin) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::ImplicitTask);
-    OmpArgs args;
-    args.ompt = omptrec;
-    ompt_collector->Log(event_id, omptrec.time, &args);
-  }
-}
-
-// Callback for masked region
-static void on_ompt_callback_masked(
-    ompt_scope_endpoint_t endpoint,
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  if (endpoint == ompt_scope_begin) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_masked;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    omptrec.record.masked.endpoint = endpoint;
-    omptrec.record.masked.codeptr_ra = codeptr_ra;
-    ompt_collector->Push(omptrec);
-  } else {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_masked ||
-        omptrec.record.masked.endpoint != ompt_scope_begin) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::Masked);
-    ompt_collector->Log(event_id, omptrec.time);
-  }
-}
-
-// Callback for task creation
-static void on_ompt_callback_task_create(
-    // tool data from the generating task
-    ompt_data_t *encountering_task_data,
-    // frame information from the generating task
-    const ompt_frame_t *encountering_task_frame,
-    // tool data location to be used by the tool for the generated task
-    ompt_data_t *new_task_data,
-    // task flags that contain the attributes of the generated task
-    int flags,
-    // flag that indicates if the new task has dependence information
-    int has_dependences,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  OmpArgs args;
-  args.ompt.type = ompt_callback_task_create;
-  args.ompt.record.task_create.new_task_id = ompt_get_unique_id();
-  new_task_data->value = args.ompt.record.task_create.new_task_id;
-  auto event_id = static_cast<uint64_t>(OmptEventID::TaskGeneration);
-  ompt_collector->Mark(event_id, &args);
-}
-
-// Callback for task schedule
-static void on_ompt_callback_task_schedule(
-  // tool data from the task that arrived at the task scheduling point
-  ompt_data_t *prior_task_data,
-  // status of the prior task
-  ompt_task_status_t prior_task_status,
-  // tool data from the task resumed at the task scheduling point
-  ompt_data_t *next_task_data) {
-  // For now, only trace task start/finish
-  UNI_OMPT_CHECK_COLLECTOR();
-  if (prior_task_status == ompt_task_switch) {
-    ompt_record_ompt_t omptrec;
-    omptrec.type = ompt_callback_task_schedule;
-    omptrec.time = UniTimer::GetHostTimestamp();
-    omptrec.record.task_schedule.prior_task_status = prior_task_status;
-    ompt_collector->Push(omptrec);
-  } else if (prior_task_status == ompt_task_complete) {
-    auto &omptrec = ompt_collector->Top();
-    if (omptrec.type != ompt_callback_task_schedule ||
-        omptrec.record.task_schedule.prior_task_status != ompt_task_switch) {
-      std::cerr << "[WARNING] Unexpected OMPT record\n";
-      return;
-    }
-    auto event_id = static_cast<uint64_t>(OmptEventID::TaskRegion);
-    ompt_collector->Log(event_id, omptrec.time);
-  }
-}
-
-static void on_ompt_callback_dispatch(
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    ompt_dispatch_t kind,
-    ompt_data_t instance) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  OmpArgs args;
-  args.ompt.type = ompt_callback_dispatch;
-  args.ompt.record.dispatch.kind = kind;
-  switch (kind) {
-  case ompt_dispatch_iteration:
-  case ompt_dispatch_section:
-    // Logical iteration number or pointer to section
-    args.ompt.record.dispatch.instance = instance;
-    break;
-  case ompt_dispatch_ws_loop_chunk:
-  case ompt_dispatch_taskloop_chunk:
-  case ompt_dispatch_distribute_chunk: {
-    // Iteration space [<Start>:<Count>]
-    auto *chunk = static_cast<ompt_dispatch_chunk_t *>(instance.ptr);
-    args.data[0] = chunk->start;
-    args.data[1] = chunk->iterations;
-    args.ompt.record.dispatch.instance = ompt_data_none;
-    break;
-  }
-  default:
-    ; // Nothing to do
-  }
-  auto event_id = static_cast<uint64_t>(OmptEventID::Dispatch) + kind;
-  ompt_collector->Mark(event_id, &args);
-}
-
-static void on_ompt_callback_sync_region_wait(
-    ompt_sync_region_t kind,
-    ompt_scope_endpoint_t endpoint,
-    ompt_data_t *parallel_data,
-    ompt_data_t *task_data,
-    const void *codeptr_ra) {
-  // sync-region events and sync-region-wait events occur together in most
-  // regions, so we may not obtain extra information from sync-region-wait.
-}
-
-static void on_ompt_callback_flush(
-    ompt_data_t *thread_data,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  auto event_id = static_cast<uint64_t>(OmptEventID::Flush);
-  ompt_collector->Mark(event_id);
-}
-
-static void on_ompt_callback_cancel(
-    ompt_data_t *task_data,
-    int flags,
-    const void *codeptr_ra) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  // ID to string mapping is hard-coded here.
-  auto event_id = static_cast<uint64_t>(OmptEventID::Cancel);
-  if (flags & ompt_cancel_parallel)
-    ;
-  else if (flags & ompt_cancel_sections)
-    event_id += 4;
-  else if (flags & ompt_cancel_loop)
-    event_id += 8;
-  else if (flags & ompt_cancel_taskgroup)
-    event_id += 12;
-  if (flags & ompt_cancel_activated)
-    ;
-  else if (flags & ompt_cancel_detected)
-    event_id += 1;
-  else if (flags & ompt_cancel_discarded_task)
-    event_id += 2;
-  else
-    event_id += 3;
-  ompt_collector->Mark(event_id);
-}
-
-static void on_ompt_callback_task_dependence(
-    ompt_data_t *first_task_data,
-    ompt_data_t *second_task_data) {
-  UNI_OMPT_CHECK_COLLECTOR();
-  OmpArgs args;
-  args.ompt.type = ompt_callback_task_dependence;
-  args.ompt.record.task_dependence.src_task_id = first_task_data->value;
-  args.ompt.record.task_dependence.sink_task_id = second_task_data->value;
-  auto event_id = static_cast<uint64_t>(OmptEventID::TaskDependence);
-  ompt_collector->Mark(event_id, &args);
-}
-
-// OMPT initialization callback
-static int ompt_initialize(ompt_function_lookup_t lookup,
-                           int initial_device_num, ompt_data_t *tool_data) {
-  init_ompt_entries(lookup);
-
-  if (!ompt_set_callback) {
-    std::cerr << "[ERROR] Failed to get ompt_set_callback\n";
-    return 0;
-  }
-
-  // Register callbacks
-#define UNI_OMPT_SET_CALLBACK(callback)                                        \
-  ompt_set_callback(callback, (ompt_callback_t)on_##callback)
-  UNI_OMPT_SET_CALLBACK(ompt_callback_parallel_begin);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_parallel_end);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_task_create);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_task_schedule);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_implicit_task);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_sync_region);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_mutex_acquire);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_mutex_acquired);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_mutex_released);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_work);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_masked);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_reduction);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_lock_init);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_lock_destroy);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_nest_lock);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_dispatch);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_flush);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_cancel);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_task_dependence);
-#if 0
-  /// Not enabled - rarely used, simple translation of user directive
-  UNI_OMPT_SET_CALLBACK(ompt_callback_error);
-  /// Not enabled - duplicate information of sync_region callback in most cases
-  UNI_OMPT_SET_CALLBACK(ompt_callback_sync_region_wait);
-  /// Not enabled - event from omp_control_tool routine call by users
-  UNI_OMPT_SET_CALLBACK(ompt_callback_control_tool);
-  /// Not enabled - event from task with depend information
-  UNI_OMPT_SET_CALLBACK(ompt_callback_dependences);
-  /// Not enabled - thread end occurs after unitrace finishes
-  UNI_OMPT_SET_CALLBACK(ompt_callback_thread_begin);
-  UNI_OMPT_SET_CALLBACK(ompt_callback_thread_end);
-#endif /* 0 */
-
-  return 1; // Success
-}
-
-// OMPT finalization callback
-static void ompt_finalize(ompt_data_t *tool_data) {}
-
-// OMPT tool registration
-ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
-                                          const char *runtime_version) {
-  static ompt_start_tool_result_t result{ompt_initialize, ompt_finalize, {0}};
-  return ompt_collector ? &result : nullptr;
-}
-
-#endif // PTI_TOOLS_UNITRACE_OMPT_COLLECTOR_H_
diff --git a/tools/unitrace/src/opencl/cl_api_callbacks.h b/tools/unitrace/src/opencl/cl_api_callbacks.h
deleted file mode 100644
index 6f7bd18c..00000000
--- a/tools/unitrace/src/opencl/cl_api_callbacks.h
+++ /dev/null
@@ -1,7275 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_CL_API_CALLBACKS_H_
-#define PTI_TOOLS_UNITRACE_CL_API_CALLBACKS_H_
-
-#include "utils_host.h"
-
-static thread_local cl_int current_error = CL_SUCCESS;
-
-static void clGetSupportedImageFormatsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetSupportedImageFormats* params =
-    reinterpret_cast<const cl_params_clGetSupportedImageFormats*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " imageType = " + std::to_string(*(params->imageType));
-  log_msg += " numEntries = " + std::to_string(*(params->numEntries));
-  log_msg += " imageFormats = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageFormats)));
-  log_msg += " numImageFormats = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->numImageFormats)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetSupportedImageFormatsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string(end - start) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetKernelInfo* params =
-    reinterpret_cast<const cl_params_clGetKernelInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string(end - start) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCompileProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCompileProgram* params =
-    reinterpret_cast<const cl_params_clCompileProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " deviceList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceList)));
-  if (*(params->options) == nullptr) {
-    log_msg += " options = 0";
-  } else if (strlen(*(params->options)) == 0) {
-    log_msg += " options = \"\"";
-  } else {
-    log_msg += " options = \"" + std::string(*(params->options)) + "\"";
-  }
-  log_msg += " numInputHeaders = " + std::to_string(*(params->numInputHeaders));
-  log_msg += " inputHeaders = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->inputHeaders)));
-  log_msg += " headerIncludeNames = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->headerIncludeNames)));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCompileProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string(end - start) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetEventCallbackOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetEventCallback* params =
-    reinterpret_cast<const cl_params_clSetEventCallback*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " commandExecCallbackType = " +
-    std::to_string(*(params->commandExecCallbackType));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetEventCallbackOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string(end - start) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clUnloadPlatformCompilerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clUnloadPlatformCompiler* params =
-    reinterpret_cast<const cl_params_clUnloadPlatformCompiler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " platform = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->platform)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clUnloadPlatformCompilerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPlatformIDsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetPlatformIDs* params =
-    reinterpret_cast<const cl_params_clGetPlatformIDs*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " numEntries = " + std::to_string(*(params->numEntries));
-  log_msg += " platforms = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->platforms)));
-  log_msg += " numPlatforms = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->numPlatforms)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPlatformIDsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clUnloadCompilerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clUnloadCompiler* params =
-    reinterpret_cast<const cl_params_clUnloadCompiler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clUnloadCompilerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueBarrierWithWaitListOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueBarrierWithWaitList* params =
-    reinterpret_cast<const cl_params_clEnqueueBarrierWithWaitList*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueBarrierWithWaitListOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMapBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueMapBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueMapBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " blockingMap = " + std::to_string(*(params->blockingMap));
-  log_msg += " mapFlags = " + std::to_string(*(params->mapFlags));
-  log_msg += " offset = " + std::to_string(*(params->offset));
-  log_msg += " cb = " + std::to_string(*(params->cb));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clEnqueueMapBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clEnqueueMapBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueMapBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  void ** result =
-    reinterpret_cast<void **>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateImage3DOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateImage3D* params =
-    reinterpret_cast<const cl_params_clCreateImage3D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " imageFormat = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageFormat)));
-  log_msg += " imageWidth = " + ToHexString(static_cast<uintptr_t>(*(params->imageWidth)));
-  log_msg += " imageHeight = " + ToHexString(static_cast<uintptr_t>(*(params->imageHeight)));
-  log_msg += " imageDepth = " + ToHexString(static_cast<uintptr_t>(*(params->imageDepth)));
-  log_msg += " imageRowPitch = " + ToHexString(static_cast<uintptr_t>(*(params->imageRowPitch)));
-  log_msg += " imageSlicePitch = " + ToHexString(static_cast<uintptr_t>(*(params->imageSlicePitch)));
-  log_msg += " hostPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostPtr)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateImage3DOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateImage3D* params =
-    reinterpret_cast<const cl_params_clCreateImage3D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelArgInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetKernelArgInfo* params =
-    reinterpret_cast<const cl_params_clGetKernelArgInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " argIndx = " + std::to_string(*(params->argIndx));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelArgInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMFreeOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMFree* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMFree*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numSvmPointers = " + std::to_string(*(params->numSvmPointers));
-  log_msg += " svmPointers = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPointers)));
-  log_msg += " pfnFreeFunc = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->pfnFreeFunc)*>(params->pfnFreeFunc)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMFreeOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyImageToBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueCopyImageToBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueCopyImageToBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " srcImage = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcImage)));
-  log_msg += " dstBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstBuffer)));
-  log_msg += " srcOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " dstOffset = " + std::to_string(*(params->dstOffset));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyImageToBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetContextInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetContextInfo* params =
-    reinterpret_cast<const cl_params_clGetContextInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetContextInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainCommandQueueOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainCommandQueue* params =
-    reinterpret_cast<const cl_params_clRetainCommandQueue*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainCommandQueueOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueWriteImage* params =
-    reinterpret_cast<const cl_params_clEnqueueWriteImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " image = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->image)));
-  log_msg += " blockingWrite = " + std::to_string(*(params->blockingWrite));
-  log_msg += " origin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->origin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " inputRowPitch = " + std::to_string(*(params->inputRowPitch));
-  log_msg += " inputSlicePitch = " + std::to_string(*(params->inputSlicePitch));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWaitForEventsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueWaitForEvents* params =
-    reinterpret_cast<const cl_params_clEnqueueWaitForEvents*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numEvents = " + std::to_string(*(params->numEvents));
-  log_msg += " eventList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventList)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWaitForEventsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMUnmapOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMUnmap* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMUnmap*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " svmPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPtr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMUnmapOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateProgramWithBinaryOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateProgramWithBinary* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithBinary*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " deviceList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceList)));
-  log_msg += " lengths = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->lengths)));
-  log_msg += " binaries = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->binaries)));
-  log_msg += " binaryStatus = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->binaryStatus)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateProgramWithBinaryOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateProgramWithBinary* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithBinary*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_program* result =
-    reinterpret_cast<cl_program*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueFillImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueFillImage* params =
-    reinterpret_cast<const cl_params_clEnqueueFillImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " image = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->image)));
-  log_msg += " fillColor = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->fillColor)));
-  log_msg += " origin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->origin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueFillImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateFromGLTexture2DOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateFromGLTexture2D* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture2D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " target = " + std::to_string(*(params->target));
-  log_msg += " miplevel = " + std::to_string(*(params->miplevel));
-  log_msg += " texture = " + std::to_string(*(params->texture));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateFromGLTexture2DOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateFromGLTexture2D* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture2D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelExecInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetKernelExecInfo* params =
-    reinterpret_cast<const cl_params_clSetKernelExecInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelExecInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReleaseGLObjectsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueReleaseGLObjects* params =
-    reinterpret_cast<const cl_params_clEnqueueReleaseGLObjects*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numObjects = " + std::to_string(*(params->numObjects));
-  log_msg += " memObjects = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memObjects)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReleaseGLObjectsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceIDsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetDeviceIDs* params =
-    reinterpret_cast<const cl_params_clGetDeviceIDs*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " platform = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->platform)));
-  log_msg += " deviceType = " + ToHexString(static_cast<uintptr_t>(*(params->deviceType)));
-  log_msg += " numEntries = " + std::to_string(*(params->numEntries));
-  log_msg += " devices = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->devices)));
-  log_msg += " numDevices = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->numDevices)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceIDsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseMemObjectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseMemObject* params =
-    reinterpret_cast<const cl_params_clReleaseMemObject*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseMemObjectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetGLObjectInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetGLObjectInfo* params =
-    reinterpret_cast<const cl_params_clGetGLObjectInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += " glObjectType = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->glObjectType)));
-  log_msg += " glObjectName = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->glObjectName)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetGLObjectInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateFromGLRenderbufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateFromGLRenderbuffer* params =
-    reinterpret_cast<const cl_params_clCreateFromGLRenderbuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " renderbuffer = " + std::to_string(*(params->renderbuffer));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateFromGLRenderbufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateFromGLRenderbuffer* params =
-    reinterpret_cast<const cl_params_clCreateFromGLRenderbuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseContextOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseContext* params =
-    reinterpret_cast<const cl_params_clReleaseContext*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseContextOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueUnmapMemObjectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueUnmapMemObject* params =
-    reinterpret_cast<const cl_params_clEnqueueUnmapMemObject*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += " mappedPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->mappedPtr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueUnmapMemObjectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateContextOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateContext* params =
-    reinterpret_cast<const cl_params_clCreateContext*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->properties)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " devices = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->devices)));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateContextOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateContext* params =
-    reinterpret_cast<const cl_params_clCreateContext*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_context* result =
-    reinterpret_cast<cl_context*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetHostTimerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetHostTimer* params =
-    reinterpret_cast<const cl_params_clGetHostTimer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " hostTimestamp = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostTimestamp)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetHostTimerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPipeInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetPipeInfo* params =
-    reinterpret_cast<const cl_params_clGetPipeInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " pipe = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->pipe)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPipeInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueAcquireGLObjectsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueAcquireGLObjects* params =
-    reinterpret_cast<const cl_params_clEnqueueAcquireGLObjects*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numObjects = " + std::to_string(*(params->numObjects));
-  log_msg += " memObjects = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memObjects)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueAcquireGLObjectsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelWorkGroupInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetKernelWorkGroupInfo* params =
-    reinterpret_cast<const cl_params_clGetKernelWorkGroupInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelWorkGroupInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateImage2DOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateImage2D* params =
-    reinterpret_cast<const cl_params_clCreateImage2D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " imageFormat = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageFormat)));
-  log_msg += " imageWidth = " + ToHexString(static_cast<uintptr_t>(*(params->imageWidth)));
-  log_msg += " imageHeight = " + ToHexString(static_cast<uintptr_t>(*(params->imageHeight)));
-  log_msg += " imageRowPitch = " + ToHexString(static_cast<uintptr_t>(*(params->imageRowPitch)));
-  log_msg += " hostPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostPtr)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateImage2DOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateImage2D* params =
-    reinterpret_cast<const cl_params_clCreateImage2D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateContextFromTypeOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateContextFromType* params =
-    reinterpret_cast<const cl_params_clCreateContextFromType*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->properties)));
-  log_msg += " deviceType = " + ToHexString(static_cast<uintptr_t>(*(params->deviceType)));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateContextFromTypeOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateContextFromType* params =
-    reinterpret_cast<const cl_params_clCreateContextFromType*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_context* result =
-    reinterpret_cast<cl_context*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainProgram* params =
-    reinterpret_cast<const cl_params_clRetainProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateProgramWithSourceOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateProgramWithSource* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithSource*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " count = " + std::to_string(*(params->count));
-  log_msg += " strings = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->strings)));
-  log_msg += " lengths = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->lengths)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateProgramWithSourceOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateProgramWithSource* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithSource*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_program* result =
-    reinterpret_cast<cl_program*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetMemObjectInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetMemObjectInfo* params =
-    reinterpret_cast<const cl_params_clGetMemObjectInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetMemObjectInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clLinkProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clLinkProgram* params =
-    reinterpret_cast<const cl_params_clLinkProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " deviceList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceList)));
-  if (*(params->options) == nullptr) {
-    log_msg += " options = 0";
-  } else if (strlen(*(params->options)) == 0) {
-    log_msg += " options = \"\"";
-  } else {
-    log_msg += " options = \"" + std::string(*(params->options)) + "\"";
-  }
-  log_msg += " numInputPrograms = " + std::to_string(*(params->numInputPrograms));
-  log_msg += " inputPrograms = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->inputPrograms)));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clLinkProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clLinkProgram* params =
-    reinterpret_cast<const cl_params_clLinkProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_program* result =
-    reinterpret_cast<cl_program*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateSamplerWithPropertiesOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateSamplerWithProperties* params =
-    reinterpret_cast<const cl_params_clCreateSamplerWithProperties*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " samplerProperties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->samplerProperties)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateSamplerWithPropertiesOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateSamplerWithProperties* params =
-    reinterpret_cast<const cl_params_clCreateSamplerWithProperties*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_sampler* result =
-    reinterpret_cast<cl_sampler*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainSamplerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainSampler* params =
-    reinterpret_cast<const cl_params_clRetainSampler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " sampler = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->sampler)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainSamplerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateFromGLTexture3DOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateFromGLTexture3D* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture3D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " target = " + std::to_string(*(params->target));
-  log_msg += " miplevel = " + std::to_string(*(params->miplevel));
-  log_msg += " texture = " + std::to_string(*(params->texture));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateFromGLTexture3DOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateFromGLTexture3D* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture3D*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMapImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueMapImage* params =
-    reinterpret_cast<const cl_params_clEnqueueMapImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " image = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->image)));
-  log_msg += " blockingMap = " + std::to_string(*(params->blockingMap));
-  log_msg += " mapFlags = " + std::to_string(*(params->mapFlags));
-  log_msg += " origin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->origin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " imageRowPitch = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageRowPitch)));
-  log_msg += " imageSlicePitch = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageSlicePitch)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clEnqueueMapImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clEnqueueMapImage* params =
-    reinterpret_cast<const cl_params_clEnqueueMapImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  void ** result =
-    reinterpret_cast<void **>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueWriteBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueWriteBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " blockingWrite = " + std::to_string(*(params->blockingWrite));
-  log_msg += " offset = " + std::to_string(*(params->offset));
-  log_msg += " cb = " + std::to_string(*(params->cb));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueCopyImage* params =
-    reinterpret_cast<const cl_params_clEnqueueCopyImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " srcImage = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcImage)));
-  log_msg += " dstImage = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstImage)));
-  log_msg += " srcOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcOrigin)));
-  log_msg += " dstOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetExtensionFunctionAddressOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetExtensionFunctionAddress* params =
-    reinterpret_cast<const cl_params_clGetExtensionFunctionAddress*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  if (*(params->funcName) == nullptr) {
-    log_msg += " funcName = 0";
-  } else if (strlen(*(params->funcName)) == 0) {
-    log_msg += " funcName = \"\"";
-  } else {
-    log_msg += " funcName = \"" + std::string(*(params->funcName)) + "\"";
-  }
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetExtensionFunctionAddressOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  void** result =
-    reinterpret_cast<void**>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadBufferRectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueReadBufferRect* params =
-    reinterpret_cast<const cl_params_clEnqueueReadBufferRect*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " blockingRead = " + std::to_string(*(params->blockingRead));
-  log_msg += " bufferOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->bufferOrigin)));
-  log_msg += " hostOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " bufferRowPitch = " + ToHexString(static_cast<uintptr_t>(*(params->bufferRowPitch)));
-  log_msg += " bufferSlicePitch = " + ToHexString(static_cast<uintptr_t>(*(params->bufferSlicePitch)));
-  log_msg += " hostRowPitch = " + std::to_string(*(params->hostRowPitch));
-  log_msg += " hostSlicePitch = " + std::to_string(*(params->hostSlicePitch));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadBufferRectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateSubDevicesOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateSubDevices* params =
-    reinterpret_cast<const cl_params_clCreateSubDevices*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " inDevice = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->inDevice)));
-  log_msg += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->properties)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " outDevices = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->outDevices)));
-  log_msg += " numDevicesRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->numDevicesRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateSubDevicesOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceAndHostTimerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetDeviceAndHostTimer* params =
-    reinterpret_cast<const cl_params_clGetDeviceAndHostTimer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " deviceTimestamp = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceTimestamp)));
-  log_msg += " hostTimestamp = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostTimestamp)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceAndHostTimerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseSamplerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseSampler* params =
-    reinterpret_cast<const cl_params_clReleaseSampler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " sampler = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->sampler)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseSamplerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueTaskOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueTask* params =
-    reinterpret_cast<const cl_params_clEnqueueTask*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  if (*(params->kernel) != nullptr) {
-    std::string kernel_name = utils::cl::GetKernelName(
-        *(params->kernel), collector->Demangle());
-    if (!kernel_name.empty()) {
-      log_msg += " (" + kernel_name + ")";
-    }
-  }
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueTaskOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clFinishOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clFinish* params =
-    reinterpret_cast<const cl_params_clFinish*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clFinishOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetEventInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetEventInfo* params =
-    reinterpret_cast<const cl_params_clGetEventInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetEventInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetEventProfilingInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetEventProfilingInfo* params =
-    reinterpret_cast<const cl_params_clGetEventProfilingInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetEventProfilingInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelArgSVMPointerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetKernelArgSVMPointer* params =
-    reinterpret_cast<const cl_params_clSetKernelArgSVMPointer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " argIndex = " + std::to_string(*(params->argIndex));
-  log_msg += " argValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->argValue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelArgSVMPointerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateImage* params =
-    reinterpret_cast<const cl_params_clCreateImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " imageFormat = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageFormat)));
-  log_msg += " imageDesc = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->imageDesc)));
-  log_msg += " hostPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostPtr)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateImage* params =
-    reinterpret_cast<const cl_params_clCreateImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMemcpyOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMMemcpy* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMMemcpy*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " blockingCopy = " + std::to_string(*(params->blockingCopy));
-  log_msg += " dstPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstPtr)));
-  log_msg += " srcPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcPtr)));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMemcpyOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseKernel* params =
-    reinterpret_cast<const cl_params_clReleaseKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueNativeKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueNativeKernel* params =
-    reinterpret_cast<const cl_params_clEnqueueNativeKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " userFunc = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->userFunc)*>(params->userFunc)));
-  log_msg += " args = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->args)));
-  log_msg += " cbArgs = " + std::to_string(*(params->cbArgs));
-  log_msg += " numMemObjects = " + std::to_string(*(params->numMemObjects));
-  log_msg += " memList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memList)));
-  log_msg += " argsMemLoc = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->argsMemLoc)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueNativeKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateKernelsInProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateKernelsInProgram* params =
-    reinterpret_cast<const cl_params_clCreateKernelsInProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += " numKernels = " + std::to_string(*(params->numKernels));
-  log_msg += " kernels = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernels)));
-  log_msg += " numKernelsRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->numKernelsRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateKernelsInProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetCommandQueuePropertyOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetCommandQueueProperty* params =
-    reinterpret_cast<const cl_params_clSetCommandQueueProperty*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " properties = " + ToHexString(static_cast<uintptr_t>(*(params->properties)));
-  log_msg += " enable = " + std::to_string(*(params->enable));
-  log_msg += " oldProperties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->oldProperties)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetCommandQueuePropertyOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetDeviceInfo* params =
-    reinterpret_cast<const cl_params_clGetDeviceInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetDeviceInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueNDRangeKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueNDRangeKernel* params =
-    reinterpret_cast<const cl_params_clEnqueueNDRangeKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  if (*(params->kernel) != nullptr) {
-    std::string kernel_name = utils::cl::GetKernelName(
-        *(params->kernel), collector->Demangle());
-    if (!kernel_name.empty()) {
-      log_msg += " (" + kernel_name + ")";
-    }
-  }
-  log_msg += " workDim = " + std::to_string(*(params->workDim));
-  log_msg += " globalWorkOffset = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->globalWorkOffset)));
-  if (*(params->globalWorkOffset) != nullptr && *(params->workDim) > 0) {
-    log_msg += " {" + std::to_string((*(params->globalWorkOffset))[0]);
-    for (cl_uint i = 1; i < *(params->workDim); ++i) {
-      log_msg += ", " + std::to_string((*(params->globalWorkOffset))[i]);
-    }
-    log_msg += "}";
-  }
-  log_msg += " globalWorkSize = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->globalWorkSize)));
-  if (*(params->globalWorkSize) != nullptr && *(params->workDim) > 0) {
-    log_msg += " {" + std::to_string((*(params->globalWorkSize))[0]);
-    for (cl_uint i = 1; i < *(params->workDim); ++i) {
-      log_msg += ", " + std::to_string((*(params->globalWorkSize))[i]);
-    }
-    log_msg += "}";
-  }
-  log_msg += " localWorkSize = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->localWorkSize)));
-  if (*(params->localWorkSize) != nullptr && *(params->workDim) > 0) {
-    log_msg += " {" + std::to_string((*(params->localWorkSize))[0]);
-    for (cl_uint i = 1; i < *(params->workDim); ++i) {
-      log_msg += ", " + std::to_string((*(params->localWorkSize))[i]);
-    }
-    log_msg += "}";
-  }
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueNDRangeKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseProgram* params =
-    reinterpret_cast<const cl_params_clReleaseProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateFromGLBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateFromGLBuffer* params =
-    reinterpret_cast<const cl_params_clCreateFromGLBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " bufobj = " + std::to_string(*(params->bufobj));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateFromGLBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateFromGLBuffer* params =
-    reinterpret_cast<const cl_params_clCreateFromGLBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetGLTextureInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetGLTextureInfo* params =
-    reinterpret_cast<const cl_params_clGetGLTextureInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetGLTextureInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetDefaultDeviceCommandQueueOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetDefaultDeviceCommandQueue* params =
-    reinterpret_cast<const cl_params_clSetDefaultDeviceCommandQueue*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetDefaultDeviceCommandQueueOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreatePipeOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreatePipe* params =
-    reinterpret_cast<const cl_params_clCreatePipe*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " pipePacketSize = " + std::to_string(*(params->pipePacketSize));
-  log_msg += " pipeMaxPackets = " + std::to_string(*(params->pipeMaxPackets));
-  log_msg += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->properties)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreatePipeOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreatePipe* params =
-    reinterpret_cast<const cl_params_clCreatePipe*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPlatformInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetPlatformInfo* params =
-    reinterpret_cast<const cl_params_clGetPlatformInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " platform = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->platform)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetPlatformInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueReadBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueReadBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " blockingRead = " + std::to_string(*(params->blockingRead));
-  log_msg += " offset = " + std::to_string(*(params->offset));
-  log_msg += " cb = " + std::to_string(*(params->cb));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetMemObjectDestructorCallbackOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetMemObjectDestructorCallback* params =
-    reinterpret_cast<const cl_params_clSetMemObjectDestructorCallback*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetMemObjectDestructorCallbackOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelSubGroupInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetKernelSubGroupInfo* params =
-    reinterpret_cast<const cl_params_clGetKernelSubGroupInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " inputValueSize = " + std::to_string(*(params->inputValueSize));
-  log_msg += " inputValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->inputValue)));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetKernelSubGroupInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferRectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueCopyBufferRect* params =
-    reinterpret_cast<const cl_params_clEnqueueCopyBufferRect*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " srcBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcBuffer)));
-  log_msg += " dstBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstBuffer)));
-  log_msg += " srcOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcOrigin)));
-  log_msg += " dstOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " srcRowPitch = " + std::to_string(*(params->srcRowPitch));
-  log_msg += " srcSlicePitch = " + std::to_string(*(params->srcSlicePitch));
-  log_msg += " dstRowPitch = " + std::to_string(*(params->dstRowPitch));
-  log_msg += " dstSlicePitch = " + std::to_string(*(params->dstSlicePitch));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferRectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clWaitForEventsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clWaitForEvents* params =
-    reinterpret_cast<const cl_params_clWaitForEvents*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " numEvents = " + std::to_string(*(params->numEvents));
-  log_msg += " eventList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventList)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clWaitForEventsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMigrateMemOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMMigrateMem* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMMigrateMem*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numSvmPointers = " + std::to_string(*(params->numSvmPointers));
-  log_msg += " svmPointers = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPointers)));
-  log_msg += " sizes = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->sizes)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMigrateMemOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainKernel* params =
-    reinterpret_cast<const cl_params_clRetainKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateCommandQueueWithPropertiesOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateCommandQueueWithProperties* params =
-    reinterpret_cast<const cl_params_clCreateCommandQueueWithProperties*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->properties)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateCommandQueueWithPropertiesOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateCommandQueueWithProperties* params =
-    reinterpret_cast<const cl_params_clCreateCommandQueueWithProperties*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_command_queue* result =
-    reinterpret_cast<cl_command_queue*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateProgramWithBuiltInKernelsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateProgramWithBuiltInKernels* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithBuiltInKernels*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " deviceList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceList)));
-  if (*(params->kernelNames) == nullptr) {
-    log_msg += " kernelNames = 0";
-  } else if (strlen(*(params->kernelNames)) == 0) {
-    log_msg += " kernelNames = \"\"";
-  } else {
-    log_msg += " kernelNames = \"" + std::string(*(params->kernelNames)) + "\"";
-  }
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateProgramWithBuiltInKernelsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateProgramWithBuiltInKernels* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithBuiltInKernels*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_program* result =
-    reinterpret_cast<cl_program*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateBuffer* params =
-    reinterpret_cast<const cl_params_clCreateBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " hostPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostPtr)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateBuffer* params =
-    reinterpret_cast<const cl_params_clCreateBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetProgramBuildInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetProgramBuildInfo* params =
-    reinterpret_cast<const cl_params_clGetProgramBuildInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetProgramBuildInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueFillBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueFillBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueFillBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " pattern = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->pattern)));
-  log_msg += " patternSize = " + std::to_string(*(params->patternSize));
-  log_msg += " offset = " + std::to_string(*(params->offset));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueFillBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueReadImage* params =
-    reinterpret_cast<const cl_params_clEnqueueReadImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " image = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->image)));
-  log_msg += " blockingRead = " + std::to_string(*(params->blockingRead));
-  log_msg += " origin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->origin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " rowPitch = " + std::to_string(*(params->rowPitch));
-  log_msg += " slicePitch = " + std::to_string(*(params->slicePitch));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueReadImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteBufferRectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueWriteBufferRect* params =
-    reinterpret_cast<const cl_params_clEnqueueWriteBufferRect*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " blockingWrite = " + std::to_string(*(params->blockingWrite));
-  log_msg += " bufferOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->bufferOrigin)));
-  log_msg += " hostOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->hostOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " bufferRowPitch = " + ToHexString(static_cast<uintptr_t>(*(params->bufferRowPitch)));
-  log_msg += " bufferSlicePitch = " + ToHexString(static_cast<uintptr_t>(*(params->bufferSlicePitch)));
-  log_msg += " hostRowPitch = " + std::to_string(*(params->hostRowPitch));
-  log_msg += " hostSlicePitch = " + std::to_string(*(params->hostSlicePitch));
-  log_msg += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->ptr)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueWriteBufferRectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferToImageOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueCopyBufferToImage* params =
-    reinterpret_cast<const cl_params_clEnqueueCopyBufferToImage*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " srcBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcBuffer)));
-  log_msg += " dstImage = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstImage)));
-  log_msg += " srcOffset = " + std::to_string(*(params->srcOffset));
-  log_msg += " dstOrigin = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstOrigin)));
-  log_msg += " region = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->region)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferToImageOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetExtensionFunctionAddressForPlatformOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetExtensionFunctionAddressForPlatform* params =
-    reinterpret_cast<
-      const cl_params_clGetExtensionFunctionAddressForPlatform*>(
-          data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " platform = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->platform)));
-  if (*(params->funcName) == nullptr) {
-    log_msg += " funcName = 0";
-  } else if (strlen(*(params->funcName)) == 0) {
-    log_msg += " funcName = \"\"";
-  } else {
-    log_msg += " funcName = \"" + std::string(*(params->funcName)) + "\"";
-  }
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetExtensionFunctionAddressForPlatformOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  void** result =
-    reinterpret_cast<void**>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelArgOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetKernelArg* params =
-    reinterpret_cast<const cl_params_clSetKernelArg*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->kernel)));
-  log_msg += " argIndex = " + std::to_string(*(params->argIndex));
-  log_msg += " argSize = " + std::to_string(*(params->argSize));
-  log_msg += " argValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->argValue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetKernelArgOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseDeviceOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseDevice* params =
-    reinterpret_cast<const cl_params_clReleaseDevice*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseDeviceOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateSubBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateSubBuffer* params =
-    reinterpret_cast<const cl_params_clCreateSubBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " buffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->buffer)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " bufferCreateType = " + std::to_string(*(params->bufferCreateType));
-  log_msg += " bufferCreateInfo = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->bufferCreateInfo)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateSubBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateSubBuffer* params =
-    reinterpret_cast<const cl_params_clCreateSubBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMigrateMemObjectsOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueMigrateMemObjects* params =
-    reinterpret_cast<const cl_params_clEnqueueMigrateMemObjects*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numMemObjects = " + std::to_string(*(params->numMemObjects));
-  log_msg += " memObjects = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memObjects)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMigrateMemObjectsOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateCommandQueueOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateCommandQueue* params =
-    reinterpret_cast<const cl_params_clCreateCommandQueue*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += " properties = " + ToHexString(static_cast<uintptr_t>(*(params->properties)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateCommandQueueOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateCommandQueue* params =
-    reinterpret_cast<const cl_params_clCreateCommandQueue*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_command_queue* result =
-    reinterpret_cast<cl_command_queue*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMemFillOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMMemFill* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMMemFill*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " svmPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPtr)));
-  log_msg += " pattern = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->pattern)));
-  log_msg += " patternSize = " + std::to_string(*(params->patternSize));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMemFillOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseCommandQueueOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseCommandQueue* params =
-    reinterpret_cast<const cl_params_clReleaseCommandQueue*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseCommandQueueOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueCopyBuffer* params =
-    reinterpret_cast<const cl_params_clEnqueueCopyBuffer*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " srcBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->srcBuffer)));
-  log_msg += " dstBuffer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->dstBuffer)));
-  log_msg += " srcOffset = " + std::to_string(*(params->srcOffset));
-  log_msg += " dstOffset = " + std::to_string(*(params->dstOffset));
-  log_msg += " cb = " + std::to_string(*(params->cb));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueCopyBufferOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetCommandQueueInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetCommandQueueInfo* params =
-    reinterpret_cast<const cl_params_clGetCommandQueueInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetCommandQueueInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clBuildProgramOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clBuildProgram* params =
-    reinterpret_cast<const cl_params_clBuildProgram*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += " numDevices = " + std::to_string(*(params->numDevices));
-  log_msg += " deviceList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->deviceList)));
-  if (*(params->options) == nullptr) {
-    log_msg += " options = 0";
-  } else if (strlen(*(params->options)) == 0) {
-    log_msg += " options = \"\"";
-  } else {
-    log_msg += " options = \"" + std::string(*(params->options)) + "\"";
-  }
-  log_msg += " funcNotify = " + ToHexString(reinterpret_cast<uintptr_t>(*reinterpret_cast<decltype(params->funcNotify)*>(params->funcNotify)));
-  log_msg += " userData = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->userData)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clBuildProgramOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainContextOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainContext* params =
-    reinterpret_cast<const cl_params_clRetainContext*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainContextOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueBarrierOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueBarrier* params =
-    reinterpret_cast<const cl_params_clEnqueueBarrier*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueBarrierOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainDeviceOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainDevice* params =
-    reinterpret_cast<const cl_params_clRetainDevice*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " device = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->device)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainDeviceOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMapOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueSVMMap* params =
-    reinterpret_cast<const cl_params_clEnqueueSVMMap*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " blockingMap = " + std::to_string(*(params->blockingMap));
-  log_msg += " mapFlags = " + std::to_string(*(params->mapFlags));
-  log_msg += " svmPtr = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPtr)));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueSVMMapOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainMemObjectOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainMemObject* params =
-    reinterpret_cast<const cl_params_clRetainMemObject*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " memobj = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->memobj)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainMemObjectOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetUserEventStatusOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSetUserEventStatus* params =
-    reinterpret_cast<const cl_params_clSetUserEventStatus*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += " executionStatus = " + std::to_string(*(params->executionStatus));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSetUserEventStatusOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateUserEventOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateUserEvent* params =
-    reinterpret_cast<const cl_params_clCreateUserEvent*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateUserEventOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateUserEvent* params =
-    reinterpret_cast<const cl_params_clCreateUserEvent*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_event* result =
-    reinterpret_cast<cl_event*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetSamplerInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetSamplerInfo* params =
-    reinterpret_cast<const cl_params_clGetSamplerInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " sampler = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->sampler)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetSamplerInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMarkerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueMarker* params =
-    reinterpret_cast<const cl_params_clEnqueueMarker*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMarkerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateKernel* params =
-    reinterpret_cast<const cl_params_clCreateKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  if (*(params->kernelName) == nullptr) {
-    log_msg += " kernelName = 0";
-  } else if (strlen(*(params->kernelName)) == 0) {
-    log_msg += " kernelName = \"\"";
-  } else {
-    log_msg += " kernelName = \"" + std::string(*(params->kernelName)) + "\"";
-    if (collector->Demangle()) {
-      log_msg += " (" + utils::Demangle(*(params->kernelName)) + ")";
-    }
-  }
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateKernel* params =
-    reinterpret_cast<const cl_params_clCreateKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_kernel* result =
-    reinterpret_cast<cl_kernel*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetProgramInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetProgramInfo* params =
-    reinterpret_cast<const cl_params_clGetProgramInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " program = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->program)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetProgramInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSVMAllocOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSVMAlloc* params =
-    reinterpret_cast<const cl_params_clSVMAlloc*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " size = " + std::to_string(*(params->size));
-  log_msg += " alignment = " + std::to_string(*(params->alignment));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSVMAllocOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  void ** result =
-    reinterpret_cast<void **>(
-        data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainEventOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clRetainEvent* params =
-    reinterpret_cast<const cl_params_clRetainEvent*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clRetainEventOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCloneKernelOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCloneKernel* params =
-    reinterpret_cast<const cl_params_clCloneKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " sourceKernel = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->sourceKernel)));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCloneKernelOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCloneKernel* params =
-    reinterpret_cast<const cl_params_clCloneKernel*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_kernel* result =
-    reinterpret_cast<cl_kernel*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetImageInfoOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clGetImageInfo* params =
-    reinterpret_cast<const cl_params_clGetImageInfo*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " image = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->image)));
-  log_msg += " paramName = " + std::to_string(*(params->paramName));
-  log_msg += " paramValueSize = " + std::to_string(*(params->paramValueSize));
-  log_msg += " paramValue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValue)));
-  log_msg += " paramValueSizeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->paramValueSizeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clGetImageInfoOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clFlushOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clFlush* params =
-    reinterpret_cast<const cl_params_clFlush*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clFlushOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMarkerWithWaitListOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clEnqueueMarkerWithWaitList* params =
-    reinterpret_cast<const cl_params_clEnqueueMarkerWithWaitList*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " commandQueue = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->commandQueue)));
-  log_msg += " numEventsInWaitList = " + std::to_string(*(params->numEventsInWaitList));
-  log_msg += " eventWaitList = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->eventWaitList)));
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clEnqueueMarkerWithWaitListOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateProgramWithILOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateProgramWithIL* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithIL*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " il = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->il)));
-  log_msg += " length = " + std::to_string(*(params->length));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateProgramWithILOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateProgramWithIL* params =
-    reinterpret_cast<const cl_params_clCreateProgramWithIL*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_program* result =
-    reinterpret_cast<cl_program*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateSamplerOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateSampler* params =
-    reinterpret_cast<const cl_params_clCreateSampler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " normalizedCoords = " + std::to_string(*(params->normalizedCoords));
-  log_msg += " addressingMode = " + std::to_string(*(params->addressingMode));
-  log_msg += " filterMode = " + std::to_string(*(params->filterMode));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateSamplerOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateSampler* params =
-    reinterpret_cast<const cl_params_clCreateSampler*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_sampler* result =
-    reinterpret_cast<cl_sampler*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clCreateFromGLTextureOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clCreateFromGLTexture* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " flags = " + std::to_string(*(params->flags));
-  log_msg += " target = " + std::to_string(*(params->target));
-  log_msg += " miplevel = " + std::to_string(*(params->miplevel));
-  log_msg += " texture = " + std::to_string(*(params->texture));
-  log_msg += " errcodeRet = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->errcodeRet)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-
-  if (*(params->errcodeRet) == nullptr) {
-    *(params->errcodeRet) = &current_error;
-  }
-}
-
-static void clCreateFromGLTextureOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  const cl_params_clCreateFromGLTexture* params =
-    reinterpret_cast<const cl_params_clCreateFromGLTexture*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  cl_mem* result =
-    reinterpret_cast<cl_mem*>(data->functionReturnValue);
-  UNITRACE_ASSERT(result != nullptr);
-  log_msg += " result = " + ToHexString(reinterpret_cast<uintptr_t>(*result));
-
-  UNITRACE_ASSERT(*(params->errcodeRet) != nullptr);
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(**(params->errcodeRet));
-  log_msg += " (" + std::to_string(**(params->errcodeRet)) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSVMFreeOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clSVMFree* params =
-    reinterpret_cast<const cl_params_clSVMFree*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " context = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->context)));
-  log_msg += " svmPointer = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->svmPointer)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clSVMFreeOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseEventOnEnter(
-    cl_callback_data* data, uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  const cl_params_clReleaseEvent* params =
-    reinterpret_cast<const cl_params_clReleaseEvent*>(
-        data->functionParams);
-  UNITRACE_ASSERT(params != nullptr);
-
-  std::string log_msg = ">>>> [" + std::to_string(start) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName) + ":";
-
-  log_msg += " event = " + ToHexString(reinterpret_cast<uintptr_t>(*(params->event)));
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-static void clReleaseEventOnExit(
-    cl_callback_data* data, uint64_t start, uint64_t end,
-    ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  std::string log_msg = "<<<< [" + std::to_string(end) + "] ";
-  if (collector->NeedPid()) {
-    log_msg += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-  }
-  if (collector->NeedTid()) {
-    log_msg += "<TID:" + std::to_string(utils::GetTid()) + "> ";
-  }
-  log_msg += std::string(data->functionName);
-  log_msg += " [" + std::to_string((end - start)) + " ns]";
-
-  cl_int* error = reinterpret_cast<cl_int*>(data->functionReturnValue);
-  UNITRACE_ASSERT(error != nullptr);
-
-  log_msg += " -> ";
-  log_msg += utils::cl::GetErrorString(*error);
-  log_msg += " (" + std::to_string(*error) + ")";
-  log_msg += "\n";
-
-  collector->Log(log_msg);
-}
-
-void OnEnterFunction(
-    ClFunctionId function, cl_callback_data* data,
-    uint64_t start, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  switch (function) {
-    case CL_FUNCTION_clBuildProgram:
-      clBuildProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCloneKernel:
-      clCloneKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCompileProgram:
-      clCompileProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateBuffer:
-      clCreateBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateCommandQueue:
-      clCreateCommandQueueOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateCommandQueueWithProperties:
-      clCreateCommandQueueWithPropertiesOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateContext:
-      clCreateContextOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateContextFromType:
-      clCreateContextFromTypeOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLBuffer:
-      clCreateFromGLBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLRenderbuffer:
-      clCreateFromGLRenderbufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture:
-      clCreateFromGLTextureOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture2D:
-      clCreateFromGLTexture2DOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture3D:
-      clCreateFromGLTexture3DOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateImage:
-      clCreateImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateImage2D:
-      clCreateImage2DOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateImage3D:
-      clCreateImage3DOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateKernel:
-      clCreateKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateKernelsInProgram:
-      clCreateKernelsInProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreatePipe:
-      clCreatePipeOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithBinary:
-      clCreateProgramWithBinaryOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithBuiltInKernels:
-      clCreateProgramWithBuiltInKernelsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithIL:
-      clCreateProgramWithILOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithSource:
-      clCreateProgramWithSourceOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateSampler:
-      clCreateSamplerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateSamplerWithProperties:
-      clCreateSamplerWithPropertiesOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateSubBuffer:
-      clCreateSubBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateSubDevices:
-      clCreateSubDevicesOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clCreateUserEvent:
-      clCreateUserEventOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueAcquireGLObjects:
-      clEnqueueAcquireGLObjectsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueBarrier:
-      clEnqueueBarrierOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueBarrierWithWaitList:
-      clEnqueueBarrierWithWaitListOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBuffer:
-      clEnqueueCopyBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBufferRect:
-      clEnqueueCopyBufferRectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBufferToImage:
-      clEnqueueCopyBufferToImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyImage:
-      clEnqueueCopyImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyImageToBuffer:
-      clEnqueueCopyImageToBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueFillBuffer:
-      clEnqueueFillBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueFillImage:
-      clEnqueueFillImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMapBuffer:
-      clEnqueueMapBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMapImage:
-      clEnqueueMapImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMarker:
-      clEnqueueMarkerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMarkerWithWaitList:
-      clEnqueueMarkerWithWaitListOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMigrateMemObjects:
-      clEnqueueMigrateMemObjectsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueNDRangeKernel:
-      clEnqueueNDRangeKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueNativeKernel:
-      clEnqueueNativeKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadBuffer:
-      clEnqueueReadBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadBufferRect:
-      clEnqueueReadBufferRectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadImage:
-      clEnqueueReadImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReleaseGLObjects:
-      clEnqueueReleaseGLObjectsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMFree:
-      clEnqueueSVMFreeOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMap:
-      clEnqueueSVMMapOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMemFill:
-      clEnqueueSVMMemFillOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMemcpy:
-      clEnqueueSVMMemcpyOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMigrateMem:
-      clEnqueueSVMMigrateMemOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMUnmap:
-      clEnqueueSVMUnmapOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueTask:
-      clEnqueueTaskOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueUnmapMemObject:
-      clEnqueueUnmapMemObjectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWaitForEvents:
-      clEnqueueWaitForEventsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteBuffer:
-      clEnqueueWriteBufferOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteBufferRect:
-      clEnqueueWriteBufferRectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteImage:
-      clEnqueueWriteImageOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clFinish:
-      clFinishOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clFlush:
-      clFlushOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetCommandQueueInfo:
-      clGetCommandQueueInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetContextInfo:
-      clGetContextInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceAndHostTimer:
-      clGetDeviceAndHostTimerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceIDs:
-      clGetDeviceIDsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceInfo:
-      clGetDeviceInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetEventInfo:
-      clGetEventInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetEventProfilingInfo:
-      clGetEventProfilingInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetExtensionFunctionAddress:
-      clGetExtensionFunctionAddressOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetExtensionFunctionAddressForPlatform:
-      clGetExtensionFunctionAddressForPlatformOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetGLObjectInfo:
-      clGetGLObjectInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetGLTextureInfo:
-      clGetGLTextureInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetHostTimer:
-      clGetHostTimerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetImageInfo:
-      clGetImageInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetKernelArgInfo:
-      clGetKernelArgInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetKernelInfo:
-      clGetKernelInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetKernelSubGroupInfo:
-      clGetKernelSubGroupInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetKernelWorkGroupInfo:
-      clGetKernelWorkGroupInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetMemObjectInfo:
-      clGetMemObjectInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetPipeInfo:
-      clGetPipeInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetPlatformIDs:
-      clGetPlatformIDsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetPlatformInfo:
-      clGetPlatformInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetProgramBuildInfo:
-      clGetProgramBuildInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetProgramInfo:
-      clGetProgramInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetSamplerInfo:
-      clGetSamplerInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clGetSupportedImageFormats:
-      clGetSupportedImageFormatsOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clLinkProgram:
-      clLinkProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseCommandQueue:
-      clReleaseCommandQueueOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseContext:
-      clReleaseContextOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseDevice:
-      clReleaseDeviceOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseEvent:
-      clReleaseEventOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseKernel:
-      clReleaseKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseMemObject:
-      clReleaseMemObjectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseProgram:
-      clReleaseProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clReleaseSampler:
-      clReleaseSamplerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainCommandQueue:
-      clRetainCommandQueueOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainContext:
-      clRetainContextOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainDevice:
-      clRetainDeviceOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainEvent:
-      clRetainEventOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainKernel:
-      clRetainKernelOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainMemObject:
-      clRetainMemObjectOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainProgram:
-      clRetainProgramOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clRetainSampler:
-      clRetainSamplerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSVMAlloc:
-      clSVMAllocOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSVMFree:
-      clSVMFreeOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetCommandQueueProperty:
-      clSetCommandQueuePropertyOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetDefaultDeviceCommandQueue:
-      clSetDefaultDeviceCommandQueueOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetEventCallback:
-      clSetEventCallbackOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetKernelArg:
-      clSetKernelArgOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetKernelArgSVMPointer:
-      clSetKernelArgSVMPointerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetKernelExecInfo:
-      clSetKernelExecInfoOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetMemObjectDestructorCallback:
-      clSetMemObjectDestructorCallbackOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clSetUserEventStatus:
-      clSetUserEventStatusOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clUnloadCompiler:
-      clUnloadCompilerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clUnloadPlatformCompiler:
-      clUnloadPlatformCompilerOnEnter(data, start, collector);
-      break;
-    case CL_FUNCTION_clWaitForEvents:
-      clWaitForEventsOnEnter(data, start, collector);
-      break;
-    default:
-      break;
-  }
-}
-
-void OnExitFunction(
-    ClFunctionId function, cl_callback_data* data,
-    uint64_t start, uint64_t end, ClCollector* collector) {
-  UNITRACE_ASSERT(collector != nullptr);
-  switch (function) {
-    case CL_FUNCTION_clBuildProgram:
-      clBuildProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCloneKernel:
-      clCloneKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCompileProgram:
-      clCompileProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateBuffer:
-      clCreateBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateCommandQueue:
-      clCreateCommandQueueOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateCommandQueueWithProperties:
-      clCreateCommandQueueWithPropertiesOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateContext:
-      clCreateContextOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateContextFromType:
-      clCreateContextFromTypeOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLBuffer:
-      clCreateFromGLBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLRenderbuffer:
-      clCreateFromGLRenderbufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture:
-      clCreateFromGLTextureOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture2D:
-      clCreateFromGLTexture2DOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateFromGLTexture3D:
-      clCreateFromGLTexture3DOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateImage:
-      clCreateImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateImage2D:
-      clCreateImage2DOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateImage3D:
-      clCreateImage3DOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateKernel:
-      clCreateKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateKernelsInProgram:
-      clCreateKernelsInProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreatePipe:
-      clCreatePipeOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithBinary:
-      clCreateProgramWithBinaryOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithBuiltInKernels:
-      clCreateProgramWithBuiltInKernelsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithIL:
-      clCreateProgramWithILOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateProgramWithSource:
-      clCreateProgramWithSourceOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateSampler:
-      clCreateSamplerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateSamplerWithProperties:
-      clCreateSamplerWithPropertiesOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateSubBuffer:
-      clCreateSubBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateSubDevices:
-      clCreateSubDevicesOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clCreateUserEvent:
-      clCreateUserEventOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueAcquireGLObjects:
-      clEnqueueAcquireGLObjectsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueBarrier:
-      clEnqueueBarrierOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueBarrierWithWaitList:
-      clEnqueueBarrierWithWaitListOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBuffer:
-      clEnqueueCopyBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBufferRect:
-      clEnqueueCopyBufferRectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyBufferToImage:
-      clEnqueueCopyBufferToImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyImage:
-      clEnqueueCopyImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueCopyImageToBuffer:
-      clEnqueueCopyImageToBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueFillBuffer:
-      clEnqueueFillBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueFillImage:
-      clEnqueueFillImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMapBuffer:
-      clEnqueueMapBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMapImage:
-      clEnqueueMapImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMarker:
-      clEnqueueMarkerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMarkerWithWaitList:
-      clEnqueueMarkerWithWaitListOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueMigrateMemObjects:
-      clEnqueueMigrateMemObjectsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueNDRangeKernel:
-      clEnqueueNDRangeKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueNativeKernel:
-      clEnqueueNativeKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadBuffer:
-      clEnqueueReadBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadBufferRect:
-      clEnqueueReadBufferRectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReadImage:
-      clEnqueueReadImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueReleaseGLObjects:
-      clEnqueueReleaseGLObjectsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMFree:
-      clEnqueueSVMFreeOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMap:
-      clEnqueueSVMMapOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMemFill:
-      clEnqueueSVMMemFillOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMemcpy:
-      clEnqueueSVMMemcpyOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMMigrateMem:
-      clEnqueueSVMMigrateMemOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueSVMUnmap:
-      clEnqueueSVMUnmapOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueTask:
-      clEnqueueTaskOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueUnmapMemObject:
-      clEnqueueUnmapMemObjectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWaitForEvents:
-      clEnqueueWaitForEventsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteBuffer:
-      clEnqueueWriteBufferOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteBufferRect:
-      clEnqueueWriteBufferRectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clEnqueueWriteImage:
-      clEnqueueWriteImageOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clFinish:
-      clFinishOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clFlush:
-      clFlushOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetCommandQueueInfo:
-      clGetCommandQueueInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetContextInfo:
-      clGetContextInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceAndHostTimer:
-      clGetDeviceAndHostTimerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceIDs:
-      clGetDeviceIDsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetDeviceInfo:
-      clGetDeviceInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetEventInfo:
-      clGetEventInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetEventProfilingInfo:
-      clGetEventProfilingInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetExtensionFunctionAddress:
-      clGetExtensionFunctionAddressOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetExtensionFunctionAddressForPlatform:
-      clGetExtensionFunctionAddressForPlatformOnExit(
-          data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetGLObjectInfo:
-      clGetGLObjectInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetGLTextureInfo:
-      clGetGLTextureInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetHostTimer:
-      clGetHostTimerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetImageInfo:
-      clGetImageInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetKernelArgInfo:
-      clGetKernelArgInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetKernelInfo:
-      clGetKernelInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetKernelSubGroupInfo:
-      clGetKernelSubGroupInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetKernelWorkGroupInfo:
-      clGetKernelWorkGroupInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetMemObjectInfo:
-      clGetMemObjectInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetPipeInfo:
-      clGetPipeInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetPlatformIDs:
-      clGetPlatformIDsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetPlatformInfo:
-      clGetPlatformInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetProgramBuildInfo:
-      clGetProgramBuildInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetProgramInfo:
-      clGetProgramInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetSamplerInfo:
-      clGetSamplerInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clGetSupportedImageFormats:
-      clGetSupportedImageFormatsOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clLinkProgram:
-      clLinkProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseCommandQueue:
-      clReleaseCommandQueueOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseContext:
-      clReleaseContextOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseDevice:
-      clReleaseDeviceOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseEvent:
-      clReleaseEventOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseKernel:
-      clReleaseKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseMemObject:
-      clReleaseMemObjectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseProgram:
-      clReleaseProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clReleaseSampler:
-      clReleaseSamplerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainCommandQueue:
-      clRetainCommandQueueOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainContext:
-      clRetainContextOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainDevice:
-      clRetainDeviceOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainEvent:
-      clRetainEventOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainKernel:
-      clRetainKernelOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainMemObject:
-      clRetainMemObjectOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainProgram:
-      clRetainProgramOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clRetainSampler:
-      clRetainSamplerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSVMAlloc:
-      clSVMAllocOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSVMFree:
-      clSVMFreeOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetCommandQueueProperty:
-      clSetCommandQueuePropertyOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetDefaultDeviceCommandQueue:
-      clSetDefaultDeviceCommandQueueOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetEventCallback:
-      clSetEventCallbackOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetKernelArg:
-      clSetKernelArgOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetKernelArgSVMPointer:
-      clSetKernelArgSVMPointerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetKernelExecInfo:
-      clSetKernelExecInfoOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetMemObjectDestructorCallback:
-      clSetMemObjectDestructorCallbackOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clSetUserEventStatus:
-      clSetUserEventStatusOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clUnloadCompiler:
-      clUnloadCompilerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clUnloadPlatformCompiler:
-      clUnloadPlatformCompilerOnExit(data, start, end, collector);
-      break;
-    case CL_FUNCTION_clWaitForEvents:
-      clWaitForEventsOnExit(data, start, end, collector);
-      break;
-    default:
-      break;
-  }
-}
-
-#endif /* PTI_TOOLS_UNITRACE_CL_API_CALLBACKS_H_ */
diff --git a/tools/unitrace/src/opencl/cl_collector.h b/tools/unitrace/src/opencl/cl_collector.h
deleted file mode 100644
index c64a9eec..00000000
--- a/tools/unitrace/src/opencl/cl_collector.h
+++ /dev/null
@@ -1,3310 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_CL_COLLECTOR_H_
-#define PTI_TOOLS_UNITRACE_CL_COLLECTOR_H_
-
-#include <atomic>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <list>
-#include <map>
-#include <mutex>
-#include <shared_mutex>
-#include <set>
-#include <string>
-#include <vector>
-#include <chrono>
-
-#include "utils/cl_api_tracer.h"
-#include "utils/cl_utils.h"
-#include "collector_options.h"
-#include "utils/unilogger.h"
-#include "unikernel.h"
-#include "unicontrol.h"
-
-#include <level_zero/zes_api.h>
-
-#include "common_header.gen"
-
-#include "cl_intel_ext.h"
-
-#include "utils_ze.h"
-#include "utils_host.h"
-
-class ClCollector;
-
-enum ClKernelType {
-  KERNEL_TYPE_USER,
-  KERNEL_TYPE_TRANSFER
-};
-
-struct ClEnqueueData {
-  cl_event event;
-  cl_ulong host_sync;
-  cl_ulong device_sync;
-};
-
-struct ClKernelProps {
-  std::string name;
-  // Never demangled: the .kprops reader matches it against .text.<mangled name>.
-  std::string mangled_name;
-  size_t simd_width;
-  size_t bytes_transferred;
-  size_t global_size[3];
-  size_t local_size[3];
-  uint64_t base_addr;
-  uint32_t size;
-  cl_device_id device_id;
-  // For .kprops: kernel id from UniKernelId (unique across backends); module id of the
-  // dumped binary holding the ISA, 0 if none.
-  uint64_t kernel_command_id = 0;
-  uint32_t module_id = 0;
-};
-
-struct ClKernelInstance {
-  cl_event event = nullptr;
-  ClKernelProps props;
-  uint64_t kernel_id = 0;
-  cl_ulong host_sync = 0;
-  cl_ulong device_sync = 0;
-  bool need_to_process = true;
-  cl_device_id device;
-  std::vector<int32_t> sub_device_list;
-};
-
-struct ClKernelInfo {
-  uint64_t queued_time;
-  uint64_t submit_time;
-  uint64_t execute_time;
-  uint64_t min_time;
-  uint64_t max_time;
-  uint64_t call_count;
-
-  bool operator>(const ClKernelInfo& r) const {
-    if (execute_time != r.execute_time) {
-      return execute_time > r.execute_time;
-    }
-    return call_count > r.call_count;
-  }
-
-  bool operator!=(const ClKernelInfo& r) const {
-    if (execute_time == r.execute_time) {
-      return call_count != r.call_count;
-    }
-    return true;
-  }
-};
-
-struct ClKernelMemInfo{
-  std::string name;
-  uint64_t base_addr;
-  uint32_t size;
-};
-
-using ClKernelMemInfoMap = std::map<uint64_t, ClKernelMemInfo>;
-
-using ClKernelInfoMap = std::map<std::string, ClKernelInfo>;
-using ClKernelInstanceList = std::list<ClKernelInstance*>;
-
-struct ClDevice {
-  cl_device_id id_;
-  bool isroot_;
-  cl_device_id parent_;
-  std::vector<cl_device_id> subdevs_;
-};
-
-typedef void (*OnClKernelFinishCallback)(
-    cl_device_pci_bus_info_khr& pci,
-    cl_device_id device,
-    cl_command_queue& queue,
-    int tile,
-    bool implicit,
-    const uint64_t id,
-    uint64_t started,
-    uint64_t ended);
-
-struct ClFunction {
-  uint64_t total_time;
-  uint64_t min_time;
-  uint64_t max_time;
-  uint64_t call_count;
-
-  bool operator>(const ClFunction& r) const {
-    if (total_time != r.total_time) {
-      return total_time > r.total_time;
-    }
-    return call_count > r.call_count;
-  }
-
-  bool operator!=(const ClFunction& r) const {
-    if (total_time == r.total_time) {
-      return call_count != r.call_count;
-    }
-    return true;
-  }
-};
-
-using ClFunctionInfoMap = std::map<std::string, ClFunction>;
-static std::shared_mutex cl_kernel_command_properties_mutex_;
-static std::map<uint64_t, ClKernelProps> cl_kernel_command_properties_;
-
-// Names of all active OpenCL devices
-std::map<cl_device_id, std::pair<uint32_t, std::string>>& GetDevicesNameMap() {
-  static std::map<cl_device_id, std::pair<uint32_t, std::string>> devices_id_name;
-  return devices_id_name;
-}
-inline std::pair<uint32_t, std::string> GetClDeviceName(cl_device_id device) {
-  auto it = GetDevicesNameMap().find(device);
-  if (it != GetDevicesNameMap().end()) {
-    return it->second;
-  }
-  return std::make_pair(-1, std::string(""));
-}
-
-struct ClKernelProfileRecord {
-  cl_device_id device_ = nullptr;
-  uint64_t global_instance_id_ = 0;
-  uint64_t device_started_;
-  uint64_t device_ended_;
-  std::string kernel_name_;
-};
-
-typedef void (*OnClFunctionFinishCallback)(std::vector<uint64_t> *kids, FLOW_DIR flow_dir, API_TRACING_ID api_id, uint64_t started, uint64_t ended);
-
-inline cl_device_pci_bus_info_khr GetDevicePciInfo(cl_device_id device) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  if (!utils::cl::CheckExtension(device, "cl_khr_pci_bus_info")) {
-    return cl_device_pci_bus_info_khr{0, 0, 0, 0};
-  }
-
-  cl_device_pci_bus_info_khr pci_info{};
-  cl_int status = clGetDeviceInfo(device, CL_DEVICE_PCI_BUS_INFO_KHR, sizeof(cl_device_pci_bus_info_khr), &pci_info, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return pci_info;
-}
-
-// TODO: compute when devices are enumerated at startup
-inline double GetZeDeviceTimerNsPerCycle(cl_device_id device_id) {
-  if (device_id == nullptr) {
-    return 0;
-  }
-
-  static cl_device_id last_seen_device_id = nullptr;
-  static double last_seen_ze_device_timer_ns_per_cycle = 0;
-
-  if (last_seen_device_id == device_id) {
-    return last_seen_ze_device_timer_ns_per_cycle;
-  }
-  cl_device_pci_bus_info_khr pci_info = GetDevicePciInfo(device_id);
-
-  for (auto device : GetDeviceList()) {
-    ze_pci_ext_properties_t pci_props;
-
-    pci_props.pNext = nullptr;
-    pci_props.stype = ZE_STRUCTURE_TYPE_PCI_EXT_PROPERTIES;
-    ze_result_t status = ZE_FUNC(zeDevicePciGetPropertiesExt)(device, &pci_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    if (pci_info.pci_domain == pci_props.address.domain &&
-        pci_info.pci_bus == pci_props.address.bus &&
-        pci_info.pci_device == pci_props.address.device &&
-        pci_info.pci_function == pci_props.address.function) {
-
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, };
-      ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-      last_seen_device_id = device_id;
-      last_seen_ze_device_timer_ns_per_cycle = static_cast<double>(NSEC_IN_SEC) / static_cast<double>(props.timerResolution);
-
-      return last_seen_ze_device_timer_ns_per_cycle;
-    }
-  }
-  // should not get here
-  return 0;
-}
-
-void OnEnterFunction(ClFunctionId function, cl_callback_data* data, uint64_t start, ClCollector* collector);
-void OnExitFunction(ClFunctionId function, cl_callback_data* data, uint64_t start, uint64_t end, ClCollector* collector);
-
-template <cl_device_type device_type>
-void *clHostMemAllocINTEL(cl_context context, const cl_mem_properties_intel *properties, size_t size, cl_uint alignment, cl_int *errcode_ret);
-template <cl_device_type device_type>
-void *clDeviceMemAllocINTEL(cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret);
-template <cl_device_type device_type>
-void *clSharedMemAllocINTEL(cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret);
-template <cl_device_type device_type>
-cl_int clMemFreeINTEL(cl_context context, void *ptr);
-template <cl_device_type device_type>
-cl_int clGetMemAllocInfoINTEL(cl_context context, const void *ptr, cl_mem_info_intel param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret);
-template <cl_device_type device_type>
-cl_int clSetKernelArgMemPointerINTEL(cl_kernel kernel, cl_uint arg_index, const void *arg_value);
-template <cl_device_type device_type>
-cl_int clEnqueueMemcpyINTEL(cl_command_queue command_queue, cl_bool blocking, void *dst_ptr, const void *src_ptr,
-        size_t size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event);
-template <cl_device_type device_type>
-cl_int clGetDeviceGlobalVariablePointerINTEL(cl_device_id device, cl_program program, const char *global_variable_name,
-        size_t *global_variable_size_ret, void **global_variable_pointer_ret);
-template <cl_device_type device_type>
-cl_int clGetKernelSuggestedLocalWorkSizeINTEL(cl_command_queue command_queue, cl_kernel kernel, cl_uint workDim,
-        const size_t *global_work_offset, const size_t *global_work_size, size_t *suggested_local_work_size);
-template <cl_device_type device_type>
-cl_mem clCreateBufferWithPropertiesINTEL( cl_context context, const cl_mem_properties_intel* properties, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret);
-template <cl_device_type device_type>
-cl_int clEnqueueMemsetINTEL(cl_command_queue command_queue, void* dst_ptr, cl_int value, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event);
-template <cl_device_type device_type>
-cl_int clEnqueueMigrateMemINTEL(cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_migration_flags flags,
-        cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event);
-template <cl_device_type device_type>
-cl_int clEnqueueMemAdviseINTEL(cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_advice_intel advice,
-        cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event);
-template <cl_device_type device_type>
-cl_int clEnqueueMemFillINTEL(cl_command_queue command_queue, void* dst_ptr, const void* pattern, size_t pattern_size, size_t size,
-        cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event);
-template <cl_device_type device_type>
-cl_int clMemBlockingFreeINTEL( cl_context context, void* ptr);
-
-inline std::string PadLeft(const std::string& str, size_t width) {
-  if (str.length() >= width) return str;
-  return std::string(width - str.length(), ' ') + str;
-}
-
-inline std::string FormatFloat(float value, int precision = 2) {
-  std::string result = std::to_string(value);
-  size_t dot_pos = result.find('.');
-  if ((dot_pos != std::string::npos) && (dot_pos + precision + 1 < result.length())) {
-    result = result.substr(0, dot_pos + precision + 1);
-  }
-  return result;
-}
-
-inline std::string GetVerboseName(const ClKernelProps* props) {
-  UNITRACE_ASSERT(props != nullptr);
-  UNITRACE_ASSERT(!props->name.empty());
-
-  std::string result = props->name;
-  if (props->simd_width > 0) {
-    result += "[SIMD";
-    if (props->simd_width == 1) {
-      result += "_ANY";
-    } else {
-      result += std::to_string(props->simd_width);
-    }
-    result += " {" +
-      std::to_string(props->global_size[0]) + "; " +
-      std::to_string(props->global_size[1]) + "; " +
-      std::to_string(props->global_size[2]) + "} {" +
-      std::to_string(props->local_size[0]) + "; " +
-      std::to_string(props->local_size[1]) + "; " +
-      std::to_string(props->local_size[2]) + "}]";
-  } else if (props->bytes_transferred > 0) {
-    result += "[" + std::to_string(props->bytes_transferred) + "]";
-  }
-
-  return result;
-}
-
-inline std::string GetClKernelCommandName(uint64_t id) {
-  return GetVerboseName(&cl_kernel_command_properties_[id]);
-}
-
-class ClCollector {
- public: // Interface
-  static ClCollector* Create(
-      cl_device_id device,
-      CollectorOptions options,
-      OnClKernelFinishCallback kcallback = nullptr,
-      OnClFunctionFinishCallback fcallback = nullptr,
-      void* callback_data = nullptr) {
-    UNITRACE_ASSERT(device != nullptr);
-
-    std::string data_dir_name = utils::GetEnv("UNITRACE_DataDir");
-
-    ClCollector* collector = new ClCollector(
-        device, options, kcallback, fcallback, callback_data, data_dir_name);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    collector->SetKernelTracingPoints();
-
-    ClApiTracer* tracer;
-    tracer = new ClApiTracer(device, TracingCallBack, collector);
-    collector->EnableTracing(tracer);
-
-    if (tracer == nullptr || !tracer->IsValid()) {
-      std::cerr << "[WARNING] Unable to create OpenCL tracer " <<
-        "for target device" << std::endl;
-      if (tracer != nullptr) {
-        delete tracer;
-      }
-      delete collector;
-      return nullptr;
-    }
-
-    collector->tracer_ = tracer;
-
-    if (collector->device_type_ == CL_DEVICE_TYPE_CPU) {
-      cl_cpu_collector_ = collector;
-    }
-    else {
-      cl_gpu_collector_ = collector;
-    }
-
-    return collector;
-  }
-
-  ~ClCollector() {
-    ReleaseDeviceMap();
-    if (tracer_ != nullptr) {
-      delete tracer_;
-    }
-  }
-
-  void FlushData() {
-    ProcessKernelInstances();
-    DumpKernelProfiles();
-  }
-
-  void DumpKernelProfiles() {
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (options_.stall_sampling) {
-      std::map<uint32_t, std::map<uint64_t, const ClKernelProps *>> device_kprops;
-      for (auto it = kprops_.begin(); it != kprops_.end(); it++) {
-        auto dev_id = present_cl_devices_.find(it->second.device_id);
-        if (dev_id == present_cl_devices_.end()) {
-          std::cerr<<"Invalid device is found\n";
-          return;
-        }
-        // Add to the device's existing map; inserting a new map would be a no-op.
-        auto dkit = device_kprops.find(dev_id->second);
-        if (dkit == device_kprops.end()) {
-          std::map<uint64_t, const ClKernelProps *> prop;
-          prop.insert({it->second.base_addr, &(it->second)});
-          device_kprops.insert({dev_id->second, std::move(prop)});
-        }
-        else {
-          // Keyed by base address: kernels sharing one keep the first seen.
-          dkit->second.insert({it->second.base_addr, &(it->second)});
-        }
-      }
-
-      // Same record format as ze_collector.h, one line each: quoted mangled name, base
-      // address, kernel command id, module id. The pid is in the file name. Module 0 means
-      // no binary was dumped, and the reader drops the record.
-      for (auto& props : device_kprops) {
-        std::shared_ptr<UniLogger> kpfs_logger =
-            logger_factory_->GetDeviceLogger(LOGGER_TYPE_KPROPS, props.first, true, true);
-        if (kpfs_logger == nullptr) {
-          std::cerr << "[ERROR] Failed to create kernel properties data file" << std::endl;
-          exit(-1);
-        }
-        for (auto it = props.second.cbegin(); it != props.second.cend(); it++) {
-          kpfs_logger->Log("\"" + it->second->mangled_name + "\"\n" +
-                           std::to_string(it->second->base_addr) + "\n" +
-                           std::to_string(it->second->kernel_command_id) + "\n" +
-                           std::to_string(it->second->module_id) + "\n");
-        }
-        kpfs_logger->Flush();
-      }
-    }
-
-    if (options_.metric_stream) {
-      std::map<int32_t, std::vector<ClKernelProfileRecord>> device_kprofiles;
-      for (const auto &record : profile_records_) {
-        auto it = present_cl_devices_.find(record.device_);
-        if (it == present_cl_devices_.end()) {
-          std::cerr << "[ERROR] Invalid device is found\n";
-          return;
-        }
-        auto device_id = it->second;
-        if (device_kprofiles.find(device_id) != device_kprofiles.end()) {
-          device_kprofiles[device_id].push_back(record);
-        } else {
-          std::vector<ClKernelProfileRecord> new_recs;
-          new_recs.push_back(record);
-          device_kprofiles[device_id] = std::move(new_recs);
-        }
-      }
-
-      for (const auto &dev_kprofile : device_kprofiles) {
-        std::shared_ptr<UniLogger> ktime_logger = logger_factory_->GetDeviceLogger(LOGGER_TYPE_KTIME, dev_kprofile.first, true, true);
-        for (const auto &profile : dev_kprofile.second) {
-          ktime_logger->Log(std::to_string((-1)) + "\n");
-          ktime_logger->Log(std::to_string(profile.global_instance_id_) + "\n");
-          ktime_logger->Log(std::to_string(profile.device_started_) + "\n");
-          ktime_logger->Log(std::to_string(profile.device_ended_) + "\n");
-          ktime_logger->Log("\"" + profile.kernel_name_ + "\"\n");
-        }
-        ktime_logger->Flush();
-      }
-    }
-  }
-
-  const ClKernelInfoMap& GetKernelInfoMap() const {
-    return kernel_info_map_;
-  }
-
-  ClCollector(const ClCollector& copy) = delete;
-  ClCollector& operator=(const ClCollector& copy) = delete;
-
-  const ClKernelMemInfoMap& GetKernelMemInfo() const {
-    return kernel_mem_info_map_;
-  }
-
-  void PrintKernelsTable(std::shared_ptr<UniLogger> logger) const {
-    std::set< std::pair<std::string, ClKernelInfo>,
-              utils::Comparator > sorted_list(
-        kernel_info_map_.begin(), kernel_info_map_.end());
-
-    uint64_t total_duration = 0;
-    size_t max_name_length = kKernelLength;
-    for (auto& value : sorted_list) {
-      total_duration += value.second.execute_time;
-      if (value.first.size() > max_name_length) {
-        max_name_length = value.first.size();
-      }
-    }
-
-    if (total_duration == 0) {
-      return;
-    }
-
-    std::string output = "";
-    output += PadLeft("Kernel", max_name_length) + "," +
-              PadLeft("Calls", kCallsLength) + "," +
-              PadLeft("Time (ns)", kTimeLength) + "," +
-              PadLeft("Time (%)", kPercentLength) + "," +
-              PadLeft("Average (ns)", kTimeLength) + "," +
-              PadLeft("Min (ns)", kTimeLength) + "," +
-              PadLeft("Max (ns)", kTimeLength) + '\n';
-
-    for (auto& value : sorted_list) {
-      const std::string& function = value.first;
-      uint64_t call_count = value.second.call_count;
-      uint64_t duration = value.second.execute_time;
-      uint64_t avg_duration = duration / call_count;
-      uint64_t min_duration = value.second.min_time;
-      uint64_t max_duration = value.second.max_time;
-      float percent_duration = 100.0f * duration / total_duration;
-      output += PadLeft(function, max_name_length) + "," +
-                PadLeft(std::to_string(call_count), kCallsLength) + "," +
-                PadLeft(std::to_string(duration), kTimeLength) + "," +
-                PadLeft(FormatFloat(percent_duration), kPercentLength) + "," +
-                PadLeft(std::to_string(avg_duration), kTimeLength) + "," +
-                PadLeft(std::to_string(min_duration), kTimeLength) + "," +
-                PadLeft(std::to_string(max_duration), kTimeLength) + '\n';
-    }
-
-    logger->Log(output);
-  }
-
-  void PrintSubmissionTable(std::shared_ptr<UniLogger> logger) const {
-    std::set< std::pair<std::string, ClKernelInfo>,
-              utils::Comparator > sorted_list(
-        kernel_info_map_.begin(), kernel_info_map_.end());
-
-    uint64_t total_queued_duration = 0;
-    uint64_t total_submit_duration = 0;
-    uint64_t total_execute_duration = 0;
-    size_t max_name_length = kKernelLength;
-    for (auto& value : sorted_list) {
-      total_queued_duration += value.second.queued_time;
-      total_submit_duration += value.second.submit_time;
-      total_execute_duration += value.second.execute_time;
-      if (value.first.size() > max_name_length) {
-        max_name_length = value.first.size();
-      }
-    }
-
-    if (total_execute_duration == 0) {
-      return;
-    }
-
-    std::string output = "";
-    output += PadLeft("Kernel", max_name_length) + "," +
-              PadLeft("Calls", kCallsLength) + "," +
-              PadLeft("Queued (ns)", kTimeLength) + "," +
-              PadLeft("Queued (%)", kPercentLength) + "," +
-              PadLeft("Submit (ns)", kTimeLength) + "," +
-              PadLeft("Submit (%)", kPercentLength) + "," +
-              PadLeft("Execute (ns)", kTimeLength) + "," +
-              PadLeft("Execute (%)", kPercentLength) + '\n';
-
-    for (auto& value : sorted_list) {
-      const std::string& function = value.first;
-      uint64_t call_count = value.second.call_count;
-      uint64_t queued_duration = value.second.queued_time;
-      float queued_percent =
-        100.0f * queued_duration / total_queued_duration;
-      uint64_t submit_duration = value.second.submit_time;
-      float submit_percent =
-        100.0f * submit_duration / total_submit_duration;
-      uint64_t execute_duration = value.second.execute_time;
-      float execute_percent =
-        100.0f * execute_duration / total_execute_duration;
-      output += PadLeft(function, max_name_length) + "," +
-                PadLeft(std::to_string(call_count), kCallsLength) + "," +
-                PadLeft(std::to_string(queued_duration), kTimeLength) + "," +
-                PadLeft(FormatFloat(queued_percent), kPercentLength) + "," +
-                PadLeft(std::to_string(submit_duration), kTimeLength) + "," +
-                PadLeft(FormatFloat(submit_percent), kPercentLength) + "," +
-                PadLeft(std::to_string(execute_duration), kTimeLength) + "," +
-                PadLeft(FormatFloat(execute_percent), kPercentLength) + '\n';
-    }
-    
-    logger->Log(output);
-  }
-
-  const ClFunctionInfoMap& GetFunctionInfoMap() const {
-    return function_info_map_;
-  }
-
-  bool NeedTid() const {
-    return options_.need_tid;
-  }
-
-  bool NeedPid() const {
-    return options_.need_pid;
-  }
-
-  bool Demangle() const {
-    return options_.demangle;
-  }
-
-  void Log(const std::string& text) {
-    logger_->Log(text);
-  }
-
-  void PrintFunctionsTable(std::shared_ptr<UniLogger> logger) const {
-    std::set< std::pair<std::string, ClFunction>,
-              utils::Comparator > sorted_list(
-        function_info_map_.begin(), function_info_map_.end());
-
-    uint64_t total_duration = 0;
-    size_t max_name_length = kFunctionLength;
-    for (auto& value : sorted_list) {
-      total_duration += value.second.total_time;
-      if (value.first.size() > max_name_length) {
-        max_name_length = value.first.size();
-      }
-    }
-
-    if (total_duration == 0) {
-      return;
-    }
-
-    std::string output;
-    output += PadLeft("Function", max_name_length) + "," +
-              PadLeft("Calls", kCallsLength) + "," +
-              PadLeft("Time (ns)", kTimeLength) + "," +
-              PadLeft("Time (%)", kPercentLength) + "," +
-              PadLeft("Average (ns)", kTimeLength) + "," +
-              PadLeft("Min (ns)", kTimeLength) + "," +
-              PadLeft("Max (ns)", kTimeLength) + '\n';
-
-    for (auto& value : sorted_list) {
-      const std::string& function = value.first;
-      uint64_t call_count = value.second.call_count;
-      uint64_t duration = value.second.total_time;
-      uint64_t avg_duration = duration / call_count;
-      uint64_t min_duration = value.second.min_time;
-      uint64_t max_duration = value.second.max_time;
-      float percent_duration = 100.0f * duration / total_duration;
-      output += PadLeft(function, max_name_length) + "," +
-                PadLeft(std::to_string(call_count), kCallsLength) + "," +
-                PadLeft(std::to_string(duration), kTimeLength) + "," +
-                PadLeft(FormatFloat(percent_duration), kPercentLength) + "," +
-                PadLeft(std::to_string(avg_duration), kTimeLength) + "," +
-                PadLeft(std::to_string(min_duration), kTimeLength) + "," +
-                PadLeft(std::to_string(max_duration), kTimeLength) + '\n';
-    }
-    
-    logger->Log(output);
-  }
-
-  static ClCollector *GetCollector(cl_device_type device_type) {
-    if (device_type == CL_DEVICE_TYPE_GPU) {
-      return cl_gpu_collector_;
-    }
-    else {
-      return cl_cpu_collector_;
-    }
-  }
-
-  uint64_t GetTimestamp() const {
-    return utils::GetSystemTime();
-  }
-
-  void AddFunctionTime(const std::string& name, uint64_t time) {
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (function_info_map_.count(name) == 0) {
-      function_info_map_[name] = {time, time, time, 1};
-    } else {
-      ClFunction& function = function_info_map_[name];
-      function.total_time += time;
-      if (time < function.min_time) {
-        function.min_time = time;
-      }
-      if (time > function.max_time) {
-        function.max_time = time;
-      }
-      ++function.call_count;
-    }
-  }
-
-  static bool IsTracingNow() {
-    return trace_now_;
-  }
-
-  static void TracingNowOn() {
-    trace_now_ = true;
-  }
-
-  static void TracingNowOff() {
-    trace_now_ = false;
-  }
-
-  static void PushTraceNesting() {
-    trace_nesting_level_++;
-    if (trace_nesting_level_ == max_trace_nesting_level_) {
-      std::cerr << "[ERROR] Nest tracing level " << trace_nesting_level_ << " is unsupported" << std::endl;
-      exit(-1);
-    }
-  }
-
-  static void PopTraceNesting() {
-    trace_nesting_level_--;
-    if (trace_nesting_level_ < -1) {
-      std::cerr << "[ERROR] Nest tracing level " << trace_nesting_level_ << " is unsupported" << std::endl;
-      exit(-1);
-    }
-  }
-
-  static uint64_t GetTraceStartTimeAndPopTraceNesting() {
-    uint64_t t = trace_start_time_[trace_nesting_level_];
-    PopTraceNesting();
-    return t;
-  }
-
-  void PushTraceNestingAndCaptureTraceStartTime(){
-    PushTraceNesting();
-    trace_start_time_[trace_nesting_level_] = GetTimestamp();
-  }
-
-  bool IsHostTimingOn() {
-    return options_.host_timing;
-  }
-
-  bool IsCallLoggingOn() {
-    return options_.call_logging;
-  }
-
-  void *GetClExtFunction(int i) {
-    void *ret;
-    cl_ext_func_lock_.lock_shared();
-    ret = cl_ext_func_[i];
-    cl_ext_func_lock_.unlock();
-    return ret;
-  }
-
-  void InvokeFunctionFinishCallback(std::vector<uint64_t> *kids, FLOW_DIR flow_dir, const cl_ext_api_id api_id, uint64_t started, uint64_t ended) {
-    if (fcallback_ != nullptr) {
-      fcallback_(kids, flow_dir, (API_TRACING_ID)api_id, started, ended);
-    }
-  }
-
- private: // Implementation Details
-  ClCollector(
-      cl_device_id device,
-      CollectorOptions options,
-      OnClKernelFinishCallback kcallback,
-      OnClFunctionFinishCallback fcallback,
-      void* /* callback_data */,
-      std::string& data_dir_name)
-      : device_(device),
-        options_(options),
-        kcallback_(kcallback),
-        fcallback_(fcallback),
-        data_dir_name_(data_dir_name) {
-    UNITRACE_ASSERT(device_ != nullptr);
-
-    // Create LoggerFactory singleton and loggers
-    logger_factory_ = LoggerFactory::Create();
-    if (options_.call_logging) {
-      logger_ = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_CALL_LOGGING);
-    }
-    if (options_.device_timeline) {
-      logger_device_timeline_ = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_DEVICE_TIMELINE);
-    }
-
-    device_type_ = utils::cl::GetDeviceType(device);
-    UNITRACE_ASSERT(device_type_ == CL_DEVICE_TYPE_CPU || device_type_ == CL_DEVICE_TYPE_GPU);
-    CreateDeviceMap();
-
-    // initialize extension function replacements to nulls
-    const std::lock_guard<std::shared_mutex> lock(cl_ext_func_lock_);
-    for (int i = 0; i < (ClExtApiEnd - ClExtApiStart); i++) {
-      cl_ext_func_[i] = nullptr;
-    }
-  }
-
-  void CreateDeviceMap() {
-    cl_device_type type = utils::cl::GetDeviceType(device_);
-
-    cl_int status = CL_SUCCESS;
-    cl_uint pcount = 0;
-    status = clGetPlatformIDs(0, nullptr, &pcount);
-
-    if ((status != CL_SUCCESS) || (pcount == 0)) {
-      std::cerr << "[WARNING] Unable to get platform identifiers" << std::endl;
-      return;
-    }
-
-    std::vector<cl_platform_id> platforms(pcount, nullptr);
-    status = clGetPlatformIDs(pcount, platforms.data(), nullptr);
-    if (status != CL_SUCCESS) {
-      std::cerr << "[WARNING] Unable to get platform identifiers" << std::endl;
-      return;
-    }
-
-    for (auto plat : platforms) {
-      cl_uint dcount = 0;
-
-      status = clGetDeviceIDs(plat, type, 0, nullptr, &dcount);
-      if ((status != CL_SUCCESS) || (dcount == 0)) {
-        std::cerr << "[WARNING] Unable to get device identifiers" << std::endl;
-        continue;
-      }
-
-      std::vector<cl_device_id> devs(dcount, nullptr);
-      status = clGetDeviceIDs(plat, type, dcount, devs.data(), nullptr);
-      if (status != CL_SUCCESS) {
-        std::cerr << "[WARNING] Unable to get device identifiers" << std::endl;
-        continue;
-      }
-
-      for (auto dev : devs) {
-        ClDevice cd;
-
-        cd.isroot_ = true;
-        cd.id_ = dev;
-        cd.parent_ = (cl_device_id)(-1);
-        cl_device_partition_property props[] = {CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN, CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE, 0};
-        cl_uint subcount = 0;
-        status = clCreateSubDevices(dev, props, 0, nullptr, &subcount);
-        if ((status != CL_SUCCESS) || (subcount == 0)) {
-          cd.subdevs_ = std::vector<cl_device_id>();
-        }
-        else {
-          std::vector<cl_device_id> subdevs(subcount);
-          status = clCreateSubDevices(dev, props, subcount, subdevs.data(), nullptr);
-          if (status != CL_SUCCESS) {
-            // TODO: check on Windows
-            std::cerr << "[WARNING] Unable to create sub-devices" << std::endl;
-            subdevs.clear();
-          }
-          else {
-            for (auto subdev : subdevs) {
-              ClDevice subcd;
-
-              subcd.id_ = subdev;
-              subcd.isroot_ = false;
-              subcd.parent_ = dev;
-              subcd.subdevs_ = std::vector<cl_device_id>();
-
-              uint32_t device_id = present_cl_devices_.size();
-
-              // get sub-device names
-              size_t name_size = 0;
-              status = clGetDeviceInfo(subdev, CL_DEVICE_NAME, 0, NULL, &name_size);
-              if (status == CL_SUCCESS) {
-                std::string str_dev_name(name_size+1, '\0');
-                status = clGetDeviceInfo(subdev, CL_DEVICE_NAME, name_size, str_dev_name.data(), NULL);
-                if (status == CL_SUCCESS) {
-                  // drop trailing NULs so they don't end up in trace output
-                  str_dev_name.resize(std::strlen(str_dev_name.c_str()));
-                  GetDevicesNameMap().insert({subdev, std::make_pair(device_id, std::move(str_dev_name))});
-                }
-              }
-              device_map_.insert({subdev, subcd});
-              present_cl_devices_.insert({subdev,device_id});
-            }
-          }
-          cd.subdevs_ = std::move(subdevs);
-        }
-
-        uint32_t device_id = present_cl_devices_.size();
-
-        // get device names
-        size_t name_size = 0;
-        status = clGetDeviceInfo(dev, CL_DEVICE_NAME, 0, NULL, &name_size);
-        if (status == CL_SUCCESS) {
-          std::string str_dev_name(name_size+1, '\0');
-          status = clGetDeviceInfo(dev, CL_DEVICE_NAME, name_size, str_dev_name.data(), NULL);
-          if (status == CL_SUCCESS) {
-            // drop trailing NULs so they don't end up in trace output
-            str_dev_name.resize(std::strlen(str_dev_name.c_str()));
-            GetDevicesNameMap().insert({dev, std::make_pair(device_id, std::move(str_dev_name))});
-          }
-        }
-
-        if (status != CL_SUCCESS) {
-          std::cerr << "[ERROR] clGetDeviceInfo failed with error "<<status<<std::endl;
-        }
-
-        device_map_.insert({dev, cd});
-        present_cl_devices_.insert({dev, device_id});
-      }
-    }
-  }
-
-  void ReleaseDeviceMap() {
-    for (auto dev : device_map_) {
-      if (dev.second.isroot_) {
-        for (auto subdev : dev.second.subdevs_) {
-          clReleaseDevice(subdev);
-        }
-      }
-    }
-  }
-
-  void SetKernelTracingPoints() {
-    for (int i = 0; i < CL_FUNCTION_COUNT; i++) {
-      kernel_tracing_points_enabled[i] = false;
-    }
-    kernel_tracing_points_enabled[CL_FUNCTION_clCreateCommandQueueWithProperties] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clCreateCommandQueue] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueNDRangeKernel] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueTask] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueReadBuffer] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueWriteBuffer] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueReadBufferRect] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueWriteBufferRect] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueCopyBuffer] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueCopyBufferRect] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueFillBuffer] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueReadImage] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueWriteImage] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueCopyImage] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueFillImage] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueCopyImageToBuffer] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clEnqueueCopyBufferToImage] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clFinish] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clReleaseCommandQueue] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clReleaseEvent] = true;
-    kernel_tracing_points_enabled[CL_FUNCTION_clWaitForEvents] = true;
-
-    // Program hooks that dump kernel binaries, needed only for stall sampling. Kernel
-    // creation needs no hook: RegisterProgramModule gets all kernel names at build time.
-    // Delivered even while paused; see IsProgramTracingPoint.
-    if (options_.stall_sampling) {
-      kernel_tracing_points_enabled[CL_FUNCTION_clBuildProgram] = true;
-      kernel_tracing_points_enabled[CL_FUNCTION_clLinkProgram] = true;
-      kernel_tracing_points_enabled[CL_FUNCTION_clReleaseProgram] = true;
-    }
-  }
-
-  void EnableTracing(ClApiTracer* tracer) {
-    UNITRACE_ASSERT(tracer != nullptr);
-
-    for (int id = 0; id < CL_FUNCTION_COUNT; ++id) {
-      if (options_.api_tracing || (kernel_tracing_points_enabled[id] && options_.kernel_tracing)) {
-        bool set = tracer->SetTracingFunction(static_cast<ClFunctionId>(id));
-        // Older runtimes may lack newer functions; core APIs (up to clWaitForEvents) must succeed.
-        if (!set) {
-          UNITRACE_ASSERT(id > CL_FUNCTION_clWaitForEvents);
-          break;
-        }
-      }
-    }
-
-    bool enabled = tracer->Enable();
-    UNITRACE_ASSERT(enabled);
-  }
-
-  void AddKernelMemInfo(const std::string& name, uint64_t base_addr, uint32_t size) {
-    if ((base_addr != 0) && (kernel_mem_info_map_.find(base_addr) == kernel_mem_info_map_.end())) {
-      ClKernelMemInfo m;
-
-      m.name = name;
-      m.base_addr = base_addr;
-      m.size = size;
-      kernel_mem_info_map_.insert(std::pair<uint64_t, ClKernelMemInfo>(base_addr, m));
-    }
-  }
-
-  void AddKernelInstance(ClKernelInstance* instance) {
-    UNITRACE_ASSERT(instance != nullptr);
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    cl_event event = instance->event;
-    cl_command_queue queue = utils::cl::GetCommandQueue(event);
-    UNITRACE_ASSERT(queue != nullptr);
-    cl_device_id device = utils::cl::GetDevice(queue);
-    UNITRACE_ASSERT(device != nullptr);
-
-    auto it = device_map_.find(device);
-    if (it != device_map_.end()) {
-      if (it->second.isroot_) {
-        int i = 0;
-        if (it->second.subdevs_.size() > 0) {
-          // implicit scaling in COMPOSITE mode
-          for (auto subdev : it->second.subdevs_) {
-            instance->device = subdev;
-            instance->sub_device_list.push_back(i++);
-          }
-        }
-        else {
-          // FLAT mode
-          instance->device = device;
-        }
-      }
-      else {
-        // explicit scaling in COMPOSITE mode
-        instance->device = device;
-      }
-    }
-    kernel_instance_list_.push_back(instance);
-    AddKernelMemInfo(instance->props.name, instance->props.base_addr, instance->props.size);
-  }
-
-  static void ComputeHostTimestamps(
-      const ClKernelInstance* instance,
-      cl_ulong started,
-      cl_ulong ended,
-      uint64_t& host_queued,
-      uint64_t& host_submitted,
-      uint64_t& host_started,
-      uint64_t& host_ended) {
-    UNITRACE_ASSERT(instance != nullptr);
-    UNITRACE_ASSERT(started < ended);
-
-    UNITRACE_ASSERT(instance->event != nullptr);
-    cl_event event = instance->event;
-
-    cl_ulong queued =
-      utils::cl::GetEventTimestamp(event, CL_PROFILING_COMMAND_QUEUED);
-    //UNITRACE_ASSERT(queued > 0);
-    cl_ulong submitted =
-      utils::cl::GetEventTimestamp(event, CL_PROFILING_COMMAND_SUBMIT);
-    //UNITRACE_ASSERT(submitted > 0);
-
-    //UNITRACE_ASSERT(instance->device_sync <= queued);
-    // Workaround for a driver bug: the queued timestamp is sometimes wrong
-    int64_t time_diff = 0 < queued ? (queued - instance->device_sync) : 0;
-    uint64_t time_shift = ((time_diff > 0) ? time_diff : 0);
-    host_queued = instance->host_sync + time_shift;
-    // TODO(Windows): find out why submitted > started sometimes
-#ifdef _WIN32
-    time_diff = queued <= submitted ? (submitted - queued) : 0;
-    host_submitted = host_queued + time_diff;
-    time_diff = submitted <= started ? (started - submitted) : 0;
-    host_started = host_submitted + time_diff;
-    time_diff = started <= ended ? (ended - started) : 0;
-    host_ended = host_started + time_diff;
-#else /* _WIN32 */
-    UNITRACE_ASSERT(queued <= submitted);
-    host_submitted = host_queued + (submitted - queued);
-    UNITRACE_ASSERT(submitted <= started);
-    host_started = host_submitted + (started - submitted);
-    UNITRACE_ASSERT(started <= ended);
-    host_ended = host_started + (ended - started);
-#endif /* _WIN32 */
-  }
-
-  void PrintOutOffloadedCommand(std::string& name, cl_device_id& device, uint64_t appended, uint64_t submitted, uint64_t kernel_start, uint64_t kernel_end) {
-    std::string output = "Thread " + std::to_string(utils::GetTid()) +
-                         " Device " + std::to_string(reinterpret_cast<uintptr_t>(device)) +
-                         " : " + name + " [ns] " +
-                         std::to_string(appended) + " (append) " +
-                         std::to_string(submitted) + " (submit) " +
-                         std::to_string(kernel_start) + " (start) " +
-                         std::to_string(kernel_end) + " (end)" + '\n';
-    logger_device_timeline_->Log(output);
-  }
-
-  inline cl_device_pci_bus_info_khr GetDevicePciInfo(cl_device_id device) {
-    cl_device_pci_bus_info_khr pciInfo;
-    cl_int status = clGetDeviceInfo(device, CL_DEVICE_PCI_BUS_INFO_KHR, sizeof(cl_device_pci_bus_info_khr), &pciInfo, nullptr);
-    UNITRACE_ASSERT(status == CL_SUCCESS);
-    return pciInfo;
-  }
-
-  void ProcessKernelInstance(const ClKernelInstance* instance, int32_t tile) {
-    UNITRACE_ASSERT(instance != nullptr);
-
-    UNITRACE_ASSERT(instance->event != nullptr);
-    cl_event event = instance->event;
-
-    cl_int event_status = utils::cl::GetEventStatus(event);
-    UNITRACE_ASSERT(event_status == CL_COMPLETE);
-
-    if (instance->need_to_process) {
-      cl_command_queue queue = utils::cl::GetCommandQueue(event);
-      UNITRACE_ASSERT(queue != nullptr);
-
-      cl_ulong started =
-        utils::cl::GetEventTimestamp(event, CL_PROFILING_COMMAND_START);
-      cl_ulong ended =
-        utils::cl::GetEventTimestamp(event, CL_PROFILING_COMMAND_END);
-
-      cl_device_id device = utils::cl::GetDevice(queue);
-      UNITRACE_ASSERT(device != nullptr);
-      cl_device_pci_bus_info_khr pciInfo = GetDevicePciInfo(device);
-
-      std::string name = instance->props.name;
-      UNITRACE_ASSERT(!name.empty());
-
-      if (options_.verbose) {
-        name = GetVerboseName(&(instance->props));
-      }
-
-      uint64_t host_queued = 0, host_submitted = 0;
-      uint64_t host_started = 0, host_ended = 0;
-      ComputeHostTimestamps(instance, started, ended, host_queued, host_submitted, host_started, host_ended);
-      AddKernelInfo(name, host_submitted - host_queued, host_started - host_submitted, host_ended - host_started);
-
-      bool implicit = false;
-
-      if (tile >= 0) {
-        auto it = device_map_.find(device);
-        if (it != device_map_.end()) {
-          if (it->second.isroot_ && (it->second.subdevs_.size() > 0)) {
-            // implicit scaling in COMPOSITE mode
-            implicit = true;
-          }
-        }
-      }
-
-      if (options_.device_timeline) {
-        PrintOutOffloadedCommand(name, device, host_queued, host_submitted, host_started, host_ended);
-      }
-
-      auto it = cl_kernel_command_properties_.find(instance->kernel_id);
-      if (it == cl_kernel_command_properties_.end()) {
-        cl_kernel_command_properties_.insert({instance->kernel_id, instance->props});
-      }
-
-      if (kcallback_ != nullptr) {
-        kcallback_(pciInfo, device, queue, tile, implicit, instance->kernel_id, host_started, host_ended);
-      }
-
-      if (options_.metric_stream) {
-        double ns_per_cycle = GetZeDeviceTimerNsPerCycle(device);
-        UNITRACE_ASSERT(ns_per_cycle > 0);
-
-        uint64_t ze_started;
-        uint64_t ze_ended;
-
-        // convert time from nano seconds to cycles
-        ze_started = static_cast<double>(started) / ns_per_cycle;
-        ze_ended = static_cast<double>(ended) / ns_per_cycle;
-
-        ClKernelProfileRecord rec{device, instance->kernel_id, ze_started, ze_ended, std::move(name)};
-
-        profile_records_.push_back(std::move(rec));
-      }
-    }
-  }
-
-  void ProcessKernelInstance(cl_event event) {
-    UNITRACE_ASSERT(event != nullptr);
-    cl_int event_status = utils::cl::GetEventStatus(event);
-    if (event_status != CL_COMPLETE) {
-      return;
-    }
-
-    const std::lock_guard<std::mutex> lock(lock_);
-    for (auto it = kernel_instance_list_.begin();
-         it != kernel_instance_list_.end(); ++it) {
-      ClKernelInstance* instance = *it;
-      UNITRACE_ASSERT(instance != nullptr);
-      UNITRACE_ASSERT(instance->event != nullptr);
-      if (instance->event == event) {
-	if (instance->sub_device_list.size()) {
-          for (size_t i = 0; i < instance->sub_device_list.size(); ++i) {
-            ProcessKernelInstance(instance,instance->sub_device_list[i]);
-	  };
-	} else {
-          ProcessKernelInstance(instance,-1);
-	};
-        cl_int status = clReleaseEvent(event);
-        UNITRACE_ASSERT(status == CL_SUCCESS);
-	delete instance;
-
-        it = kernel_instance_list_.erase(it);
-        break;
-      }
-    }
-  }
-
-  void ProcessKernelInstances() {
-    const std::lock_guard<std::mutex> lock(lock_);
-
-    auto it = kernel_instance_list_.begin();
-    while (it != kernel_instance_list_.end()) {
-      ClKernelInstance* instance = *it;
-      UNITRACE_ASSERT(instance != nullptr);
-
-      UNITRACE_ASSERT(instance->event != nullptr);
-      cl_int event_status = utils::cl::GetEventStatus(instance->event);
-      if (event_status == CL_COMPLETE) {
-        if (instance->sub_device_list.size()) {
-          for (size_t i = 0; i < instance->sub_device_list.size(); ++i) {
-            ProcessKernelInstance(instance,instance->sub_device_list[i]);
-          }
-        } else {
-          ProcessKernelInstance(instance,-1);
-	}
-        it = kernel_instance_list_.erase(it);
-      } else {
-        ++it;
-      }
-    }
-  }
-
-  void AddKernelInfo(std::string name, uint64_t queued_time, uint64_t submit_time, uint64_t execute_time) {
-    UNITRACE_ASSERT(!name.empty());
-
-    if (kernel_info_map_.count(name) == 0) {
-      ClKernelInfo info;
-      info.queued_time = queued_time;
-      info.submit_time = submit_time;
-      info.execute_time = execute_time;
-      info.min_time = execute_time;
-      info.max_time = execute_time;
-      info.call_count = 1;
-      kernel_info_map_[name] = info;
-    } else {
-      ClKernelInfo& kernel = kernel_info_map_[name];
-      kernel.queued_time += queued_time;
-      kernel.submit_time += submit_time;
-      kernel.execute_time += execute_time;
-      if (execute_time > kernel.max_time) {
-        kernel.max_time = execute_time;
-      }
-      if (execute_time < kernel.min_time) {
-        kernel.min_time = execute_time;
-      }
-      kernel.call_count += 1;
-    }
-  }
-
-
-  void CalculateKernelLocalSize(const cl_params_clEnqueueNDRangeKernel* params, ClKernelProps* props) {
-    UNITRACE_ASSERT(params != nullptr);
-    UNITRACE_ASSERT(props != nullptr);
-
-    props->local_size[0] = 1;
-    props->local_size[1] = 1;
-    props->local_size[2] = 1;
-    if (*(params->localWorkSize) == nullptr) {
-      props->local_size[0] = 0;
-      props->local_size[1] = 0;
-      props->local_size[2] = 0;
-    } else {
-      UNITRACE_ASSERT(*(params->workDim) <= 3);
-      for (cl_uint i = 0; i < *(params->workDim); ++i) {
-        props->local_size[i] = (*(params->localWorkSize))[i];
-      }
-    }
-  }
-
-  void CalculateKernelLocalSize(const cl_params_clEnqueueTask* /* params */, ClKernelProps* props) {
-    UNITRACE_ASSERT(props != nullptr);
-    props->local_size[0] = 1;
-    props->local_size[1] = 1;
-    props->local_size[2] = 1;
-  }
-
-  void CalculateKernelGlobalSize(const cl_params_clEnqueueNDRangeKernel* params, ClKernelProps* props) {
-    UNITRACE_ASSERT(params != nullptr);
-    UNITRACE_ASSERT(props != nullptr);
-    props->global_size[0] = 1;
-    props->global_size[1] = 1;
-    props->global_size[2] = 1;
-
-    UNITRACE_ASSERT(*(params->workDim) <= 3);
-    for (cl_uint i = 0; i < *(params->workDim); ++i) {
-      props->global_size[i] = (*(params->globalWorkSize))[i];
-    }
-  }
-
-  void CalculateKernelGlobalSize(const cl_params_clEnqueueTask* /* params */, ClKernelProps* props) {
-    UNITRACE_ASSERT(props != nullptr);
-    props->global_size[0] = 1;
-    props->global_size[1] = 1;
-    props->global_size[2] = 1;
-  }
-
-  // Callbacks
-  static void OnEnterCreateCommandQueueWithProperties(cl_callback_data* data, ClCollector* /* collector */) {
-    UNITRACE_ASSERT(data != nullptr);
-
-    const cl_params_clCreateCommandQueueWithProperties* params =
-      reinterpret_cast<const cl_params_clCreateCommandQueueWithProperties*>(data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-
-    data->correlationData[0] = reinterpret_cast<cl_ulong>(nullptr);
-    cl_queue_properties *props = (cl_queue_properties *)(*(params->properties));
-    if (props == nullptr) {
-      props = new cl_queue_properties[3];
-      props[0] = CL_QUEUE_PROPERTIES;
-      props[1] = CL_QUEUE_PROFILING_ENABLE;
-      props[2] = 0;
-      data->correlationData[0] = reinterpret_cast<cl_ulong>(props);
-    } else {
-      cl_queue_properties *p = props;
-      int i;
-
-      for (i = 0; p[i]; i += 2) {
-        if (p[i] == CL_QUEUE_PROPERTIES) {
-          p[i + 1] |= CL_QUEUE_PROFILING_ENABLE;
-          break;
-        }
-      }
-      if (p[i] == 0) {
-        p = props;
-        props = new cl_queue_properties[i + 3];
-        for (int j = 0; j < i; j++) {
-          props[j] = p[j];
-        }
-        props[i++] = CL_QUEUE_PROPERTIES;
-        props[i++] = CL_QUEUE_PROFILING_ENABLE;
-        props[i] = 0;
-        data->correlationData[0] = reinterpret_cast<cl_ulong>(props);
-      }
-    }
-
-    *(params->properties) = props;
-  }
-
-  static void OnExitCreateCommandQueueWithProperties(cl_callback_data* data, ClCollector* /* collector */) {
-    UNITRACE_ASSERT(data != nullptr);
-
-    cl_queue_properties* props = reinterpret_cast<cl_queue_properties*>(data->correlationData[0]);
-    if (props != nullptr) {
-      delete[] props;
-    }
-  }
-
-  static void OnEnterCreateCommandQueue(cl_callback_data* data, ClCollector* /* collector */) {
-    UNITRACE_ASSERT(data != nullptr);
-
-    const cl_params_clCreateCommandQueue* params =
-      reinterpret_cast<const cl_params_clCreateCommandQueue*>(
-          data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-    // Cast away const to enable profiling, which kernel timing needs
-    *const_cast<cl_command_queue_properties*>(params->properties) |=
-      static_cast<unsigned long>(CL_QUEUE_PROFILING_ENABLE);
-  }
-
-  template <typename T>
-  static void OnEnterEnqueueKernel(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(collector->device_ != nullptr);
-
-    ClEnqueueData* enqueue_data = new ClEnqueueData;
-    enqueue_data->event = nullptr;
-
-    utils::cl::GetTimestamps(collector->device_, &enqueue_data->host_sync, &enqueue_data->device_sync);
-
-    const T* params = reinterpret_cast<const T*>(data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-
-    if (*(params->event) == nullptr) {
-      *(params->event) = &(enqueue_data->event);
-    }
-
-    data->correlationData[0] = reinterpret_cast<cl_ulong>(enqueue_data);
-  }
-
-  template<typename T>
-  static void OnExitEnqueueKernel(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    ClEnqueueData* enqueue_data = reinterpret_cast<ClEnqueueData*>(data->correlationData[0]);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const T* params = reinterpret_cast<const T*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      UNITRACE_ASSERT(*(params->event) != nullptr);
-      cl_int status = CL_SUCCESS;
-
-      if (*(params->event) != reinterpret_cast<cl_event*>(data->correlationData)) {
-        status = clRetainEvent(**(params->event));
-        UNITRACE_ASSERT(status == CL_SUCCESS);
-      }
-
-      ClKernelInstance* instance = new ClKernelInstance;
-      UNITRACE_ASSERT(instance != nullptr);
-      instance->event = **(params->event);
-
-      cl_kernel kernel = *(params->kernel);
-      // name is for reports, mangled_name for .kprops
-      instance->props.mangled_name = utils::cl::GetKernelName(kernel);
-      instance->props.name = collector->options_.demangle
-                                 ? utils::Demangle(instance->props.mangled_name.c_str())
-                                 : instance->props.mangled_name;
-
-      cl_command_queue queue = *(params->commandQueue);
-      UNITRACE_ASSERT(queue != nullptr);
-      cl_device_id device = utils::cl::GetDevice(queue);
-      UNITRACE_ASSERT(device != nullptr);
-      instance->props.device_id = device;
-
-      size_t simd_width = utils::cl::GetKernelSimdWidth(device, kernel);
-      UNITRACE_ASSERT(simd_width > 0);
-
-      instance->props.simd_width = simd_width;
-      instance->props.bytes_transferred = 0;
-
-      collector->CalculateKernelGlobalSize(params, &instance->props);
-      collector->CalculateKernelLocalSize(params, &instance->props);
-
-      size_t base_addr = 0;
-      size_t size = 0;
-
-      status = clGetKernelInfo(kernel, CL_KERNEL_BINARY_GPU_ADDRESS_INTEL, 0, nullptr, &size);
-      status = clGetKernelInfo(kernel, CL_KERNEL_BINARY_GPU_ADDRESS_INTEL, size, &base_addr, &size);
-
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-      instance->props.base_addr = (base_addr & 0xFFFFFFFF);
-      size = 0;
-      status = clGetKernelInfo(kernel, CL_KERNEL_BINARY_PROGRAM_INTEL, 0, nullptr, &size);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-      instance->props.size = size;
-
-      auto it = collector->kprops_.find(instance->props.name);
-      if (it == collector->kprops_.end()) {
-        // Set the .kprops values on first sight; kprops_ keeps the first of a repeated
-        // name. The module id was recorded at build time; 0 means no binary was dumped.
-        if (collector->options_.stall_sampling) {
-          instance->props.kernel_command_id = UniKernelId::GetKernelId();
-          instance->props.module_id =
-              collector->GetKernelModuleId(instance->props.mangled_name);
-        }
-        collector->kprops_.insert(std::pair<std::string, ClKernelProps>(instance->props.name, instance->props));
-      }
-
-      instance->kernel_id = UniKernelInstanceId::GetKernelInstanceId();
-      if (kid) {
-        *kid = instance->kernel_id;
-      }
-      instance->need_to_process = UniController::IsCollectionEnabled();
-
-      UNITRACE_ASSERT(enqueue_data != nullptr);
-      instance->device_sync = enqueue_data->device_sync;
-      instance->host_sync = enqueue_data->host_sync;
-
-      collector->AddKernelInstance(instance);
-
-      delete enqueue_data;
-    }
-  }
-
-  static void OnExitEnqueueTransfer(std::string name, size_t bytes_transferred, cl_event* event, cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(event != nullptr);
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    if (event != reinterpret_cast<cl_event*>(data->correlationData)) {
-      cl_int status = clRetainEvent(*event);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-    }
-
-    ClKernelInstance* instance = new ClKernelInstance;
-    UNITRACE_ASSERT(instance != nullptr);
-    instance->event = *event;
-    instance->props.name = std::move(name);
-
-    instance->props.simd_width = 0;
-    instance->props.bytes_transferred = bytes_transferred;
-
-    instance->props.base_addr = 0;
-    instance->props.size = 0;
-
-    instance->kernel_id = UniKernelInstanceId::GetKernelInstanceId();
-    if (kid) {
-      *kid = instance->kernel_id;
-    }
-    instance->need_to_process = UniController::IsCollectionEnabled();
-
-    ClEnqueueData* enqueue_data = reinterpret_cast<ClEnqueueData*>(data->correlationData[0]);
-    UNITRACE_ASSERT(enqueue_data != nullptr);
-    instance->device_sync = enqueue_data->device_sync;
-    instance->host_sync = enqueue_data->host_sync;
-
-    collector->AddKernelInstance(instance);
-
-    delete enqueue_data;
-  }
-
-  static void OnExitEnqueueReadBuffer(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(
-        data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueReadBuffer* params =
-        reinterpret_cast<const cl_params_clEnqueueReadBuffer*>(
-            data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      OnExitEnqueueTransfer( "clEnqueueReadBuffer", *(params->cb), *(params->event), data, collector, kid);
-
-      if (*params->blockingRead) {
-        collector->ProcessKernelInstances();
-      }
-    }
-  }
-
-  static void OnExitEnqueueWriteBuffer(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueWriteBuffer* params = reinterpret_cast<const cl_params_clEnqueueWriteBuffer*>( data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      OnExitEnqueueTransfer( "clEnqueueWriteBuffer", *(params->cb), *(params->event), data, collector, kid);
-
-      if (*params->blockingWrite) {
-        collector->ProcessKernelInstances();
-      }
-    }
-  }
-
-  static void OnExitEnqueueCopyBuffer(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueCopyBuffer* params = reinterpret_cast<const cl_params_clEnqueueCopyBuffer*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      OnExitEnqueueTransfer("clEnqueueCopyBuffer", *(params->cb), *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueFillBuffer(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueFillBuffer* params = reinterpret_cast<const cl_params_clEnqueueFillBuffer*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      OnExitEnqueueTransfer("clEnqueueFillBuffer", *(params->size), *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueReadBufferRect(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueReadBufferRect* params = reinterpret_cast<const cl_params_clEnqueueReadBufferRect*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *params->region;
-      UNITRACE_ASSERT(region != nullptr);
-      size_t bytes_transferred = region[0] * region[1] * region[2];
-
-      OnExitEnqueueTransfer("clEnqueueReadBufferRect", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueWriteBufferRect(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>( data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueWriteBufferRect* params = reinterpret_cast<const cl_params_clEnqueueWriteBufferRect*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *params->region;
-      UNITRACE_ASSERT(region != nullptr);
-      size_t bytes_transferred = region[0] * region[1] * region[2];
-
-      OnExitEnqueueTransfer("clEnqueueWriteBufferRect", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueCopyBufferRect(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueCopyBufferRect* params = reinterpret_cast<const cl_params_clEnqueueCopyBufferRect*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *params->region;
-      UNITRACE_ASSERT(region != nullptr);
-      size_t bytes_transferred = region[0] * region[1] * region[2];
-
-      OnExitEnqueueTransfer("clEnqueueCopyBufferRect", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueReadImage(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueReadImage* params = reinterpret_cast<const cl_params_clEnqueueReadImage*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->image), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer("clEnqueueReadImage", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueWriteImage(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueWriteImage* params = reinterpret_cast<const cl_params_clEnqueueWriteImage*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->image), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer("clEnqueueWriteImage", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueCopyImage(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueCopyImage* params = reinterpret_cast<const cl_params_clEnqueueCopyImage*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->srcImage), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer("clEnqueueCopyImage", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueFillImage(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueFillImage* params = reinterpret_cast<const cl_params_clEnqueueFillImage*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->image), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer("clEnqueueFillImage", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueCopyImageToBuffer(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueCopyImageToBuffer* params = reinterpret_cast<const cl_params_clEnqueueCopyImageToBuffer*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->srcImage), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer( "clEnqueueCopyImageToBuffer", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitEnqueueCopyBufferToImage(cl_callback_data* data, ClCollector* collector, uint64_t *kid) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clEnqueueCopyBufferToImage* params = reinterpret_cast<const cl_params_clEnqueueCopyBufferToImage*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const size_t* region = *(params->region);
-      UNITRACE_ASSERT(region != nullptr);
-
-      size_t element_size = 0;
-      cl_int status = clGetImageInfo(*(params->dstImage), CL_IMAGE_ELEMENT_SIZE, sizeof(size_t), &element_size, nullptr);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-
-      size_t bytes_transferred = region[0] * region[1] * region[2] * element_size;
-      OnExitEnqueueTransfer("clEnqueueCopyBufferToImage", bytes_transferred, *(params->event), data, collector, kid);
-    }
-  }
-
-  static void OnExitFinish(ClCollector* collector) {
-    UNITRACE_ASSERT(collector != nullptr);
-    collector->ProcessKernelInstances();
-  }
-
-  static void OnExitReleaseCommandQueue(ClCollector* collector) {
-    UNITRACE_ASSERT(collector != nullptr);
-    collector->ProcessKernelInstances();
-  }
-
-  static void OnEnterReleaseEvent(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    const cl_params_clReleaseEvent* params = reinterpret_cast<const cl_params_clReleaseEvent*>(data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-
-    if (*(params->event) != nullptr) {
-      collector->ProcessKernelInstance(*(params->event));
-    }
-  }
-
-  static void OnExitWaitForEvents(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_int* return_value = reinterpret_cast<cl_int*>(data->functionReturnValue);
-    if (*return_value == CL_SUCCESS) {
-      const cl_params_clWaitForEvents* params = reinterpret_cast<const cl_params_clWaitForEvents*>(data->functionParams);
-      UNITRACE_ASSERT(params != nullptr);
-
-      const cl_event* event_list = *(params->eventList);
-      if (event_list != nullptr) {
-        for (cl_uint i = 0; i < *(params->numEvents); ++i) {
-          collector->ProcessKernelInstance(event_list[i]);
-        }
-      }
-    }
-  }
-
-  // Dump the program's device binary (for IGC, the zebin as is) and map its kernel names
-  // to the module id, as Level Zero does at zeModuleCreate; see
-  // ZeMetricProfiler::ReadModuleAndKernelProps for the reader. Idempotent per cl_program,
-  // since both build and link reach here, and both CPU and GPU collectors see every build.
-  // Currently disabled (#if 0), so every module id is 0.
-  void RegisterProgramModule(cl_program program) {
-#if 0
-    if (!options_.stall_sampling || program == nullptr) {
-      return;
-    }
-
-    const std::lock_guard<std::mutex> lock(module_lock_);
-    if (program_module_ids_.count(program) != 0) {
-      return;
-    }
-
-    // Find this collector's device, sub-devices included, via device_map_
-    std::vector<cl_device_id> devices = utils::cl::GetDeviceList(program);
-    size_t slot = devices.size();
-    for (size_t i = 0; i < devices.size(); ++i) {
-      if (device_map_.count(devices[i]) != 0) {
-        slot = i;
-        break;
-      }
-    }
-    if (slot == devices.size()) {
-      return;
-    }
-
-    // CL_PROGRAM_BINARIES writes every device's binary, so every slot needs a buffer
-    std::vector<size_t> sizes(devices.size(), 0);
-    if (clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, sizes.size() * sizeof(size_t),
-                         sizes.data(), nullptr) != CL_SUCCESS) {
-      return;
-    }
-    if (sizes[slot] == 0) {
-      return;
-    }
-
-    std::vector<std::vector<uint8_t>> binaries(devices.size());
-    std::vector<uint8_t*> pointers(devices.size(), nullptr);
-    for (size_t i = 0; i < devices.size(); ++i) {
-      binaries[i].resize(sizes[i] == 0 ? 1 : sizes[i]);
-      pointers[i] = binaries[i].data();
-    }
-    if (clGetProgramInfo(program, CL_PROGRAM_BINARIES, pointers.size() * sizeof(uint8_t*),
-                         pointers.data(), nullptr) != CL_SUCCESS) {
-      return;
-    }
-
-    const uint32_t module_id = UniModuleId::GetModuleId();
-    if (!WriteOutModuleNativeBinary(logger_factory_, data_dir_name_, module_id,
-                                    binaries[slot].data(), sizes[slot])) {
-      return;
-    }
-    program_module_ids_.insert({program, module_id});
-
-    // Map every exported kernel name to this module. insert keeps an earlier program's
-    // claim, as kprops_ does.
-    size_t names_size = 0;
-    if (clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, 0, nullptr, &names_size) !=
-            CL_SUCCESS ||
-        names_size == 0) {
-      return;
-    }
-    std::vector<char> names(names_size, '\0');
-    if (clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, names_size, names.data(),
-                         nullptr) != CL_SUCCESS) {
-      return;
-    }
-    const std::string name_list(names.data());
-    for (size_t start = 0; start <= name_list.size();) {
-      const size_t end = name_list.find(';', start);
-      const std::string name = name_list.substr(
-          start, (end == std::string::npos) ? std::string::npos : end - start);
-      if (!name.empty()) {
-        kernel_module_ids_.insert({name, module_id});
-      }
-      if (end == std::string::npos) {
-        break;
-      }
-      start = end + 1;
-    }
-#endif /* 0 */
-  }
-
-  uint32_t GetKernelModuleId(const std::string& mangled_name) {
-    const std::lock_guard<std::mutex> lock(module_lock_);
-    auto it = kernel_module_ids_.find(mangled_name);
-    return (it == kernel_module_ids_.end()) ? 0 : it->second;
-  }
-
-  static void OnExitBuildProgram(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    const cl_int* return_value = reinterpret_cast<const cl_int*>(data->functionReturnValue);
-    if (*return_value != CL_SUCCESS) {
-      return;
-    }
-    const cl_params_clBuildProgram* params =
-        reinterpret_cast<const cl_params_clBuildProgram*>(data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-    collector->RegisterProgramModule(*(params->program));
-  }
-
-  // clLinkProgram returns the program, not a status
-  static void OnExitLinkProgram(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    cl_program* program = reinterpret_cast<cl_program*>(data->functionReturnValue);
-    if (program != nullptr) {
-      collector->RegisterProgramModule(*program);
-    }
-  }
-
-  // On the last release, forget the program: the runtime reuses handles. Runs while
-  // paused, like the build hook. kernel_module_ids_ is kept for writing .kprops later.
-  static void OnEnterReleaseProgram(cl_callback_data* data, ClCollector* collector) {
-    UNITRACE_ASSERT(data != nullptr);
-    UNITRACE_ASSERT(collector != nullptr);
-
-    if (!collector->options_.stall_sampling) {
-      return;
-    }
-    const cl_params_clReleaseProgram* params =
-        reinterpret_cast<const cl_params_clReleaseProgram*>(data->functionParams);
-    UNITRACE_ASSERT(params != nullptr);
-    cl_program program = *(params->program);
-    if (program == nullptr) {
-      return;
-    }
-
-    cl_uint ref_count = 0;
-    if (clGetProgramInfo(program, CL_PROGRAM_REFERENCE_COUNT, sizeof(ref_count), &ref_count,
-                         nullptr) != CL_SUCCESS ||
-        ref_count > 1) {
-      return;
-    }
-    const std::lock_guard<std::mutex> lock(collector->module_lock_);
-    collector->program_module_ids_.erase(program);
-  }
-
-  static void KernelTracingCallBackOnEnter(ClFunctionId function, ClCollector *collector, cl_callback_data *callback_data, uint64_t * /* kid */) {
-    switch (function) {
-      case CL_FUNCTION_clCreateCommandQueueWithProperties:
-        OnEnterCreateCommandQueueWithProperties(callback_data, collector);
-        break;
-      case CL_FUNCTION_clCreateCommandQueue:
-        OnEnterCreateCommandQueue(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueNDRangeKernel:
-        OnEnterEnqueueKernel<cl_params_clEnqueueNDRangeKernel>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueTask:
-        OnEnterEnqueueKernel<cl_params_clEnqueueTask>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueReadBuffer:
-        OnEnterEnqueueKernel<cl_params_clEnqueueReadBuffer>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueWriteBuffer:
-        OnEnterEnqueueKernel<cl_params_clEnqueueWriteBuffer>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueCopyBuffer:
-        OnEnterEnqueueKernel<cl_params_clEnqueueCopyBuffer>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueFillBuffer:
-        OnEnterEnqueueKernel<cl_params_clEnqueueFillBuffer>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueReadBufferRect:
-        OnEnterEnqueueKernel<cl_params_clEnqueueReadBufferRect>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueWriteBufferRect:
-        OnEnterEnqueueKernel<cl_params_clEnqueueWriteBufferRect>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueReadImage:
-        OnEnterEnqueueKernel<cl_params_clEnqueueReadImage>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueWriteImage:
-        OnEnterEnqueueKernel<cl_params_clEnqueueWriteImage>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueCopyImage:
-        OnEnterEnqueueKernel<cl_params_clEnqueueCopyImage>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueFillImage:
-        OnEnterEnqueueKernel<cl_params_clEnqueueFillImage>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueCopyImageToBuffer:
-        OnEnterEnqueueKernel<cl_params_clEnqueueCopyImageToBuffer>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clEnqueueCopyBufferToImage:
-        OnEnterEnqueueKernel<cl_params_clEnqueueCopyBufferToImage>(callback_data, collector);
-        break;
-      case CL_FUNCTION_clFinish:
-      case CL_FUNCTION_clReleaseCommandQueue:
-        break;
-      case CL_FUNCTION_clReleaseEvent:
-        OnEnterReleaseEvent(callback_data, collector);
-        break;
-      case CL_FUNCTION_clWaitForEvents:
-        break;
-      case CL_FUNCTION_clReleaseProgram:
-        OnEnterReleaseProgram(callback_data, collector);
-        break;
-      case CL_FUNCTION_clBuildProgram:
-      case CL_FUNCTION_clLinkProgram:
-        break;
-      default:
-        break;
-    }
-  }
-
-  static void KernelTracingCallBackOnExit(ClFunctionId function, ClCollector *collector, cl_callback_data *callback_data, uint64_t *kid) {
-    switch (function) {
-      case CL_FUNCTION_clCreateCommandQueueWithProperties:
-        OnExitCreateCommandQueueWithProperties(callback_data, collector);
-        break;
-      case CL_FUNCTION_clCreateCommandQueue:
-        break;
-      case CL_FUNCTION_clEnqueueNDRangeKernel:
-        OnExitEnqueueKernel<cl_params_clEnqueueNDRangeKernel>(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueTask:
-        OnExitEnqueueKernel<cl_params_clEnqueueTask>(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueReadBuffer:
-        OnExitEnqueueReadBuffer(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueWriteBuffer:
-        OnExitEnqueueWriteBuffer(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueCopyBuffer:
-        OnExitEnqueueCopyBuffer(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueFillBuffer:
-        OnExitEnqueueFillBuffer(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueReadBufferRect:
-        OnExitEnqueueReadBufferRect(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueWriteBufferRect:
-        OnExitEnqueueWriteBufferRect(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueReadImage:
-        OnExitEnqueueReadImage(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueWriteImage:
-        OnExitEnqueueWriteImage(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueCopyImage:
-        OnExitEnqueueCopyImage(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueFillImage:
-        OnExitEnqueueFillImage(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueCopyImageToBuffer:
-        OnExitEnqueueCopyImageToBuffer(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clEnqueueCopyBufferToImage:
-        OnExitEnqueueCopyBufferToImage(callback_data, collector, kid);
-        break;
-      case CL_FUNCTION_clFinish:
-        OnExitFinish(collector);
-        break;
-      case CL_FUNCTION_clReleaseCommandQueue:
-        OnExitReleaseCommandQueue(collector);
-        break;
-      case CL_FUNCTION_clReleaseEvent:
-        break;
-      case CL_FUNCTION_clWaitForEvents:
-        OnExitWaitForEvents(callback_data, collector);
-        break;
-      case CL_FUNCTION_clBuildProgram:
-        OnExitBuildProgram(callback_data, collector);
-        break;
-      case CL_FUNCTION_clLinkProgram:
-        OnExitLinkProgram(callback_data, collector);
-        break;
-      case CL_FUNCTION_clReleaseProgram:
-        break;
-      default:
-        break;
-    }
-  }
-
-  // Program hooks run even while paused: programs are usually built before a resume, and
-  // skipping them would lose the binaries of kernels run later. Level Zero does the same.
-  // clReleaseProgram is included so a reused handle does not inherit a stale module id.
-  static bool IsProgramTracingPoint(ClFunctionId function) {
-    return (function == CL_FUNCTION_clBuildProgram) ||
-           (function == CL_FUNCTION_clLinkProgram) ||
-           (function == CL_FUNCTION_clReleaseProgram);
-  }
-
-  static void TracingCallBack(ClFunctionId function, cl_callback_data* callback_data, void* user_data) {
-    if (IsTracingNow()) {
-      // no recursive tracing
-      return;
-    }
-
-    ClCollector* collector = reinterpret_cast<ClCollector*>(user_data);
-    if (callback_data->site == CL_CALLBACK_SITE_ENTER) {
-      const bool collection_enabled = UniController::IsCollectionEnabled();
-      if (collection_enabled || IsProgramTracingPoint(function)) {
-        collector->TracingNowOn();
-        uint64_t kid = KERNEL_INSTANCE_ID_INVALID;
-        if (collector->options_.kernel_tracing && collector->kernel_tracing_points_enabled[function]) {
-          KernelTracingCallBackOnEnter(function, collector, callback_data, &kid);
-        }
-
-        // Only the kernel tracing above bypasses the pause
-        if (collection_enabled && collector->options_.call_logging) {
-          OnEnterFunction(function, callback_data, collector->GetTimestamp(), collector);
-        }
-
-        collector->TracingNowOff();
-      }
-      collector->PushTraceNestingAndCaptureTraceStartTime();
-    }
-    else {
-      // take end timestamp first to avoid tool overhead
-      uint64_t end_time = collector->GetTimestamp();
-
-      collector->TracingNowOn();
-      uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-      const bool collection_enabled = UniController::IsCollectionEnabled();
-      // Read below by the flow callback
-      uint64_t kid = KERNEL_INSTANCE_ID_INVALID;
-      if ((collection_enabled || IsProgramTracingPoint(function)) &&
-          collector->options_.kernel_tracing && collector->kernel_tracing_points_enabled[function]) {
-        KernelTracingCallBackOnExit(function, collector, callback_data, &kid);
-      }
-
-      if (collection_enabled) {
-        if (collector->options_.host_timing) {
-          collector->AddFunctionTime(callback_data->functionName, end_time - start_time);
-        }
-
-        if (collector->options_.call_logging) {
-          OnExitFunction(function, callback_data, start_time, end_time, collector);
-        }
-
-        if (collector->fcallback_ != nullptr) {
-          FLOW_DIR flow_dir = FLOW_NUL;
-          std::vector<uint64_t> kids;
-          if (function == CL_FUNCTION_clEnqueueNDRangeKernel ||
-              function == CL_FUNCTION_clWaitForEvents ||
-              function == CL_FUNCTION_clEnqueueReadBuffer ||
-              function == CL_FUNCTION_clEnqueueWriteBuffer) {
-            flow_dir = (function == CL_FUNCTION_clWaitForEvents ? FLOW_D2H : FLOW_H2D);
-            if (kid != KERNEL_INSTANCE_ID_INVALID) {
-              kids.push_back(kid);
-            }
-          }
-
-          API_TRACING_ID api_id = (API_TRACING_ID)(OCLStartTracingId + function);
-          collector->fcallback_((kids.empty() ? nullptr: &kids), flow_dir, api_id, start_time, end_time);
-        }
-      }
-
-      #define REPLACE_INTEL_EXTENSION_FUNCTION(params, name, i, cb_data) \
-        if (strcmp(#name, *(params->funcName)) == 0) { \
-          if (collector->cl_ext_func_[i] == nullptr) { \
-            const std::lock_guard<std::shared_mutex> lock(collector->cl_ext_func_lock_); \
-            if (collector->cl_ext_func_[i] == nullptr) { \
-              collector->cl_ext_func_[i] = *(void **)(cb_data->functionReturnValue); \
-            } \
-          } \
-          if (collector->device_type_ == CL_DEVICE_TYPE_GPU) { \
-            *reinterpret_cast<decltype(name<CL_DEVICE_TYPE_CPU>)**>(cb_data->functionReturnValue) = &name<CL_DEVICE_TYPE_GPU>; \
-          } \
-          else { \
-            *reinterpret_cast<decltype(name<CL_DEVICE_TYPE_CPU>)**>(cb_data->functionReturnValue) = &name<CL_DEVICE_TYPE_CPU>; \
-          } \
-        }
-
-      if (function == CL_FUNCTION_clGetExtensionFunctionAddress) {
-        const cl_params_clGetExtensionFunctionAddress *params =
-          reinterpret_cast<const cl_params_clGetExtensionFunctionAddress *>(callback_data->functionParams);
-        if (params == nullptr) {
-          std::cout<<"[ERROR] functionParams in callbackdata is null.";
-          return;
-        }
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clHostMemAllocINTEL, ClExtHostMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clDeviceMemAllocINTEL, ClExtDeviceMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clSharedMemAllocINTEL, ClExtSharedMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clMemFreeINTEL, ClExtMemFreeINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetMemAllocInfoINTEL, ClExtGetMemAllocInfoINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clSetKernelArgMemPointerINTEL, ClExtSetKernelArgMemPointerINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemcpyINTEL, ClExtEnqueueMemcpyINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetDeviceGlobalVariablePointerINTEL, ClExtGetDeviceGlobalVariablePointerINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetKernelSuggestedLocalWorkSizeINTEL, ClExtGetKernelSuggestedLocalWorkSizeINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clCreateBufferWithPropertiesINTEL, ClExtCreateBufferWithPropertiesINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemsetINTEL, ClExtEnqueueMemsetINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMigrateMemINTEL, ClExtEnqueueMigrateMemINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemAdviseINTEL, ClExtEnqueueMemAdviseINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemFillINTEL, ClExtEnqueueMemFillINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clMemBlockingFreeINTEL, ClExtMemBlockingFreeINTEL - ClExtApiStart, callback_data);
-      } else if (function == CL_FUNCTION_clGetExtensionFunctionAddressForPlatform) {
-        const cl_params_clGetExtensionFunctionAddressForPlatform *params =
-          reinterpret_cast<const cl_params_clGetExtensionFunctionAddressForPlatform *>(callback_data->functionParams);
-        if (params == nullptr) {
-          std::cout<<"[ERROR] functionParams in callbackdata is null.";
-          return;
-        }
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clHostMemAllocINTEL, ClExtHostMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clDeviceMemAllocINTEL, ClExtDeviceMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clSharedMemAllocINTEL, ClExtSharedMemAllocINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clMemFreeINTEL, ClExtMemFreeINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetMemAllocInfoINTEL, ClExtGetMemAllocInfoINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clSetKernelArgMemPointerINTEL, ClExtSetKernelArgMemPointerINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemcpyINTEL, ClExtEnqueueMemcpyINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetDeviceGlobalVariablePointerINTEL, ClExtGetDeviceGlobalVariablePointerINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clGetKernelSuggestedLocalWorkSizeINTEL, ClExtGetKernelSuggestedLocalWorkSizeINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clCreateBufferWithPropertiesINTEL, ClExtCreateBufferWithPropertiesINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemsetINTEL, ClExtEnqueueMemsetINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMigrateMemINTEL, ClExtEnqueueMigrateMemINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemAdviseINTEL, ClExtEnqueueMemAdviseINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clEnqueueMemFillINTEL, ClExtEnqueueMemFillINTEL - ClExtApiStart, callback_data);
-        REPLACE_INTEL_EXTENSION_FUNCTION(params, clMemBlockingFreeINTEL, ClExtMemBlockingFreeINTEL - ClExtApiStart, callback_data);
-      }
-      collector->TracingNowOff();
-    }
-  }
-
-
-  constexpr static int max_trace_nesting_level_ = 2;
-  inline static thread_local int trace_nesting_level_ = -1; // in case an extension is called within an OCL call
-  inline static thread_local uint64_t trace_start_time_[max_trace_nesting_level_] = {0}; // start time of traced API
-  inline static thread_local bool trace_now_ = false; // prevent recursive tracing
-
-  cl_device_id device_ = nullptr;
-  LoggerFactory* logger_factory_ = nullptr;
-  std::shared_ptr<UniLogger> logger_ = nullptr;
-  std::shared_ptr<UniLogger> logger_device_timeline_ = nullptr;
-  CollectorOptions options_;
-  ClApiTracer* tracer_ = nullptr;
-
-  OnClKernelFinishCallback kcallback_ = nullptr;
-  OnClFunctionFinishCallback fcallback_ = nullptr;
-
-  std::mutex lock_;
-  ClKernelInfoMap kernel_info_map_;
-  ClKernelInstanceList kernel_instance_list_;
-
-  bool kernel_tracing_points_enabled[CL_FUNCTION_COUNT];
-
-  std::map<cl_device_id, ClDevice> device_map_;
-
-  ClKernelMemInfoMap kernel_mem_info_map_;
-
-  static const uint32_t kFunctionLength = 10;
-  static const uint32_t kKernelLength = 10;
-  static const uint32_t kCallsLength = 12;
-  static const uint32_t kTimeLength = 20;
-  static const uint32_t kPercentLength = 12;
-
-  cl_device_type device_type_ = CL_DEVICE_TYPE_ALL;
-
-
-  ClFunctionInfoMap function_info_map_;
-
-  std::map<std::string, ClKernelProps> kprops_;
-  std::string data_dir_name_;
-
-  // Module bookkeeping for --stall-sampling; separate from lock_, which is held during flush
-  std::mutex module_lock_;
-  // Dumped programs; erased on release because handles are reused
-  std::map<cl_program, uint32_t> program_module_ids_;
-  // Mangled kernel name -> module id. Never evicted: .kprops is written after programs are released.
-  std::map<std::string, uint32_t> kernel_module_ids_;
-
-  std::vector<ClKernelProfileRecord> profile_records_;
-  std::map<cl_device_id, uint32_t> present_cl_devices_;
-
-  std::shared_mutex cl_ext_func_lock_;  // for cl_ext_func_
-  void *cl_ext_func_[ClExtApiEnd - ClExtApiStart] = {nullptr};
-
-  inline static ClCollector *cl_gpu_collector_ = nullptr;
-  inline static ClCollector *cl_cpu_collector_ = nullptr;
-};
-
-template <cl_device_type device_type>
-void *clHostMemAllocINTEL(cl_context context, const cl_mem_properties_intel *properties, size_t size, cl_uint alignment, cl_int *errcode_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clHostMemAllocINTEL:";
-
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(properties));
-        str += " size = " + std::to_string(size);
-        str += " alignment = " + std::to_string(alignment);
-        str += " errcode_ret = " + ToHexString(reinterpret_cast<uintptr_t>(errcode_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (void *(*)(cl_context, const cl_mem_properties_intel *, size_t, cl_uint, cl_int *))(collector->GetClExtFunction(ClExtHostMemAllocINTEL - ClExtApiStart));
-  auto result = f(context, properties, size, alignment, errcode_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clHostMemAllocINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clHostMemAllocINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " result = " + ToHexString(reinterpret_cast<uintptr_t>(result));
-
-      str += " -> " + std::string(utils::cl::GetErrorString(*errcode_ret));
-      str += " (" + std::to_string(*errcode_ret) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtHostMemAllocINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-void *clDeviceMemAllocINTEL(cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clDeviceMemAllocINTEL:";
-
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " device = " + ToHexString(reinterpret_cast<uintptr_t>(device));
-        str += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(properties));
-        str += " size = " + std::to_string(size);
-        str += " alignment = " + std::to_string(alignment);
-        str += " errcode_ret = " + ToHexString(reinterpret_cast<uintptr_t>(errcode_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (void *(*)(cl_context, cl_device_id, const cl_mem_properties_intel *, size_t, cl_uint, cl_int *))(collector->GetClExtFunction(ClExtDeviceMemAllocINTEL - ClExtApiStart));
-  auto result = f(context, device, properties, size, alignment, errcode_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clDeviceMemAllocINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clDeviceMemAllocINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " result = " + ToHexString(reinterpret_cast<uintptr_t>(result));
-
-      str += " -> " + std::string(utils::cl::GetErrorString(*errcode_ret));
-      str += " (" + std::to_string(*errcode_ret) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtDeviceMemAllocINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-void *clSharedMemAllocINTEL(cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clSharedMemAllocINTEL:";
-
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " device = " + ToHexString(reinterpret_cast<uintptr_t>(device));
-        str += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(properties));
-        str += " size = " + std::to_string(size);
-        str += " alignment = " + std::to_string(alignment);
-        str += " errcode_ret = " + ToHexString(reinterpret_cast<uintptr_t>(errcode_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (void *(*)(cl_context, cl_device_id, const cl_mem_properties_intel *, size_t, cl_uint, cl_int *))(collector->GetClExtFunction(ClExtSharedMemAllocINTEL - ClExtApiStart));
-  auto result = f(context, device, properties, size, alignment, errcode_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clSharedMemAllocINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str += "clSharedMemAllocINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " result = " + ToHexString(reinterpret_cast<uintptr_t>(result));
-
-      if (errcode_ret) {
-        str += " -> " + std::string(utils::cl::GetErrorString(*errcode_ret));
-        str += " (" + std::to_string(*errcode_ret) + ")";
-      }
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtSharedMemAllocINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clMemFreeINTEL(cl_context context, void *ptr) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clMemFreeINTEL:";
-
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(ptr));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_context, void *))(collector->GetClExtFunction(ClExtMemFreeINTEL - ClExtApiStart));
-  auto result = f(context, ptr);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clMemFreeINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clMemFreeINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-      str += " result = " + std::to_string(result);
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtMemFreeINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clGetMemAllocInfoINTEL(cl_context context, const void *ptr, cl_mem_info_intel param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clGetMemAllocInfoINTEL:";
-
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(ptr));
-        str += " param_name = " + std::to_string(param_name);
-        str += " param_value_size = " + std::to_string(param_value_size);
-        str += " param_value = " + ToHexString(reinterpret_cast<uintptr_t>(param_value));
-        str += " param_value_size_ret = " + ToHexString(reinterpret_cast<uintptr_t>(param_value_size_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_context, const void *, cl_mem_info_intel, size_t, void *, size_t *))(collector->GetClExtFunction(ClExtGetMemAllocInfoINTEL - ClExtApiStart));
-  auto result = f(context, ptr, param_name, param_value_size, param_value, param_value_size_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clGetMemAllocInfoINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clGetMemAllocInfoINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtGetMemAllocInfoINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clSetKernelArgMemPointerINTEL(cl_kernel kernel, cl_uint arg_index, const void *arg_value) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clSetKernelArgMemPointerINTEL:";
-
-        str += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(kernel));
-        str += " arg_index = " + std::to_string(arg_index);
-        str += " arg_value = " + ToHexString(reinterpret_cast<uintptr_t>(arg_value));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_kernel, cl_uint, const void *))(collector->GetClExtFunction(ClExtSetKernelArgMemPointerINTEL - ClExtApiStart));
-  auto result = f(kernel, arg_index, arg_value);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clSetKernelArgMemPointerINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clSetKernelArgMemPointerINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtSetKernelArgMemPointerINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clEnqueueMemcpyINTEL(cl_command_queue command_queue, cl_bool blocking, void *dst_ptr, const void *src_ptr,
-          size_t size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clEnqueueMemcpyINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " blocking = " + std::to_string(blocking);
-        str += " dst_ptr = " + ToHexString(reinterpret_cast<uintptr_t>(dst_ptr));
-        str += " src_ptr = " + ToHexString(reinterpret_cast<uintptr_t>(src_ptr));
-        str += " size = " + std::to_string(size);
-        str += " num_events_in_wait_list = " + std::to_string(num_events_in_wait_list);
-        str += " event_wait_list = " + ToHexString(reinterpret_cast<uintptr_t>(event_wait_list));
-        str += " event = " + ToHexString(reinterpret_cast<uintptr_t>(event));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, cl_bool, void *, const void *, size_t, cl_uint, const cl_event *, cl_event *))(collector->GetClExtFunction(ClExtEnqueueMemcpyINTEL - ClExtApiStart));
-  auto result = f(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, event);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clEnqueueMemcpyINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clEnqueueMemcpyINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtEnqueueMemcpyINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clGetDeviceGlobalVariablePointerINTEL(cl_device_id device, cl_program program, const char *global_variable_name,
-          size_t *global_variable_size_ret, void **global_variable_pointer_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clGetDeviceGlobalVariablePointerINTEL:";
-        str += " device = " + ToHexString(reinterpret_cast<uintptr_t>(device));
-        str += " program = " + ToHexString(reinterpret_cast<uintptr_t>(program));
-        str += " global_variable_name = " + std::string(global_variable_name);
-        str += " global_variable_size_ret = " + ToHexString(reinterpret_cast<uintptr_t>(global_variable_size_ret));
-        str += " global_variable_pointer_ret = " + ToHexString(reinterpret_cast<uintptr_t>(global_variable_pointer_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_device_id, cl_program, const char *, size_t *, void **))(collector->GetClExtFunction(ClExtGetDeviceGlobalVariablePointerINTEL- ClExtApiStart));
-  auto result = f(device, program, global_variable_name, global_variable_size_ret, global_variable_pointer_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clGetDeviceGlobalVariablePointerINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clGetDeviceGlobalVariablePointerINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtGetDeviceGlobalVariablePointerINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clGetKernelSuggestedLocalWorkSizeINTEL(cl_command_queue command_queue, cl_kernel kernel, cl_uint workDim,
-          const size_t *global_work_offset, const size_t *global_work_size, size_t *suggested_local_work_size) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clGetKernelSuggestedLocalWorkSizeINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " kernel = " + ToHexString(reinterpret_cast<uintptr_t>(kernel));
-        str += " workDim = " + std::to_string(workDim);
-        str += " global_work_offset = " + ToHexString(reinterpret_cast<uintptr_t>(global_work_offset));
-        str += " global_work_size = " + ToHexString(reinterpret_cast<uintptr_t>(global_work_size));
-        str += " suggested_local_work_size = " + ToHexString(reinterpret_cast<uintptr_t>(suggested_local_work_size));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, cl_kernel, cl_uint, const size_t *, const size_t *, size_t *))(collector->GetClExtFunction(ClExtGetKernelSuggestedLocalWorkSizeINTEL - ClExtApiStart));
-  auto result = f(command_queue, kernel, workDim, global_work_offset, global_work_size, suggested_local_work_size);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clGetKernelSuggestedLocalWorkSizeINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clGetKernelSuggestedLocalWorkSizeINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-      str += " suggested_local_work_size = " + ToHexString(reinterpret_cast<uintptr_t>(suggested_local_work_size));
-      if (suggested_local_work_size != nullptr) {
-        str += " (" + std::to_string(*suggested_local_work_size) + ")";
-      }
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtGetKernelSuggestedLocalWorkSizeINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_mem clCreateBufferWithPropertiesINTEL(cl_context context, const cl_mem_properties_intel *properties, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clCreateBufferWithPropertiesINTEL:";
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " properties = " + ToHexString(reinterpret_cast<uintptr_t>(properties));
-        str += " cl_mem_flags = " + std::to_string(flags);
-        str += " size = " + std::to_string(size);
-        str += " host_ptr = " + ToHexString(reinterpret_cast<uintptr_t>(host_ptr));
-        str += " errcode_ret = " + ToHexString(reinterpret_cast<uintptr_t>(errcode_ret));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_mem (*)(cl_context, const cl_mem_properties_intel *, cl_mem_flags, size_t, void *, cl_int *))(collector->GetClExtFunction(ClExtCreateBufferWithPropertiesINTEL - ClExtApiStart));
-  auto result = f(context, properties, flags, size, host_ptr, errcode_ret);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clCreateBufferWithPropertiesINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clCreateBufferWithPropertiesINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " result = " + ToHexString(reinterpret_cast<uintptr_t>(result));
-
-      if (errcode_ret) {
-        str += " -> " + std::string(utils::cl::GetErrorString(*errcode_ret));
-        str += " (" + std::to_string(*errcode_ret) + ")";
-      }
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtCreateBufferWithPropertiesINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clEnqueueMemsetINTEL(cl_command_queue command_queue, void *dst_ptr, cl_int value, size_t size, cl_uint num_events_in_wait_list,
-                const cl_event *event_wait_list, cl_event *event) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clEnqueueMemsetINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " dst_ptr = " + ToHexString(reinterpret_cast<uintptr_t>(dst_ptr));
-        str += " value = " + std::to_string(value);
-        str += " size = " + std::to_string(size);
-        str += " num_events_in_wait_list = " + std::to_string(num_events_in_wait_list);
-        str += " event_wait_list = " + ToHexString(reinterpret_cast<uintptr_t>(event_wait_list));
-        str += " event = " + ToHexString(reinterpret_cast<uintptr_t>(event));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, void *, cl_int, size_t, cl_uint, const cl_event *, cl_event *))(collector->GetClExtFunction(ClExtEnqueueMemsetINTEL - ClExtApiStart));
-  auto result = f(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list, event);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clEnqueueMemsetINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clEnqueueMemsetINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtEnqueueMemsetINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clEnqueueMigrateMemINTEL(cl_command_queue command_queue, const void *ptr, size_t size, cl_mem_migration_flags flags,
-        cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clEnqueueMigrateMemINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(ptr));
-        str += " size = " + std::to_string(size);
-        str += " flags = " + ToHexString(static_cast<uintptr_t>(flags));
-        str += " num_events_in_wait_list = " + std::to_string(num_events_in_wait_list);
-        str += " event_wait_list = " + ToHexString(reinterpret_cast<uintptr_t>(event_wait_list));
-        str += " event = " + ToHexString(reinterpret_cast<uintptr_t>(event));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, const void *, size_t, cl_mem_migration_flags, cl_uint, const cl_event *, cl_event *))(collector->GetClExtFunction(ClExtEnqueueMigrateMemINTEL - ClExtApiStart));
-  auto result = f(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list, event);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clEnqueueMigrateMemINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clEnqueueMigrateMemINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtEnqueueMigrateMemINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clEnqueueMemAdviseINTEL(cl_command_queue command_queue, const void *ptr, size_t size, cl_mem_advice_intel advice,
-        cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clEnqueueMemAdviseINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(ptr));
-        str += " size = " + std::to_string(size);
-        str += " advice = " + ToHexString(static_cast<uintptr_t>(advice));
-        str += " num_events_in_wait_list = " + std::to_string(num_events_in_wait_list);
-        str += " event_wait_list = " + ToHexString(reinterpret_cast<uintptr_t>(event_wait_list));
-        str += " event = " + ToHexString(reinterpret_cast<uintptr_t>(event));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, const void *, size_t, cl_mem_advice_intel, cl_uint, const cl_event *, cl_event *))(collector->GetClExtFunction(ClExtEnqueueMemAdviseINTEL - ClExtApiStart));
-  auto result = f(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list, event);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clEnqueueMemAdviseINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clEnqueueMemAdviseINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtEnqueueMemAdviseINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clEnqueueMemFillINTEL(cl_command_queue command_queue, void *dst_ptr, const void *pattern, size_t pattern_size, size_t size,
-        cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clEnqueueMemFillINTEL:";
-        str += " command_queue = " + ToHexString(reinterpret_cast<uintptr_t>(command_queue));
-        str += " dst_ptr = " + ToHexString(reinterpret_cast<uintptr_t>(dst_ptr));
-        str += " pattern = " + ToHexString(reinterpret_cast<uintptr_t>(pattern));
-        str += " pattern_size = " + std::to_string(pattern_size);
-        str += " size = " + std::to_string(size);
-        str += " num_events_in_wait_list = " + std::to_string(num_events_in_wait_list);
-        str += " event_wait_list = " + ToHexString(reinterpret_cast<uintptr_t>(event_wait_list));
-        str += " event = " + ToHexString(reinterpret_cast<uintptr_t>(event));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_command_queue, void *, const void *, size_t, size_t, cl_uint, const cl_event *, cl_event *))(collector->GetClExtFunction(ClExtEnqueueMemFillINTEL - ClExtApiStart));
-  auto result = f(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, event);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clEnqueueMemFillINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clEnqueueMemFillINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtEnqueueMemFillINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-
-template <cl_device_type device_type>
-cl_int clMemBlockingFreeINTEL(cl_context context, void *ptr) {
-  ClCollector *collector = ClCollector::GetCollector(device_type);
-
-  if (collector->IsTracingNow() == false) {
-    if (UniController::IsCollectionEnabled()) {
-      if (collector->IsCallLoggingOn()) {
-        collector->TracingNowOn();
-        std::string str;
-        str = ">>>> [" + std::to_string(collector->GetTimestamp()) + "] ";
-        if (collector->NeedPid()) {
-          str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-        }
-        if (collector->NeedTid()) {
-          str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-        }
-        str += "clMemBlockingFreeINTEL:";
-        str += " context = " + ToHexString(reinterpret_cast<uintptr_t>(context));
-        str += " ptr = " + ToHexString(reinterpret_cast<uintptr_t>(ptr));
-        str += "\n";
-
-        collector->Log(str);
-        collector->TracingNowOff();
-      }
-    }
-    collector->PushTraceNestingAndCaptureTraceStartTime();
-  }
-
-  auto f = (cl_int (*)(cl_context, void *))(collector->GetClExtFunction(ClExtMemBlockingFreeINTEL - ClExtApiStart));
-  auto result = f(context, ptr);
-
-  if (collector->IsTracingNow() == false) {
-    // take end timestamp first to avoid tool overhead
-    uint64_t end_time = collector->GetTimestamp();
-    collector->TracingNowOn();
-    uint64_t start_time = collector->GetTraceStartTimeAndPopTraceNesting();
-
-    if (collector->IsHostTimingOn()) {
-      collector->AddFunctionTime("clMemBlockingFreeINTEL", end_time - start_time);
-    }
-
-    if (collector->IsCallLoggingOn()) {
-      std::string str;
-      str = "<<<< ["  + std::to_string(end_time) + "] ";
-      if (collector->NeedPid()) {
-        str += "<PID:" + std::to_string(utils::GetPid()) + "> ";
-      }
-      if (collector->NeedTid()) {
-        str += "<TID:" + std::to_string((unsigned int)(utils::GetTid())) + "> ";
-      }
-      str +=  "clMemBlockingFreeINTEL";
-      str += " [" + std::to_string(end_time - start_time) + " ns]";
-
-      str += " -> " + std::string(utils::cl::GetErrorString(result));
-      str += " (" + std::to_string(result) + ")";
-      str += "\n";
-
-      collector->Log(str);
-    }
-
-    collector->InvokeFunctionFinishCallback(nullptr, FLOW_NUL, ClExtMemBlockingFreeINTEL, start_time, end_time);
-    collector->TracingNowOff();
-  }
-
-  return result;
-}
-#endif //PTI_TOOLS_UNITRACE_CL_COLLECTOR_H_
diff --git a/tools/unitrace/src/opencl/cl_intel_ext.h b/tools/unitrace/src/opencl/cl_intel_ext.h
deleted file mode 100644
index b5e69d9b..00000000
--- a/tools/unitrace/src/opencl/cl_intel_ext.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_CL_INTEL_EXT_H_
-#define PTI_TOOLS_UNITRACE_CL_INTEL_EXT_H_
-
-enum cl_ext_api_id {
-  ClExtApiStart = 4321,
-  ClExtHostMemAllocINTEL = ClExtApiStart,
-  ClExtDeviceMemAllocINTEL,
-  ClExtSharedMemAllocINTEL,
-  ClExtMemFreeINTEL,
-  ClExtGetMemAllocInfoINTEL,
-  ClExtSetKernelArgMemPointerINTEL,
-  ClExtEnqueueMemcpyINTEL,
-  ClExtGetDeviceGlobalVariablePointerINTEL,
-  ClExtGetKernelSuggestedLocalWorkSizeINTEL,
-  ClExtCreateBufferWithPropertiesINTEL,
-  ClExtEnqueueMemsetINTEL,
-  ClExtEnqueueMigrateMemINTEL,
-  ClExtEnqueueMemAdviseINTEL,
-  ClExtEnqueueMemFillINTEL,
-  ClExtMemBlockingFreeINTEL,
-  ClExtApiEnd
-};
-
-static const char *cl_ext_api[] = {
-  "clHostMemAllocINTEL",
-  "clDeviceMemAllocINTEL",
-  "clSharedMemAllocINTEL",
-  "clMemFreeINTEL",
-  "clGetMemAllocInfoINTEL",
-  "clSetKernelArgMemPointerINTEL",
-  "clEnqueueMemcpyINTEL",
-  "clGetDeviceGlobalVariablePointerINTEL",
-  "clGetKernelSuggestedLocalWorkSizeINTEL",
-  "clCreateBufferWithPropertiesINTEL",
-  "clEnqueueMemsetINTEL",
-  "clEnqueueMigrateMemINTEL",
-  "clEnqueueMemAdviseINTEL",
-  "clEnqueueMemFillINTEL",
-  "clMemBlockingFreeINTEL"
-};
-
-#endif /* PTI_TOOLS_UNITRACE_CL_INTEL_EXT_H_ */
diff --git a/tools/unitrace/src/perfettologger.h b/tools/unitrace/src/perfettologger.h
deleted file mode 100644
index e95c2524..00000000
--- a/tools/unitrace/src/perfettologger.h
+++ /dev/null
@@ -1,259 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_PERFETTO_LOGGER_H_
-#define PTI_TOOLS_UNITRACE_PERFETTO_LOGGER_H_
-
-// Perfetto protobuf trace emitter (compiled only when BUILD_WITH_PERFETTO=1).
-//
-// Builds TracePacket messages directly and appends one single-packet Trace per
-// event to a binary UniLogger; concatenated single-packet Traces are a valid trace,
-// so merging per-rank files is byte concatenation.
-
-#include <atomic>
-#include <cstdint>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include "utils/unilogger.h"
-#include "perfetto_trace.pb.h"
-
-namespace perfetto_emit {
-
-// The binary UniLogger this emitter appends to. Set once by the ChromeLogger ctor
-inline std::shared_ptr<UniLogger>& EmitLogger() {
-  static std::shared_ptr<UniLogger> logger;
-  return logger;
-}
-
-// Serializes writes to EmitLogger() (see EmitTrace) so concurrent writer threads
-// don't interleave packets in the binary stream.
-inline std::recursive_mutex& EmitLock() {
-  static std::recursive_mutex lock;
-  return lock;
-}
-
-// Perfetto BuiltinClock ids. REALTIME is globally meaningful (NTP) for cross-rank
-// sync; MONOTONIC_RAW is the fallback under UNITRACE_SystemTime=1. The
-// ClockSnapshot must relate the event clock to BOOTTIME, else the trace processor
-// drops every event with clock_sync_failure_no_path.
-constexpr uint32_t kClockRealtime    = 1;  // BUILTIN_CLOCK_REALTIME
-constexpr uint32_t kClockMonotonicRaw = 5;  // BUILTIN_CLOCK_MONOTONIC_RAW
-constexpr uint32_t kClockBoottime    = 6;  // BUILTIN_CLOCK_BOOTTIME
-
-// The clock domain every timestamp in this process resolves to
-inline uint32_t& ClockId() {
-  static uint32_t clock_id = kClockRealtime;
-  return clock_id;
-}
-
-// Deterministic, stable 64-bit track UUID from integer key parts (FNV-1a); keyed
-// on the per-rank-unique device pid/tid so tracks stay distinct across ranks.
-inline uint64_t MakeUuid(uint64_t a, uint64_t b = 0, uint64_t c = 0) {
-  uint64_t h = 1469598103934665603ull;  // FNV offset basis
-  const uint64_t prime = 1099511628211ull;
-  const uint64_t parts[3] = {a, b, c};
-  for (uint64_t p : parts) {
-    for (int i = 0; i < 8; i++) {
-      h ^= (p >> (i * 8)) & 0xff;
-      h *= prime;
-    }
-  }
-  // Avoid 0 (Perfetto treats uuid 0 as "unset").
-  return h ? h : 1;
-}
-
-// Per-writer-thread packet sequence id, so each thread's slice begin/end pairs
-// stack correctly per track.
-inline uint32_t NextSequenceId() {
-  static std::atomic<uint32_t> next{1};
-  return next.fetch_add(1, std::memory_order_relaxed);
-}
-
-// One shared sequence id for TrackDescriptors and the ClockSnapshot, which are
-// sequence-independent (global) in the trace processor.
-inline uint32_t DescriptorSeqId() {
-  static uint32_t id = NextSequenceId();
-  return id;
-}
-
-// TODO(perf): reuse a per-thread Trace/string to avoid the per-event allocation. It
-//   must NOT be a lazily-initialized thread_local object: first-touch TLS init runs
-//   under the Windows loader lock, deadlocking with logger_lock_.
-
-// Serialize one single-packet Trace and append it to the binary logger.
-inline void EmitTrace(const perfetto::protos::Trace& trace) {
-  std::string out;
-  if (!trace.SerializeToString(&out)) {
-    std::cerr << "[WARNING] failed to serialize a Perfetto trace packet; "
-                 "dropping one event from the timeline." << std::endl;
-    return;
-  }
-  std::lock_guard<std::recursive_mutex> lock(EmitLock());
-  auto& logger = EmitLogger();
-  if (logger) {
-    logger->Log(out.data(), out.size());
-  }
-}
-
-// Common packet scaffolding: set timestamp + clock domain + sequence id.
-inline perfetto::protos::TracePacket* NewPacket(perfetto::protos::Trace& trace,
-                                                uint64_t ts_ns, uint32_t seq_id) {
-  auto* packet = trace.add_packet();
-  packet->set_timestamp(ts_ns);
-  packet->set_timestamp_clock_id(ClockId());
-  packet->set_trusted_packet_sequence_id(seq_id);
-  return packet;
-}
-
-// Emit a ClockSnapshot relating the event clock to BOOTTIME (the trace
-// processor's base); without this pair every event is dropped with
-// clock_sync_failure_no_path.
-inline void EmitClockSnapshot(uint64_t event_ts, uint64_t boottime_ts, uint32_t seq_id) {
-  perfetto::protos::Trace trace;
-  auto* packet = trace.add_packet();
-  packet->set_trusted_packet_sequence_id(seq_id);
-  auto* snap = packet->mutable_clock_snapshot();
-  auto* ev_clock = snap->add_clocks();
-  ev_clock->set_clock_id(ClockId());
-  ev_clock->set_timestamp(event_ts);
-  if (ClockId() != kClockBoottime) {
-    auto* boot_clock = snap->add_clocks();
-    boot_clock->set_clock_id(kClockBoottime);
-    boot_clock->set_timestamp(boottime_ts);
-  }
-  EmitTrace(trace);
-}
-
-// Emit a process TrackDescriptor (embeds ProcessDescriptor).
-// uuid identifies the track.
-inline void EmitProcessTrack(uint64_t uuid, int32_t pid, const std::string& name,
-                             uint64_t ts_ns, uint32_t seq_id) {
-  perfetto::protos::Trace trace;
-  auto* packet = NewPacket(trace, ts_ns, seq_id);
-  auto* desc = packet->mutable_track_descriptor();
-  desc->set_uuid(uuid);
-  desc->set_name(name);
-  auto* proc = desc->mutable_process();
-  proc->set_pid(pid & 0x7FFFFFFF);
-  proc->set_process_name(name);
-  EmitTrace(trace);
-}
-
-// Emit a thread TrackDescriptor (embeds ThreadDescriptor). parent_uuid links the
-// thread track to its process track.
-inline void EmitThreadTrack(uint64_t uuid, uint64_t parent_uuid, int32_t pid,
-                            int32_t tid, const std::string& name, uint64_t ts_ns,
-                            uint32_t seq_id) {
-  perfetto::protos::Trace trace;
-  auto* packet = NewPacket(trace, ts_ns, seq_id);
-  auto* desc = packet->mutable_track_descriptor();
-  desc->set_uuid(uuid);
-  desc->set_parent_uuid(parent_uuid);
-  desc->set_name(name);
-  auto* thread = desc->mutable_thread();
-  thread->set_pid(pid & 0x7FFFFFFF);
-  thread->set_tid(tid & 0x7FFFFFFF);
-  thread->set_thread_name(name);
-  EmitTrace(trace);
-}
-
-// A key/value debug annotation to attach to a slice. Only one value field is
-// used per annotation (mirrors the proto's value oneof).
-struct Annotation {
-  enum Kind { kString, kInt, kUint } kind = kString;
-  std::string name;
-  std::string str_value;
-  int64_t int_value = 0;
-  uint64_t uint_value = 0;
-
-  static Annotation Str(const std::string& n, const std::string& v) {
-    Annotation a; a.kind = kString; a.name = n; a.str_value = v; return a;
-  }
-  static Annotation Int(const std::string& n, int64_t v) {
-    Annotation a; a.kind = kInt; a.name = n; a.int_value = v; return a;
-  }
-  static Annotation Uint(const std::string& n, uint64_t v) {
-    Annotation a; a.kind = kUint; a.name = n; a.uint_value = v; return a;
-  }
-};
-
-inline void ApplyAnnotations(perfetto::protos::TrackEvent* ev,
-                             const std::vector<Annotation>& annotations) {
-  for (const auto& a : annotations) {
-    auto* da = ev->add_debug_annotations();
-    da->set_name(a.name);
-    switch (a.kind) {
-      case Annotation::kString: da->set_string_value(a.str_value); break;
-      case Annotation::kInt:    da->set_int_value(a.int_value); break;
-      case Annotation::kUint:   da->set_uint_value(a.uint_value); break;
-    }
-  }
-}
-
-
-// Optional fields shared by slice-begin / instant events;
-struct SliceOptions {
-  std::string name;
-  std::string category;                 // -> TrackEvent.categories
-  std::vector<Annotation> annotations;  // -> debug_annotations
-  std::vector<uint64_t> flow_ids;       // -> TrackEvent.flow_ids (flow arrows)
-};
-
-// Emit one TrackEvent of |type| on |track_uuid|. The single builder behind
-// EmitSliceBegin/End/Instant.
-inline void EmitTrackEvent(uint32_t seq_id, uint64_t track_uuid, uint64_t ts_ns,
-                           perfetto::protos::TrackEvent::Type type,
-                           const SliceOptions& opts) {
-  perfetto::protos::Trace trace;
-  auto* packet = NewPacket(trace, ts_ns, seq_id);
-  auto* ev = packet->mutable_track_event();
-  ev->set_type(type);
-  ev->set_track_uuid(track_uuid);
-  if (!opts.name.empty()) {
-    ev->set_name(opts.name);
-  }
-  if (!opts.category.empty()) {
-    ev->add_categories(opts.category);
-  }
-  for (uint64_t fid : opts.flow_ids) {
-    ev->add_flow_ids(fid);
-  }
-  ApplyAnnotations(ev, opts.annotations);
-  EmitTrace(trace);
-}
-
-// Begin of a duration slice on track_uuid.
-inline void EmitSliceBegin(uint32_t seq_id, uint64_t track_uuid, uint64_t ts_ns,
-                           const SliceOptions& opts) {
-  EmitTrackEvent(seq_id, track_uuid, ts_ns,
-                 perfetto::protos::TrackEvent::TYPE_SLICE_BEGIN, opts);
-}
-
-// End of a duration slice on track_uuid. The begin/end pair is matched by
-// track + order, so the end carries no name/category.
-inline void EmitSliceEnd(uint32_t seq_id, uint64_t track_uuid, uint64_t ts_ns) {
-  perfetto::protos::Trace trace;
-  auto* packet = NewPacket(trace, ts_ns, seq_id);
-  auto* ev = packet->mutable_track_event();
-  ev->set_type(perfetto::protos::TrackEvent::TYPE_SLICE_END);
-  ev->set_track_uuid(track_uuid);
-  EmitTrace(trace);
-}
-
-// A zero-duration mark on track_uuid.
-inline void EmitInstant(uint32_t seq_id, uint64_t track_uuid, uint64_t ts_ns,
-                        const SliceOptions& opts) {
-  EmitTrackEvent(seq_id, track_uuid, ts_ns,
-                 perfetto::protos::TrackEvent::TYPE_INSTANT, opts);
-}
-
-}  // namespace perfetto_emit
-
-#endif  // PTI_TOOLS_UNITRACE_PERFETTO_LOGGER_H_
diff --git a/tools/unitrace/src/tracer.cc b/tools/unitrace/src/tracer.cc
deleted file mode 100644
index 6db099dc..00000000
--- a/tools/unitrace/src/tracer.cc
+++ /dev/null
@@ -1,474 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <csignal>
-#include <fstream>
-#include <iostream>
-
-#ifdef _WIN32
-#include <windows.h>
-#include <atomic>
-#include <string>
-#endif /* _WIN32 */
-
-#include "tracer.h"
-#include "unitimer.h"
-#include "unicontrol.h"
-
-#include "version.h"
-#include "unitrace_tool_commit_hash.h"
-
-#ifdef _WIN32
-#define CONSTRUCTOR
-#define DESTRUCTOR
-#else /* _WIN32 */
-#define CONSTRUCTOR __attribute__((constructor))
-#define DESTRUCTOR __attribute__((destructor))
-#endif /* _WIN32 */
-
-static UniTracer* tracer = nullptr;
-
-static CollectorOptions ReadArgs() {
-  std::string value;
-
-  CollectorOptions options;
-
-  value = utils::GetEnv("UNITRACE_CallLogging");
-  if (!value.empty() && value == "1") {
-    options.call_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_HostTiming");
-  if (!value.empty() && value == "1") {
-    options.host_timing = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_DeviceTiming");
-  if (!value.empty() && value == "1") {
-    options.device_timing = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_DeviceTimeline");
-  if (!value.empty() && value == "1") {
-    options.device_timeline = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_KernelSubmission");
-  if (!value.empty() && value == "1") {
-    options.kernel_submission = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_OpenCLTracing");
-  if (!value.empty() && value == "1") {
-    options.opencl = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeSyclRuntimeLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_syclrt_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeUrLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_ur_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_CclSummaryReport");
-  if (!value.empty() && value == "1") {
-    options.ccl_summary_report = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeIttLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_itt_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeCallLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_call_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeKernelLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_kernel_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeDeviceLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_device_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeNoThreadOnDevice");
-  if (!value.empty() && value == "1") {
-    options.chrome_no_thread_on_device = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeNoEngineOnDevice");
-  if (!value.empty() && value == "1") {
-    options.chrome_no_engine_on_device = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_Verbose");
-  if (!value.empty() && value == "1") {
-    options.verbose = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_Demangle");
-  if (!value.empty() && value == "1") {
-    options.demangle = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_KernelOnSeparateTiles");
-  if (!value.empty() && value == "1") {
-    options.kernels_per_tile = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_Tid");
-  if (!value.empty() && value == "1") {
-    options.need_tid = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_Pid");
-  if (!value.empty() && value == "1") {
-    options.need_pid = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_LogToFile");
-  if (!value.empty() && value == "1") {
-    options.log_to_file = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_StartPaused");
-  if (!value.empty() && value == "1") {
-    options.start_paused = 1;
-  }
-  
-  value = utils::GetEnv("UNITRACE_TraceOutputDirPath");
-  if (!value.empty() && value == "1") {
-    options.output_dir_path = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_MetricQuery");
-  if (!value.empty()) {
-    options.metric_query = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_KernelMetrics");
-  if (!value.empty()) {
-    options.metric_stream = 1;
-
-    value = utils::GetEnv("UNITRACE_MetricGroup");
-    if (!value.empty() && value == "EuStallSampling") {
-      options.stall_sampling = 1;
-    }
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeMpiLogging");
-  if (!value.empty()) {
-    options.chrome_mpi_logging = 1;
-  }
-
-  value = utils::GetEnv("UNITRACE_ChromeOmpLogging");
-  if (!value.empty() && value == "1") {
-    options.chrome_omp_logging = 1;
-  }
-
-#if BUILD_WITH_PERFETTO
-  value = utils::GetEnv("UNITRACE_OutputFormat");
-  if (value == "protobuf") {
-    options.protobuf_output = 1;
-  }
-#endif /* BUILD_WITH_PERFETTO */
-
-  options.DeriveFlags();
-  return options;
-}
-
-std::string get_version() {
-  return std::string(UNITRACE_VERSION) + " ("+ std::string(COMMIT_HASH) + ")";
-}
-
-void Teardown(void) {
-  // Stop and join the session-stop watcher first: it may be mid-flush inside
-  // OnSessionStopped() -> tracer->Flush(), so it must finish before the tracer
-  // it touches is deleted.
-  UniController::StopSessionStopWatcher();
-  if (tracer != nullptr) {
-    delete tracer;
-    tracer = nullptr;
-  }
-}
-
-typedef void (*SignalHandler)(int);
-static SignalHandler sigint_handler = nullptr;
-static SignalHandler sigabrt_handler = nullptr;
-static SignalHandler sigfpe_handler = nullptr;
-static SignalHandler sigill_handler = nullptr;
-static SignalHandler sigsegv_handler = nullptr;
-static SignalHandler sigterm_handler = nullptr;
-static SignalHandler siguser_handler = nullptr;
-
-void HandleAbnormalTermination(int sig) {
-  Teardown();
-
-  switch (sig) {
-    case SIGINT:
-      if (sigint_handler) {
-        sigint_handler(sig);
-      }
-      break;
-    case SIGABRT:
-      if (sigabrt_handler) {
-        sigabrt_handler(sig);
-      }
-      break;
-    case SIGFPE:
-      if (sigfpe_handler) {
-        sigfpe_handler(sig);
-      }
-      break;
-    case SIGILL:
-      if (sigill_handler) {
-        sigill_handler(sig);
-      }
-      break;
-    case SIGSEGV:
-      if (sigsegv_handler) {
-        sigsegv_handler(sig);
-      }
-      break;
-    case SIGTERM:
-      if (sigterm_handler) {
-        sigterm_handler(sig);
-      }
-      break;
-    default:
-      if (siguser_handler) {
-        siguser_handler(sig);
-      }
-      break;
-  }
-}
-
-void OnSessionStopped(void) {
-  if (tracer != nullptr) {
-    // Emit a user-facing acknowledgement that the session stop was observed,
-    // BEFORE the (potentially long) flush runs. In metric-query mode there is no
-    // separate parent process that waits and reports on stop: the in-process tool
-    // runs inside the application process itself (launched via execvp), so the
-    // metric data is flushed here and this message must be emitted here too.
-    std::cerr << "[INFO] Flush profile data as the session is stopped" << std::endl;
-
-    // Metric data flush handshake is only active for time-based metric sampling
-    // (UNITRACE_KernelMetrics) and per-kernel metric query (UNITRACE_MetricQuery).
-      const bool metric_handshake =
-        utils::GetEnv("UNITRACE_KernelMetrics") == "1" ||
-        utils::GetEnv("UNITRACE_MetricQuery") == "1";
-
-    // Announce that this child observed the session stop and is about to flush,
-    // BEFORE the flush runs. This increments the shared flush_started_ counter
-    if (metric_handshake) {
-      UniController::SignalChildFlushStarted();
-    }
-    tracer->Flush();
-    // Signal the parent process that child metric data is flushed.
-    // This is needed for both time-based metric sampling (UNITRACE_KernelMetrics)
-    // and per-kernel metric query (UNITRACE_MetricQuery) so the parent can
-    // safely run final post-processing (e.g. ComputeMetricsQueried on Windows)
-    if (metric_handshake) {
-      UniController::SignalChildDataReady();
-    }
-
-    // Session stopped but the app keeps running: close the result files now so
-    // the data is durable even if the process is later killed. Metric files are
-    // finalized by the parent via the handshake above and left untouched.
-    tracer->CloseResultFiles();
-  }
-}
-
-#ifndef _WIN32
-// pthread_atfork handlers for fork() without exec. Prepare/parent hold the
-// logging locks across fork() so a thread mid-flush cannot leave one locked
-// in the child, where no thread exists to release it.
-static void OnForkPrepare(void) {
-  if (tracer != nullptr) {
-    tracer->LockForFork();
-  }
-}
-
-static void OnForkParent(void) {
-  if (tracer != nullptr) {
-    tracer->UnlockAfterForkParent();
-  }
-}
-
-// Child: release the locks, give the child its own result files, then re-arm
-// the stop watcher (in that order, so a racing stop flushes into the child's
-// file). Single-threaded here; no app code has resumed yet.
-static void OnForkChild(void) {
-  if (tracer != nullptr) {
-    tracer->ReopenResultFilesAfterFork();
-  }
-  UniController::RearmSessionWatcherAfterFork();
-}
-#endif /* _WIN32 */
-
-void CONSTRUCTOR Init(void) {
-  std::string unitrace_version = utils::GetEnv("UNITRACE_VERSION");
-  if (unitrace_version.size() > 0) {
-    auto libunitrace_version = get_version();
-    if (unitrace_version.compare(libunitrace_version) != 0) {
-      std::cerr << "[ERROR] Versions of unitrace and " << LIB_UNITRACE_TOOL_NAME << " do not match" << std::endl;
-      exit(-1);
-    }
-  }
-
-  if (!utils::GetEnv("UNITRACE_Session").empty()) {
-    UniController::AttachTemporalControlRead(utils::GetEnv("UNITRACE_Session").c_str());
-    UniController::SetSessionStoppedCallback(OnSessionStopped);
-  } else if (utils::GetEnv("UNITRACE_StartPaused") == "1") {
-    // No named session, but --start-paused is on, so
-    // the application can still stop the tool from within via __itt_detach()
-    // (UniController::IttStop). Register the flush callback so that stop has
-    // somewhere to flush; without this the callback stays null and the data
-    // would only be written at process teardown.
-    UniController::SetSessionStoppedCallback(OnSessionStopped);
-  }
-
-  if (!utils::GetEnv("UNITRACE_TeardownOnSignal").empty()) {
-    // save previous handlers and install new handlers
-    // default signals first
-    auto handler = std::signal(SIGINT, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigint_handler = handler;
-    }
-    handler = std::signal(SIGABRT, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigabrt_handler = handler;
-    }
-    handler = std::signal(SIGFPE, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigfpe_handler = handler;
-    }
-    handler = std::signal(SIGILL, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigill_handler = handler;
-    }
-    handler = std::signal(SIGSEGV, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigsegv_handler = handler;
-    }
-    handler = std::signal(SIGTERM, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      sigterm_handler = handler;
-    }
-
-    // signals user specified
-    int signum = std::atoi(utils::GetEnv("UNITRACE_TeardownOnSignal").c_str());
-    handler = std::signal(signum, HandleAbnormalTermination);
-    if (handler != SIG_ERR) {
-      siguser_handler = handler;
-    }
-    else {
-      std::cerr << "[ERROR] Invalid signal specified for teardown" << std::endl;
-    }
-  }
-
-  if (!tracer) {
-    UniTimer::StartUniTimer();
-    tracer = UniTracer::Create(ReadArgs());
-  }
-
-  // Start the watcher only once the tracer exists: OnSessionStopped() no-ops
-  // while tracer is null, so starting earlier could drop the flush.
-  // Self-gates to named sessions with a registered callback.
-  UniController::StartSessionStopWatcher();
-
-#ifndef _WIN32
-  // Registered once, pre-main; the registration is inherited by every forked
-  // descendant. Not gated on a session: every fork-without-exec child needs
-  // its own result files. On failure children keep the old behavior.
-  pthread_atfork(OnForkPrepare, OnForkParent, OnForkChild);
-#endif /* _WIN32 */
-
-  if (utils::GetEnv("UNITRACE_FollowChildProcess") == "0") {
-    // restore LD_PRELOAD from UNITRACE_LD_PRELOAD_OLD to prevent the unitrace library
-    // from being loaded and this Init() function being called in a child process
-    // to disable child process following
-#ifndef _WIN32
-    auto oldpreload = utils::GetEnv("UNITRACE_LD_PRELOAD_OLD");
-    if (oldpreload.empty()) {
-     unsetenv("LD_PRELOAD");
-    }
-    else {
-      utils::SetEnv("LD_PRELOAD", oldpreload.c_str());
-    }
-#endif /* _WIN32 */
-  }
-}
-
-void DESTRUCTOR Fini(void) {
-  Teardown();
-}
-
-#ifdef _WIN32
-// Init() must not run from DllMain: it calls into the OpenCL and Level Zero drivers,
-// which can deadlock under the loader lock or when this DLL is loaded during another
-// library's unfinished init (e.g. tbbmalloc via INTEL_LIBITTNOTIFY64). DllMain only
-// starts a thread, which runs Init() after DllMain returns. The launcher keeps the
-// application suspended until UNITRACE_INIT_DONE_EVENT_PREFIX<pid> is signaled.
-
-static std::atomic<bool> init_completed{false};
-
-static DWORD WINAPI InitThreadProc(LPVOID) {
-  Init();
-  init_completed.store(true, std::memory_order_release);
-
-  // Signal the launcher, if any (see unitrace.cc).
-  const std::string event_name =
-      std::string(UNITRACE_INIT_DONE_EVENT_PREFIX) + std::to_string(GetCurrentProcessId());
-  HANDLE init_done = OpenEventA(EVENT_MODIFY_STATE, FALSE, event_name.c_str());
-  if (init_done != nullptr) {
-    SetEvent(init_done);
-    CloseHandle(init_done);
-  }
-
-  return 0;
-}
-
-BOOL WINAPI DllMain(
-    HINSTANCE hinstDLL,  // handle to DLL module
-    DWORD fdwReason,     // reason for calling function
-    LPVOID lpReserved)  // reserved
-{
-  switch (fdwReason)
-  {
-    case DLL_PROCESS_ATTACH: {
-      // No driver calls here; see the note above InitThreadProc.
-      HANDLE init_thread = CreateThread(nullptr, 0, InitThreadProc, nullptr, 0, nullptr);
-      if (init_thread == nullptr) {
-        std::cerr << "[ERROR] Failed to start the unitrace initialization thread: " <<
-          GetLastError() << std::endl;
-        return FALSE;
-      }
-      CloseHandle(init_thread);
-      break;
-    }
-    case DLL_THREAD_ATTACH:
-      break;
-    case DLL_THREAD_DETACH:
-      break;
-    case DLL_PROCESS_DETACH:
-      // Skip Fini() if Init() is still running: freeing the tracer under it is a
-      // use-after-free, and waiting for it would deadlock on the loader lock.
-      if (init_completed.load(std::memory_order_acquire)) {
-        Fini();
-      }
-      break;
-  }
-  return TRUE;
-}
-#endif /* _WIN32 */
diff --git a/tools/unitrace/src/tracer.h b/tools/unitrace/src/tracer.h
deleted file mode 100644
index d68d7b4f..00000000
--- a/tools/unitrace/src/tracer.h
+++ /dev/null
@@ -1,714 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNIFIED_TRACER_H_
-#define PTI_TOOLS_UNITRACE_UNIFIED_TRACER_H_
-
-#include <chrono>
-#include <cstdint>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <string>
-
-#include "collector_options.h"
-#include "utils/unilogger.h"
-#include "utils/utils.h"
-#include "ze_collector.h"
-
-#if BUILD_WITH_OPENCL
-  #include "cl_collector.h"
-  #include "cl_api_callbacks.h"
-#else /* BUILD_WITH_OPENCL */
-  class ClCollector;
-#endif /* BUILD_WITH_OPENCL */
-
-#if BUILD_WITH_XPTI
-  #include "xpti_collector.h"
-#endif /* BUILD_WITH_XPTI */
-
-#if BUILD_WITH_ITT
-  #include "itt_collector.h"
-#endif /* BUILD_WITH_ITT */
-
-#if BUILD_WITH_OMP
-  #include "ompt_collector.h"
-#endif /* BUILD_WITH_OMP */
-
-#include "chromelogger.h"
-#include "unimemory.h"
-#include "ze_loader.h"
-#include "logger_factory.h"
-
-class UniTracer {
- public:
-  static UniTracer* Create(const CollectorOptions& options) {
-    if (!InitializeL0()) {
-      exit(-1);
-    }
-
-    UniTracer* tracer = new UniTracer(options);
-    UniMemory::ExitIfOutOfMemory((void *)tracer);
-
-    OnZeKernelFinishCallback ze_kcallback = nullptr;
-    OnZeFunctionFinishCallback ze_fcallback = nullptr;
-    ZeCollector* ze_collector = nullptr;
-#if BUILD_WITH_OPENCL
-    OnClKernelFinishCallback cl_kcallback = nullptr;
-    OnClFunctionFinishCallback cl_fcallback = nullptr;
-
-    ClCollector* cl_gpu_collector = nullptr;
-    ClCollector* cl_cpu_collector = nullptr;
-#endif /* BUILD_WITH_OPENCL */
-
-#if BUILD_WITH_XPTI
-    if (options.chrome_syclrt_logging || options.chrome_ur_logging) {
-        xpti_collector = XptiCollector::Create(ChromeLogger::XptiLoggingCallback);
-    }
-#endif /* BUILD_WITH_XPTI */
-
-#if BUILD_WITH_OMP
-    if (options.chrome_omp_logging) {
-        ompt_collector = OmptCollector::Create(ChromeLogger::OmptLoggingCallback);
-    }
-#endif /* BUILD_WITH_OMP */
-
-#if BUILD_WITH_ITT
-    if (options.chrome_itt_logging || options.ccl_summary_report) {
-        itt_collector = IttCollector::Create(ChromeLogger::IttLoggingCallback);
-        if (itt_collector) {
-            if (options.ccl_summary_report) {
-                itt_collector->EnableCclSummary();
-            }
-            if (options.chrome_itt_logging) {
-                itt_collector->EnableChromeLogging();
-            }
-            if (options.chrome_mpi_logging) {
-              itt_collector->SetMpiCallback(ChromeLogger::MpiLoggingCallback);
-              itt_collector->SetMpiInternalCallback(ChromeLogger::MpiInternalLoggingCallback);
-            }
-        }
-    }
-    else {
-        //TODO: clean it up later
-        itt_collector = IttCollector::Create(nullptr);
-    }
-#endif /* BUILD_WITH_ITT */
-
-    if (options.device_timing ||
-        options.device_timeline ||
-        options.kernel_submission ||
-        options.chrome_device_logging ||
-        options.chrome_kernel_logging) {
-
-      if (options.chrome_kernel_logging) {
-        ze_kcallback = ChromeLogger::ZeChromeKernelLoggingCallback;
-        // also set fcallback functions
-        ze_fcallback = ChromeLogger::ChromeCallLoggingCallback;
-#if BUILD_WITH_OPENCL
-        cl_kcallback = ChromeLogger::ClChromeKernelLoggingCallback;
-        cl_fcallback = ChromeLogger::ClChromeCallLoggingCallback;
-#endif /* BUILD_WITH_OPENCL */
-      }
-      else if (options.chrome_device_logging) {
-        ze_kcallback = ChromeLogger::ZeChromeKernelLoggingCallback;
-#if BUILD_WITH_OPENCL
-        cl_kcallback = ChromeLogger::ClChromeKernelLoggingCallback;
-#endif /* BUILD_WITH_OPENCL */
-      }
-    }
-
-    if (options.call_logging ||
-        options.chrome_call_logging ||
-        options.host_timing) {
-
-      if (options.chrome_call_logging) {
-        ze_fcallback = ChromeLogger::ChromeCallLoggingCallback;
-#if BUILD_WITH_OPENCL
-        cl_fcallback = ChromeLogger::ClChromeCallLoggingCallback;
-#endif /* BUILD_WITH_OPENCL */
-      }
-    }
-
-    if (options.kernel_tracing || options.api_tracing) {
-#if BUILD_WITH_OPENCL
-      if (options.opencl) {
-        cl_device_id cl_cpu_device = utils::cl::GetIntelDevice(CL_DEVICE_TYPE_CPU);
-        cl_device_id cl_gpu_device = utils::cl::GetIntelDevice(CL_DEVICE_TYPE_GPU);
-
-        if (cl_cpu_device != nullptr) {
-          cl_cpu_collector = ClCollector::Create(cl_cpu_device, options, cl_kcallback, cl_fcallback, tracer);
-          if (cl_cpu_collector == nullptr) {
-            std::cerr <<
-              "[WARNING] Unable to create kernel collector for CL CPU backend" <<
-              std::endl;
-          }
-          tracer->cl_cpu_collector_ = cl_cpu_collector;
-        }
-
-        if (cl_gpu_device != nullptr) {
-          cl_gpu_collector = ClCollector::Create(cl_gpu_device, options, cl_kcallback, cl_fcallback, tracer);
-          if (cl_gpu_collector == nullptr) {
-            std::cerr << "[WARNING] Unable to create kernel collector for CL GPU backend" << std::endl;
-          }
-          tracer->cl_gpu_collector_ = cl_gpu_collector;
-        }
-
-        if (cl_cpu_collector == nullptr && cl_gpu_collector == nullptr) {
-          std::cerr << "[WARNING] Unable to trace any OpenCL kernels" << std::endl;
-          delete tracer;
-          return nullptr;
-        }
-      }
-#endif /* BUILD_WITH_OPENCL */
-
-#if BUILD_WITH_L0
-      ze_collector = ZeCollector::Create(options, ze_kcallback, ze_fcallback, tracer);
-      tracer->ze_collector_ = ze_collector;
-#endif /* BUILD_WITH_L0 */
-    }
-
-    return tracer;
-  }
-
-  void Flush() {
-    total_execution_time_ = utils::GetSystemTime() - start_time_;
-
-    if (ze_collector_ != nullptr) {
-      ze_collector_->FlushData();
-    }
-
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector_ != nullptr) {
-      cl_cpu_collector_->FlushData();
-    }
-    if (cl_gpu_collector_ != nullptr) {
-      cl_gpu_collector_->FlushData();
-    }
-#endif /* BUILD_WITH_OPENCL */
-
-    Report();
-
-#if BUILD_WITH_ITT
-    if (itt_collector != nullptr) {
-      std::string summary = itt_collector->CclSummaryReport();
-      if (summary.size() > 0) {
-        std::shared_ptr<UniLogger> logger_ccl_summary = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT);
-        logger_ccl_summary->Log(summary);
-        // Force flush so the summary is durable on abnormal termination (e.g. SIGKILL)
-        logger_ccl_summary->Flush();
-      }
-    }
-#endif /* BUILD_WITH_ITT */
-
-    if (chrome_logger_ != nullptr) {
-      chrome_logger_->Flush();
-    }
-
-    data_flushed_ = true;
-  }
-
-  // Finalize and close the result files without tearing down the tracer. Used
-  // when a session stops while the app keeps running, so the result is durable
-  // immediately. Metric files are left to the parent's handshake. Idempotent.
-  void CloseResultFiles() {
-    if (!data_flushed_) {
-      Flush();
-    }
-    if (chrome_logger_ != nullptr) {
-      chrome_logger_->Close();
-    }
-    logger_factory_->CloseTraceLoggers();
-  }
-
-#ifndef _WIN32
-  // atfork prepare: hold every logging lock across fork() so no other thread
-  // can leave one locked in the child. Order: chrome logger locks, then
-  // factory/Logger locks (matches how flush paths nest them).
-  void LockForFork() {
-    ChromeLoggerLockForFork();
-    logger_factory_->LockForFork();
-  }
-
-  void UnlockAfterForkParent() {
-    logger_factory_->UnlockAfterFork();
-    ChromeLoggerUnlockAfterForkParent();
-  }
-
-  // Fork child: release/re-create the locks taken in LockForFork(), then
-  // replace the inherited (shared) result files with the child's own. Loggers
-  // are reopened first, then the chrome logger writes a fresh header.
-  void ReopenResultFilesAfterFork() {
-    logger_factory_->UnlockAfterFork();
-    ChromeLoggerUnlockAfterForkChild();
-    if (ze_collector_ != nullptr) {
-      ze_collector_->MarkForkedChild();
-    }
-    logger_factory_->ReopenAfterFork();
-    if (chrome_logger_ != nullptr) {
-      chrome_logger_->ReopenAfterFork();
-    }
-    data_flushed_ = false;
-  }
-#endif /* _WIN32 */
-
-  ~UniTracer() {
-    if (ze_collector_ != nullptr) {
-      ze_collector_->DisableTracing();
-    }
-
-    // Write all reports before ZeCollector::Finalize(). On Windows, Finalize()
-    // deactivates metric groups and destroys metric contexts with Level Zero
-    // calls that run while the runtime may already be unloading
-    // (DLL_PROCESS_DETACH); those calls can intermittently take the process
-    // down. The raw metric (.q) data is dumped by FlushData() inside Flush()
-    // and survived, but the not-yet-written timing reports were lost. Flush
-    // first so the reports are on disk before the risky teardown.
-    if (!data_flushed_) {
-      Flush();
-    }
-
-    if (ze_collector_ != nullptr) {
-      ze_collector_->Finalize();
-    }
-
-#if BUILD_WITH_ITT
-    if (itt_collector != nullptr){
-      // Print CCL summary before deleting the object
-      // If CCL summary is not enabled summary string will be empty
-      std::string summary = itt_collector->CclSummaryReport();
-      if (summary.size() > 0){
-        std::shared_ptr<UniLogger> logger_ccl_summary = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT);
-        logger_ccl_summary->Log(summary);
-      }
-      delete itt_collector;
-    }
-#endif /* BUILD_WITH_ITT */
-
-#if BUILD_WITH_OMP
-    if (ompt_collector) {
-      delete ompt_collector;
-      ompt_collector = nullptr;
-    }
-#endif /* BUILD_WITH_OMP */
-
-    if (options_.log_to_file) {
-      std::shared_ptr<UniLogger> logger = logger_factory_->GetLogger(LOGGER_TYPE_LEGACY_SHARED_TRACE);
-      if (logger && !logger->IsEmpty()) {
-        std::cerr << "[INFO] Log is stored in " <<
-          logger->GetLogFileName() << std::endl;
-      }
-    }
-
-    if (ze_collector_ != nullptr) {
-      delete ze_collector_;
-    }
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector_ != nullptr) {
-      delete cl_cpu_collector_;
-    }
-    if (cl_gpu_collector_ != nullptr) {
-      delete cl_gpu_collector_;
-    }
-#endif /* BUILD_WITH_OPENCL */
-    if (chrome_logger_ != nullptr) {
-      delete chrome_logger_;
-    }
-  }
-
-
-  UniTracer(const UniTracer& that) = delete;
-  UniTracer& operator=(const UniTracer& that) = delete;
-
- private:
-  UniTracer(const CollectorOptions& options)
-      : options_(options),
-        logger_factory_(LoggerFactory::Create()) {
-    start_time_ = utils::GetSystemTime();
-    if (options_.chrome_call_logging || options_.chrome_kernel_logging ||
-        options_.chrome_device_logging || options_.chrome_syclrt_logging ||
-        options_.chrome_ur_logging ||
-        options_.chrome_itt_logging || options_.chrome_omp_logging) {
-      chrome_logger_ = ChromeLogger::Create(logger_factory_->GetAppName().c_str());
-    }
-
-  }
-
-  static uint64_t CalculateTotalFunctionTime(const ZeCollector* collector) {
-    return collector->CalculateTotalFunctionTime();
-  }
-
-  static uint64_t CalculateTotalKernelTime(const ZeCollector* collector) {
-    return collector->CalculateTotalKernelTime();
-  }
-
-#if BUILD_WITH_OPENCL
-  static uint64_t CalculateTotalFunctionTime(const ClCollector* collector) {
-    UNITRACE_ASSERT(collector != nullptr);
-    uint64_t total_time = 0;
-
-    const ClFunctionInfoMap& function_info_map = collector->GetFunctionInfoMap();
-    if (function_info_map.size() != 0) {
-      for (auto& value : function_info_map) {
-        total_time += value.second.total_time;
-      }
-    }
-
-    return total_time;
-  }
-
-  static uint64_t CalculateTotalKernelTime(const ClCollector* collector) {
-    UNITRACE_ASSERT(collector != nullptr);
-    uint64_t total_time = 0;
-
-    const ClKernelInfoMap& kernel_info_map = collector->GetKernelInfoMap();
-    if (kernel_info_map.size() != 0) {
-      for (auto& value : kernel_info_map) {
-        total_time += value.second.execute_time;
-      }
-    }
-
-    return total_time;
-  }
-#endif /* BUILD_WITH_OPENCL */
-
-  void PrintFunctionTable(std::shared_ptr<UniLogger> logger,
-      const ZeCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalFunctionTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintFunctionsTable(logger);
-    }
-  }
-
-  void PrintKernelTable(std::shared_ptr<UniLogger> logger,
-      const ZeCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalKernelTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintKernelsTable(logger);
-    }
-  }
-
-  void PrintSubmissionTable(std::shared_ptr<UniLogger> logger,
-      const ZeCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalKernelTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintSubmissionTable(logger);
-    }
-  }
-
-#if BUILD_WITH_OPENCL
-  void PrintFunctionTable(std::shared_ptr<UniLogger> logger,
-      const ClCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalFunctionTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintFunctionsTable(logger);
-    }
-  }
-
-  void PrintKernelTable(std::shared_ptr<UniLogger> logger,
-      const ClCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalKernelTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintKernelsTable(logger);
-    }
-  }
-
-  void PrintSubmissionTable(std::shared_ptr<UniLogger> logger,
-      const ClCollector* collector, const char* device_type) {
-    UNITRACE_ASSERT(collector != nullptr);
-    UNITRACE_ASSERT(device_type != nullptr);
-
-    uint64_t total_duration = CalculateTotalKernelTime(collector);
-    if (total_duration > 0) {
-      std::string str("\n== ");
-      str += std::string(device_type) + " Backend ==\n\n";
-      logger->Log(str);
-      collector->PrintSubmissionTable(logger);
-    }
-  }
-#endif /* BUILD_WITH_OPENCL */
-
-  void ReportTiming(
-      const ZeCollector* ze_collector,
-      const ClCollector* cl_cpu_collector,
-      const ClCollector* cl_gpu_collector,
-      const char* type) {
-
-    if ((ze_collector == nullptr) && (cl_cpu_collector == nullptr) && (cl_gpu_collector == nullptr)) {
-        return;
-    }
-
-    std::string stype = std::string(type);
-
-    std::string ze_title =
-      std::string("Total ") + stype +
-      " Time for L0 backend (ns): ";
-    std::string cl_cpu_title =
-      std::string("Total ") + stype +
-      " Time for CL CPU backend (ns): ";
-    std::string cl_gpu_title =
-      std::string("Total ") + stype +
-      " Time for CL GPU backend (ns): ";
-    size_t title_width = std::max(cl_cpu_title.size(), cl_gpu_title.size());
-    title_width = std::max(title_width, ze_title.size());
-    const size_t time_width = 20;
-
-    std::string str("\n=== ");
-    str += stype + " Timing Summary ===\n\n" +
-           std::string(std::max(int(title_width - sizeof("Total Execution Time (ns): ") + 1), 0), ' ') +
-           "Total Execution Time (ns): " +
-           std::string(std::max(int(time_width - std::to_string(total_execution_time_).length()), 0), ' ') +
-           std::to_string(total_execution_time_) +
-           "\n";
-
-    if (ze_collector != nullptr) {
-      uint64_t total_time{0};
-      if (stype == "API") {
-        total_time = CalculateTotalFunctionTime(ze_collector);
-      }
-      if (stype == "Device") {
-        total_time = CalculateTotalKernelTime(ze_collector);
-      }
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - ze_title.length()), 0), ' ') + ze_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector != nullptr) {
-      uint64_t total_time{0};
-      if (stype == "API") {
-        total_time = CalculateTotalFunctionTime(cl_cpu_collector);
-      }
-      if (stype == "Device") {
-        total_time = CalculateTotalKernelTime(cl_cpu_collector);
-      }
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - cl_cpu_title.length()), 0), ' ') +  cl_cpu_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-
-    if (cl_gpu_collector != nullptr) {
-      uint64_t total_time{0};
-      if (stype == "API") {
-        total_time = CalculateTotalFunctionTime(cl_gpu_collector);
-      }
-      if (stype == "Device") {
-        total_time = CalculateTotalKernelTime(cl_gpu_collector);
-      }
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - cl_gpu_title.length()), 0), ' ') + cl_gpu_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-#endif /* BUILD_WITH_OPENCL */
-    std::shared_ptr<UniLogger> timing_logger = (stype == "API") ? 
-                              logger_factory_->GetLogger(LOGGER_TYPE_TRACE_HOST_TIMING) :
-                              logger_factory_->GetLogger(LOGGER_TYPE_TRACE_DEVICE_TIMING);
-    timing_logger->Log(str);
-
-    if (ze_collector != nullptr) {
-      if (stype == "API") {
-        PrintFunctionTable(timing_logger, ze_collector, "L0");
-      }
-      if (stype == "Device") {
-        PrintKernelTable(timing_logger, ze_collector, "L0");
-      }
-    }
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector != nullptr) {
-      if (stype == "API") {
-        PrintFunctionTable(timing_logger, cl_cpu_collector, "CL CPU");
-      }
-      if (stype == "Device") {
-        PrintKernelTable(timing_logger, cl_cpu_collector, "CL CPU");
-      }
-    }
-    if (cl_gpu_collector != nullptr) {
-      if (stype == "API") {
-        PrintFunctionTable(timing_logger, cl_gpu_collector, "CL GPU");
-      }
-      if (stype == "Device") {
-        PrintKernelTable(timing_logger, cl_gpu_collector, "CL GPU");
-      }
-    }
-#endif /* BUILD_WITH_OPENCL */
-    timing_logger->Log("\n\n");
-  }
-
-  void ReportKernelSubmission(
-      const ZeCollector* ze_collector,
-      const ClCollector* cl_cpu_collector,
-      const ClCollector* cl_gpu_collector,
-      const char* type) {
-
-    if ((ze_collector == nullptr) && (cl_cpu_collector == nullptr) && (cl_gpu_collector == nullptr)) {
-      return;
-    }
-
-    std::string ze_title =
-      std::string("Total ") + std::string(type) +
-      " Time for L0 backend (ns): ";
-    std::string cl_cpu_title =
-      std::string("Total ") + std::string(type) +
-      " Time for CL CPU backend (ns): ";
-    std::string cl_gpu_title =
-      std::string("Total ") + std::string(type) +
-      " Time for CL GPU backend (ns): ";
-    size_t title_width = std::max(cl_cpu_title.size(), cl_gpu_title.size());
-    title_width = std::max(title_width, ze_title.size());
-    const size_t time_width = 20;
-
-    std::string str("\n=== Kernel Submission Summary ===\n\n");
-    str += std::string(std::max(int(title_width - sizeof("Total Execution Time (ns): ") + 1), 0), ' ') + "Total Execution Time (ns): " +
-           std::string(std::max(int(time_width - std::to_string(total_execution_time_).length()), 0), ' ') + std::to_string(total_execution_time_)           + "\n";
-
-    if (ze_collector != nullptr) {
-      uint64_t total_time = CalculateTotalKernelTime(ze_collector);
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - ze_title.length()), 0), ' ') + ze_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector != nullptr) {
-      uint64_t total_time = CalculateTotalKernelTime(cl_cpu_collector);
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - cl_cpu_title.length()), 0), ' ') + cl_cpu_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-    if (cl_gpu_collector != nullptr) {
-      uint64_t total_time = CalculateTotalKernelTime(cl_gpu_collector);
-      if (total_time > 0) {
-        str += std::string(std::max(int(title_width - cl_gpu_title.length()), 0), ' ') + cl_gpu_title +
-               std::string(std::max(int(time_width - std::to_string(total_time).length()), 0), ' ') + std::to_string(total_time) +
-               "\n";
-      }
-    }
-#endif /* BUILD_WITH_OPENCL */
-
-    std::shared_ptr<UniLogger> submission_logger = logger_factory_->GetLogger(LOGGER_TYPE_TRACE_DEVICE_SUBMISSION);
-    submission_logger->Log(str);
-
-    if (ze_collector != nullptr) {
-      PrintSubmissionTable(submission_logger, ze_collector, "L0");
-    }
-#if BUILD_WITH_OPENCL
-    if (cl_cpu_collector != nullptr) {
-      PrintSubmissionTable(submission_logger, cl_cpu_collector, "CL CPU");
-    }
-    if (cl_gpu_collector != nullptr) {
-      PrintSubmissionTable(submission_logger, cl_gpu_collector, "CL GPU");
-    }
-#endif /* BUILD_WITH_OPENCL */
-
-    submission_logger->Log("\n\n");
-  }
-
-  void Report() {
-#if BUILD_WITH_OPENCL
-    if (options_.host_timing) {
-      ReportTiming(
-          ze_collector_,
-          cl_cpu_collector_,
-          cl_gpu_collector_,
-          "API");
-    }
-    if (options_.device_timing) {
-      ReportTiming(
-          ze_collector_,
-          cl_cpu_collector_,
-          cl_gpu_collector_,
-          "Device");
-    }
-    if (options_.kernel_submission) {
-      ReportKernelSubmission(
-          ze_collector_,
-          cl_cpu_collector_,
-          cl_gpu_collector_,
-          "Device");
-    }
-#else /* BUILD_WITH_OPENCL */
-    if (options_.host_timing) {
-      ReportTiming(
-          ze_collector_,
-          nullptr,
-          nullptr,
-          "API");
-    }
-    if (options_.device_timing) {
-      ReportTiming(
-        ze_collector_,
-        nullptr,
-        nullptr,
-          "Device");
-    }
-    if (options_.kernel_submission) {
-      ReportKernelSubmission(
-        ze_collector_,
-        nullptr,
-        nullptr,
-          "Device");
-    }
-#endif /* BUILD_WITH_OPENCL */
-  }
-
- private:
-  CollectorOptions options_;
-
-  LoggerFactory* logger_factory_;
-  uint64_t start_time_;
-  uint64_t total_execution_time_ = 0;
-  bool data_flushed_ = false;
-
-  ZeCollector* ze_collector_ = nullptr;
-
-#if BUILD_WITH_OPENCL
-  ClCollector* cl_cpu_collector_ = nullptr;
-  ClCollector* cl_gpu_collector_ = nullptr;
-#endif /* BUILD_WITH_OPENCL */
-  ChromeLogger* chrome_logger_ = nullptr;
-};
-
-#endif // PTI_TOOLS_UNITRACE_UNIFIED_TRACER_H_
-
diff --git a/tools/unitrace/src/unicontrol.h b/tools/unitrace/src/unicontrol.h
deleted file mode 100644
index d75bef19..00000000
--- a/tools/unitrace/src/unicontrol.h
+++ /dev/null
@@ -1,791 +0,0 @@
-
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNICONTROL_H_
-#define PTI_TOOLS_UNITRACE_UNICONTROL_H_
-
-#include "shared_memory.h"
-#ifndef _WIN32
-#include <stdlib.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/syscall.h>
-#include <linux/futex.h>
-#include <unistd.h>
-#include <csignal>
-#include <climits>
-#include <pthread.h>
-#else  /* _WIN32 */
-#include <windows.h>
-#endif /* _WIN32 */
-#include <atomic>
-#include <chrono>
-#include <cstdint>
-#include <iostream>
-#include <thread>
-
-extern char **environ;
-
-#define UNITRACE_METRIC_SAMPLING_CONTROL "unitrace_metric_sampling_control"
-#define UNITRACE_METRIC_FLUSH_CONTROL "unitrace_metric_flush_control"
-
-#ifdef _WIN32
-// Signaled by the collector when initialization finishes; the target PID is appended.
-#define UNITRACE_INIT_DONE_EVENT_PREFIX "unitrace_init_done_"
-#endif /* _WIN32 */
-
-enum TemporalControlState {
-  TEMPORAL_RESUMED = 0,
-  TEMPORAL_PAUSED = 1,
-  TEMPORAL_STOPPED = 2
-};
-
-struct TemporalControl {
-  TemporalControlState state_;
-  // Count of transitions into TEMPORAL_RESUMED. Never reset; readers detect
-  // a resume by comparing with the value they last saw.
-  std::atomic<uint32_t> resume_epoch_;
-  char padding_[1024 - sizeof(TemporalControlState) - sizeof(std::atomic<uint32_t>)];
-};
-
-// Collection state a sampling thread saw at its previous metric drain.
-struct MetricSamplingWindow {
-  uint32_t resume_epoch_ = 0;
-  bool resumed_ = true;
-};
-
-// Shared-memory control used by the parent unitrace process to know when its
-// instrumented child processes have flushed their metric data, using a simple
-// pair of counters instead of a per-PID slot table:
-//
-//   flush_started_   monotonic count of children that have BEGUN flushing since
-//                    the session stopped (only ever incremented). It opens the
-//                    readiness gate: until at least one child has started there
-//                    is nothing to wait for.
-//   flush_completed_ number of children that have COMPLETED flushing
-//
-// A child only touches these counters when it actually flushes: on observing
-// the session stop it increments flush_started_(SignalChildFlushStarted), and
-// decrements flush_completed_ (SignalChildDataReady) after the flushing is
-// completed. A child that never observes the stop (e.g. a non-GPU process 
-// that inherited the tool via LD_PRELOAD but issues no L0/CL calls
-// never touches the counters, so it is naturally invisible and cannot
-// stall the parent -- no registration or per-PID bookkeeping is needed.
-//
-// Readiness: flush_started_ == flush_completed_ (see CheckChildDataReadyState).
-// Because a child observes the stop only on its next collection check, the
-// parent applies a short start-of-flush grace (kChildFlushStartGraceMs_) before
-// trusting an early ready result, so a fast sibling that already finished does
-// not cause the parent to skip a child that has not begun flushing yet (see
-// IsChildDataReadyTrusted).
-//
-// Tradeoff vs. the per-PID slot table: a child killed mid-flush increments
-// flush_started_ but never increments flush_completed_, so readiness never goes
-// true and // the parent falls back to its bounded timeout. The counters carry
-// no per-PID identity, so there is no liveness-based reaping to recover such a
-// child early; this simplicity is the intended cost.
-struct MetricFlushControl {
-  std::atomic<int32_t> flush_started_;
-  std::atomic<int32_t> flush_completed_;
-};
-
-
-class UniController{
-  public:
-    typedef void (*SessionStoppedCallback)(void);
-
-    static void SetSessionStoppedCallback(SessionStoppedCallback callback) {
-      session_stopped_callback_ = callback;
-    }
-
-    // Idle-process fix: a stop is normally only seen from collector callbacks,
-    // so an idle process never flushes. This watcher blocks on the named
-    // session's shm state and fires the flush itself, holding no collector lock.
-    static void StartSessionStopWatcher() {
-      if (utils::GetEnv("UNITRACE_Session").empty()) {
-        return;
-      }
-      if (session_stopped_callback_ == nullptr) {
-        return;  // nothing to flush to; do not spin a thread
-      }
-      if (session_watcher_running_.exchange(true)) {
-        return;  // already started
-      }
-
-#ifndef _WIN32
-      // Spawn the watcher with all signals blocked (a new thread copies the
-      // creator's mask) so a signal handler never runs on it and self-joins
-      // in Teardown -> StopSessionStopWatcher (EDEADLK -> std::terminate).
-      sigset_t all_signals, prev_mask;
-      sigfillset(&all_signals);
-      pthread_sigmask(SIG_SETMASK, &all_signals, &prev_mask);
-#endif /* _WIN32 */
-
-      // Heap-allocated so a forked child can drop the inherited handle without
-      // touching its stale pthread descriptor (see RearmSessionWatcherAfterFork).
-      bool started = false;
-      try {
-        session_watcher_thread_ = new std::thread(SessionWatcherLoop);
-        started = true;
-      }
-      catch (...) {
-        // Runs from a library constructor / fork handler: never let the
-        // exception escape. Degrade to passive stop detection instead.
-        session_watcher_thread_ = nullptr;
-      }
-
-#ifndef _WIN32
-      pthread_sigmask(SIG_SETMASK, &prev_mask, nullptr);
-#endif /* _WIN32 */
-
-      if (!started) {
-        // Release the guard so a later attempt (e.g. a forked child) can retry.
-        session_watcher_running_.store(false, std::memory_order_release);
-      }
-    }
-
-    // Stop and join the watcher. MUST run before the tracer is destroyed so a
-    // mid-flush watcher finishes first. Idempotent; safe with no watcher.
-    static void StopSessionStopWatcher() {
-      if (!session_watcher_running_.load(std::memory_order_acquire)) {
-        return;
-      }
-      session_watcher_stop_.store(true, std::memory_order_release);
-      // Wake a parked watcher so it sees the stop flag now. The state word is
-      // unchanged (teardown is not a session stop), so it exits without flushing.
-      WakeSessionWaiters();
-      std::thread* watcher = session_watcher_thread_;
-      session_watcher_thread_ = nullptr;
-      if (watcher != nullptr) {
-        if (watcher->joinable()) {
-          // Signal masking makes a self-join unreachable for async signals;
-          // guard anyway: on the watcher thread detach instead (EDEADLK).
-          if (watcher->get_id() == std::this_thread::get_id()) {
-            watcher->detach();
-          } else {
-            watcher->join();
-          }
-        }
-        delete watcher;
-      }
-      session_watcher_running_.store(false, std::memory_order_release);
-    }
-
-#ifndef _WIN32
-    // Fork child: the watcher thread was not duplicated by fork(), so start a
-    // new one. Runs inside the atfork child handler: single-threaded, no app
-    // code has resumed yet, so no locking is needed and no stop can be missed.
-    static void RearmSessionWatcherAfterFork() {
-      if (temporal_control_stopped_.load(std::memory_order_acquire)) {
-        return;  // session already stopped before the fork; nothing to watch
-      }
-      // The inherited handle names a thread that does not exist here: drop it
-      // without join()/detach() (leaks a tiny std::thread object). Reset both
-      // guards copied from the parent so StartSessionStopWatcher() proceeds.
-      session_watcher_thread_ = nullptr;
-      session_watcher_running_.store(false, std::memory_order_release);
-      session_watcher_stop_.store(false, std::memory_order_release);
-      // session_shm_ is MAP_SHARED, so the new watcher parks on the same state
-      // word as the parent: one FUTEX_WAKE from --stop releases every process.
-      StartSessionStopWatcher();
-    }
-#endif /* _WIN32 */
-
-    static void CreateTemporalControl(const char* session) {
-      SharedMemoryReturnStatus ret = session_shm_.Create(session, sizeof(TemporalControl));
-      if (ret == SHM_FAILED) {
-        exit(-1);
-      }
-      if (ret == SHM_ALREADY_EXISTS) {
-        // The mapping already existed (Windows: named mapping still held by
-        // another process).  Only warn if it wasn't properly stopped.
-        if (((TemporalControl*)session_shm_.GetPtr())->state_ != TEMPORAL_STOPPED) {
-          std::cerr << "[WARNING] Session " << session << " was not stopped before reusing" << std::endl;
-        }
-      }
-      SetTemporalState((TemporalControl*)session_shm_.GetPtr(), TEMPORAL_RESUMED);
-    }
-
-    static void AttachTemporalControlWrite(const char *session) {
-      if (session_shm_.AttachWrite(session, sizeof(TemporalControl)) == SHM_FAILED) {
-        exit(-1);
-      }
-    }
-
-    static void AttachTemporalControlRead(const char *session) {
-      SharedMemoryReturnStatus ret = session_shm_.AttachRead(session, sizeof(TemporalControl));
-      if (ret == SHM_FAILED) {
-        exit(-1);
-      }
-      if (ret == SHM_STOPPED) {
-        temporal_control_stopped_ = true;
-        return;
-      }
-    }
-
-    static void ReleaseTemporalControl(void) {
-      if (session_shm_.Release() == SHM_FAILED) {
-        std::cerr << "[WARNING] ReleaseTemporalControl Failed" << std::endl;
-      }
-    }
-
-    static void TemporalPause(const char *session) {
-      AttachTemporalControlWrite(session);
-      if (session_shm_.GetPtr() != nullptr) {
-        if (((TemporalControl*)session_shm_.GetPtr())->state_ == TEMPORAL_STOPPED) {
-          return;
-        }
-        SetTemporalState((TemporalControl*)session_shm_.GetPtr(), TEMPORAL_PAUSED);
-        std::cerr << "[INFO] Session " << session << " is paused" << std::endl;
-      }
-    }
-
-    static void TemporalResume(const char *session) {
-      AttachTemporalControlWrite(session);
-      if (session_shm_.GetPtr() != nullptr) {
-        if (((TemporalControl*)session_shm_.GetPtr())->state_ == TEMPORAL_STOPPED) {
-          return;
-        }
-        SetTemporalState((TemporalControl*)session_shm_.GetPtr(), TEMPORAL_RESUMED);
-        std::cerr << "[INFO] Session " << session << " is resumed" << std::endl;
-      }
-    }
-
-    static void TemporalStop(const char *session) {
-      AttachTemporalControlWrite(session);
-      if (session_shm_.GetPtr() != nullptr) {
-        SetTemporalState((TemporalControl*)session_shm_.GetPtr(), TEMPORAL_STOPPED);
-        // Wake every traced process parked on this session's state word. The
-        // futex keys on the shared page, so this write mapping reaches all
-        // read-mapped waiters. Must happen before Release() unmaps the page.
-        WakeSessionWaiters();
-        std::cerr << "[INFO] Session " << session << " is stopped and can no longer be paused or resumed" << std::endl;
-      }
-      // Release (unmap + unlink) the shared memory so a new session with the
-      // same name can be created immediately.  The profiled process already has
-      // the TEMPORAL_STOPPED value; its mapping remains valid until it munmaps.
-      session_shm_.Release();
-    }
-
-    static void CreateMetricSamplingControl() {
-      if (metric_sample_shm_.Create(UNITRACE_METRIC_SAMPLING_CONTROL, sizeof(TemporalControl), true) == SHM_FAILED) {
-        exit(-1);
-      }
-
-      // Static init ran before main() parsed --start-paused; refresh it.
-      start_paused_ = (utils::GetEnv("UNITRACE_StartPaused") == "1");
-      if (start_paused_) {
-        SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), TEMPORAL_PAUSED);
-      } else {
-        SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), TEMPORAL_RESUMED);
-      }
-    }
-
-    static void ReleaseMetricSamplingControl() {
-      if (metric_sample_shm_.GetPtr() != nullptr) {
-        metric_sample_shm_.Release();
-      }
-    }
-
-    static void CreateMetricFlushControl() {
-      if (metric_flush_shm_.Create(UNITRACE_METRIC_FLUSH_CONTROL, sizeof(MetricFlushControl), true) == SHM_FAILED) {
-        exit(-1);
-      }
-      auto* ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      ctl->flush_started_.store(0, std::memory_order_release);
-      ctl->flush_completed_.store(0, std::memory_order_release);
-    }
-
-    static void ReleaseMetricFlushControl() {
-      if (metric_flush_shm_.GetPtr() != nullptr) {
-        metric_flush_shm_.Release();
-      }
-    }
-
-    // Called by the in-process tool (child) when it observes the session stop
-    // and is about to flush its metric data, BEFORE the flush runs. Increments
-    // flush_started_ (monotonic; opens the readiness gate) 
-    // The matching increment of flush_completed_
-    // happens in SignalChildDataReady() once the flush completes. A child that
-    // never observes the stop never calls this, so it stays invisible to the
-    // parent's readiness check.
-    static void SignalChildFlushStarted() {
-      auto* ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      if (ctl == nullptr) {
-        if (metric_flush_shm_.AttachWrite(UNITRACE_METRIC_FLUSH_CONTROL, sizeof(MetricFlushControl)) != SHM_SUCCESS) {
-          return;
-        }
-        ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      }
-      ctl->flush_started_.fetch_add(1, std::memory_order_acq_rel);
-    }
-
-    // Called by the in-process tool (child) when its session stops and metric
-    // data has been flushed. Increments flush_completed_, balancing the
-    // increment done by SignalChildFlushStarted().
-    static void SignalChildDataReady() {
-      auto* ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      if (ctl == nullptr) {
-        if (metric_flush_shm_.AttachWrite(UNITRACE_METRIC_FLUSH_CONTROL, sizeof(MetricFlushControl)) != SHM_SUCCESS) {
-          return;
-        }
-        ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      }
-      ctl->flush_completed_.fetch_add(1, std::memory_order_acq_rel);
-    }
-
-    // Returns:
-    //   -1 : no child has started flushing
-    //    0 : one or more children have started flusheing but not all of them
-    //        have finished flushing. 
-    //    1 : one or more children have started flusheing and all of them have
-    //        finished flushing
-    // If a child is killed mid-flush, flush_completed_ will not be bumped and 0
-    // is returned and the parent falls back to its bounded timeout.
-    // 
-    static int CheckChildDataReadyState() {
-      auto* ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      if (ctl == nullptr) {
-        if (metric_flush_shm_.AttachRead(UNITRACE_METRIC_FLUSH_CONTROL, sizeof(MetricFlushControl)) != SHM_SUCCESS) {
-          return false;
-        }
-        ctl = (MetricFlushControl*)metric_flush_shm_.GetPtr();
-      }
-      
-      auto started = ctl->flush_started_.load(std::memory_order_acquire);
-      auto completed = ctl->flush_completed_.load(std::memory_order_acquire);
-      if (started == 0) {
-        return -1;
-      }
-      if (started == completed) {
-        return 1;
-      }
-      return 0; 
-    }
-
-    // Grace period (ms) the parent waits after a session stop before it trusts
-    // an CheckChildDataReady(State) == 1 result. This closes the start-of-flush race:
-    // with multiple GPU children, a fast child can begin and finish flushing
-    // (flush_started_ == 1, flush_completed_ == 0) before a slower sibling has
-    // observed the stop and incremented the counters. Because the counters carry
-    // no notion of "how many children will participate", the parent cannot tell
-    // the slow child apart from "all done"; waiting out the grace gives every
-    // child time to begin flushing (and thus raise flush_completed_) first.
-    static constexpr int kChildFlushStartGraceMs_ = 500;
-
-    // Combines CheckChildDataReadyState() with the start-of-flush grace: readiness is
-    // trusted only when it holds AND the grace has elapsed since the parent
-    // began waiting (elapsed_ms). 
-    static bool IsChildDataReadyTrusted(int elapsed_ms) {
-      auto state = CheckChildDataReadyState();
-      if ((state != -1) && (state == 0)) {
-        return false;
-      }
-      // No child ever flushed or all children completed flushing in elapsed_time
-      return (elapsed_ms >= kChildFlushStartGraceMs_);
-    }
-
-    // Read-only check of the named session's state. Returns true if the
-    // session shared memory is mapped and currently TEMPORAL_STOPPED. Unlike
-    // IsMetricSamplingEnabled()/IsCollectionEnabled() this does NOT fire the
-    // session-stopped callback, so it is safe to poll from the parent process.
-    static bool IsSessionStopped(void) {
-      if (metric_sample_shm_.GetPtr() != nullptr) {
-        if (((TemporalControl*)metric_sample_shm_.GetPtr())->state_ == TEMPORAL_STOPPED) {
-          return true;
-        }
-      }
-      if (session_shm_.GetPtr() == nullptr) {
-        return false;
-      }
-      return (((TemporalControl*)session_shm_.GetPtr())->state_ == TEMPORAL_STOPPED);
-    }
-
-    // Called once per sampling thread before its first IsMetricSamplingEnabled().
-    static MetricSamplingWindow BeginMetricSamplingWindow(void) {
-      MetricSamplingWindow window;
-      const TemporalControl* ctl = MetricSamplingControl();
-      if (ctl != nullptr) {
-        window.resume_epoch_ = ctl->resume_epoch_.load(std::memory_order_acquire);
-        window.resumed_ = (ctl->state_ == TEMPORAL_RESUMED);
-      }
-      return window;
-    }
-
-    // True if collection was resumed at any point since the previous call on
-    // this window, i.e. the data drained since then may hold resumed samples.
-    static bool IsMetricSamplingEnabled(MetricSamplingWindow& window) {
-      const TemporalControl* ctl = MetricSamplingControl();
-      if (ctl == nullptr) {
-        return true;
-      }
-
-      // Epoch before state, so a racing resume is seen now or on the next call.
-      const uint32_t epoch = ctl->resume_epoch_.load(std::memory_order_acquire);
-      const TemporalControlState state = ctl->state_;
-
-      if ((state == TEMPORAL_STOPPED) && (ctl == (TemporalControl*)session_shm_.GetPtr())) {
-        // Named session was stopped. Fire the session-stopped callback once
-        // so the owner of the metric sampling thread (the parent process)
-        // can react to the stop. The callback is invoked at most once across
-        // all sampling threads via the atomic exchange guard.
-        if (session_stopped_callback_) {
-          if (!session_stopped_notified_.exchange(true)) {
-            session_stopped_callback_();
-          }
-        }
-      }
-
-      const bool resumed = (state == TEMPORAL_RESUMED);
-      const bool save = window.resumed_ || resumed || (epoch != window.resume_epoch_);
-      window.resume_epoch_ = epoch;
-      window.resumed_ = resumed;
-      return save;
-    }
-
-    // defer_callback: when true, report the stopped state WITHOUT synchronously
-    // firing the session-stopped callback (and without consuming the one-shot
-    // notify guard, so the notification stays armed). Pass true when calling
-    // from code that already holds the collector's processing locks: firing
-    // OnSessionStopped() there re-enters the collector (Flush ->
-    // ProcessAllCommandsSubmitted) and deadlocks on the non-recursive
-    // global_device_submissions_mutex_ (std::system_error / EDEADLK). With the
-    // notification deferred, it fires later from a safe top-level call site
-    // (e.g. the next OnEnter*Append* callback) where no collector lock is held.
-    static bool IsCollectionEnabled(bool defer_callback = false) {
-      // __itt_detach() is a permanent, one-way stop (see IttStop()). Once it
-      // has been called, collection stays off for the rest of the process, so
-      // short-circuit here before any of the pause/session/env-var checks
-      // below. The flush is fired by IttStop() itself, not from here, so this
-      // path does not need to touch session_stopped_notified_.
-      if (itt_stopped_) {
-        return false;
-      }
-
-      if (temporal_control_stopped_) {
-        // Session is stopped. The very first detection may have happened in a
-        // deferred context (under a collector lock, where firing the callback
-        // synchronously would re-enter and deadlock), which set
-        // temporal_control_stopped_ but skipped the notification. If the
-        // notification is still pending and this is a safe (non-deferred)
-        // top-level call site, fire it now -- otherwise the deferred callback
-        // would be lost forever because every later call short-circuits here.
-        if (session_stopped_callback_) {
-          if (!defer_callback && !session_stopped_notified_.exchange(true)) {
-            session_stopped_callback_();
-          }
-        }
-        return false;
-      }
-
-      if (session_shm_.GetPtr() != nullptr) {
-        TemporalControlState state = ((TemporalControl*)session_shm_.GetPtr())->state_;
-        if (state == TEMPORAL_STOPPED) {
-          temporal_control_stopped_ = true;
-          if (session_stopped_callback_) {
-            if (!defer_callback && !session_stopped_notified_.exchange(true)) {
-              session_stopped_callback_();
-            }
-          }
-          return false;
-        }
-        return (state == TEMPORAL_RESUMED);
-      }
-
-      if (start_paused_) {
-        if (itt_paused_) {
-          return false;
-        }
-
-        // Consult PTI_ENABLE_COLLECTION on every check rather than returning a
-        // cached metric-sampling shm state: the application may toggle the env
-        // var at any point to gate collection. IsCollectionEnabledByEnv() also
-        // pushes the resulting state into the metric-sampling shared memory so
-        // the parent's sampling thread -- which cannot see this child's
-        // environment -- tracks the change.
-        return IsCollectionEnabledByEnv(defer_callback);
-      }
-      return true;
-    }
-
-    static void IttPause(void) {
-      itt_paused_ = true;
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "0");
-      // shared memory for metric sampling created by parent process
-      // we always need to check in child process if it still exist
-      if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        if (metric_sample_shm_.AttachWrite(UNITRACE_METRIC_SAMPLING_CONTROL, sizeof(TemporalControl)) == SHM_SUCCESS) {
-          SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), TEMPORAL_PAUSED);
-        }
-      }
-    }
-
-    static void IttResume(void) {
-      itt_paused_ = false;
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "1");
-      // shared memory for metric sampling created by parent process
-      // we always need to check in child process if it still exist
-      if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        if (metric_sample_shm_.AttachWrite(UNITRACE_METRIC_SAMPLING_CONTROL, sizeof(TemporalControl)) == SHM_SUCCESS) {
-          SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), TEMPORAL_RESUMED);
-        }
-      }
-    }
-
-    // Handles __itt_detach(): a permanent, one-way stop of collection, as
-    // opposed to the reversible IttPause()/IttResume() pair. Unlike pause,
-    // this takes effect regardless of --start-paused and cannot be undone --
-    // there is no "itt resume" that clears itt_stopped_. It models an
-    // application that profiles a phase and then detaches the tool for good.
-    static void IttStop(void) {
-      itt_stopped_ = true;
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "-1");
-      // shared memory for metric sampling created by parent process
-      // we always need to check in child process if it still exist
-      if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        if (metric_sample_shm_.AttachWrite(UNITRACE_METRIC_SAMPLING_CONTROL, sizeof(TemporalControl)) == SHM_SUCCESS) {
-          SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), TEMPORAL_STOPPED);
-        }
-      }
-      // Flush the data collected so far, now. This is the purpose of detach:
-      // get the profile out at stop time rather than waiting for process
-      // teardown. Firing synchronously here is safe (no deadlock): __itt_detach()
-      // runs on the application thread and the ITT path holds no collector lock,
-      // so OnSessionStopped() -> Flush() -> ProcessAllCommandsSubmitted() can
-      // take global_device_submissions_mutex_ without re-entering it. (This is
-      // why the deferred-callback hazard documented on IsCollectionEnabled()
-      // does not apply here.) The session_stopped_notified_ one-shot guard is
-      // shared with those deferred sites, so the flush runs at most once.
-      if (session_stopped_callback_ && !session_stopped_notified_.exchange(true)) {
-        session_stopped_callback_();
-      }
-    }
-
-  private:
-    // All state_ writes go through here so each transition into
-    // TEMPORAL_RESUMED bumps resume_epoch_.
-    static void SetTemporalState(TemporalControl* ctl, TemporalControlState state) {
-      if ((state == TEMPORAL_RESUMED) && (ctl->state_ != TEMPORAL_RESUMED)) {
-        ctl->resume_epoch_.fetch_add(1, std::memory_order_release);
-      }
-      ctl->state_ = state;
-    }
-
-    // State gating metric sampling: the named session's, else (with
-    // --start-paused) the one the application updates. nullptr if not gated.
-    static const TemporalControl* MetricSamplingControl(void) {
-      if (session_shm_.GetPtr() != nullptr) {
-        return (const TemporalControl*)session_shm_.GetPtr();
-      }
-      if (start_paused_) {
-        return (const TemporalControl*)metric_sample_shm_.GetPtr();
-      }
-      return nullptr;
-    }
-
-    // Body of the session-stop watcher thread (see StartSessionStopWatcher).
-    static void SessionWatcherLoop() {
-      while (!session_watcher_stop_.load(std::memory_order_acquire)) {
-        if (IsSessionStopped()) {
-          NotifySessionStopped();
-          return;  // stop observed and flushed -- the watcher's job is done
-        }
-        // Block until the state word changes instead of polling: idle workers
-        // cost no periodic wakeups; the bounded timeout is only a safety
-        // backstop. Returns false (no futex / no word) -> exit, never poll.
-        if (!WaitForSessionStateChange()) {
-          return;
-        }
-      }
-    }
-
-    // Latch the stopped state and fire the one-shot flush. Shared by the
-    // watcher and the collection-state call sites; the atomic exchange
-    // guarantees the flush runs at most once whichever thread detects first.
-    static void NotifySessionStopped() {
-      temporal_control_stopped_ = true;
-      if (session_stopped_callback_ &&
-          !session_stopped_notified_.exchange(true)) {
-        session_stopped_callback_();
-      }
-    }
-
-    // Address of the named session's state word the watcher blocks on, or
-    // null if session_shm_ is not mapped (already stopped+unlinked, or unnamed).
-    static TemporalControlState* SessionStatePtr() {
-      void* p = session_shm_.GetPtr();
-      if (p == nullptr) {
-        return nullptr;
-      }
-      return &((TemporalControl*)p)->state_;
-    }
-
-    // Park the watcher until the state word changes, a wake arrives, or the
-    // safety timeout elapses; the caller re-checks what happened. Returns false
-    // when no blocking wait is possible (no word, or Windows: no futex) -> exit.
-    static bool WaitForSessionStateChange() {
-#ifndef _WIN32
-      TemporalControlState* state = SessionStatePtr();
-      if (state == nullptr) {
-        return false;  // nothing to wait on -> caller exits; never poll
-      }
-      // Volatile read forces a fresh load of the cross-process word and matches
-      // what FUTEX_WAIT compares against, so "expected" is never stale.
-      const uint32_t observed =
-          *reinterpret_cast<volatile uint32_t*>(state);
-      struct timespec ts;
-      ts.tv_sec = kSessionWatchTimeoutMs_ / 1000;
-      ts.tv_nsec = (kSessionWatchTimeoutMs_ % 1000) * 1000000L;
-      // FUTEX_WAIT returns immediately (EAGAIN) if *state already differs from
-      // observed, so a change that already happened is never missed; otherwise
-      // it parks until FUTEX_WAKE, the timeout, or a signal (EINTR -> re-check).
-      syscall(SYS_futex, reinterpret_cast<uint32_t*>(state), FUTEX_WAIT,
-              observed, &ts, nullptr, 0);
-      return true;
-#else  /* _WIN32 */
-      // No futex on Windows. Do NOT poll as a fallback -- exit the watcher.
-      return false;
-#endif /* _WIN32 */
-    }
-
-    // Wake any watcher parked on this process's session state word. Called
-    // after a stop and on teardown. No-op without a futex (timeout re-checks).
-    static void WakeSessionWaiters() {
-#ifndef _WIN32
-      TemporalControlState* state = SessionStatePtr();
-      if (state == nullptr) {
-        return;
-      }
-      syscall(SYS_futex, reinterpret_cast<uint32_t*>(state), FUTEX_WAKE,
-              INT_MAX, nullptr, nullptr, 0);
-#endif /* _WIN32 */
-    }
-
-    // Propagate the env-derived start-paused state into the
-    // metric-sampling shared memory so the parent process (which owns the
-    // sampling thread and cannot see this child's PTI_ENABLE_COLLECTION) can
-    // pause/resume/stop sampling in step with the application. Only relevant
-    // when kernel-metric sampling is active. Mirrors the shm writes done by
-    // IttPause()/IttResume()/IttStop(); the child attaches lazily on first use
-    // and only stores on subsequent calls, so this stays cheap on the hot path.
-    static void PropagateCollectionStateToMetricSampling(TemporalControlState state) {
-      if (utils::GetEnv("UNITRACE_KernelMetrics") != "1") {
-        return;
-      }
-      if (metric_sample_shm_.GetPtr() == nullptr) {
-        if (metric_sample_shm_.AttachWrite(UNITRACE_METRIC_SAMPLING_CONTROL, sizeof(TemporalControl)) != SHM_SUCCESS) {
-          return;
-        }
-      }
-      SetTemporalState((TemporalControl*)metric_sample_shm_.GetPtr(), state);
-    }
-
-    // Shared by IsCollectionEnabled() and IsMetricSamplingEnabled() under
-    // --start-paused: consult the
-    // PTI_ENABLE_COLLECTION environment variable, which the application (or
-    // an outside controller that exported it) uses to gate collection, and
-    // mirror the resulting state into the metric-sampling shared memory.
-    //   "-1" -> permanent stop: latch temporal_control_stopped_ and fire the
-    //           one-shot session-stopped flush (the env-var form of __itt_detach;
-    //           IttStop() writes it and child processes inherit it).
-    //   "0" / unset -> collection currently disabled.
-    //   anything else -> enabled.
-    // defer_callback follows the same contract as IsCollectionEnabled(): when
-    // true, report the stopped state without firing the callback or consuming
-    // the notify guard (used by callers holding a collector lock).
-    static bool IsCollectionEnabledByEnv(bool defer_callback = false) {
-      if (environ == nullptr) {
-        return true;
-      }
-
-      char *env;
-      char *value = nullptr;
-      constexpr int len = sizeof("PTI_ENABLE_COLLECTION") - 1;  // do not count trailing '\0'
-      char **cursor = environ;
-      // PTI_ENABLE_COLLECTION is likely at the end if it is set
-      while (*cursor) {
-        cursor++;
-      }
-      cursor--;
-      for (; (cursor != environ - 1) && ((env = *cursor) != nullptr); cursor--) {
-        if ((env[0] == 'P') && (env[1] == 'T') && (env[2] == 'I') && (strncmp(env + 3, "_ENABLE_COLLECTION", len - 3) == 0) && (env[len] == '=')) {
-          value = (env + len + 1);
-          break;
-        }
-      }
-
-      // Map the env-var value to a collection state and propagate it into the
-      // metric-sampling shared memory. PTI_ENABLE_COLLECTION is process-local,
-      // so a value set inside this (child) process is invisible to the parent
-      // process that owns the metric sampling thread; pushing the state here
-      // lets the parent's IsMetricSamplingEnabled() react to in-application
-      // PTI_ENABLE_COLLECTION changes.
-      //   "-1"        -> permanent stop
-      //   "0" / unset -> paused (collection currently disabled)
-      //   otherwise   -> resumed (collection enabled)
-      const bool stopped = (value != nullptr) && (value[0] == '-') && (value[1] == '1');
-      const bool disabled = (value == nullptr) || (*value == '0');
-      PropagateCollectionStateToMetricSampling(
-          stopped ? TEMPORAL_STOPPED : (disabled ? TEMPORAL_PAUSED : TEMPORAL_RESUMED));
-
-      // "-1": env-var form of a permanent stop. Treat like a stopped session --
-      // latch the stopped state and fire the one-shot flush callback so the data
-      // is flushed once and every later check short-circuits at the top.
-      if (stopped) {
-        temporal_control_stopped_ = true;
-        if (session_stopped_callback_) {
-          if (!defer_callback && !session_stopped_notified_.exchange(true)) {
-            session_stopped_callback_();
-          }
-        }
-        return false;
-      }
-
-      if (disabled) {
-        return false;
-      }
-      return true;
-    }
-
-    inline static bool start_paused_ = (utils::GetEnv("UNITRACE_StartPaused") == "1") ? true : false;
-    inline static bool itt_paused_ = false;
-    inline static bool itt_stopped_ = false;
-    // when the session is stopped, the shared memory will be removed so processes started afterwards
-    // gets null value for session_shm_.GetPtr()
-    // but session_shm_.GetPtr() can also be null if the session is unnamed
-    // this flag is true when session_shm_.GetPtr() is null but the named session is stopped
-    // so subsequent processes are not profiled
-    // Atomic: written by app threads and the watcher. Monotonic false->true
-    // latch; the actual flush is gated by session_stopped_notified_.
-    inline static std::atomic<bool> temporal_control_stopped_{false};
-    inline static SessionStoppedCallback session_stopped_callback_ = nullptr;
-    inline static std::atomic<bool> session_stopped_notified_{false};
-
-    // Safety backstop for the watcher's blocking futex wait: bounds teardown
-    // latency and covers a wake racing the wait arming. Stop-to-flush latency
-    // on Linux comes from the cross-process wake, not this timeout.
-    static constexpr int kSessionWatchTimeoutMs_ = 250;
-    // Heap-allocated so a forked child can abandon the inherited handle by
-    // nulling the pointer, never join()/detach() on a stale pthread descriptor.
-    inline static std::thread* session_watcher_thread_ = nullptr;
-    inline static std::atomic<bool> session_watcher_running_{false};
-    inline static std::atomic<bool> session_watcher_stop_{false};
-
-    inline static SharedMemory session_shm_;
-    // shared memory to interact between child and parent process for metric sampling.
-    // In application control can't be done using environment variable for metric sampling.
-    // the sampling thread is owned by the parent process.
-    inline static SharedMemory metric_sample_shm_;
-    // shared memory for metric flush handshake between parent and child.
-    // Used when -k is present to coordinate flushing metric data and computing metrics.
-    inline static SharedMemory metric_flush_shm_;
-};
-
-#endif // PTI_TOOLS_UNITRACE_UNICONTROL_H_
-
-
-
diff --git a/tools/unitrace/src/unievent.h b/tools/unitrace/src/unievent.h
deleted file mode 100644
index c54a7d2d..00000000
--- a/tools/unitrace/src/unievent.h
+++ /dev/null
@@ -1,78 +0,0 @@
-
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNIEVENT_H
-#define PTI_TOOLS_UNITRACE_UNIEVENT_H
-
-#if BUILD_WITH_OMP
-#include <omp-tools.h>
-#endif /* BUILD_WITH_OMP */
-
-enum EVENT_TYPE {
-  EVENT_NULL = 0,
-  EVENT_DURATION_START,
-  EVENT_DURATION_END,
-  EVENT_FLOW_SOURCE,
-  EVENT_FLOW_SINK,
-  EVENT_COMPLETE,
-  EVENT_MARK,
-};
-
-enum API_TYPE {
-  API_TYPE_NONE,
-  API_TYPE_MPI,
-  API_TYPE_ITT,
-  API_TYPE_CCL,
-  API_TYPE_OMP
-};
-
-typedef struct MpiArgs_ {
-  int src_location;
-  int src_tag;
-  int dst_location;
-  int dst_tag;
-  size_t src_size;
-  size_t dst_size;
-  int64_t mpi_counter;
-  bool is_tagged;
-} MpiArgs;
-
-typedef struct IttArgs_ {
-  size_t count = 0;
-  bool isIndirectData = false;
-  int type;
-  const char* key;
-  struct IttArgs_* next = nullptr;
-  void* data[1];
-} IttArgs;
-
-typedef struct OmpArgs_ {
-#if BUILD_WITH_OMP
-  /// Use ompt record data
-  ompt_record_ompt_t ompt;
-#endif /* BUILD_WITH_OMP */
-  /// Space for extra data
-  uint64_t data[2];
-} OmpArgs;
-
-typedef struct HostEventRecord_ {
-  uint64_t id_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-  char *name_ = nullptr;
-  API_TRACING_ID api_id_;
-  EVENT_TYPE type_;
-
-  API_TYPE api_type_ = API_TYPE::API_TYPE_NONE;
-  union {
-    MpiArgs mpi_args_;
-    IttArgs itt_args_;
-    OmpArgs omp_args_;
-  };
-} HostEventRecord;
-
-#endif // PTI_TOOLS_UNITRACE_UNIEVENT_H
diff --git a/tools/unitrace/src/unikernel.h b/tools/unitrace/src/unikernel.h
deleted file mode 100644
index bf86b50f..00000000
--- a/tools/unitrace/src/unikernel.h
+++ /dev/null
@@ -1,94 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNIKERNEL_H
-#define PTI_TOOLS_UNITRACE_UNIKERNEL_H
-
-#include <iostream>
-#if BUILD_WITH_OPENCL
-  #include <CL/cl.h>
-  #include <CL/cl_ext_private.h>
-#endif /* BUILD_WITH_OPENCL */
-#include <level_zero/layers/zel_tracing_api.h>
-
-#define KERNEL_ID_INVALID              0
-#define KERNEL_INSTANCE_ID_INVALID     0
-
-class UniKernelId{
-  public:
-    static uint64_t GetKernelId(void) {
-        return kernel_id_.fetch_add(1, std::memory_order::memory_order_relaxed);
-    }
-
-  private:
-    inline static std::atomic<uint64_t> kernel_id_ = 1;  // start with 1
-};
-
-class UniKernelInstanceId{
-  public:
-    static uint64_t GetKernelInstanceId(void) {
-        return kernel_instance_id_.fetch_add(1, std::memory_order::memory_order_relaxed);
-    }
-
-  private:
-    inline static std::atomic<uint64_t> kernel_instance_id_ = 1;  // start with 1
-};
-
-// Ids for the module binaries dumped for stall sampling. Process-wide rather than
-// per collector: the id names a file in the shared data directory
-// (LoggerFactory::GetModuleBinaryFileName) and is what a kernel record points at, so
-// two collectors counting separately - Level Zero and OpenCL, or the OpenCL CPU and
-// GPU collectors - would have one module's binary overwrite another's.
-class UniModuleId{
-  public:
-    static uint32_t GetModuleId(void) {
-        return module_id_.fetch_add(1, std::memory_order::memory_order_relaxed);
-    }
-
-  private:
-    inline static std::atomic<uint32_t> module_id_ = 1;  // 0 means "no module binary"
-};
-
-enum FLOW_DIR {
-  FLOW_NUL = 0,
-  FLOW_D2H = 1,
-  FLOW_H2D = 2,
-};
-
-struct ZeKernelCommandExecutionRecord {
-  uint64_t kid_;
-  uint64_t tid_;
-  uint64_t kernel_command_id_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-  ze_device_handle_t device_;
-  size_t mem_size_;
-  int32_t tile_;
-  uint32_t engine_ordinal_;
-  uint32_t engine_index_;
-  ze_group_count_t group_count_;
-  bool implicit_scaling_;
-};
-
-struct ClKernelCommandExecutionRecord {
-  uint64_t kid_;
-  uint64_t tid_;
-  int32_t  tile_;
-  uint64_t kernel_command_id_;
-  uint64_t start_time_;
-  uint64_t end_time_;
-#if BUILD_WITH_OPENCL
-  cl_device_id device_;
-  cl_device_pci_bus_info_khr pci_;
-  cl_command_queue queue_;
-#endif /* BUILD_WITH_OPENCL */
-  // size_t mem_size_;
-  // uint32_t engine_ordinal_;
-  // uint32_t engine_index_;
-  // ze_group_count_t group_count_;
-  bool implicit_scaling_;
-};
-#endif // PTI_TOOLS_UNITRACE_UNIKERNEL_H
diff --git a/tools/unitrace/src/unimemory.h b/tools/unitrace/src/unimemory.h
deleted file mode 100644
index f69b9344..00000000
--- a/tools/unitrace/src/unimemory.h
+++ /dev/null
@@ -1,32 +0,0 @@
-
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNIMEMORY_H
-#define PTI_TOOLS_UNITRACE_UNIMEMORY_H
-
-#include <iostream>
-#include <cstdlib>
-
-namespace UniMemory {
-  void
-  AbortIfOutOfMemory(void *ptr) {
-    if (ptr == nullptr) {
-      std::cerr << "Out of memory" << std::endl;
-      std::abort();
-    }
-  }
-
-  void
-  ExitIfOutOfMemory(void *ptr) {
-    if (ptr == nullptr) {
-      std::cerr << "Out of memory" << std::endl;
-      std::_Exit(-1);
-    }
-  }
-}
-
-#endif // PTI_TOOLS_UNITRACE_UNIMEMORY_H
diff --git a/tools/unitrace/src/unitimer.h b/tools/unitrace/src/unitimer.h
deleted file mode 100644
index 0ff06046..00000000
--- a/tools/unitrace/src/unitimer.h
+++ /dev/null
@@ -1,157 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UNITIMER_H
-#define PTI_TOOLS_UNITRACE_UNITIMER_H
-
-#include "utils/utils.h"
-#include <chrono>
-#include <iostream>
-
-class UniTimer {
-public:
-    static void StartUniTimer(void) {
-#if defined(_WIN32)
-        if (frequency_.QuadPart == 0) {
-          if (!QueryPerformanceFrequency(&frequency_)) {
-            std::cerr << "[ERROR] Failed to query performance counter frequency" << std::endl;
-            exit(-1);
-          }
-        }
-#endif /* _WIN32 */
-        uint64_t smallest_delta = uint64_t(-1);
-        if ((utils::GetEnv("UNITRACE_SystemTime") != "1") && (epoch_start_time_ == 0)) {
-            // loop multiple times to mitigate context switch impact
-            for (int i = 0; i < 200; i++) {
-                const std::chrono::time_point<std::chrono::system_clock> t0 = std::chrono::system_clock::now();
-                uint64_t t1 = GetHostBootTimestamp();
-                uint64_t t2 = GetHostBootTimestamp();
-                const std::chrono::time_point<std::chrono::system_clock> t3 = std::chrono::system_clock::now();
-                uint64_t delta = std::chrono::duration_cast<std::chrono::nanoseconds>(t3.time_since_epoch()).count() - std::chrono::duration_cast<std::chrono::nanoseconds>(t0.time_since_epoch()).count();
-                if (delta < smallest_delta) {
-                    // approximate epoch time of system boot
-                    // t2 - t1 is the time to get boot time
-                    // t0 + (t2 - t1) - t1 is the epoch time of system boot
-                    epoch_start_time_ = std::chrono::duration_cast<std::chrono::nanoseconds>(t0.time_since_epoch()).count() + (t2 - t1) - t1;
-                    smallest_delta = delta;
-                }
-            }
-        }
-        smallest_delta = uint64_t(-1);
-        for (int i = 0; i < 200; i++) {
-            uint64_t t0 = GetHostTimestamp();
-            uint64_t t1 = GetHostBootTimestamp();
-            uint64_t t2 = GetHostBootTimestamp();
-            uint64_t t3 = GetHostTimestamp();
-            uint64_t delta = t3 - t0;
-            if (delta < smallest_delta) {
-                boot_monotonic_raw_time_diff_  = t0 + (t2 - t1) - t1;
-                smallest_delta = delta;
-            }
-        }
-        smallest_delta = uint64_t(-1);
-        for (int i = 0; i < 200; i++) {
-            uint64_t t0 = GetHostTimestamp();
-            uint64_t t1 = GetHostTaiTimestamp();
-            uint64_t t2 = GetHostTaiTimestamp();
-            uint64_t t3 = GetHostTimestamp();
-            uint64_t delta = t3 - t0;
-            if (delta < smallest_delta) {
-                tai_monotonic_raw_time_diff_  = t0 + (t2 - t1) - t1;
-                smallest_delta = delta;
-            }
-        }
-    }
-
-    static uint64_t GetEpochTime(uint64_t systime) {
-        return epoch_start_time_ + systime;
-    }
-
-    static double GetEpochTimeInUs(uint64_t systime) {
-        // (double(1.0) * (epoch_start_time_ + systime) / 1000.0);
-        uint64_t us = (epoch_start_time_ + systime) / 1000;
-        uint64_t ns = (epoch_start_time_ + systime) % 1000;
-        return double(us) + (double(ns) * 0.001);
-    }
-
-    static double GetTimeInUs(uint64_t systime) {
-        // (double(1.0) * systime / 1000.0);
-        uint64_t us = systime / 1000;
-        uint64_t ns = systime % 1000;
-        return double(us) + (double(ns) * 0.001);
-    }
-
-    static uint64_t GetHostTimestampFromBootTimestamp(uint64_t ts) {
-        return ts + boot_monotonic_raw_time_diff_;
-    }
-
-    static uint64_t GetHostTimestampFromTaiTimestamp(uint64_t ts) {
-        return ts + tai_monotonic_raw_time_diff_;
-    }
-
-    static uint64_t GetHostTaiTimestamp() {
-#if defined(_WIN32)
-        LARGE_INTEGER ticks;
-        if (!QueryPerformanceCounter(&ticks)) {
-          std::cerr << "[ERROR] Failed to query performance counter" << std::endl;
-          exit(-1);
-        }
-        return ticks.QuadPart * (NSEC_IN_SEC / frequency_.QuadPart);
-#else /* _WIN32 */
-        timespec ts;
-        if (clock_gettime(CLOCK_TAI, &ts)) {
-          std::cerr << "[ERROR] Failed to get timestamp" << std::endl;
-          exit(-1);
-        }
-        return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-#endif /* _WIN32 */
-    }
-
-    static uint64_t GetHostBootTimestamp() {
-#if defined(_WIN32)
-        LARGE_INTEGER ticks;
-        if (!QueryPerformanceCounter(&ticks)) {
-          std::cerr << "[ERROR] Failed to query performance counter" << std::endl;
-          exit(-1);
-        }
-        return ticks.QuadPart * (NSEC_IN_SEC / frequency_.QuadPart);
-#else /* _WIN32 */
-        timespec ts;
-        if (clock_gettime(CLOCK_BOOTTIME, &ts)) {
-          std::cerr << "[ERROR] Failed to get timestamp" << std::endl;
-          exit(-1);
-        }
-        return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-#endif /* _WIN32 */
-    }
-
-    static uint64_t GetHostTimestamp() {
-#if defined(_WIN32)
-        LARGE_INTEGER ticks;
-        if (!QueryPerformanceCounter(&ticks)) {
-          std::cerr << "[ERROR] Failed to query performance counter" << std::endl;
-          exit(-1);
-        }
-        return ticks.QuadPart * (NSEC_IN_SEC / frequency_.QuadPart);
-#else /* _WIN32 */
-        timespec ts;
-        if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts)) {
-          std::cerr << "[ERROR] Failed to get timestamp" << std::endl;
-          exit(-1);
-        }
-        return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-#endif /* _WIN32 */
-    }
-private:
-    inline static uint64_t epoch_start_time_ = 0;
-    inline static int64_t boot_monotonic_raw_time_diff_ = 0;
-    inline static int64_t tai_monotonic_raw_time_diff_ = 0;
-#if defined(_WIN32)
-    inline static LARGE_INTEGER frequency_{{0}};
-#endif /* _WIN32 */
-};
-
-#endif // PTI_TOOLS_UNITRACE_UNITIMER_H
diff --git a/tools/unitrace/src/unitrace.cc b/tools/unitrace/src/unitrace.cc
deleted file mode 100644
index 939f8a27..00000000
--- a/tools/unitrace/src/unitrace.cc
+++ /dev/null
@@ -1,1768 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <array>
-#include <set>
-#include <iostream>
-#include <cstdio>
-#include <cstdlib>
-
-#if !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__))
-
-#if CXX_STD_FILESYSTEM_EXPERIMENTAL
-#include <experimental/filesystem>
-#define CXX_STD_FILESYSTEM_NAMESPACE std::experimental::filesystem
-#else /* CXX_STD_FILESYSTEM_EXPERIMENTAL */
-#include <filesystem>
-#define CXX_STD_FILESYSTEM_NAMESPACE std::filesystem
-#endif /* CXX_STD_FILESYSTEM_EXPERIMENTAL */
-
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <dlfcn.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <signal.h>
-
-#else /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-
-#include <filesystem>
-#define CXX_STD_FILESYSTEM_NAMESPACE std::filesystem
-
-#endif /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-
-#include <atomic>
-#include <csignal>
-#include <stdlib.h>
-#include "ze_metrics.h"
-#include "utils/utils.h"
-#include "cli_options.h"
-#include "metric_config_validator.h"
-#include "version.h"
-#include "unitrace_commit_hash.h"
-#include "unicontrol.h"
-#include "logger_factory.h"
-#include "unitimer.h"
-#include "utils_host.h"
-
-#if !defined(UNITRACE_INSTALL_LIBDIR)
-#define UNITRACE_INSTALL_LIBDIR "lib"
-#endif /* UNITRACE_INSTALL_LIBDIR */
-
-// Atomic so DisableProfiling() can run from both the normal exit path and
-// CleanUp() (a signal may arrive while the normal path is deleting it) and the
-// profiler is deleted exactly once.
-static std::atomic<ZeMetricProfiler*> metric_profiler{nullptr};
-static bool idle_sampling = false;
-
-// ============================================================================
-// CLI option table: the single source of truth for argument parsing, the
-// --help text (Usage), and --print-options-schema. Add or rename a flag by editing
-// one row of kCliOptions[] below; ParseArgs, Usage and the JSON schema all derive
-// from it. The generic engine lives in cli_options.h for reuse by other tools;
-// ArgParseState (this file's Ctx) and FinalizeParse are unitrace-specific.
-// ============================================================================
-
-// Shared state written by handlers, consumed after the parse loop by FinalizeParse.
-struct ArgParseState {
-  char* progname_ = nullptr;
-  int   app_index_ = 1;
-  bool  show_metric_list_ = false;
-  const char* gen_metric_config_ = nullptr;
-  bool  stall_sampling_ = false;
-  bool  metric_sampling_ = false;
-  bool  devices_to_sample_present_ = false;
-  std::set<int> ranks_to_sample_;
-  std::set<int> devices_to_sample_;
-};
-
-// ParseArgs result for an error that was already reported in detail: exit with
-// status 1 without the generic "Invalid command line" message and usage text.
-static constexpr int kParseErrorReported = -2;
-
-using CliOption = cli::CliOption<ArgParseState>;
-using Status    = cli::Status;
-
-// Row factories for the kCliOptions[] table below: Opt::Bool, Opt::Value, Opt::BoolH, ...
-using Opt = cli::Factory<ArgParseState>;
-
-void Usage(char* progname);
-void PrintOptionsSchema(std::ostream& os);
-static int FinalizeParse(ArgParseState& st);
-
-bool IsAlphanumericString(const std::string& str) {
-  return std::all_of(str.begin(), str.end(), [](unsigned char c) {return std::isalnum(c);});
-}
-
-bool IsNumericString(const std::string& str) {
-  return std::all_of(str.begin(), str.end(), [](unsigned char c) {return std::isdigit(c);});
-}
-
-static bool IsZeroOrOne(const std::string& str) {
-  return str == "0" || str == "1";
-}
-
-#if BUILD_WITH_PERFETTO
-static bool IsTraceFormat(const std::string& str) {
-  return str == "json" || str == "protobuf";
-}
-#endif /* BUILD_WITH_PERFETTO */
-
-void SetTracingEnvironment() {
-  utils::SetEnv("ZE_ENABLE_TRACING_LAYER", "1");
-}
-
-void SetProfilingEnvironment() {
-  utils::SetEnv("ZET_ENABLE_METRICS", "1");
-}
-
-void SetSysmanEnvironment() {
-  utils::SetEnv("ZES_ENABLE_SYSMAN", "1");
-}
-
-// ============================================================================
-// Handlers for flags that are not a plain 1:1 "set one env var" mapping.
-// ============================================================================
-
-static Status OnOutput(ArgParseState&, const CliOption&, const char* value) {
-  utils::SetEnv("UNITRACE_LogToFile", "1");
-  utils::SetEnv("UNITRACE_LogFilename", value);
-  return Status::Ok;
-}
-
-static Status OnOutputDirPath(ArgParseState&, const CliOption&, const char* value) {
-  utils::SetEnv("UNITRACE_TraceOutputDirPath", "1");
-  utils::SetEnv("UNITRACE_TraceOutputDir", value);
-  return Status::Ok;
-}
-
-static Status OnResultDir(ArgParseState&, const CliOption&, const char* value) {
-  utils::SetEnv("UNITRACE_UseResultDirectory", "1");
-  utils::SetEnv("UNITRACE_ResultDirectory", value);
-  return Status::Ok;
-}
-
-#if BUILD_WITH_ITT
-static Status OnCclSummaryReport(ArgParseState&, const CliOption&, const char*) {
-  utils::SetEnv("UNITRACE_CclSummaryReport", "1");
-  utils::SetEnv("UNITRACE_ChromeIttLogging", "1");
-  utils::SetEnv("CCL_ITT_LEVEL", "1");
-  return Status::Ok;
-}
-
-static Status OnChromeCclLogging(ArgParseState&, const CliOption&, const char*) {
-  utils::SetEnv("UNITRACE_ChromeCclLogging", "1");
-  utils::SetEnv("UNITRACE_ChromeIttLogging", "1");
-  utils::SetEnv("CCL_ITT_LEVEL", "1");
-  return Status::Ok;
-}
-
-static Status OnChromeDnnLogging(ArgParseState&, const CliOption&, const char*) {
-  utils::SetEnv("UNITRACE_ChromeIttLogging", "1");
-  // what should be set here?
-  return Status::Ok;
-}
-#endif /* BUILD_WITH_ITT */
-
-#if BUILD_WITH_MPI
-static Status OnChromeMpiLogging(ArgParseState&, const CliOption&, const char*) {
-  utils::SetEnv("UNITRACE_ChromeMpiLogging", "1");
-  utils::SetEnv("UNITRACE_ChromeIttLogging", "1");
-  return Status::Ok;
-}
-#endif /* BUILD_WITH_MPI */
-
-#if BUILD_WITH_XPTI
-// (C) SYCL runtime and Unified Runtime tracing are decoupled:
-//   --chrome-syclrt-logging  traces the SYCL runtime
-//   --chrome-ur-logging      traces the Unified Runtime (layer beneath SYCL rt)
-//   --chrome-sycl-logging    kept for backward compatibility; both of the above
-static Status OnXptiLogging(ArgParseState&, const CliOption& o, const char*) {
-  const bool sycl = (strcmp(o.name_, "--chrome-sycl-logging") == 0);
-  if (sycl || strcmp(o.name_, "--chrome-syclrt-logging") == 0) {
-    utils::SetEnv("UNITRACE_ChromeSyclRuntimeLogging", "1");
-  }
-  if (sycl || strcmp(o.name_, "--chrome-ur-logging") == 0) {
-    utils::SetEnv("UNITRACE_ChromeUrLogging", "1");
-    utils::SetEnv("UR_ENABLE_LAYERS", "UR_LAYER_TRACING");
-  }
-  utils::SetEnv("XPTI_TRACE_ENABLE", "1");
-#ifdef _WIN32
-  utils::SetEnv("XPTI_SUBSCRIBERS", "unitrace_tool.dll");
-  utils::SetEnv("XPTI_FRAMEWORK_DISPATCHER", "xptifw.dll");
-#else /* _WIN32 */
-  utils::SetEnv("XPTI_SUBSCRIBERS", "libunitrace_tool.so");
-  utils::SetEnv("XPTI_FRAMEWORK_DISPATCHER", "libxptifw.so");
-#endif /* _WIN32 */
-  return Status::Ok;
-}
-#endif /* BUILD_WITH_XPTI */
-
-#if BUILD_WITH_L0
-// These flags only record intent; the actual logic runs in FinalizeParse
-// once every flag has been seen (mutual exclusion, defaulting, MPI-rank gating).
-static Status OnStallSampling(ArgParseState& st, const CliOption&, const char*) {
-  st.stall_sampling_ = true;
-  return Status::Ok;
-}
-
-static Status OnMetricSampling(ArgParseState& st, const CliOption&, const char*) {
-  utils::SetEnv("UNITRACE_KernelMetrics", "1");
-  st.metric_sampling_ = true;
-  return Status::Ok;
-}
-
-static Status OnMetricList(ArgParseState& st, const CliOption&, const char*) {
-  st.show_metric_list_ = true;  // PrintMetricList runs in FinalizeParse
-  return Status::Ok;
-}
-
-static Status OnGenMetricConfig(ArgParseState& st, const CliOption&, const char* value) {
-  st.gen_metric_config_ = value;  // GenMetricConfig runs in FinalizeParse
-  return Status::Ok;
-}
-
-static Status OnIdleSampling(ArgParseState&, const CliOption&, const char*) {
-  idle_sampling = true;  // file-scope global, consumed by main()
-  return Status::Ok;
-}
-
-// Repeated --ranks-to-sample flags accumulate into UNITRACE_RanksToSample.
-static Status OnRanksToSample(ArgParseState& st, const CliOption&, const char* value) {
-  std::string ranks = utils::GetEnv("UNITRACE_RanksToSample");
-  if (ranks.empty()) {
-    utils::SetEnv("UNITRACE_RanksToSample", value);
-  } else {
-    ranks += ",";
-    ranks += value;
-    utils::SetEnv("UNITRACE_RanksToSample", ranks.c_str());
-  }
-  st.ranks_to_sample_.clear();
-  if (GetZeRanksToSample(st.ranks_to_sample_) != 0) {
-    std::cerr << "[ERROR] Invalid MPI ranks to sample" << std::endl;
-    return Status::Error;
-  }
-  return Status::Ok;
-}
-
-// Repeated --devices-to-sample flags accumulate into UNITRACE_DevicesToSampleArg.
-static Status OnDevicesToSample(ArgParseState& st, const CliOption&, const char* value) {
-  st.devices_to_sample_present_ = true;
-  std::string devices = utils::GetEnv("UNITRACE_DevicesToSampleArg");
-  if (devices.empty()) {
-    utils::SetEnv("UNITRACE_DevicesToSampleArg", value);
-  } else {
-    devices += ",";
-    devices += value;
-    utils::SetEnv("UNITRACE_DevicesToSampleArg", devices.c_str());
-  }
-  st.devices_to_sample_.clear();
-  if (GetZeDevicesToSample(st.devices_to_sample_) != 0) {
-    std::cout << "[ERROR] Invalid devices to sample" << std::endl;
-    return Status::Error;
-  }
-  return Status::Ok;
-}
-
-// Print-and-exit.
-static Status OnDeviceList(ArgParseState&, const CliOption&, const char*) {
-  SetSysmanEnvironment();  // enable ZES_ENABLE_SYSMAN
-  PrintDeviceList();
-  return Status::ExitOk;
-}
-#endif /* BUILD_WITH_L0 */
-
-static Status OnHelp(ArgParseState& st, const CliOption&, const char*) {
-  Usage(st.progname_);
-  return Status::ExitOk;
-}
-
-static Status OnVersion(ArgParseState&, const CliOption&, const char*) {
-  std::cout << UNITRACE_VERSION << " (" << COMMIT_HASH << ")" << std::endl;
-  return Status::ExitOk;
-}
-
-static Status OnPrintOptionsSchema(ArgParseState&, const CliOption&, const char*) {
-  PrintOptionsSchema(std::cout);  // runs before any Level Zero init => HW-independent
-  return Status::ExitOk;
-}
-
-// ============================================================================
-// The option table.
-// ============================================================================
-inline constexpr CliOption kCliOptions[] = {
-#if BUILD_WITH_L0 || BUILD_WITH_OPENCL
-  Opt::Bool("--call-logging", "-c", "core", "Trace host API calls", "UNITRACE_CallLogging"),
-  Opt::Bool("--host-timing", "-h", "core", "Report host API execution time", "UNITRACE_HostTiming"),
-  Opt::Bool("--device-timing", "-d", "core", "Report kernels execution time", "UNITRACE_DeviceTiming"),
-#endif /* BUILD_WITH_L0 || BUILD_WITH_OPENCL */
-#if BUILD_WITH_ITT
-  Opt::BoolH("--ccl-summary-report", "-r", "core", "Report CCL execution time summary", OnCclSummaryReport),
-#endif /* BUILD_WITH_ITT */
-#if BUILD_WITH_L0 || BUILD_WITH_OPENCL
-  Opt::Bool("--kernel-submission", "-s", "core",
-       "Report append (queued), submit and execute intervals for kernels", "UNITRACE_KernelSubmission"),
-  Opt::Bool("--device-timeline", "-t", "core", "Report device timeline", "UNITRACE_DeviceTimeline"),
-#endif /* BUILD_WITH_L0 || BUILD_WITH_OPENCL */
-#if BUILD_WITH_OPENCL
-  Opt::Bool("--opencl", nullptr, "core", "Trace OpenCL", "UNITRACE_OpenCLTracing"),
-#endif /* BUILD_WITH_OPENCL */
-#if BUILD_WITH_OMP
-  Opt::Bool("--chrome-omp-logging", nullptr, "chrome", "Trace OpenMP", "UNITRACE_ChromeOmpLogging"),
-#endif /* BUILD_WITH_OMP */
-#if BUILD_WITH_MPI
-  Opt::BoolH("--chrome-mpi-logging", nullptr, "chrome", "Trace MPI", OnChromeMpiLogging),
-#endif /* BUILD_WITH_MPI */
-#if BUILD_WITH_XPTI
-  Opt::BoolH("--chrome-syclrt-logging", nullptr, "chrome", "Trace SYCL runtime", OnXptiLogging),
-  Opt::BoolH("--chrome-ur-logging", nullptr, "chrome",
-        "Trace Unified Runtime (implementation layer beneath the SYCL runtime)", OnXptiLogging),
-  Opt::BoolH("--chrome-sycl-logging", nullptr, "chrome",
-        "Trace SYCL runtime and Unified Runtime (same as --chrome-syclrt-logging --chrome-ur-logging)",
-        OnXptiLogging),
-#endif /* BUILD_WITH_XPTI */
-#if BUILD_WITH_ITT
-  Opt::BoolH("--chrome-ccl-logging", nullptr, "chrome", "Trace oneCCL", OnChromeCclLogging),
-  Opt::BoolH("--chrome-dnn-logging", nullptr, "chrome", "Trace oneDNN", OnChromeDnnLogging),
-#endif /* BUILD_WITH_ITT */
-#if BUILD_WITH_L0 || BUILD_WITH_OPENCL
-  Opt::Bool("--chrome-call-logging", nullptr, "chrome",
-       "Trace Level Zero and/or OpenCL host calls", "UNITRACE_ChromeCallLogging"),
-  Opt::Bool("--chrome-kernel-logging", nullptr, "chrome",
-       "Trace device and host kernel activities", "UNITRACE_ChromeKernelLogging"),
-  Opt::Bool("--chrome-device-logging", nullptr, "chrome", "Trace device activities", "UNITRACE_ChromeDeviceLogging"),
-#endif /* BUILD_WITH_L0 || BUILD_WITH_OPENCL */
-#if BUILD_WITH_ITT
-  Opt::Bool("--chrome-itt-logging", nullptr, "chrome",
-       "Trace activities in applications instrumented using Intel(R) Instrumentation and Tracing Technology APIs",
-       "UNITRACE_ChromeIttLogging"),
-#endif /* BUILD_WITH_ITT */
-#if BUILD_WITH_L0 || BUILD_WITH_OPENCL
-  Opt::Bool("--chrome-no-thread-on-device", nullptr, "chrome",
-       "Trace device activities without per-thread info", "UNITRACE_ChromeNoThreadOnDevice"),
-#endif /* BUILD_WITH_L0 || BUILD_WITH_OPENCL */
-#if BUILD_WITH_L0
-  Opt::Bool("--chrome-no-engine-on-device", nullptr, "chrome",
-       "Trace device activities without per-Level-Zero-engine-or-OpenCL-queue info",
-       "UNITRACE_ChromeNoEngineOnDevice"),
-#endif /* BUILD_WITH_L0 */
-  Opt::Value("--chrome-event-buffer-size", nullptr, "int", "chrome", "number-of-events",
-        "Size of event buffer on host per host thread (default is -1 or unlimited)",
-        "UNITRACE_ChromeEventBufferSize", nullptr, "-1"),
-#ifndef _WIN32
-  Opt::Value("--chrome-kmd-logging", nullptr, "path", "chrome", "script",
-        "Trace OS/KMD activities. The argument <script> file defines the OS kernel or device driver activities to trace",
-        "UNITRACE_ChromeKmdLogging").PathFile(),
-#endif /* _WIN32 */
-
-#if BUILD_WITH_L0
-  Opt::Bool("--metric-query", "-q", "metrics",
-       "Query hardware metrics for each kernel instance (Level Zero)", "UNITRACE_MetricQuery")
-      .Conflicts("--metric-sampling,--stall-sampling"),
-  Opt::BoolH("--metric-sampling", "-k", "metrics",
-        "Sample hardware performance metrics for each kernel instance in time-based mode", OnMetricSampling)
-      .Conflicts("--metric-query,--stall-sampling"),
-  Opt::BoolH("--stall-sampling", nullptr, "metrics",
-        "Sample hardware execution unit stalls. Valid for Intel(R) Data Center GPU Max Series and later GPUs",
-        OnStallSampling)
-      .Conflicts("--metric-query,--metric-sampling"),
-  Opt::Value("--group", "-g", "enum", "metrics", "metric-group",
-        "Hardware metric group (ComputeBasic by default)", "UNITRACE_MetricGroup", nullptr, "ComputeBasic")
-      .ChoicesFrom("metric-groups").Requires("--metric-query,--metric-sampling,--stall-sampling"),
-  Opt::Value("--metric-config", nullptr, "path", "metrics", "filename",
-        "Configuration file with metrics to collect", "UNITRACE_MetricConfig")
-      .PathFile().Requires("--metric-query,--metric-sampling"),
-  Opt::Value("--sampling-interval", "-i", "float", "metrics", "interval",
-        "Hardware performance metric sampling interval in us, fractional values allowed (default is " DEFAULT_SAMPLING_INTERVAL_US_STR " us) in time-based mode",
-        "UNITRACE_SamplingInterval", nullptr, DEFAULT_SAMPLING_INTERVAL_US_STR)
-      .Requires("--metric-query,--metric-sampling,--stall-sampling"),
-  Opt::ValueH("--ranks-to-sample", nullptr, "string", "metrics", "ranks",
-         "MPI ranks to sample. The argument <ranks> is a list of comma separated MPI ranks", OnRanksToSample),
-  Opt::ValueH("--devices-to-sample", nullptr, "string", "metrics", "devices",
-         "Devices ID to sample. The argument <devices> is a list of comma separated devices as reported by --device-list",
-         OnDevicesToSample),
-  Opt::BoolH("--idle-sampling", nullptr, "metrics", "Continue metric sampling while the device is idle", OnIdleSampling),
-  Opt::Action("--device-list", "metrics", "Print available devices", OnDeviceList),
-  Opt::Action("--metric-list", "metrics", "Print available metric groups and metrics", OnMetricList),
-  Opt::ValueH("--gen-metric-config", nullptr, "path", "metrics", "filename",
-         "Generate a metric configuration file template with all supported predefined and programmable metrics",
-         OnGenMetricConfig).PathFile(),
-  Opt::Value("--include-kernels", nullptr, "string", "filter", "kernel-names",
-        "Trace kernels, the names of which contain substrings in the comma-separated <kernel-names> (Level Zero only)",
-        "UNITRACE_IncludeKernels"),
-  Opt::Value("--exclude-kernels", nullptr, "string", "filter", "kernel-names",
-        "Trace kernels, the names of which do not contain any substrings in the comma-separated <kernel-names> (Level Zero only)",
-        "UNITRACE_ExcludeKernels"),
-  Opt::Value("--include-kernels-file", nullptr, "path", "filter", "file",
-        "Same as --include-kernels, except that the kernel name substrings are in <file>",
-        "UNITRACE_IncludeKernelsFile").PathFile(),
-  Opt::Value("--exclude-kernels-file", nullptr, "path", "filter", "file",
-        "Same as --exclude-kernels, except that the kernel name substrings are in <file>",
-        "UNITRACE_ExcludeKernelsFile").PathFile(),
-#endif /* BUILD_WITH_L0 */
-
-  Opt::ValueH("--result-dir", nullptr, "path", "output", "path",
-         "Output result to a hierarchical directory", OnResultDir)
-      .PathDir().Conflicts("--output,--output-dir-path"),
-  Opt::ValueH("--output", "-o", "path", "output", "filename",
-         "Output profiling result to file", OnOutput)
-      .PathFile().Conflicts("--result-dir,--output-dir-path"),
-  Opt::ValueH("--output-dir-path", nullptr, "path", "output", "path",
-         "Output result to a flat directory", OnOutputDirPath)
-      .PathDir().Conflicts("--result-dir,--output"),
-#if BUILD_WITH_PERFETTO
-  Opt::Value("--output-format", nullptr, "enum", "output", "format",
-        "Timeline trace format: \"json\" (Chrome trace, default) or \"protobuf\" (Perfetto)",
-        "UNITRACE_OutputFormat", IsTraceFormat, "json", "json,protobuf"),
-#endif /* BUILD_WITH_PERFETTO */
-
-  Opt::Bool("--start-paused", nullptr, "session",
-       "Start the tool with tracing and profiling paused", "UNITRACE_StartPaused"),
-  Opt::Value("--follow-child-process", nullptr, "enum", "session", "0/1",
-        "0: Do not follow or profile child processes on Linux; 1: Follow and profile child processes on Linux (default)",
-        "UNITRACE_FollowChildProcess", IsZeroOrOne, "1", "0,1"),
-  Opt::Value("--session", nullptr, "string", "session", "session",
-        "Name this session for dynamic control. The argument <session> is an alphanumeric string",
-        "UNITRACE_Session", IsAlphanumericString),
-  Opt::Value("--teardown-on-signal", nullptr, "int", "session", "signum",
-        "Try to gracefully shut down in case the application crashes or is terminated or <signum> is raised",
-        "UNITRACE_TeardownOnSignal", IsNumericString),
-  // pause/resume/stop stay in --help and dispatch, but are SchemaOmit()ted:
-  // the launcher UI drives session control with dedicated buttons, not the form.
-  Opt::Value("--pause", nullptr, "string", "session", "session",
-        "Pause session <session>. The argument <session> must be the same session named with --session option",
-        "UNITRACE_PauseSession", IsAlphanumericString).SchemaOmit(),
-  Opt::Value("--resume", nullptr, "string", "session", "session",
-        "Resume session <session>. The argument <session> must be the same session named with --session option",
-        "UNITRACE_ResumeSession", IsAlphanumericString).SchemaOmit(),
-  Opt::Value("--stop", nullptr, "string", "session", "session",
-        "Stop session <session>. The argument <session> must be the same session named with --session option",
-        "UNITRACE_StopSession", IsAlphanumericString).SchemaOmit(),
-
-  Opt::Bool("--verbose", "-v", "misc", "Enable verbose mode to show kernel shapes", "UNITRACE_Verbose"),
-  Opt::Bool("--demangle", nullptr, "misc",
-       "Demangle kernel names. For OpenCL backend only. Kernel names are always demangled for Level Zero backend",
-       "UNITRACE_Demangle"),
-#if BUILD_WITH_L0 || BUILD_WITH_OPENCL
-  Opt::Bool("--separate-tiles", nullptr, "misc",
-       "Trace each tile separately in case of implicit scaling", "UNITRACE_KernelOnSeparateTiles"),
-#endif /* BUILD_WITH_L0 || BUILD_WITH_OPENCL */
-  Opt::Bool("--tid", nullptr, "misc", "Output TID in host API trace", "UNITRACE_Tid"),
-  Opt::Bool("--pid", nullptr, "misc", "Output PID in host API and device activity trace", "UNITRACE_Pid"),
-
-  Opt::Action("--version", "misc", "Print version", OnVersion),
-  Opt::Action("--help", "misc",
-         "Show this help message and exit. Please refer to the README.md file for further details", OnHelp),
-
-  // ---- hidden: internal/deprecated flags (excluded from --help, still in JSON) ----
-  Opt::Bool("--conditional-collection", nullptr, "session",
-       "Enable conditional collection. This option is deprecated. Use --start-paused instead",
-       "UNITRACE_StartPaused", /*hidden=*/true),
-  Opt::Value("--reset-event-on-device", nullptr, "enum", "session", "0/1",
-        "Internal: reset events on device", "UNITRACE_ResetEventOnDevice", IsZeroOrOne,
-        /*def=*/nullptr, /*choices=*/"0,1", /*hidden=*/true),
-  Opt::Bool("--system-time", nullptr, "misc", "Internal: use system time", "UNITRACE_SystemTime", /*hidden=*/true),
-  Opt::Action("--print-options-schema", "misc", "Print the option schema as JSON and exit", OnPrintOptionsSchema, /*hidden=*/true),
-};
-
-// Group id -> human label, for the launcher form's section headers.
-using CliGroup = cli::CliGroup;
-inline constexpr CliGroup kCliGroups[] = {
-  {"core",    "Core Collection"},
-  {"chrome",  "Chrome Timeline"},
-  {"metrics", "Hardware Metrics"},
-  {"filter",  "Kernel Filtering"},
-  {"output",  "Output"},
-  {"session", "Session & Control"},
-  {"misc",    "Formatting & Misc"},
-};
-
-// Emit the build's flag schema for the launcher UI. Covers the mechanical
-// attributes, the group labels, and the schema-only relations set via
-// CliOption's chained modifiers (pathKind, conflictsWith, requires,
-// choicesFrom). Flags marked SchemaOmit() (pause/resume/stop) are excluded --
-// the extension drives those with dedicated UI, not the generic form.
-void PrintOptionsSchema(std::ostream& os) {
-  std::string header("  \"schemaVersion\": 1,\n");
-  header += "  \"unitraceVersion\": \"";
-  header += UNITRACE_VERSION;
-  header += " (";
-  header += COMMIT_HASH;
-  header += ")\",\n";
-  header += "  \"build\": { \"L0\": " + std::to_string(BUILD_WITH_L0);
-  header += ", \"OPENCL\": " + std::to_string(BUILD_WITH_OPENCL);
-  header += ", \"ITT\": " + std::to_string(BUILD_WITH_ITT);
-  header += ", \"XPTI\": " + std::to_string(BUILD_WITH_XPTI);
-  header += ", \"MPI\": " + std::to_string(BUILD_WITH_MPI);
-  header += ", \"OMP\": " + std::to_string(BUILD_WITH_OMP);
-  header += ", \"PERFETTO\": " + std::to_string(BUILD_WITH_PERFETTO);
-  header += " },\n";
-  cli::PrintOptionsSchema<ArgParseState>(os, kCliGroups, std::size(kCliGroups),
-                                     kCliOptions, std::size(kCliOptions), header);
-}
-
-static void PrintBuildBanner() {
-  std::cout << "(Built with ";
-  std::cout << "BUILD_WITH_L0=" << BUILD_WITH_L0 << ", ";
-  std::cout << "BUILD_WITH_OPENCL=" << BUILD_WITH_OPENCL << ", ";
-  std::cout << "BUILD_WITH_ITT=" << BUILD_WITH_ITT << ", ";
-  std::cout << "BUILD_WITH_XPTI=" << BUILD_WITH_XPTI << ", ";
-  std::cout << "BUILD_WITH_MPI=" << BUILD_WITH_MPI << ", ";
-  std::cout << "BUILD_WITH_OMP=" << BUILD_WITH_OMP << ", ";
-  std::cout << "BUILD_WITH_PERFETTO=" << BUILD_WITH_PERFETTO;
-  std::cout << ")" << std::endl;
-}
-
-void Usage(char* progname) {
-  PrintBuildBanner();
-  cli::Usage<ArgParseState>(std::cout, progname, kCliOptions, std::size(kCliOptions));
-}
-
-int ParseArgs(int argc, char* argv[]) {
-  ArgParseState st;
-  st.progname_ = argv[0];
-
-  int app_index = cli::ParseArgs<ArgParseState>(argc, argv, kCliOptions, std::size(kCliOptions), st);
-  if (app_index <= 0) {
-    return app_index;
-  }
-  st.app_index_ = app_index;
-
-  return FinalizeParse(st);
-}
-
-// True when a metric run should behave as if -d were given, either to turn on
-// the kernel tracing that metric attribution needs, or to get the device-timing
-// report a stall capture into a result directory wants.
-static bool NeedsImplicitDeviceTiming() {
-  if (!utils::GetEnv("UNITRACE_DeviceTiming").empty()) {
-    return false;  // the user asked for it already
-  }
-  if (utils::GetEnv("UNITRACE_ChromeKernelLogging").empty() &&
-      utils::GetEnv("UNITRACE_ChromeDeviceLogging").empty()) {
-    return true;  // nothing else derives kernel_tracing, so no .kprops map
-  }
-  // Kernel tracing is covered, but chrome logging writes no timing report.
-  return utils::GetEnv("UNITRACE_UseResultDirectory") == "1" &&
-         utils::GetEnv("UNITRACE_MetricGroup") == "EuStallSampling";
-}
-
-static int FinalizeParse(ArgParseState& st) {
-#ifndef _WIN32
-  if (!utils::GetEnv("UNITRACE_ChromeKmdLogging").empty()) {
-    if (geteuid() != 0) {
-      std::cout << "[ERROR] OS kernel tracing requires root privilege" << std::endl;
-      return -1;
-    }
-  }
-#endif /* _WIN32 */
-  if (!utils::GetEnv("UNITRACE_PauseSession").empty()) {
-    UniController::TemporalPause(utils::GetEnv("UNITRACE_PauseSession").c_str());
-    return 0;
-  }
-
-  if (!utils::GetEnv("UNITRACE_ResumeSession").empty()) {
-    UniController::TemporalResume(utils::GetEnv("UNITRACE_ResumeSession").c_str());
-    return 0;
-  }
-
-  if (!utils::GetEnv("UNITRACE_StopSession").empty()) {
-    UniController::TemporalStop(utils::GetEnv("UNITRACE_StopSession").c_str());
-    return 0;
-  }
-
-  if (utils::GetEnv("UNITRACE_FollowChildProcess").empty()) {
-    utils::SetEnv("UNITRACE_FollowChildProcess", "1");  // default is to follow child processes
-  }
-
-  if (st.stall_sampling_) {
-    if (st.metric_sampling_ && (utils::GetEnv("UNITRACE_MetricGroup") != "EuStallSampling")) {
-      std::cerr << "[ERROR] Stall sampling cannot be enabled together with other metric group sampling" << std::endl;
-      return -1;
-    }
-    if (utils::GetEnv("UNITRACE_MetricGroup").empty()) {
-      utils::SetEnv("UNITRACE_MetricGroup", "EuStallSampling");
-    }
-    utils::SetEnv("UNITRACE_KernelMetrics", "1");
-  }
-
-  if (st.stall_sampling_ || st.metric_sampling_) {
-    auto my_MPI_rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-    if (!my_MPI_rank.empty()) {
-      if (st.ranks_to_sample_.empty()) {
-        std::cout << "[WARNING] MPI ranks to sample are not specified" << std::endl;
-      }
-      else {
-        int my_MPI_rank_ = -1;
-        if (!ToInt(my_MPI_rank, my_MPI_rank_)) {
-          std::cerr << "[ERROR] MPI rank (" << my_MPI_rank << ") is not a number" << std::endl;
-          return -1;
-        }
-        if (st.ranks_to_sample_.find(my_MPI_rank_) == st.ranks_to_sample_.end()) {
-          // turn off sampling on this rank
-          st.stall_sampling_ = false;
-          st.metric_sampling_ = false;
-          // reset UNITRACE_KernelMetrics
-          utils::SetEnv("UNITRACE_KernelMetrics", "");
-          // ignore devices to samples
-          st.devices_to_sample_present_ = false;
-        }
-      }
-    }
-
-    if (st.devices_to_sample_present_) {
-      // Need to initialize L0 now to get the device list
-      SetTracingEnvironment();
-      SetSysmanEnvironment();
-      if (utils::GetEnv("UNITRACE_MetricQuery") == "1" || utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        SetProfilingEnvironment();
-      }
-      if (!InitializeL0()) {
-        return -1;
-      }
-      auto device_list = GetDeviceList();
-      auto device_count = device_list.size();
-      if (device_count == 0) {
-        std::cerr << "[ERROR] No Level Zero devices found" << std::endl;
-        return -1;
-      }
-      std::string s;
-      for (const auto &device_no : st.devices_to_sample_) {
-        if ((0 <= device_no) && (device_no < device_count)) {
-          if (s.length() == 0) {
-            s = std::to_string(device_no);
-          } else {
-            s += "," + std::to_string(device_no);
-          }
-        } else {
-          std::cout << "[WARNING] Given device to sample (" << device_no << ") does not exist. Ignoring." << std::endl;
-        }
-      }
-      if (s.length() > 0) {
-        utils::SetEnv("UNITRACE_DevicesToSample", s.c_str());
-      } else {
-        std::cout << "[WARNING] Given devices to sample resulted in an empty device list. Skipping metric sampling." << std::endl;
-        utils::SetEnv("UNITRACE_KernelMetrics", "");
-      }
-    }
-  }
-
-  if (utils::GetEnv("UNITRACE_MetricQuery") == "1") {
-    if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-      std::cerr << "[ERROR] Hardware performance metric query mode cannot be used together with time-based mode" << std::endl;
-      return -1;
-    }
-  }
-
-  if ((utils::GetEnv("UNITRACE_MetricQuery") == "1") || (utils::GetEnv("UNITRACE_KernelMetrics") == "1")) {
-    if (NeedsImplicitDeviceTiming()) {
-      utils::SetEnv("UNITRACE_DeviceTiming", "1");
-    }
-
-    // default metric group is "ComputeBasic" unless a metric config file is given
-    if (utils::GetEnv("UNITRACE_MetricGroup").empty() && utils::GetEnv("UNITRACE_MetricConfig").empty()) {
-      utils::SetEnv("UNITRACE_MetricGroup", "ComputeBasic");
-    }
-
-    // Check the metric config file before the application starts; device-specific
-    // checks (names, valid parameter values) happen when the metric groups are created.
-    std::string metric_config = utils::GetEnv("UNITRACE_MetricConfig");
-    if (!metric_config.empty()) {
-      std::string error;
-      if (metric_config::Load(metric_config, metric_config::CountGroups(utils::GetEnv("UNITRACE_MetricGroup")), error) == nullptr) {
-        std::cerr << "[ERROR] Invalid metric configuration file: " << error << std::endl;
-        return kParseErrorReported;
-      }
-    }
-
-    // default sampling interval is DEFAULT_SAMPLING_INTERVAL_US
-    // does not hurt to set UNITRACE_SamplingInterval in query mode
-    if (utils::GetEnv("UNITRACE_SamplingInterval").empty()) {
-      utils::SetEnv("UNITRACE_SamplingInterval", DEFAULT_SAMPLING_INTERVAL_US_STR);
-    }
-  }
-
-  if (!utils::GetEnv("UNITRACE_SamplingInterval").empty() || !utils::GetEnv("UNITRACE_MetricGroup").empty()) {
-    if (utils::GetEnv("UNITRACE_DeviceTiming").empty() && utils::GetEnv("UNITRACE_ChromeKernelLogging").empty() && utils::GetEnv("UNITRACE_ChromeDeviceLogging").empty()) {
-      std::cerr << "[ERROR] No time-based hardware performance metric sampling option (-k/--stall-sampling) specified" << std::endl;
-    }
-  }
-
-  if (utils::GetEnv("UNITRACE_ChromeEventBufferSize").empty()) {
-    utils::SetEnv("UNITRACE_ChromeEventBufferSize", "-1");  // does not hurt to set to default even if chrome logging is not enabled
-  }
-  // Only validated here; the collector reads the value from the environment.
-  int chrome_event_buffer_size = -1;
-  if (!ParseChromeEventBufferSize(utils::GetEnv("UNITRACE_ChromeEventBufferSize"), chrome_event_buffer_size)) {
-    std::cerr << "[ERROR] Chrome event buffer size (" << utils::GetEnv("UNITRACE_ChromeEventBufferSize") << ") is invalid" << std::endl;
-    return -1;
-  }
-
-  if (!utils::GetEnv("UNITRACE_UseResultDirectory").empty() && utils::GetEnv("UNITRACE_UseResultDirectory") == "1") {
-    if ((!utils::GetEnv("UNITRACE_TraceOutputDirPath").empty()) || !utils::GetEnv("UNITRACE_LogToFile").empty()) {
-        std::cerr << "[ERROR] Option --result-dir cannot be used together with --output-dir-path or --output." << std::endl;
-      return -1;
-    }
-  }
-
-  std::string include_kernels_file = utils::GetEnv("UNITRACE_IncludeKernelsFile");
-  if (!include_kernels_file.empty()) {
-      if (!CXX_STD_FILESYSTEM_NAMESPACE::exists(CXX_STD_FILESYSTEM_NAMESPACE::path(include_kernels_file))) {
-          std::cerr << "[ERROR] Include kernels file does not exist: " << include_kernels_file << std::endl;
-          return -1;
-      }
-  }
-  std::string exclude_kernels_file = utils::GetEnv("UNITRACE_ExcludeKernelsFile");
-  if (!exclude_kernels_file.empty()) {
-      if (!CXX_STD_FILESYSTEM_NAMESPACE::exists(CXX_STD_FILESYSTEM_NAMESPACE::path(exclude_kernels_file))) {
-          std::cerr << "[ERROR] Filter-out file does not exist: " << exclude_kernels_file << std::endl;
-          return -1;
-      }
-  }
-  if (st.show_metric_list_ || st.gen_metric_config_ != nullptr) {
-    SetProfilingEnvironment(); // enable ZET_ENABLE_METRICS
-    std::string value = utils::GetEnv("UNITRACE_DeviceId");
-    uint32_t device_id = 0;
-    if (!ParseDeviceIndex(value, device_id)) {
-      std::cerr << "[ERROR] Device id (" << value << ") is invalid" << std::endl;
-      return -1;
-    }
-    if (st.show_metric_list_ && !PrintMetricList(device_id)) {
-      return -1;
-    }
-    if (st.gen_metric_config_ != nullptr && !GenMetricConfig(device_id, st.gen_metric_config_)) {
-      return kParseErrorReported;
-    }
-    return 0;
-  }
-
-
-  // __itt_pause()/__itt_resume()/__itt_detach() support always enabled.
-  // On Linux the LD_PRELOAD'd collector resolves the bare SONAME. On Windows
-  // the collector DLL is not on the default DLL search path, so this must be
-  // the FULL path to unitrace_tool.dll -- set from main() once lib_path is
-  // resolved (see below).
-#ifndef _WIN32
-  utils::SetEnv("INTEL_LIBITTNOTIFY64", "libunitrace_tool.so");
-#endif /* _WIN32 */
-
-  return st.app_index_;
-}
-
-ZeMetricProfiler *EnableProfiling(uint32_t app_pid, char *dir, std::string& logfile, bool idle_sampling) {
-#if BUILD_WITH_L0
-  if (!InitializeL0()) {
-    return nullptr;
-  } else {
-    return ZeMetricProfiler::Create(app_pid, dir, logfile, idle_sampling, utils::GetEnv("UNITRACE_DevicesToSample"));
-  }
-#else /* BUILD_WITH_L0 */
-  return nullptr;
-#endif /* BUILD_WITH_L0 */
-}
-
-void DisableProfiling() {
-  ZeMetricProfiler* profiler = metric_profiler.exchange(nullptr);
-  if (profiler != nullptr) {
-    delete profiler;
-  }
-}
-
-#ifndef _WIN32
-static void TerminateProcess(pid_t pid) {
-  if (pid <= 0) {
-    return;
-  }
-
-  if (kill(pid, SIGINT) != 0) {
-    // Already terminated
-    return;
-  }
-
-  usleep(1000 * 1000);
-
-  auto r = waitpid(pid, nullptr, WNOHANG);
-  if ((r == pid) || (r == -1)) {
-    // Already terminated
-    return;
-  }
-
-  if (kill(pid, SIGTERM) != 0) {
-    // Already terminated
-    return;
-  }
-
-  usleep(1000 * 1000);
-
-  r = waitpid(pid, nullptr, WNOHANG);
-  if ((r == pid) || (r == -1)) {
-    // Already terminated
-    return;
-  }
-
-  kill(pid, SIGKILL);
-  waitpid(pid, nullptr, 0);
-}
-#endif /* _WIN32 */
-
-static char *data_dir = nullptr;
-
-void TearDown() {
-  if (data_dir == nullptr) {
-    return;
-  }
-  if (CXX_STD_FILESYSTEM_NAMESPACE::exists(CXX_STD_FILESYSTEM_NAMESPACE::path(data_dir))) {
-    for (const auto& e: CXX_STD_FILESYSTEM_NAMESPACE::directory_iterator(CXX_STD_FILESYSTEM_NAMESPACE::path(data_dir))) {
-      CXX_STD_FILESYSTEM_NAMESPACE::remove_all(e.path());
-    }
-    if (!CXX_STD_FILESYSTEM_NAMESPACE::remove(CXX_STD_FILESYSTEM_NAMESPACE::path(data_dir))) {
-      std::cerr << "[WARNING] " << data_dir << " is not removed. Please manually remove it." << std::endl;
-    }
-  }
-#ifdef _WIN32
-  free(data_dir);
-#endif /* _WIN32 */
-  data_dir = nullptr;
-
-  if (!utils::GetEnv("UNITRACE_Session").empty()) {
-    UniController::ReleaseTemporalControl();
-#ifdef _WIN32
-    if (utils::GetEnv("UNITRACE_KernelMetrics") == "1" || utils::GetEnv("UNITRACE_MetricQuery") == "1") {
-#else /* _WIN32 */
-    if (utils::GetEnv("UNITRACE_KernelMetrics") == "1" || utils::GetEnv("UNITRACE_ChromeKmdLogging") == "1") {
-#endif /* _WIN32 */
-      UniController::ReleaseMetricFlushControl();
-    }
-  } else if (utils::GetEnv("UNITRACE_StartPaused") == "1" &&
-             utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-    // Nameless start-paused session created the flush control above;
-    // release it here (no-op if it was never created).
-    UniController::ReleaseMetricFlushControl();
-  }
-
-  if ((utils::GetEnv("UNITRACE_KernelMetrics") == "1")) {
-    UniController::ReleaseMetricSamplingControl();
-  }
-}
-
-void CleanUp(int sig) {
-  // Stopping the metric profiler joins its sampling threads, which is only safe
-  // on the main thread. SIGINT/SIGTERM are blocked in those threads (see
-  // EnableProfiling() in main()), so on Linux they run here on the main thread;
-  // on Windows SIGINT runs on a thread of its own. Faults (SIGSEGV, SIGABRT...)
-  // run on the faulting thread and may hold locks the shutdown needs, so they
-  // only tear down.
-  if (sig == SIGINT || sig == SIGTERM) {
-    DisableProfiling();
-  }
-  TearDown();
-  _Exit(-1);
-}
-
-
-// One `"label": [...],` line of the --result-dir config log.
-//   label      the key, e.g. "unitrace_args"
-//   arr        nullptr-terminated strings, e.g. argv
-//   start_idx  the first element to write
-// Returns the line, each element escaped as a JSON string.
-static std::string StringifyJsonArray(const char* label, char* const* arr, size_t start_idx = 0) {
-  std::string json = std::string("  ") + JsonString(label) + ": [";
-  bool first = true;
-  for (size_t i = start_idx; arr[i] != nullptr; ++i) {
-    if (!first) json += ", ";
-    json += JsonString(arr[i]);
-    first = false;
-  }
-  json += "],\n";
-  return json;
-}
-
-// Build the "device" line for the config log by querying the GPU device
-// directly, so downstream tooling (e.g. the VS Code extension picking a
-// metric-view config) knows the exact hardware even when analysis runs on a
-// different machine than capture. Returns "" when no GPU/Level Zero is
-// available -- this runs before the app is exec'd and must never abort a
-// capture, so every Level Zero status is checked and no path asserts. It carries
-// ground truth (device name + PCI id); mapping the PCI id to a HW family is
-// left to the consumer.
-static std::string StringifyDevice() {
-  // Level Zero latches these at the first zeInit(), which is now this one --
-  // ahead of where main() sets them. Without ZET_ENABLE_METRICS a metric run
-  // would come up with metrics disabled and later fail to enumerate metric
-  // groups. Setting them twice is harmless.
-  SetSysmanEnvironment();
-  if (utils::GetEnv("UNITRACE_MetricQuery") == "1" ||
-      utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-    SetProfilingEnvironment();
-  }
-  // Silent, guarded init: unlike InitializeL0() this must not print anything,
-  // because a plain (non-metrics) --result-dir capture would otherwise emit a
-  // spurious "Failed to initialize Level Zero" line on hosts where the perf
-  // paranoid sysctl blocks L0. If L0 is unavailable we simply omit the field.
-  if (!ZE_HAVE_FUNC(zeInit) ||
-      ZE_FUNC(zeInit)(ZE_INIT_FLAG_GPU_ONLY) != ZE_RESULT_SUCCESS) {
-    return "";
-  }
-  // Enumerate locally instead of calling GetGpuDevice(): that helper, and the
-  // GetDriverList/GetDeviceList it builds on, UNITRACE_ASSERT on every Level Zero
-  // status. Any driver that errored here would then abort the capture -- the
-  // opposite of this function's contract. Everything below checks return codes.
-  uint32_t driver_count = 0;
-  if (!ZE_HAVE_FUNC(zeDriverGet) ||
-      ZE_FUNC(zeDriverGet)(&driver_count, nullptr) != ZE_RESULT_SUCCESS ||
-      driver_count == 0) {
-    return "";
-  }
-  std::vector<ze_driver_handle_t> drivers(driver_count, nullptr);
-  if (ZE_FUNC(zeDriverGet)(&driver_count, drivers.data()) != ZE_RESULT_SUCCESS) {
-    return "";
-  }
-
-  // Name the device being sampled: the first of --devices-to-sample, which
-  // FinalizeParse has already validated into UNITRACE_DevicesToSample. Indices
-  // match unitrace's own, since the GPU_ONLY zeInit above leaves this walking the
-  // same devices in the same order. Anything unusable falls back to the first
-  // device; strtoul, because stoul throws on a huge value and would abort the run.
-  size_t wanted = 0;
-  const std::string devices_env = utils::GetEnv("UNITRACE_DevicesToSample");
-  if (!devices_env.empty()) {
-    const std::string first = devices_env.substr(0, devices_env.find(','));
-    if (!first.empty() && IsNumericString(first)) {
-      wanted = std::strtoul(first.c_str(), nullptr, 10);
-    }
-  }
-
-  std::vector<ze_device_properties_t> gpus;
-  for (auto driver : drivers) {
-    uint32_t device_count = 0;
-    if (!ZE_HAVE_FUNC(zeDeviceGet) ||
-        ZE_FUNC(zeDeviceGet)(driver, &device_count, nullptr) != ZE_RESULT_SUCCESS ||
-        device_count == 0) {
-      continue;
-    }
-    std::vector<ze_device_handle_t> devices(device_count, nullptr);
-    if (ZE_FUNC(zeDeviceGet)(driver, &device_count, devices.data()) != ZE_RESULT_SUCCESS) {
-      continue;
-    }
-    for (auto device : devices) {
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-      if (ZE_FUNC(zeDeviceGetProperties)(device, &props) == ZE_RESULT_SUCCESS &&
-          props.type == ZE_DEVICE_TYPE_GPU) {
-        gpus.push_back(props);
-      }
-    }
-  }
-  if (gpus.empty()) {
-    return "";
-  }
-  const ze_device_properties_t& chosen = gpus[wanted < gpus.size() ? wanted : 0];
-
-  char pci_id[8];
-  std::snprintf(pci_id, sizeof(pci_id), "0x%04X", chosen.deviceId & 0xFFFF);
-  return std::string("  \"device\": { \"name\": ") + JsonString(chosen.name) +
-         ", \"pci_id\": \"" + pci_id + "\" },\n";
-}
-
-void CreateConfigLog(const std::string& unitrace_version, const std::vector<char*>& unitrace_args, const std::vector<char*>& app_args) {
-  std::string value = utils::GetEnv("UNITRACE_UseResultDirectory");
-  if (!value.empty() && value == "1") {
-    LoggerFactory* logger_factory = LoggerFactory::Create();
-    std::shared_ptr<UniLogger> config_logger = logger_factory->GetLogger(LOGGER_TYPE_CONFIG, true, true);
-
-    config_logger->Log("{ \"unitrace version\": \"" + unitrace_version + "\",\n");
-    config_logger->Log("  \"app\": " + JsonString(app_args[0]) + ",\n");
-    config_logger->Log(StringifyJsonArray("unitrace_args", unitrace_args.data()));
-    config_logger->Log(StringifyJsonArray("app_args", app_args.data(), 1));
-    config_logger->Log("  \"Host\": " + JsonString(GetHostName()) + ",\n");
-    config_logger->Log(StringifyDevice());
-    config_logger->Log("  \"pid\": \"" + std::to_string(utils::GetPid()) + "\"\n");
-    config_logger->Log("}\n");
-    config_logger->Flush();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Raw KMD trace (bpftrace output): tid,event,timestamp,duration[,data]
-// ---------------------------------------------------------------------------
-
-// true if s is a non-empty string of ASCII decimal digits: the form the KMD trace
-// script writes thread ids, timestamps and durations in.
-static bool IsDecimal(const std::string& s) { return !s.empty() && IsDigits(s); }
-
-// One event of the raw KMD trace (--chrome-kmd-logging), as the bpftrace script
-// writes it: tid,event,timestamp,duration[,data]
-//   tid_        the kernel thread id
-//   name_       the kernel function
-//   timestamp_  boot-time timestamp of the start, in ns
-//   duration_   duration, in ns
-//   data_       optional data after the duration, possibly with commas
-struct KmdEvent {
-  uint64_t tid_ = 0;
-  std::string name_;
-  uint64_t timestamp_ = 0;
-  uint64_t duration_ = 0;
-  std::string data_;
-};
-
-// Parses one line of the raw KMD trace into event.
-//   line   the line, with or without a trailing \r
-//   event  receives the event
-// Returns false if the line has fewer than four fields, or tid, timestamp or
-// duration is not decimal digits or does not fit 64 bits; such lines are other
-// output of the bpftrace script, not events.
-static bool ParseKmdLine(std::string line, KmdEvent& event) {
-  if (!line.empty() && line.back() == '\r') {
-    line.pop_back();
-  }
-  const size_t p1 = line.find(',');
-  const size_t p2 = (p1 == std::string::npos) ? p1 : line.find(',', p1 + 1);
-  const size_t p3 = (p2 == std::string::npos) ? p2 : line.find(',', p2 + 1);
-  if (p3 == std::string::npos) {
-    return false;
-  }
-  const std::string tid = line.substr(0, p1);
-  const std::string ts = line.substr(p2 + 1, p3 - p2 - 1);
-  std::string dur = line.substr(p3 + 1);
-  event.data_.clear();
-  const size_t p4 = dur.find(',');
-  if (p4 != std::string::npos) {
-    event.data_ = dur.substr(p4 + 1);
-    dur = dur.substr(0, p4);
-  }
-  // tid is written unquoted, and ts/dur are unsigned, so all three must be decimal.
-  if (!IsDecimal(tid) || !IsDecimal(ts) || !IsDecimal(dur)) {
-    return false;
-  }
-  try {
-    event.tid_ = std::stoull(tid);
-    event.timestamp_ = std::stoull(ts);
-    event.duration_ = std::stoull(dur);
-  } catch (...) {
-    return false;
-  }
-  event.name_ = line.substr(p1 + 1, p2 - p1 - 1);
-  return true;
-}
-
-// Reads the next event of the raw KMD trace into event, skipping lines that are not
-// one (other output of the bpftrace script).
-//   in     the raw trace
-//   event  receives the event
-// Returns false at the end of the input.
-static bool ReadKmdEvent(std::istream& in, KmdEvent& event) {
-  std::string line;
-  while (std::getline(in, line)) {
-    if (ParseKmdLine(line, event)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// The Chrome trace event (a complete "X" event on pid 0) for a KMD event.
-//   event   the event
-//   ts_us   its start, already converted to epoch time in us, fractional
-//   dur_us  its duration, already converted to us, fractional (a 500 ns
-//           event is 0.5)
-// Returns the JSON object; the name and data are escaped, so it is valid JSON for
-// any input line.
-static std::string KmdEventToJson(const KmdEvent& event, double ts_us, double dur_us) {
-  std::string str = "{";
-  str += "\"ph\": \"X\"";
-  str += ", \"tid\": " + std::to_string(event.tid_);
-  str += ", \"pid\": 0";
-  if (!event.name_.empty()) {
-    str += ", \"name\": " + JsonString(event.name_);
-  }
-  str += ", \"cat\": \"os_op\"";
-  str += ", \"ts\": " + std::to_string(ts_us);
-  str += ", \"dur\": " + std::to_string(dur_us);
-  if (!event.data_.empty()) {
-    str += ", \"args\": {\"data\": " + JsonString(event.data_) + "}";
-  }
-  str += "}";
-  return str;
-}
-
-static void DumpKmdTraceData(std::string& raw_data_file) {
-  std::ifstream inf = std::ifstream(raw_data_file);
-  if (!inf.is_open()) {
-    std::cerr << "[ERROR] Failed to open raw kernel/kmd tracing date file" << std::endl;
-    return;
-  }
-
-  UniTimer::StartUniTimer();  // need the timer to get the epoch time of system boot and difference between boot time and monotonic time
-
-  LoggerFactory* logger_factory = LoggerFactory::Create();
-  std::shared_ptr<UniLogger> oskmd_logger = logger_factory->GetLogger(LOGGER_TYPE_KMD_TRACE, true, true);
-  if (oskmd_logger == nullptr) {
-    std::cerr << "[ERROR] Failed to create kernel/kmd trace file" << std::endl;
-    return;
-  }
-
-  oskmd_logger->Log("{ \"traceEvents\":[\n");
-
-  std::string str("{\"ph\": \"M\", \"name\": \"process_name\", \"pid\": 0,");  // 0 as dummy process id
-
-  str += "\"args\": {\"name\": \"";
-
-  std::string host = GetHostName();
-
-  if (logger_factory->GetRank().empty()) {
-    str += "HOST-OS-KMD<" + host + ">\"}}";
-  }
-  else {
-    str += "RANK " + logger_factory->GetRank() + " HOST-OS-KMD<" + host + ">\"}}";
-  }
-
-  oskmd_logger->Log(str);
-
-  KmdEvent event;
-  while (ReadKmdEvent(inf, event)) {
-    str = ",\n" + KmdEventToJson(
-        event,
-        UniTimer::GetEpochTimeInUs(UniTimer::GetHostTimestampFromBootTimestamp(event.timestamp_)),
-        UniTimer::GetTimeInUs(event.duration_));
-    oskmd_logger->Log(str);
-  }
-
-  oskmd_logger->Log("\n]}");
-  oskmd_logger->Flush();
-
-  std::cerr << "[INFO] KMD profiling data are stored in " << oskmd_logger->GetLogFileName() << std::endl;
-}
-
-// The fuzz targets include this file to reach its parsers, and bring their own main.
-#ifndef UNITRACE_FUZZ
-int main(int argc, char *argv[]) {
-  if (argc < 2) {
-    Usage(argv[0]);
-    return 0;
-  }
-
-#if !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__))
-  struct rlimit	rlim;
-  rlim.rlim_cur = RLIM_INFINITY;
-  rlim.rlim_max = RLIM_INFINITY;
-  if (setrlimit(RLIMIT_STACK, &rlim)) {
-    // cannot set stack size to unlimited
-    // set soft limit to the same as hard limit
-    getrlimit(RLIMIT_STACK, &rlim);
-    rlim.rlim_cur = rlim.rlim_max;
-    setrlimit(RLIMIT_STACK, &rlim);
-  }
-
-#endif /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-
-  std::string executable_path = utils::GetExecutablePath();
-
-  bool use_ld_lib_path = false;
-  std::string lib_path = executable_path + LIB_UNITRACE_TOOL_NAME;
-  FILE *fp;
-#ifdef _WIN32
-  errno_t err = fopen_s(&fp, lib_path.c_str(), "rb");
-  if (err != 0 || fp == nullptr) {
-    lib_path = executable_path + "/../" UNITRACE_INSTALL_LIBDIR "/" + LIB_UNITRACE_TOOL_NAME;
-    err = fopen_s(&fp, lib_path.c_str(), "rb");
-    if (err != 0 || fp == nullptr) {
-      use_ld_lib_path = true;
-      lib_path = LIB_UNITRACE_TOOL_NAME;
-    } else {
-      fclose(fp);
-    }
-  } else {
-    fclose(fp);
-  }
-#else /* _WIN32 */
-  fp = fopen(lib_path.c_str(), "rb");
-  if (fp == nullptr) {
-      lib_path = executable_path + "/../" UNITRACE_INSTALL_LIBDIR "/" + LIB_UNITRACE_TOOL_NAME;
-      fp = fopen(lib_path.c_str(), "rb");
-      if (fp == nullptr) {
-        use_ld_lib_path = true;
-        lib_path = LIB_UNITRACE_TOOL_NAME;
-      } else {
-          fclose(fp);
-      }
-  } else {
-      fclose(fp);
-  }
-#endif /* _WIN32 */
-
-#ifdef _WIN32
-  // The static ittnotify in the target app loads the collector named by
-  // INTEL_LIBITTNOTIFY64 via LoadLibrary. On Windows unitrace_tool.dll is not
-  // on the default DLL search path, so pass the full resolved path; otherwise
-  // the load fails and __itt_pause/resume/detach silently no-op. (Linux sets
-  // the bare SONAME in ParseArgs.)
-  utils::SetEnv("INTEL_LIBITTNOTIFY64", lib_path.c_str());
-#endif /* _WIN32 */
-
-#if BUILD_WITH_MPI
-  std::string mpi_interceptor_path = executable_path + LIB_UNITRACE_MPI_NAME;
-  if (use_ld_lib_path) {
-    mpi_interceptor_path = LIB_UNITRACE_MPI_NAME;
-  } else {
-    fp = fopen(mpi_interceptor_path.c_str(), "rb");
-    if (fp == nullptr) {
-      mpi_interceptor_path = executable_path + "/../" UNITRACE_INSTALL_LIBDIR "/" + LIB_UNITRACE_MPI_NAME;
-      fp = fopen(mpi_interceptor_path.c_str(), "rb");
-      if (fp == nullptr) {
-        std::cerr << "[ERROR] Library " << mpi_interceptor_path << " cannot be found or opened. " << std::endl;
-        return -1;
-      }
-      else {
-        fclose(fp);
-      }
-    } else {
-      fclose(fp);
-    }
-  }
-#endif /* BUILD_WITH_MPI */
-
-  // Set unitrace version
-  auto unitrace_version =  std::string(UNITRACE_VERSION) + " (" +  std::string(COMMIT_HASH) + ")";
-  utils::SetEnv("UNITRACE_VERSION", unitrace_version.c_str());
-
-  int app_index = ParseArgs(argc, argv);
-  if (app_index <= 0 || app_index >= argc) {
-    if (app_index >= argc) {
-      std::cerr << "[ERROR] Application is missing" << std::endl;
-      Usage(argv[0]);
-    } else if (app_index < 0 && app_index != kParseErrorReported) {
-      std::cerr << "[ERROR] Invalid command line" << std::endl;
-      Usage(argv[0]);
-    }
-    return app_index? 1 : 0;
-  }
-
-  std::vector<char*> app_args;
-  std::vector<char*> unitrace_args;
-
-  for (int i = 1; i < app_index; ++i) {
-    unitrace_args.push_back(argv[i]);
-  }
-  unitrace_args.push_back(nullptr);
-
-  for (int i = app_index; i < argc; ++i) {
-    app_args.push_back(argv[i]);
-  }
-  app_args.push_back(nullptr);
-
-  CreateConfigLog(unitrace_version, unitrace_args, app_args);
-
-  const bool named_session = !utils::GetEnv("UNITRACE_Session").empty();
-  // A nameless session can still be stopped from within the application via
-  // __itt_detach() or by setting PTI_ENABLE_COLLECTION=-1 when conditional
-  // collection (--start-paused) is enabled. That stop is reflected in the
-  // metric-sampling shared memory, which IsSessionStopped() also inspects.
-  const bool app_can_stop_collection =
-      (utils::GetEnv("UNITRACE_StartPaused") == "1") &&
-      (utils::GetEnv("UNITRACE_KernelMetrics") == "1");
-  // Collection may stop before the application exits: either externally via
-  // --stop (named session) or from within the application (nameless session).
-  const bool stoppable_session = named_session || app_can_stop_collection;
-
-  if (named_session) {
-    UniController::CreateTemporalControl(utils::GetEnv("UNITRACE_Session").c_str());
-    if (!utils::GetEnv("UNITRACE_StartPaused").empty()) {
-      UniController::TemporalPause(utils::GetEnv("UNITRACE_Session").c_str());
-    }
-#ifdef _WIN32
-    if (utils::GetEnv("UNITRACE_KernelMetrics") == "1" || utils::GetEnv("UNITRACE_MetricQuery") == "1") {
-#else /* _WIN32 */
-    if (utils::GetEnv("UNITRACE_KernelMetrics") == "1" || utils::GetEnv("UNITRACE_ChromeKmdLogging") == "1") {
-#endif /* _WIN32 */
-      UniController::CreateMetricFlushControl();
-    }
-  } else if (app_can_stop_collection) {
-    // Nameless start-paused session: enable the flush handshake so the
-    // parent can wait for the child to flush metric data on an in-application
-    // __itt_detach()/PTI_ENABLE_COLLECTION=-1 stop, just like a named session.
-    UniController::CreateMetricFlushControl();
-  }
-
-  std::string preload = utils::GetEnv("LD_PRELOAD");
-  utils::SetEnv("UNITRACE_LD_PRELOAD_OLD", preload.c_str());
-  if (preload.empty()) {
-#ifdef _WIN32
-    preload = lib_path;	// lib_path is needed later
-#else /* _WIN32 */
-    preload = std::move(lib_path);
-#endif /* _WIN32 */
-  }
-  else {
-    preload = preload + ":" + lib_path;
-  }
-
-#if BUILD_WITH_MPI
-  if (utils::GetEnv("UNITRACE_ChromeMpiLogging") == "1") {
-    preload = preload + ":" + mpi_interceptor_path;
-    // For tracing MPI calls from oneCCL, we need to set CCL_MPI_LIBRARY_PATH
-    // with unitrace's MPI intercepter path, because oneCCL directly picks up
-    // MPI functions with dlopen/dlsym, not through the dynamic linker. Thus,
-    // LD_PRELOAD would not work.
-    // TODO: We have to consider a case where CCL_MPI_LIBRARY_PATH is already
-    //       set. In this case, unitrace needs to call MPIs in the specified libs
-    //       before/after ITT annotation.
-    utils::SetEnv("CCL_MPI_LIBRARY_PATH", mpi_interceptor_path.c_str());
-  }
-#endif /* BUILD_WITH_MPI */
-
-  std::string logfile;
-  if (utils::GetEnv("UNITRACE_LogToFile") == "1") {
-    logfile = utils::GetEnv("UNITRACE_LogFilename");
-  }
-
-  SetTracingEnvironment();
-  //OpenCL and oneCCL require sysman enabled
-  SetSysmanEnvironment();
-
-  if (utils::GetEnv("UNITRACE_MetricQuery") == "1" || utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-    SetProfilingEnvironment();
-    if ((utils::GetEnv("UNITRACE_KernelMetrics") == "1")) {
-        // create shared memory for metric sampling control between the profiler and the application
-        UniController::CreateMetricSamplingControl();
-    }
-  }
-
-#ifndef _WIN32
-  // For some environments (e.g. virtualenv), the required shared libraries may be in the virtualenv folder which is not in LD_LIBRARY_PATH.
-  // To address this, we append the virtualenv lib folder to LD_LIBRARY_PATH if VIRTUAL_ENV is set.
-  // It is noticed while running pytorch test apps.
-  std::string virtual_env = utils::GetEnv("VIRTUAL_ENV");
-  if (!virtual_env.empty()) {
-    std::string ld_library_path = utils::GetEnv("LD_LIBRARY_PATH");
-    // append virtualenv lib folder to LD_LIBRARY_PATH
-    virtual_env = virtual_env + "/lib";
-    if (ld_library_path.empty()) {
-      ld_library_path = std::move(virtual_env);
-    } else {
-      ld_library_path = ld_library_path + ":" + virtual_env;
-    }
-    utils::SetEnv("LD_LIBRARY_PATH", ld_library_path.c_str());
-  }
-
-  utils::SetEnv("LD_PRELOAD", preload.c_str());
-
-
-  if (utils::GetEnv("UNITRACE_KernelMetrics") == "1" || !utils::GetEnv("UNITRACE_ChromeKmdLogging").empty()) {
-
-    // static: data_dir points into it, and TearDown() runs after this block.
-    static char pattern[] = "/tmp/tmpdir.XXXXXX";
-
-    data_dir = mkdtemp(pattern);
-    if (data_dir == nullptr) {
-      std::cerr << "[ERROR] Failed to create data folder" << std::endl;
-      exit(-1);
-    }
-
-    std::signal(SIGABRT, CleanUp);
-    std::signal(SIGFPE, CleanUp);
-    std::signal(SIGILL, CleanUp);
-    std::signal(SIGINT, CleanUp);
-    std::signal(SIGSEGV, CleanUp);
-    std::signal(SIGTERM, CleanUp);
-
-    std::string latch_file_name = std::string(data_dir) + "/latch.tmp";
-    std::string oskmd_data_file_name = std::string(data_dir) + "/.oskmd.csv";
-
-    utils::SetEnv("UNITRACE_DataDir", data_dir);
-
-    int child;
-
-    child = fork();
-
-    if (child == 0) {
-      if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        // child process
-        // wait for the profiler to be ready
-        std::ifstream inf;
-
-        inf.open(latch_file_name, std::ios_base::in);
-        uint32_t t = 0;
-        while (!inf.is_open() && (t < 10)) {	// wait for no more than 10s
-          sleep(1);
-          t += 1;
-          inf.open(latch_file_name, std::ios_base::in);
-        }
-        if (inf.is_open()) {
-          inf.close();
-        }
-      }
-
-      // ready to go
-      utils::SetEnv("UNITRACE_DataDir", data_dir);
-
-      int ret = 0;
-
-      if (!utils::GetEnv("UNITRACE_ChromeKmdLogging").empty()) {
-        std::string cmdline(app_args[0]);
-
-        for (int i = 1; i < app_args.size() - 1; ++i) {
-          cmdline += " ";
-          cmdline += app_args[i];
-        }
-
-        ret = execlp("bpftrace", "bpftrace", "-q", "-o", oskmd_data_file_name.c_str(), "-c", cmdline.c_str(), utils::GetEnv("UNITRACE_ChromeKmdLogging").c_str(), nullptr);
-      }
-      else {
-        ret = execvp(app_args[0], app_args.data());
-      }
-
-      if (ret) {
-        std::cerr << "[ERROR] Failed to launch target application: " << app_args[0] << std::endl;
-        Usage(argv[0]);
-        std::_Exit(-1);
-      }
-    } else if (child > 0) {
-      // parent process
-      pid_t bpftrace_pid = 0; // keep bpftrace pid if KMD profiling is enabled
-
-      if (!utils::GetEnv("UNITRACE_ChromeKmdLogging").empty()) {
-        bpftrace_pid = child;
-      }
-      if (utils::GetEnv("UNITRACE_KernelMetrics") == "1") {
-        // Child threads ignore SIGINT/SIGTERM: the sampling threads started
-        // here inherit this blocked mask, so the signals are handled on the
-        // main thread, where CleanUp() can stop the profiler (which joins the
-        // sampling threads). A signal raised meanwhile stays pending and is
-        // delivered to the main thread when the mask is restored.
-        sigset_t termination_signals, prev_mask;
-        sigemptyset(&termination_signals);
-        sigaddset(&termination_signals, SIGINT);
-        sigaddset(&termination_signals, SIGTERM);
-        pthread_sigmask(SIG_BLOCK, &termination_signals, &prev_mask);
-        metric_profiler = EnableProfiling(child, data_dir, logfile, idle_sampling);
-        pthread_sigmask(SIG_SETMASK, &prev_mask, nullptr);
-
-        // create a latch file to notify the application process to proceed
-        std::ofstream outf(latch_file_name, std::ios_base::out);
-        if (!outf.is_open()) {
-          std::cerr << "[ERROR] Failed to create profiler latch file: " << app_args[0] << std::endl;
-        }
-        else {
-          outf.close();
-        }
-      }
-
-      // Poll for session stop while waiting for child processes.
-      // This allows --stop to trigger metric finalization without waiting
-      // for the application to exit naturally.
-      bool session_stopped = false;
-      if (stoppable_session) {
-        // Poll for stop signal: external --stop (named session) or an
-        // in-application __itt_detach()/PTI_ENABLE_COLLECTION=-1 (nameless session)
-        while (true) {
-          // Check if child(ren) have exited
-          if (waitpid(-1, nullptr, WNOHANG) < 0) {
-            // No more children (ECHILD) or error
-            break;
-          }
-          if (UniController::IsSessionStopped()) {
-            session_stopped = true;
-            std::cerr << "[INFO] Stop profiling as the session is stopped" << std::endl;
-            break;
-          }
-          // Sleep briefly before polling again
-          usleep(100 * 1000);  // 100ms
-        }
-        if (session_stopped) {
-          // Give child processes some time to flush profile data
-          usleep(1000 * 1000);  // 1000ms
-          // Just like a namesless session if all child processes exited
-          if (waitpid(-1, nullptr, WNOHANG) < 0) {
-             session_stopped = false;
-          }
-          else {
-            // Session was stopped via --stop command
-            // Stop profiling, wait for children to flush data, then compute metrics
-            std::cerr << "[INFO] Wait for child process(es) to flush profile data" << std::endl;
-            constexpr int kTimeoutSeconds = 5;
-            constexpr int kPollIntervalMs = 100;
-            const int max_iters = kTimeoutSeconds * 1000 / kPollIntervalMs;
-
-            bool data_ready = false;
-            int elapsed_ms = 0;
-            for (int i = 0; i < max_iters; ++i) {
-              if (waitpid(-1, nullptr, WNOHANG) < 0) {
-                // Just like a namesless session if all child processes exited
-                session_stopped = false;
-                data_ready = true;
-                break;
-              }
-              // IsChildDataReadyTrusted() applies the start-of-flush grace: an early
-              // ready result (the shared flush counters showing no flush in flight)
-              // is not trusted until the grace elapses, so a child that has not yet
-              // observed the stop and begun flushing is not skipped.
-              if (UniController::IsChildDataReadyTrusted(elapsed_ms)) {
-                data_ready = true;
-                break;
-              }
-
-              usleep(kPollIntervalMs * 1000);
-              elapsed_ms += kPollIntervalMs;
-            }
-
-            if (!data_ready) {
-              std::cerr << "[WARNING] Timed out waiting for child process(es) to flush profile data after " << kTimeoutSeconds << "s. Metric output may be incomplete." << std::endl;
-            }
-          }
-          if (bpftrace_pid && session_stopped) {
-            // Exception to the "wait for the application to complete" rule
-            // below: with --chrome-kmd-logging the application runs as a -c
-            // grandchild of bpftrace, so once the session is stopped we stop
-            // the bpftrace process here. Terminating bpftrace propagates the
-            // signal to its -c grandchild, so the application process also
-            // exits as a side effect.
-            TerminateProcess(bpftrace_pid);
-          }
-        }
-      } else {
-        // Collection cannot be stopped before the app exits: just wait for
-        // all children to exit
-        while (wait(nullptr) > 0);
-      }
-
-      DisableProfiling();
-      if (bpftrace_pid) {
-        DumpKmdTraceData(oskmd_data_file_name);
-      }
-
-      if (session_stopped) {
-        // After the session stop is handled we still need to wait for the
-        // parent application process to complete. Otherwise we would let the
-        // application process exit prematurely, which may not be what the user
-        // wants -- stopping the profiling session should not kill the workload.
-        //
-        // One exception: with --chrome-kmd-logging, stopping the session
-        // already terminated the bpftrace process above, and because the
-        // application runs as bpftrace's -c grandchild it exits along with it.
-        // In that case there is nothing left to wait for here.
-        while (wait(nullptr) > 0);
-      }
-    } else {
-      std::cerr << "[ERROR] Failed to create child process" << std::endl;
-      DisableProfiling();
-    }
-  }
-  else {
-    if (execvp(app_args[0], app_args.data())) {
-      std::cerr << "[ERROR] Failed to launch target application: " << app_args[0] << std::endl;
-      Usage(argv[0]);
-      return 1;
-    }
-  }
-#else /* _WIN32 */
-  bool metrics_sampling_enabled = (utils::GetEnv("UNITRACE_KernelMetrics") == "1");
-  bool metrics_query_enabled = (utils::GetEnv("UNITRACE_MetricQuery") == "1");
-
-  // metric data collection
-  if (metrics_sampling_enabled || metrics_query_enabled) {
-    char tpath[MAX_PATH];
-    auto tpath_length = GetTempPathA(MAX_PATH, tpath);
-    if (tpath_length == 0) {
-      std::cerr << "[ERROR] Path for temporary files does not exit." << std::endl;
-      exit(-1);
-    }
-
-    if (!CXX_STD_FILESYSTEM_NAMESPACE::exists(CXX_STD_FILESYSTEM_NAMESPACE::path(tpath))) {
-      // First check if folder for temporary files exist
-      std::cerr << "[ERROR] Directory for temporary files does not exist." << std::endl;
-      exit(-1);
-    }
-
-    // set data_dir for cleaning up
-    data_dir = (char *)malloc(strlen(tpath) + sizeof("\\.data.") + 32);	// enough for the data_dir
-    UniMemory::ExitIfOutOfMemory(data_dir);
-    sprintf(data_dir, "%s\\.data.%d", tpath, utils::GetPid());
-    auto status = CreateDirectoryA(LPCSTR(data_dir), nullptr);
-    if (status == false) {
-      std::cerr << "[ERROR] Failed to create temporary data folder." << std::endl;
-      free(data_dir);
-      exit(-1);
-    }
-
-    std::signal(SIGABRT, CleanUp);
-    std::signal(SIGFPE, CleanUp);
-    std::signal(SIGILL, CleanUp);
-    std::signal(SIGINT, CleanUp);
-    std::signal(SIGSEGV, CleanUp);
-    std::signal(SIGTERM, CleanUp);
-
-    utils::SetEnv("UNITRACE_DataDir", data_dir);
-  }
-
-  std::string cmdline = "";
-  for (int i = 0; i < app_args.size() - 1; ++i) {
-    cmdline += app_args[i];
-    cmdline += " ";
-  }
-
-  PROCESS_INFORMATION pi = {0};
-  STARTUPINFO si = {0};
-  si.cb = sizeof(si);
-
-  if (CreateProcessA(app_args[0], LPSTR(cmdline.c_str()), nullptr, nullptr, false, CREATE_SUSPENDED, nullptr, nullptr, &si, &pi)) {
-    BOOL success = FALSE;
-    HANDLE init_done = nullptr;
-    do {
-      // Created before injection; the collector signals it once Init() finishes (see tracer.cc).
-      const std::string init_done_name =
-        std::string(UNITRACE_INIT_DONE_EVENT_PREFIX) + std::to_string(pi.dwProcessId);
-      init_done = CreateEventA(nullptr, TRUE, FALSE, init_done_name.c_str());
-      if (init_done == nullptr) {
-        std::cerr << "[ERROR] Failed to create initialization event: " << GetLastError() << std::endl;
-        break;
-      }
-
-      void *pathname = VirtualAllocEx(pi.hProcess, nullptr, lib_path.size() + 1, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
-      if (pathname == nullptr) {
-        std::cerr << "[ERROR] Failed to allocate memory: " << GetLastError() << std::endl;
-        break;
-      }
-
-      if (!WriteProcessMemory(pi.hProcess, pathname, lib_path.c_str(), lib_path.size() + 1, nullptr)) {
-        std::cerr << "[ERROR] Failed to write target process memory: " << GetLastError() << std::endl;
-        break;
-      }
-
-      LPTHREAD_START_ROUTINE loadlibrary = reinterpret_cast<LPTHREAD_START_ROUTINE>(GetProcAddress(GetModuleHandleA("kernel32.dll"), "LoadLibraryA"));
-      if (!loadlibrary) {
-        std::cerr << "[ERROR] Failed to get address of LoadLibraryA: " << GetLastError() << std::endl;
-        break;
-      }
-
-      HANDLE thr = CreateRemoteThread(pi.hProcess, nullptr, CREATE_SUSPENDED, loadlibrary, pathname, 0, nullptr);
-      if (!thr) {
-        std::cerr << "[ERROR] Failed to create thread for initialization: " << GetLastError() << std::endl;
-        break;
-      }
-
-      if (WaitForSingleObject(thr, INFINITE) != WAIT_OBJECT_0) {
-        std::cerr << "[ERROR] Failed to wait for thread to complete the initialization: " << GetLastError() << std::endl;
-        break;
-      }
-      DWORD ret = 0;
-      GetExitCodeThread(thr, &ret);
-      if (ret == 0) {
-        std::cerr << "[ERROR] Initialization thread failed: " << GetLastError() << std::endl;
-        break;
-      }
-
-      CloseHandle(thr);
-
-      // Keep the application suspended until the collector has initialized. Bounded so a
-      // stuck driver gives a warning instead of a silent hang.
-      constexpr DWORD kInitTimeoutMs = 120000;
-      if (WaitForSingleObject(init_done, kInitTimeoutMs) != WAIT_OBJECT_0) {
-        std::cerr << "[WARNING] Timed out waiting for unitrace initialization to complete."
-          " Starting the application anyway; early activity may be missed" << std::endl;
-      }
-
-      DWORD app_pid = pi.dwProcessId;
-
-      if (metrics_sampling_enabled) {
-        SetProfilingEnvironment();
-        metric_profiler = EnableProfiling(app_pid, data_dir, logfile, idle_sampling);
-      }
-
-      ResumeThread(pi.hThread);
-
-      if (metrics_query_enabled || metrics_sampling_enabled) {
-        bool session_stopped = false;
-        if (stoppable_session) {
-          constexpr DWORD kPollIntervalMs = 100;
-          while (true) {
-            if (WaitForSingleObject(pi.hProcess, kPollIntervalMs) == WAIT_OBJECT_0) {
-              break;  // application exited
-            }
-            if (UniController::IsSessionStopped()) {
-              session_stopped = true;
-              std::cerr << "[INFO] Stop profiling as the session is stopped" << std::endl;
-              break;
-            }
-          }
-          if (session_stopped) {
-            if (WaitForSingleObject(pi.hProcess, kPollIntervalMs) == WAIT_OBJECT_0) {
-              session_stopped = false;
-            }
-            else {
-              // Session was stopped via --stop command
-              // Stop profiling, wait for children to flush data, then compute metrics
-              // Wait for all child processes to flush their metric data
-              std::cerr << "[INFO] Wait for child process(es) to flush profile data" << std::endl;
-              constexpr int kTimeoutSeconds = 5;
-              const int max_iters = kTimeoutSeconds * 1000 / kPollIntervalMs;
-
-              bool data_ready = false;
-              int elapsed_ms = 0;
-              for (int i = 0; i < max_iters; ++i) {
-                // IsChildDataReadyTrusted() applies the start-of-flush grace: an early
-                // ready result (the shared flush counters showing no flush in flight)
-                // is not trusted until the grace elapses, so a child that has not yet
-                // observed the stop and begun flushing is not skipped.
-                if (UniController::IsChildDataReadyTrusted(elapsed_ms)) {
-                  data_ready = true;
-                  break;
-                }
-
-                if (WaitForSingleObject(pi.hProcess, kPollIntervalMs) == WAIT_OBJECT_0) {
-                  session_stopped = false;
-                  data_ready = true;
-                  break;
-                }
-                elapsed_ms += kPollIntervalMs;
-              }
-
-              if (!data_ready) {
-                std::cerr << "[WARNING] Timed out waiting for child process(es) to flush profile data after " << kTimeoutSeconds << "s. Metric profile data may be incomplete." << std::endl;
-              }
-            }
-          }
-        }
-        else {
-          WaitForSingleObject(pi.hProcess, INFINITE);
-        }
-        DisableProfiling();
-        if (metrics_query_enabled) {
-          // compute metrics
-	  ZeMetricProfiler::ComputeMetricsQueried(app_pid);
-        }
-        if (session_stopped) {
-          // wait for the application to complete
-          WaitForSingleObject(pi.hProcess, INFINITE);
-        }
-      } else {
-        WaitForSingleObject(pi.hProcess, INFINITE);
-      }
-      success = TRUE;
-    }
-    while (0);
-
-    if (init_done != nullptr) {
-      CloseHandle(init_done);
-    }
-
-    if (!success) {
-      std::cerr << "[ERROR] Failed to initialize the tool " << std::endl;
-    }
-  }
-  else {
-    std::cerr << "[ERROR] Failed to launch target application: " << app_args[0] << std::endl;
-    Usage(argv[0]);
-    return 1;
-  }
-#endif /* _WIN32 */
-
-  TearDown();
-
-  return 0;
-}
-#endif /* UNITRACE_FUZZ */
diff --git a/tools/unitrace/src/utils/cli_options.h b/tools/unitrace/src/utils/cli_options.h
deleted file mode 100644
index b224e60e..00000000
--- a/tools/unitrace/src/utils/cli_options.h
+++ /dev/null
@@ -1,300 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_CLI_OPTIONS_H_
-#define PTI_TOOLS_UNITRACE_UTILS_CLI_OPTIONS_H_
-
-// Generic table-driven CLI parser: one constexpr CliOption<Ctx>[] table drives
-// argument dispatch, --help text, and a JSON schema dump. `Ctx` is the
-// caller's own business-state struct, threaded through to Handler.
-
-#include <cstddef>
-#include <cstring>
-#include <iostream>
-#include <string>
-
-#include "utils/utils.h"
-#include "utils/utils_host.h"
-
-namespace cli {
-
-// Handler return status: continue parsing, exit with a command-line error
-// (ParseArgs returns -1), or exit cleanly (ParseArgs returns 0, e.g. --help).
-enum class Status { Ok, Error, ExitOk };
-
-using Validator = bool (*)(const std::string&);
-
-template <typename Ctx>
-struct CliOption;
-
-template <typename Ctx>
-using Handler = Status (*)(Ctx&, const CliOption<Ctx>&, const char* value);
-
-template <typename Ctx>
-struct CliOption {
-  const char* name_;        // "--call-logging"
-  const char* alias_;       // "-c" or nullptr
-  const char* type_;        // schema only: "bool"|"int"|"float"|"string"|"enum"|"path"|"action"
-  bool        takes_value_; // consumes the next argv token (set by the factory below)
-  const char* group_;       // caller-defined group id, e.g. "core"|"output"
-  const char* value_hint_;  // "number-of-events" -> "<number-of-events>"; nullptr for bool/action
-  const char* def_;         // default as a string ("false","-1","50","ComputeBasic"); nullptr
-  const char* choices_;     // comma-separated ("0,1") or nullptr
-  bool        hidden_;      // excluded from Usage; still emitted to JSON with hidden:true
-  const char* help_;        // the single help string
-
-  // ---- behavior (what the parser executes) ----
-  const char* env_;         // "UNITRACE_CallLogging"; nullptr when a handler does its own SetEnv
-  Validator   validate_;    // nullptr = no validation
-  Handler<Ctx> handler_;    // nullptr for plain data rows; set for multi-env/stateful/exit rows
-
-  // ---- schema-only relations (emitted to the JSON schema for a launcher UI;
-  //      the parser itself does not read these). Set via the chained modifiers
-  //      below so only the few flags that have a relation carry one. ----
-  const char* path_kind_      = nullptr; // "file" | "directory" for a path flag
-  const char* conflicts_with_ = nullptr; // comma-separated flags that cannot be combined with this
-  const char* requires_any_   = nullptr; // comma-separated flags, at least one of which must be active
-  const char* choices_from_   = nullptr; // dynamic choice source resolved by the client, e.g. "metric-groups"
-  bool        schema_omit_    = false;   // stays in --help and dispatch, but excluded from the JSON schema
-
-  constexpr CliOption PathFile() const { CliOption o = *this; o.path_kind_ = "file";      return o; }
-  constexpr CliOption PathDir()  const { CliOption o = *this; o.path_kind_ = "directory"; return o; }
-  constexpr CliOption Conflicts(const char* c) const { CliOption o = *this; o.conflicts_with_ = c; return o; }
-  constexpr CliOption Requires(const char* r)  const { CliOption o = *this; o.requires_any_   = r; return o; }
-  constexpr CliOption ChoicesFrom(const char* c) const { CliOption o = *this; o.choices_from_ = c; return o; }
-  constexpr CliOption SchemaOmit() const { CliOption o = *this; o.schema_omit_ = true; return o; }
-};
-
-// Factories for the CliOption<Ctx> rows of an option table. Bind Ctx once with
-// `using Opt = cli::Factory<MyCtx>;`, then build rows as Opt::Bool(...), Opt::Value(...).
-template <typename Ctx>
-struct Factory {
-  using Opt = CliOption<Ctx>;
-  using HandlerFn = Handler<Ctx>;
-
-  // Boolean switch (no value) that sets `env` to "1".
-  static constexpr Opt Bool(const char* name, const char* alias, const char* group,
-                            const char* help, const char* env, bool hidden = false) {
-    return {name, alias, "bool", false, group, nullptr, "false", nullptr, hidden, help, env, nullptr, nullptr};
-  }
-
-  // Boolean switch whose behavior is a handler (multi-env / stateful), not an env var.
-  static constexpr Opt BoolH(const char* name, const char* alias, const char* group,
-                             const char* help, HandlerFn handler, bool hidden = false) {
-    return {name, alias, "bool", false, group, nullptr, "false", nullptr, hidden, help, nullptr, nullptr, handler};
-  }
-
-  // Value flag (takes the next argv token) that sets `env` to that value.
-  static constexpr Opt Value(const char* name, const char* alias, const char* type,
-                             const char* group, const char* value_hint, const char* help,
-                             const char* env, Validator validate = nullptr,
-                             const char* def = nullptr, const char* choices = nullptr,
-                             bool hidden = false) {
-    return {name, alias, type, true, group, value_hint, def, choices, hidden, help, env, validate, nullptr};
-  }
-
-  // Value flag whose behavior is a handler (multi-env / stateful), not an env var.
-  static constexpr Opt ValueH(const char* name, const char* alias, const char* type,
-                              const char* group, const char* value_hint, const char* help,
-                              HandlerFn handler) {
-    return {name, alias, type, true, group, value_hint, nullptr, nullptr, false, help, nullptr, nullptr, handler};
-  }
-
-  // Print-and-exit flag (no value): the handler prints and returns Status::ExitOk.
-  static constexpr Opt Action(const char* name, const char* group, const char* help,
-                              HandlerFn handler, bool hidden = false) {
-    return {name, nullptr, "action", false, group, nullptr, nullptr, nullptr, hidden, help, nullptr, nullptr, handler};
-  }
-};
-
-// Group id -> human label, for a launcher form's section headers.
-struct CliGroup { const char* id_; const char* label_; };
-
-// Match an argv token against a flag name or its short alias.
-template <typename Ctx>
-inline const CliOption<Ctx>* Lookup(const CliOption<Ctx>* table, size_t n, const char* arg) {
-  for (size_t i = 0; i < n; ++i) {
-    const CliOption<Ctx>& o = table[i];
-    if (strcmp(arg, o.name_) == 0 || (o.alias_ && strcmp(arg, o.alias_) == 0)) {
-      return &o;
-    }
-  }
-  return nullptr;
-}
-
-// Generic dispatch loop. Returns >0 (app_index, where the app begins), 0
-// (handled and exited cleanly, e.g. --help), or -1 (command-line error).
-// Callers with post-loop logic (defaults, conflict checks) run it themselves
-// after a positive app_index -- that's caller-specific, not engine logic.
-template <typename Ctx>
-int ParseArgs(int argc, char* argv[], const CliOption<Ctx>* table, size_t n, Ctx& ctx) {
-  int app_index = 1;
-  for (int i = 1; i < argc; ++i) {
-    const CliOption<Ctx>* o = Lookup<Ctx>(table, n, argv[i]);
-    if (!o) {
-      break;  // first token that is not a known flag => the application begins here
-    }
-
-    // Resolved before dispatch so handlers and SetEnv never see a null value.
-    const char* value = "1";  // valueless rows (bool/action) keep this
-    if (o->takes_value_) {
-      if (++i >= argc) {
-        std::cerr << "[ERROR] Option " << o->name_ << " requires a value" << std::endl;
-        return -1;
-      }
-      value = argv[i];
-      if (o->validate_ && !o->validate_(value)) {
-        std::cerr << "[ERROR] Invalid value for " << o->name_ << ": " << value << std::endl;
-        return -1;
-      }
-    }
-
-    if (o->handler_) {
-      switch (o->handler_(ctx, *o, value)) {
-        case Status::Error:  return -1;
-        case Status::ExitOk: return 0;
-        case Status::Ok:     break;
-      }
-    } else if (o->env_) {
-      utils::SetEnv(o->env_, value);
-    }
-
-    app_index += o->takes_value_ ? 2 : 1;
-  }
-
-  return app_index;
-}
-
-inline std::string PadRight(std::string s, size_t width) {
-  s.append((s.size() < width) ? (width - s.size()) : 1, ' ');
-  return s;
-}
-
-// Print --help text: name [alias] <value-hint>, padded, then the help string.
-// Skips hidden rows.
-template <typename Ctx>
-void Usage(std::ostream& os, const char* progname, const CliOption<Ctx>* table, size_t n) {
-  os << "Usage: " << progname << " [options] <application> <args>" << std::endl;
-  os << "Options:" << std::endl;
-  for (size_t i = 0; i < n; ++i) {
-    const CliOption<Ctx>& o = table[i];
-    if (o.hidden_) {
-      continue;
-    }
-    std::string left = o.name_;
-    if (o.alias_) {
-      left += std::string(" [") + o.alias_ + "]";
-    }
-    if (o.value_hint_) {
-      left += std::string(" <") + o.value_hint_ + ">";
-    }
-    os << PadRight(left, 34) << o.help_ << std::endl;
-  }
-}
-
-inline void JsonEscape(std::ostream& os, const char* s) {
-  os << ::JsonString(s ? s : "");
-}
-
-// Emit a comma-separated list (e.g. "0,1" or "--a,--b") as a JSON string array.
-inline void JsonStringArray(std::ostream& os, const char* csv) {
-  os << "[";
-  std::string s = csv;
-  size_t start = 0;
-  bool first = true;
-  while (start <= s.size()) {
-    size_t comma = s.find(',', start);
-    std::string one = (comma == std::string::npos)
-        ? s.substr(start) : s.substr(start, comma - start);
-    if (!first) {
-      os << ", ";
-    }
-    first = false;
-    JsonEscape(os, one.c_str());
-    if (comma == std::string::npos) {
-      break;
-    }
-    start = comma + 1;
-  }
-  os << "]";
-}
-
-// Emit the option schema as JSON: flag attributes, group labels, and the
-// schema-only relations set via CliOption's chained modifiers. SchemaOmit()
-// flags are excluded. `header` lets the caller prepend its own top-level
-// fields (schemaVersion, tool version, ...) before groups/flags.
-template <typename Ctx>
-void PrintOptionsSchema(std::ostream& os, const CliGroup* groups, size_t n_groups,
-                        const CliOption<Ctx>* table, size_t n_flags,
-                        const std::string& header) {
-  os << "{\n";
-  os << header;
-  os << "  \"groups\": [\n";
-  bool first_group = true;
-  for (size_t i = 0; i < n_groups; ++i) {
-    const CliGroup& g = groups[i];
-    if (!first_group) {
-      os << ",\n";
-    }
-    first_group = false;
-    os << "    {\"id\": ";  JsonEscape(os, g.id_);
-    os << ", \"label\": ";  JsonEscape(os, g.label_);
-    os << "}";
-  }
-  os << "\n  ],\n";
-  os << "  \"flags\": [\n";
-  bool first = true;
-  for (size_t i = 0; i < n_flags; ++i) {
-    const CliOption<Ctx>& o = table[i];
-    if (o.schema_omit_) {
-      continue;  // in --help and dispatch, but not the machine schema
-    }
-    if (!first) {
-      os << ",\n";
-    }
-    first = false;
-    os << "    {";
-    os << "\"name\": ";  JsonEscape(os, o.name_);
-    if (o.alias_) {
-      os << ", \"alias\": ";  JsonEscape(os, o.alias_);
-    }
-    os << ", \"type\": ";   JsonEscape(os, o.type_);
-    os << ", \"group\": ";  JsonEscape(os, o.group_);
-    if (o.value_hint_) {
-      os << ", \"valueHint\": ";  JsonEscape(os, o.value_hint_);
-    }
-    if (o.def_) {
-      os << ", \"default\": ";  JsonEscape(os, o.def_);
-    }
-    if (o.choices_) {
-      os << ", \"choices\": ";  JsonStringArray(os, o.choices_);
-    }
-    if (o.path_kind_) {
-      os << ", \"pathKind\": ";  JsonEscape(os, o.path_kind_);
-    }
-    if (o.conflicts_with_) {
-      os << ", \"conflictsWith\": ";  JsonStringArray(os, o.conflicts_with_);
-    }
-    if (o.requires_any_) {
-      os << ", \"requires\": ";  JsonStringArray(os, o.requires_any_);
-    }
-    if (o.choices_from_) {
-      os << ", \"choicesFrom\": ";  JsonEscape(os, o.choices_from_);
-    }
-    if (o.hidden_) {
-      os << ", \"hidden\": true";
-    }
-    if (o.help_) {
-      os << ", \"help\": ";  JsonEscape(os, o.help_);
-    }
-    os << "}";
-  }
-  os << "\n  ]\n}\n";
-}
-
-}  // namespace cli
-
-#endif  // PTI_TOOLS_UNITRACE_UTILS_CLI_OPTIONS_H_
diff --git a/tools/unitrace/src/utils/config_node.h b/tools/unitrace/src/utils/config_node.h
deleted file mode 100644
index e03ce097..00000000
--- a/tools/unitrace/src/utils/config_node.h
+++ /dev/null
@@ -1,589 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_CONFIG_NODE_H_
-#define UNITRACE_UTILS_CONFIG_NODE_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <fstream>
-#include <functional>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-enum class AttributeType{
-  STRING,
-  UNSIGNED_64,
-  INT,
-  DOUBLE,
-  BOOL,
-  UNSIGNED_64_RANGE_LIST
-};
-
-namespace config_node_detail {
-
-inline std::string Trim(const std::string& input) {
-  size_t begin = 0;
-  while (begin < input.size() && std::isspace(static_cast<unsigned char>(input[begin]))) {
-    ++begin;
-  }
-  size_t end = input.size();
-  while (end > begin && std::isspace(static_cast<unsigned char>(input[end - 1]))) {
-    --end;
-  }
-  return input.substr(begin, end - begin);
-}
-
-// Strict decimal parse: the whole string must be digits and fit in uint64_t.
-inline bool ParseU64(const std::string& str, uint64_t& out) {
-  if (str.empty() ||
-      !std::all_of(str.begin(), str.end(), [](unsigned char c) { return std::isdigit(c); })) {
-    return false;
-  }
-  try {
-    size_t pos = 0;
-    out = std::stoull(str, &pos, 10);
-    return pos == str.size();
-  } catch (const std::exception&) {
-    return false;
-  }
-}
-
-// Shortest decimal text that parses back to exactly value. Always contains a '.'
-// (e.g. "1.0", "1.0e+20") so that ConfigNode::load reads it back as a decimal.
-inline std::string FormatDouble(double value) {
-  char buf[64];
-  for (int precision = 15; precision <= 17; ++precision) {
-    snprintf(buf, sizeof(buf), "%.*g", precision, value);
-    if (strtod(buf, nullptr) == value) {
-      break;
-    }
-  }
-  std::string str(buf);
-  if (str.find('.') == std::string::npos) {
-    size_t exp = str.find_first_of("eE");
-    if (exp != std::string::npos) {
-      str.insert(exp, ".0");
-    } else if (str.find_first_of("ni") == std::string::npos) {  // not inf/nan
-      str += ".0";
-    }
-  }
-  return str;
-}
-
-// Removes a trailing "# comment", ignoring '#' inside single-quoted strings.
-inline std::string StripComment(const std::string& line) {
-  bool in_quotes = false;
-  for (size_t i = 0; i < line.size(); ++i) {
-    if (line[i] == '\'') {
-      in_quotes = !in_quotes;
-    } else if (line[i] == '#' && !in_quotes) {
-      return line.substr(0, i);
-    }
-  }
-  return line;
-}
-
-// Node names and attribute keys: non-empty, no whitespace or syntax characters.
-inline bool IsValidName(const std::string& name) {
-  if (name.empty()) {
-    return false;
-  }
-  for (unsigned char c : name) {
-    if (std::isspace(c) || c == '{' || c == '}' || c == '=' || c == '#' ||
-        c == '\'' || c == '[' || c == ']') {
-      return false;
-    }
-  }
-  return true;
-}
-
-} // namespace config_node_detail
-
-class Attribute;
-typedef std::shared_ptr<Attribute> AttributePtr;
-
-class Attribute{
-  public:
-    Attribute(const std::string& key, AttributeType type, const std::string &desc) :
-      key(key), type(type), desc(desc) {}
-
-    virtual ~Attribute() = default;
-
-    std::string getKey() const{
-      return key;
-    }
-
-    AttributeType getType() const{
-      return type;
-    }
-
-    virtual std::string getValue() const = 0;
-
-    const std::string &getDesc() const{
-      return desc;
-    }
-
-    // Line in the loaded file; 0 if not loaded from a file.
-    uint32_t getLine() const{
-      return line;
-    }
-
-    void setLine(uint32_t l){
-      line = l;
-    }
-
-  private:
-    std::string key;
-    AttributeType type;
-    std::string desc;
-    uint32_t line = 0;
-};
-
-template <typename T>
-class TemplateAttribute : public Attribute{
-  public:
-    TemplateAttribute(const std::string& key, const T& value , AttributeType type, const std::string &desc = "") : Attribute(key, type, desc), value(value) {}
-
-    std::string getValue() const override{
-      return ConvertToString(value);
-    }
-
-    void setValue(const T& value)  {
-      this->value = value;
-    }
-
-    T getTypedValue() const{
-      return value;
-    }
-
-  protected:
-    static std::string ConvertToString(const std::string& value) {
-      return value;
-    }
-
-    static std::string ConvertToString(const bool& value) {
-      return value ? "true" : "false";
-    }
-
-    static std::string ConvertToString(const double& value) {
-      return config_node_detail::FormatDouble(value);
-    }
-
-    template <typename U>
-    static std::string ConvertToString(const U& value) {
-      return std::to_string(value);
-    }
-
-    T value;
-};
-
-class StringAttribute : public TemplateAttribute<std::string>{
-  public:
-    StringAttribute(const std::string& key, const std::string& value, const std::string &desc = "") : TemplateAttribute<std::string>(key, value, AttributeType::STRING, desc) {}
-};
-
-class IntAttribute : public TemplateAttribute<int>{
-  public:
-    IntAttribute(const std::string& key, int value, const std::string &desc = "") : TemplateAttribute<int>(key, value, AttributeType::INT, desc) {}
-};
-
-class UInt64Attribute : public TemplateAttribute<uint64_t>{
-  public:
-    UInt64Attribute(const std::string& key, uint64_t value, const std::string &desc = "") : TemplateAttribute<uint64_t>(key, value, AttributeType::UNSIGNED_64, desc) {}
-};
-
-class DoubleAttribute : public TemplateAttribute<double>{
-  public:
-    DoubleAttribute(const std::string& key, double value, const std::string &desc = "") : TemplateAttribute<double>(key, value, AttributeType::DOUBLE, desc) {}
-};
-
-class BoolAttribute : public TemplateAttribute<bool>{
-  public:
-    BoolAttribute(const std::string& key, bool value, const std::string &desc = "") : TemplateAttribute<bool>(key, value, AttributeType::BOOL, desc) {}
-};
-
-struct U64Range {
-  uint64_t min;
-  uint64_t max;
-  uint64_t step;
-
-  U64Range(uint64_t min, uint64_t max, uint64_t step) : min(min), max(max), step(step) {}
-
-  // Parses "a,b:c,d:e:f" (step defaults to 1). Ranges must be ascending and
-  // non-overlapping. Returns an empty vector on any syntax error.
-  static std::vector<U64Range> fromString(const std::string& str) {
-    std::vector<U64Range> ranges;
-    size_t start = 0;
-    while (start <= str.size()) {
-      size_t end = str.find(',', start);
-      if (end == std::string::npos) {
-        end = str.size();
-      }
-      std::string rangeStr = config_node_detail::Trim(str.substr(start, end - start));
-
-      std::vector<std::string> parts;
-      size_t pstart = 0;
-      while (true) {
-        size_t colon = rangeStr.find(':', pstart);
-        parts.push_back(config_node_detail::Trim(rangeStr.substr(pstart, colon == std::string::npos ? std::string::npos : colon - pstart)));
-        if (colon == std::string::npos) {
-          break;
-        }
-        pstart = colon + 1;
-      }
-
-      uint64_t min = 0;
-      uint64_t max = 0;
-      uint64_t step = 1;
-      if (parts.size() > 3 ||
-          !config_node_detail::ParseU64(parts[0], min) ||
-          (parts.size() >= 2 && !config_node_detail::ParseU64(parts[1], max)) ||
-          (parts.size() == 3 && !config_node_detail::ParseU64(parts[2], step))) {
-        return {};
-      }
-      if (parts.size() == 1) {
-        max = min;
-      }
-
-      if (min > max || step == 0 ||
-          (!ranges.empty() && min <= ranges.back().max)) {
-        return {};
-      }
-
-      ranges.emplace_back(min, max, step);
-      start = end + 1;
-    }
-    return ranges;
-  }
-};
-
-class U64RangeListAttribute : public Attribute{
-  public:
-
-    U64RangeListAttribute(const std::string& key,
-                          const std::vector<U64Range>& ranges,
-                          const std::string &desc = "") :
-      Attribute(key, AttributeType::UNSIGNED_64_RANGE_LIST, desc),
-      ranges_(ranges) {
-      assert(!ranges_.empty());
-    }
-
-    std::string getValue() const override{
-      std::string result = "[";
-      for (const auto& range : ranges_) {
-        result += std::to_string(range.min);
-        if (range.max > range.min) {
-          result += ":" + std::to_string(range.max);
-          if (range.step != 1) {
-            result += ":" + std::to_string(range.step);
-          }
-        }
-        if (&range != &ranges_.back()) {
-          result += ",";
-        }
-      }
-      result += "]";
-      return result;
-    }
-
-    uint64_t getMin() const {
-      return ranges_.front().min;
-    }
-    uint64_t getMax() const {
-      return ranges_.back().max;
-    }
-    // Sets next to the value following current. Returns false when current is the last value.
-    bool getNext(uint64_t current, uint64_t& next) const {
-      for (const auto& range : ranges_) {
-        if (current < range.min) {
-          next = range.min;
-          return true;
-        }
-        if (current < range.max && range.max - current >= range.step) {
-          next = current + range.step;
-          return true;
-        }
-      }
-      return false;
-    }
-private:
-    std::vector<U64Range> ranges_;
-};
-
-class ConfigNode;
-typedef std::shared_ptr<ConfigNode> ConfigNodePtr;
-
-class ConfigNode{
-  public:
-    // Parses a config file. The syntax is:
-    //   <name>{            opens a node (one per line)
-    //   }                  closes the innermost node
-    //   <key>=<value>      attribute of the innermost node
-    //   # ...              comment, to the end of the line (not inside '...')
-    // A value is true/false, an unsigned integer, a negative integer, a decimal
-    // number (contains '.'), a quoted string '...', or a range list [a,b:c,d:e:f].
-    // Returns the root node (unnamed, holding the top-level nodes), or nullptr with
-    // error set to "<filename>:<line>: <reason>". Only the syntax is checked here;
-    // see metric_config_validator.h for the structure of a metric config file.
-    static ConfigNodePtr load(const std::string& filename, std::string& error){
-      error.clear();
-      std::ifstream fp(filename);
-      if (!fp.is_open()) {
-        error = filename + ": cannot open file";
-        return nullptr;
-      }
-
-      std::vector<ConfigNodePtr> nodeStack;
-      ConfigNodePtr root = std::make_shared<ConfigNode>("");
-      nodeStack.push_back(root);
-      uint32_t lineNumber = 0;
-
-      auto fail = [&](const std::string& reason) -> ConfigNodePtr {
-        error = filename + ":" + std::to_string(lineNumber) + ": " + reason;
-        return nullptr;
-      };
-
-      std::string line;
-      while (std::getline(fp, line)) {
-        ++lineNumber;
-
-        while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) {
-          line.pop_back();
-        }
-
-        std::string content = config_node_detail::Trim(config_node_detail::StripComment(line));
-        if (content.empty()) {
-          continue;
-        }
-
-        if (content == "}") {
-          if (nodeStack.size() <= 1) {
-            return fail("'}' without a matching '{'");
-          }
-          nodeStack.pop_back();
-          continue;
-        }
-        ConfigNodePtr currentNode = nodeStack.back();
-
-        if (content.back() == '{') {
-          std::string childName = config_node_detail::Trim(content.substr(0, content.size() - 1));
-          if (!config_node_detail::IsValidName(childName)) {
-            return fail("invalid node name '" + childName + "'");
-          }
-          ConfigNodePtr child = std::make_shared<ConfigNode>(childName);
-          child->line = lineNumber;
-          currentNode->addChild(child);
-          nodeStack.push_back(child);
-          continue;
-        }
-
-        size_t equalPos = content.find('=');
-        if (equalPos == std::string::npos) {
-          return fail("expected '<name>{', '}' or '<key>=<value>', found '" + content + "'");
-        }
-
-        std::string key = config_node_detail::Trim(content.substr(0, equalPos));
-        std::string value = config_node_detail::Trim(content.substr(equalPos + 1));
-
-        if (!config_node_detail::IsValidName(key)) {
-          return fail("invalid key '" + key + "'");
-        }
-        if (value.empty()) {
-          return fail("missing value for '" + key + "'");
-        }
-
-        AttributePtr attr;
-        if (value.size() >= 2 && value.front() == '\'' && value.back() == '\'') {
-          attr = std::make_shared<StringAttribute>(key, value.substr(1, value.size() - 2));
-        } else if (value.front() == '[' || value.back() == ']') {
-          std::vector<U64Range> ranges;
-          if (value.size() >= 2 && value.front() == '[' && value.back() == ']') {
-            ranges = U64Range::fromString(value.substr(1, value.size() - 2));
-          }
-          if (ranges.empty()) {
-            return fail("invalid range list '" + value + "' for '" + key +
-                        "' (expected e.g. [0,2,4:8] or [0:16:4], ascending and not overlapping)");
-          }
-          attr = std::make_shared<U64RangeListAttribute>(key, ranges);
-        } else if (value == "true") {
-          attr = std::make_shared<BoolAttribute>(key, true);
-        } else if (value == "false") {
-          attr = std::make_shared<BoolAttribute>(key, false);
-        } else if (value.find('.') != std::string::npos) {
-          try {
-            size_t pos = 0;
-            double doubleValue = std::stod(value, &pos);
-            if (pos != value.size()) {
-              throw std::invalid_argument(value);
-            }
-            attr = std::make_shared<DoubleAttribute>(key, doubleValue);
-          } catch (const std::exception&) {
-            return fail("invalid decimal value '" + value + "' for '" + key + "'");
-          }
-        } else if (value.front() == '-') {
-          try {
-            size_t pos = 0;
-            int intValue = std::stoi(value, &pos);
-            if (pos != value.size()) {
-              throw std::invalid_argument(value);
-            }
-            attr = std::make_shared<IntAttribute>(key, intValue);
-          } catch (const std::exception&) {
-            return fail("invalid integer value '" + value + "' for '" + key + "'");
-          }
-        } else {
-          uint64_t uint64Value = 0;
-          if (!config_node_detail::ParseU64(value, uint64Value)) {
-            return fail("invalid value '" + value + "' for '" + key +
-                        "' (expected true/false, a number, '<string>' or a range list)");
-          }
-          attr = std::make_shared<UInt64Attribute>(key, uint64Value);
-        }
-        attr->setLine(lineNumber);
-        currentNode->addAttribute(attr);
-      }
-
-      if (nodeStack.size() > 1) {
-        lineNumber = nodeStack.back()->line;
-        return fail("'" + nodeStack.back()->name + "{' is not closed");
-      }
-
-      return root;
-    }
-
-    // Same as load(filename, error), printing the error to stderr.
-    static ConfigNodePtr load(const std::string& filename){
-      std::string error;
-      ConfigNodePtr root = load(filename, error);
-      if (root == nullptr) {
-        fprintf(stderr, "[ERROR] %s\n", error.c_str());
-      }
-      return root;
-    }
-
-    // Returns false if the file cannot be created or written.
-    static bool save(const ConfigNodePtr root, const std::string& filename){
-      //save the configNode object to file in the same format as described in load function
-      FILE *fp = fopen(filename.c_str(), "wt");
-      if (!fp) {
-        fprintf(stderr, "Could not open %s for writing\n", filename.c_str());
-        return false;
-      }
-
-      std::function<void(const ConfigNodePtr, int)> writeConfigNode = [&](const ConfigNodePtr node, int indent) {
-
-        fprintf(fp, "%*s%s{\n", indent, "", node->name.c_str());
-
-        for (const auto& attr : node->getAttributes()) {
-          if (attr->getDesc().size() > 0) {
-            fprintf(fp, "%*s# %s\n", indent + 4, "", attr->getDesc().c_str());
-          }
-
-          if (attr->getType() == AttributeType::STRING) {
-            fprintf(fp, "%*s%s='%s'\n", indent + 4, "", attr->getKey().c_str(), attr->getValue().c_str());
-          } else {
-            fprintf(fp, "%*s%s=%s\n", indent + 4, "", attr->getKey().c_str(), attr->getValue().c_str());
-          }
-        }
-        for (const auto& child : node->getChildren()) {
-          writeConfigNode(child, indent + 4);
-        }
-
-        fprintf(fp, "%*s}\n", indent, "");
-      };
-
-      for (const auto& child : root->getChildren()) {
-        writeConfigNode(child, 0);
-      }
-
-      bool ok = (ferror(fp) == 0);
-      if (fclose(fp) != 0) {
-        ok = false;
-      }
-      if (!ok) {
-        fprintf(stderr, "Failed to write %s\n", filename.c_str());
-      }
-      return ok;
-    }
-
-    const std::string& getName() const{
-      return name;
-    }
-
-    // Line in the loaded file; 0 for the root or if not loaded from a file.
-    uint32_t getLine() const{
-      return line;
-    }
-
-    const std::vector<AttributePtr>& getAttributes() const{
-      return attributes;
-    }
-
-    const std::vector<ConfigNodePtr>& getChildren() const{
-      return children;
-    }
-
-    ConfigNodePtr findChildByName(const std::string& childName) const{
-      ConfigNodePtr result = nullptr;
-      for (const auto& child : children) {
-        if (child->getName().compare(childName) == 0) {
-          if(result != nullptr) {
-            fprintf(stderr, "[WARNING] Multiple children with name %s found. Returning the first one.\n", childName.c_str());
-            return result;
-          }
-          result =  child;
-        }
-      }
-      return result;
-    }
-
-    std::vector<ConfigNodePtr> findChildrenByName(const std::string& childName) const{
-      std::vector<ConfigNodePtr> result;
-      for (const auto& child : children) {
-        if (child->getName().compare(childName) == 0) {
-          result.push_back(child);
-        }
-      }
-      return result;
-    }
-
-    AttributePtr findAttributeByKey(const std::string& key) const{
-      for (const auto& attr : attributes) {
-        if (attr->getKey().compare(key) == 0) {
-          return attr;
-        }
-      }
-      return nullptr;
-    }
-
-    ~ConfigNode() = default;
-
-    void addAttribute(AttributePtr attr){
-      attributes.push_back(attr);
-    }
-
-    void addChild(ConfigNodePtr child){
-      children.push_back(child);
-    }
-
-    ConfigNode(std::string name) : name(name) {}
-    ConfigNode() : name("") {}
-
-  private:
-    std::string name;
-    uint32_t line = 0;
-    std::vector<AttributePtr> attributes;
-    std::vector<ConfigNodePtr> children;
-};
-
-#endif  // UNITRACE_UTILS_CONFIG_NODE_H_
diff --git a/tools/unitrace/src/utils/elf64_reader.h b/tools/unitrace/src/utils/elf64_reader.h
deleted file mode 100644
index 2304a452..00000000
--- a/tools/unitrace/src/utils/elf64_reader.h
+++ /dev/null
@@ -1,524 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// ELF64 Reading
-//
-// Reads the ELF64 container of a ZeBin module binary: identifies it, walks the section
-// header table and resolves section names. Finding a kernel's ISA (kernel_extractor.h)
-// and its line table (source_resolver.h) both start here. Section contents are returned
-// as raw bytes.
-//
-// The structures are read per the gABI rather than through <elf.h>, which Windows lacks.
-// Every offset and length from the file is bounds-checked, since a truncated file can
-// claim sections that are not there.
-//
-// References:
-//   System V ABI, Chapter 4: Object Files (ELF)
-//   https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
-//   Intel Graphics Compiler, the ZEBIN specification; elf.md covers the container
-//   https://github.com/intel/intel-graphics-compiler/tree/master/IGC/ZEBinWriter/zebin/spec
-//
-//==============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_ELF64_READER_H_
-#define PTI_TOOLS_UNITRACE_UTILS_ELF64_READER_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <string_view>
-#include <vector>
-
-// ---------------------------------------------------------------------------
-// Reading bytes safely
-//
-// Bounds-checked primitives, also used by callers decoding section contents.
-// ---------------------------------------------------------------------------
-
-// Is [offset, offset + length) inside a buffer of total bytes? Written so it cannot
-// overflow, since both values come from the file.
-inline bool Elf64RangeInBounds(uint64_t offset, uint64_t length, uint64_t total) {
-  return length <= total && offset <= total - length;
-}
-
-// Little-endian reads, byte by byte so the result does not depend on host byte order.
-inline uint16_t Elf64ReadU16(const uint8_t* p) {
-  return static_cast<uint16_t>(static_cast<uint16_t>(p[0]) | (static_cast<uint16_t>(p[1]) << 8));
-}
-
-inline uint32_t Elf64ReadU32(const uint8_t* p) {
-  return static_cast<uint32_t>(p[0]) | (static_cast<uint32_t>(p[1]) << 8) |
-         (static_cast<uint32_t>(p[2]) << 16) | (static_cast<uint32_t>(p[3]) << 24);
-}
-
-inline uint64_t Elf64ReadU64(const uint8_t* p) {
-  return static_cast<uint64_t>(Elf64ReadU32(p)) |
-         (static_cast<uint64_t>(Elf64ReadU32(p + 4)) << 32);
-}
-
-// The NUL ending the string at data, or nullptr if there is none within length bytes.
-// A zero length does not touch data, which may then be null or one past the end.
-inline const uint8_t* FindNul(const uint8_t* data, uint64_t length) {
-  if (length == 0) {
-    return nullptr;
-  }
-  return static_cast<const uint8_t*>(std::memchr(data, 0, static_cast<size_t>(length)));
-}
-
-// A position in a buffer that cannot move outside it. Errors are sticky: after a
-// failure every read returns zero, so a caller decoding byte code (e.g. a DWARF line
-// program) checks Ok() once rather than after every operand.
-class ByteCursor {
- public:
-  ByteCursor(const uint8_t* data, uint64_t size) : data_(data), size_(size) {
-    if (data_ == nullptr) {
-      size_ = 0;
-    }
-  }
-
-  bool Ok() const { return !failed_; }
-  uint64_t Offset() const { return pos_; }
-  uint64_t Size() const { return size_; }
-  // Has the cursor reached the end, or failed trying?
-  bool Done() const { return failed_ || pos_ >= size_; }
-
-  void Seek(uint64_t pos) {
-    if (pos > size_) {
-      failed_ = true;
-      return;
-    }
-    pos_ = pos;
-  }
-
-  // Returns count bytes and advances past them, or fails. Every fixed-width read goes
-  // through it; String() does its own bounds check.
-  const uint8_t* Take(uint64_t count) {
-    if (failed_ || count > size_ - pos_) {
-      failed_ = true;
-      return nullptr;
-    }
-    const uint8_t* p = data_ + pos_;
-    pos_ += count;
-    return p;
-  }
-
-  void Skip(uint64_t count) { (void)Take(count); }
-
-  uint8_t U8() {
-    const uint8_t* p = Take(1);
-    return (p == nullptr) ? 0 : p[0];
-  }
-
-  int8_t I8() { return static_cast<int8_t>(U8()); }
-
-  uint16_t U16() {
-    const uint8_t* p = Take(2);
-    return (p == nullptr) ? 0 : Elf64ReadU16(p);
-  }
-
-  uint32_t U32() {
-    const uint8_t* p = Take(4);
-    return (p == nullptr) ? 0 : Elf64ReadU32(p);
-  }
-
-  uint64_t U64() {
-    const uint8_t* p = Take(8);
-    return (p == nullptr) ? 0 : Elf64ReadU64(p);
-  }
-
-  // An address of address_size (1 to 8) bytes; any other size fails.
-  uint64_t Address(uint8_t address_size) {
-    if (address_size == 0 || address_size > 8) {
-      failed_ = true;
-      return 0;
-    }
-    const uint8_t* p = Take(address_size);
-    if (p == nullptr) {
-      return 0;
-    }
-    uint64_t value = 0;
-    for (unsigned i = 0; i < address_size; ++i) {
-      value |= static_cast<uint64_t>(p[i]) << (8 * i);
-    }
-    return value;
-  }
-
-  // Unsigned LEB128. Padding (extra 0x80 bytes) can take shift past 63, and shifting
-  // by 64 or more is undefined, so bits past 63 are dropped and over ten bytes fail.
-  uint64_t Uleb() {
-    // Fast path: most ULEBs in IGC's .debug_line are one byte.
-    if (!failed_ && pos_ < size_ && (data_[pos_] & 0x80) == 0) {
-      return data_[pos_++];
-    }
-    uint64_t result = 0;
-    unsigned shift = 0;
-    for (;;) {
-      const uint8_t byte = U8();
-      if (failed_) {
-        return 0;
-      }
-      if (shift < 64) {
-        result |= static_cast<uint64_t>(byte & 0x7F) << shift;
-      }
-      if ((byte & 0x80) == 0) {
-        break;
-      }
-      shift += 7;
-      if (shift > 64) {
-        failed_ = true;
-        return 0;
-      }
-    }
-    return result;
-  }
-
-  // Signed LEB128, sign-extended from wherever the encoding stopped.
-  int64_t Sleb() {
-    // Fast path, as in Uleb(): one byte, with bit 6 as the sign.
-    if (!failed_ && pos_ < size_ && (data_[pos_] & 0x80) == 0) {
-      const uint8_t byte = data_[pos_++];
-      return static_cast<int64_t>(((byte & 0x40) != 0) ? (byte | ~static_cast<uint64_t>(0x7F))
-                                                       : byte);
-    }
-    uint64_t result = 0;
-    unsigned shift = 0;
-    uint8_t byte = 0;
-    do {
-      byte = U8();
-      if (failed_) {
-        return 0;
-      }
-      if (shift < 64) {
-        result |= static_cast<uint64_t>(byte & 0x7F) << shift;
-      }
-      shift += 7;
-      if (shift > 71) {
-        failed_ = true;
-        return 0;
-      }
-    } while ((byte & 0x80) != 0);
-    if (shift < 64 && (byte & 0x40) != 0) {
-      result |= ~static_cast<uint64_t>(0) << shift;
-    }
-    return static_cast<int64_t>(result);
-  }
-
-  // A NUL-terminated string; fails if the terminator is not inside the buffer.
-  bool String(std::string& out) {
-    if (failed_) {
-      return false;
-    }
-    const uint8_t* terminator = FindNul(data_ + pos_, size_ - pos_);
-    if (terminator == nullptr) {
-      failed_ = true;
-      return false;
-    }
-    const uint64_t length = static_cast<uint64_t>(terminator - (data_ + pos_));
-    out.assign(reinterpret_cast<const char*>(data_ + pos_), static_cast<size_t>(length));
-    pos_ += length + 1;
-    return true;
-  }
-
- private:
-  const uint8_t* data_ = nullptr;
-  uint64_t size_ = 0;
-  uint64_t pos_ = 0;
-  bool failed_ = false;
-};
-
-// A table of NUL-terminated strings addressed by byte offset, such as the section-name
-// table, .debug_str and .debug_line_str.
-struct StringTableView {
-  const uint8_t* data_ = nullptr;
-  uint64_t size_ = 0;
-
-  // Copies out the string at offset. False, with out untouched, if there is none.
-  bool Get(uint64_t offset, std::string& out) const {
-    const uint8_t* text = nullptr;
-    uint64_t length = 0;
-    if (!Find(offset, text, length)) {
-      return false;
-    }
-    out.assign(reinterpret_cast<const char*>(text), static_cast<size_t>(length));
-    return true;
-  }
-
-  // Is the string at offset equal to text? Like Get(), without the copy.
-  bool Equals(uint64_t offset, const std::string& text) const {
-    const uint8_t* found = nullptr;
-    uint64_t length = 0;
-    if (!Find(offset, found, length)) {
-      return false;  // unterminated or out of bounds
-    }
-    return length == text.size() && std::memcmp(found, text.data(), text.size()) == 0;
-  }
-
-  // The string at offset, as a view into the table. Empty for both an empty string and
-  // none; Get() tells them apart.
-  std::string_view View(uint64_t offset) const {
-    const uint8_t* text = nullptr;
-    uint64_t length = 0;
-    if (!Find(offset, text, length)) {
-      return std::string_view();
-    }
-    return std::string_view(reinterpret_cast<const char*>(text), static_cast<size_t>(length));
-  }
-
- private:
-  // Locates the string at offset, bounded by the table: a truncated table need not
-  // contain a NUL.
-  bool Find(uint64_t offset, const uint8_t*& out_text, uint64_t& out_length) const {
-    if (data_ == nullptr || offset >= size_) {
-      return false;
-    }
-    const uint8_t* terminator = FindNul(data_ + offset, size_ - offset);
-    if (terminator == nullptr) {
-      return false;
-    }
-    out_text = data_ + offset;
-    out_length = static_cast<uint64_t>(terminator - out_text);
-    return true;
-  }
-};
-
-// ---------------------------------------------------------------------------
-// ELF64, only as far as the sections
-// ---------------------------------------------------------------------------
-
-// Field offsets from the gABI, used instead of structs so host alignment and padding
-// do not matter.
-constexpr size_t kElf64MagicSize = 4;         // \x7f E L F
-constexpr size_t kElf64ClassOffset = 4;       // e_ident[EI_CLASS]
-constexpr size_t kElf64DataOffset = 5;        // e_ident[EI_DATA]
-constexpr uint8_t kElf64Class64 = 2;          // ELFCLASS64
-constexpr uint8_t kElf64Data2Lsb = 1;         // ELFDATA2LSB
-
-constexpr size_t kElf64HeaderSize = 64;
-constexpr size_t kElf64MachineOffset = 0x12;    // e_machine,   u16
-constexpr size_t kElf64ShoffOffset = 0x28;      // e_shoff,     u64
-constexpr size_t kElf64ShentsizeOffset = 0x3A;  // e_shentsize, u16
-constexpr size_t kElf64ShnumOffset = 0x3C;      // e_shnum,     u16
-constexpr size_t kElf64ShstrndxOffset = 0x3E;   // e_shstrndx,  u16
-
-constexpr size_t kElf64SectionHeaderSize = 64;
-constexpr size_t kElf64ShNameOffset = 0x00;     // sh_name,    u32
-constexpr size_t kElf64ShTypeOffset = 0x04;     // sh_type,    u32
-constexpr size_t kElf64ShOffsetOffset = 0x18;   // sh_offset,  u64
-constexpr size_t kElf64ShSizeOffset = 0x20;     // sh_size,    u64
-constexpr size_t kElf64ShLinkOffset = 0x28;     // sh_link,    u32
-constexpr size_t kElf64ShInfoOffset = 0x2C;     // sh_info,    u32
-constexpr size_t kElf64ShEntSizeOffset = 0x38;  // sh_entsize, u64
-
-// Elf64_Sym and Elf64_Rel/Elf64_Rela, for callers reading symbol or relocation tables.
-constexpr uint64_t kElf64SymSize = 24;
-constexpr size_t kElf64SymNameOffset = 0x00;   // st_name,  u32 (into sh_link's table)
-constexpr size_t kElf64SymShndxOffset = 0x06;  // st_shndx, u16
-constexpr size_t kElf64SymValueOffset = 0x08;  // st_value, u64
-constexpr uint64_t kElf64RelaSize = 24;
-constexpr uint64_t kElf64RelSize = 16;
-constexpr size_t kElf64RelOffsetOffset = 0x00;   // r_offset, u64
-constexpr size_t kElf64RelInfoOffset = 0x08;     // r_info,   u64
-constexpr size_t kElf64RelaAddendOffset = 0x10;  // r_addend, i64 (SHT_RELA only)
-
-constexpr uint32_t kElf64ShtNoBits = 8;    // SHT_NOBITS: occupies no file space
-constexpr uint32_t kElf64ShtRela = 4;      // SHT_RELA
-constexpr uint32_t kElf64ShtRel = 9;       // SHT_REL
-constexpr uint16_t kElf64ShnUndef = 0;     // SHN_UNDEF
-constexpr uint16_t kElf64ShnXindex = 0xFFFF;  // SHN_XINDEX: the real index is elsewhere
-
-// One section, as a view into the buffer it was read from. Non-owning: valid only
-// while that buffer is alive and unmodified.
-struct Elf64Section {
-  // A view into the section-name table, not NUL-terminated.
-  std::string_view name_;
-  uint32_t type_ = 0;
-  uint32_t link_ = 0;
-  uint32_t info_ = 0;
-  uint64_t entry_size_ = 0;
-  // As recorded in the header, even if outside the buffer, so a caller can report it.
-  uint64_t file_offset_ = 0;
-  uint64_t size_ = 0;
-  // The contents, or nullptr for SHT_NOBITS or a range outside the buffer.
-  const uint8_t* data_ = nullptr;
-
-  bool HasContents() const { return data_ != nullptr && size_ != 0; }
-};
-
-// Why reading the sections failed. kNotElf is not always an error: a pre-ZeBin module
-// binary is raw ISA with no container.
-enum class Elf64Status {
-  kOk,
-  kNotElf,            // No ELF magic
-  kNotElf64,          // Not ELFCLASS64
-  kNotLittleEndian,   // Not ELFDATA2LSB
-  kMalformed,         // Truncated, or a header that does not describe this file
-};
-
-// Reads the section header table into out_sections, indexed as in the file (entry 0 is
-// the null section), since relocations and symbols refer to sections by index.
-//
-// A section whose range is outside the buffer is kept with no contents; the read fails
-// only if the header or the section table is bad. Every failure, kNotElf included, is
-// reported on std::cerr as "[WARNING] ..."; the status says which it was.
-inline Elf64Status ReadElf64Sections(const uint8_t* binary, size_t binary_size,
-                                     std::vector<Elf64Section>& out_sections) {
-  auto fail = [](Elf64Status status, const char* message) {
-    std::cerr << "[WARNING] Cannot read ELF sections: " << message << std::endl;
-    return status;
-  };
-
-  out_sections.clear();
-  const uint64_t total = static_cast<uint64_t>(binary_size);
-  if (binary == nullptr || total < kElf64HeaderSize) {
-    return fail(Elf64Status::kNotElf, "binary is empty or too small to be an ELF container");
-  }
-  static const uint8_t kMagic[kElf64MagicSize] = {0x7F, 'E', 'L', 'F'};
-  for (size_t i = 0; i < kElf64MagicSize; ++i) {
-    if (binary[i] != kMagic[i]) {
-      // a pre-ZeBin module binary is raw ISA
-      return fail(Elf64Status::kNotElf, "binary is not an ELF container (raw ISA?)");
-    }
-  }
-  // Only ELF64 little-endian is read. elf.md requires ELFDATA2LSB but allows ELFCLASS32,
-  // which is refused: the ELF64 offsets above would silently misread it.
-  if (binary[kElf64ClassOffset] != kElf64Class64) {
-    return fail(Elf64Status::kNotElf64, "ELF container is not 64-bit");
-  }
-  if (binary[kElf64DataOffset] != kElf64Data2Lsb) {
-    return fail(Elf64Status::kNotLittleEndian, "ELF container is not little-endian");
-  }
-
-  ByteCursor header(binary, total);
-  header.Seek(kElf64ShoffOffset);
-  const uint64_t table_offset = header.U64();
-  header.Seek(kElf64ShentsizeOffset);
-  const uint16_t entry_size = header.U16();
-  uint64_t section_count = header.U16();
-  uint32_t name_table_index = header.U16();
-  if (!header.Ok()) {
-    return fail(Elf64Status::kMalformed, "ELF header is truncated");
-  }
-
-  if (table_offset == 0) {
-    return fail(Elf64Status::kMalformed, "ELF container has no section header table");
-  }
-  // Larger entries are allowed (the stride below honours them); smaller ones overlap.
-  if (entry_size < kElf64SectionHeaderSize) {
-    return fail(Elf64Status::kMalformed, "ELF section header entry is too small");
-  }
-  if (!Elf64RangeInBounds(table_offset, kElf64SectionHeaderSize, total)) {
-    return fail(Elf64Status::kMalformed,
-                "ELF section header table starts past the end of the binary");
-  }
-
-  // With 0xFF00 or more sections, or a name table index that does not fit in 16 bits,
-  // the real values are in the null section's sh_size and sh_link.
-  ByteCursor null_entry(binary, total);
-  null_entry.Seek(table_offset + kElf64ShSizeOffset);
-  const uint64_t null_size = null_entry.U64();
-  null_entry.Seek(table_offset + kElf64ShLinkOffset);
-  const uint32_t null_link = null_entry.U32();
-  if (!null_entry.Ok()) {
-    return fail(Elf64Status::kMalformed, "ELF null section header is truncated");
-  }
-  if (section_count == 0) {
-    section_count = null_size;
-  }
-  if (name_table_index == kElf64ShnXindex) {
-    name_table_index = null_link;
-  }
-
-  if (section_count == 0) {
-    return fail(Elf64Status::kMalformed, "ELF container has no sections");
-  }
-  // Divide rather than multiply: a count from the null section's sh_size is 64 bits,
-  // so count * entry_size can wrap. table_offset <= total was checked above.
-  if (section_count > (total - table_offset) / entry_size) {
-    return fail(Elf64Status::kMalformed,
-                "ELF section header table runs past the end of the binary");
-  }
-  // Sections are found by name, so the name table is required.
-  if (name_table_index == kElf64ShnUndef || name_table_index >= section_count) {
-    return fail(Elf64Status::kMalformed, "ELF container has no valid section name table");
-  }
-
-  // Read the name table first, since it names the sections.
-  const uint64_t name_table_header =
-      table_offset + static_cast<uint64_t>(name_table_index) * entry_size;
-  ByteCursor name_header(binary, total);
-  name_header.Seek(name_table_header + kElf64ShOffsetOffset);
-  const uint64_t name_table_offset = name_header.U64();
-  name_header.Seek(name_table_header + kElf64ShSizeOffset);
-  const uint64_t name_table_size = name_header.U64();
-  if (!name_header.Ok() || name_table_size == 0 ||
-      !Elf64RangeInBounds(name_table_offset, name_table_size, total)) {
-    return fail(Elf64Status::kMalformed, "ELF section name table lies outside the binary");
-  }
-  const StringTableView name_table{binary + name_table_offset, name_table_size};
-
-  out_sections.reserve(static_cast<size_t>(section_count));
-  for (uint64_t i = 0; i < section_count; ++i) {
-    const uint64_t base = table_offset + i * static_cast<uint64_t>(entry_size);
-    // One bounds check for the whole entry covers every field read from it.
-    if (!Elf64RangeInBounds(base, kElf64SectionHeaderSize, total)) {
-      return fail(Elf64Status::kMalformed, "ELF section header is truncated");
-    }
-    const uint8_t* entry = binary + base;
-
-    Elf64Section section;
-    const uint32_t name_offset = Elf64ReadU32(entry + kElf64ShNameOffset);
-    section.type_ = Elf64ReadU32(entry + kElf64ShTypeOffset);
-    section.file_offset_ = Elf64ReadU64(entry + kElf64ShOffsetOffset);
-    section.size_ = Elf64ReadU64(entry + kElf64ShSizeOffset);
-    section.link_ = Elf64ReadU32(entry + kElf64ShLinkOffset);
-    section.info_ = Elf64ReadU32(entry + kElf64ShInfoOffset);
-    section.entry_size_ = Elf64ReadU64(entry + kElf64ShEntSizeOffset);
-
-    // A nameless section is kept, so later indices do not shift.
-    section.name_ = name_table.View(name_offset);
-
-    // SHT_NOBITS occupies no file space, so it has no contents.
-    if (section.type_ != kElf64ShtNoBits && section.size_ != 0 &&
-        Elf64RangeInBounds(section.file_offset_, section.size_, total)) {
-      section.data_ = binary + section.file_offset_;
-    }
-    out_sections.push_back(std::move(section));
-  }
-  return Elf64Status::kOk;
-}
-
-// Returns the table index of the first section named name, or -1.
-inline int64_t FindElf64Section(const std::vector<Elf64Section>& sections,
-                                std::string_view name) {
-  for (size_t i = 0; i < sections.size(); ++i) {
-    if (sections[i].name_ == name) {
-      return static_cast<int64_t>(i);
-    }
-  }
-  return -1;
-}
-
-// ---------------------------------------------------------------------------
-// ZeBin conventions
-// ---------------------------------------------------------------------------
-
-// The e_machine of a ZeBin. Not needed to find sections, but it tells a ZeBin that
-// lacks a section apart from an ELF that is not a ZeBin.
-constexpr uint16_t kElf64MachineIntelGt = 205;  // EM_INTELGT
-
-// A ZeBin has one ".text.<mangled kernel name>" section per kernel, holding its code;
-// the kernel's debug information refers to it by relocation. Code outside the kernel's
-// section (e.g. external functions) is in the module's plain ".text", not read here.
-constexpr const char* kElf64KernelTextSectionPrefix = ".text.";
-
-// The name of a kernel's code section. Takes the mangled name.
-inline std::string Elf64KernelTextSectionName(const std::string& mangled_kernel_name) {
-  return std::string(kElf64KernelTextSectionPrefix) + mangled_kernel_name;
-}
-
-#endif  // PTI_TOOLS_UNITRACE_UTILS_ELF64_READER_H_
diff --git a/tools/unitrace/src/utils/kernel_disassembler.h b/tools/unitrace/src/utils/kernel_disassembler.h
deleted file mode 100644
index ca2b0fa3..00000000
--- a/tools/unitrace/src/utils/kernel_disassembler.h
+++ /dev/null
@@ -1,557 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Kernel ISA Disassembly
-//
-// DisassembleKernelInstructions() turns a kernel's Gen ISA into IGA's whole-kernel
-// listing, the same as "iga64 -d" prints. ConstructDefsAndUses() reads the listing's
-// defs back as records. HexOffset() prints the stall report's offsets.
-//
-// The padding after a kernel's code decodes as "illegal", so it is cut off first
-// (GenCodeSize(), kernel_extractor.h).
-//
-// Failures are reported on std::cerr as "[WARNING] ..." and return false: a kernel
-// that will not disassemble costs its listing, not the trace.
-//
-// References:
-//   iga.h, the IGA C API. The text IGA returns is owned by the context and invalidated
-//   by the next call on it, so it is copied out immediately.
-//
-//==============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_KERNEL_DISASSEMBLER_H_
-#define PTI_TOOLS_UNITRACE_UTILS_KERNEL_DISASSEMBLER_H_
-
-#include <iga/iga.h>
-#include <igc/igfxfmid.h>
-
-#include <cinttypes>
-#include <cstdint>
-#include <cstdio>
-#include <iostream>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "kernel_extractor.h"
-#include "library_loader.h"
-
-// A kernel-relative offset as "0x" and at least 8 hex digits, as the stall report's
-// Offset and Dependency columns print it.
-inline std::string HexOffset(uint64_t offset) {
-  char buf[32];
-  std::snprintf(buf, sizeof(buf), "0x%08" PRIx64, offset);
-  return buf;
-}
-
-// ---------------------------------------------------------------------------
-// Product config or device IP -> IGA architecture
-// ---------------------------------------------------------------------------
-
-// A product config or device IP packs bitfields
-// (compute-runtime NEO::HardwareIpVersion):
-//
-//   bits 31:22  architecture (10 bits)
-//   bits 21:14  release       (8 bits)
-//   bits 13:6   reserved
-//   bits  5:0   revision      (6 bits)
-
-constexpr iga_gen_t ProductConfigToIgaGen(uint32_t product_config) {
-  const uint32_t architecture = (product_config >> 22) & 0x3FF;
-  const uint32_t release = (product_config >> 14) & 0xFF;
-
-  switch (architecture) {
-    case 8:  return IGA_GEN8;
-    case 9:  return IGA_GEN9;
-    case 10: return IGA_GEN10;
-    case 11: return IGA_GEN11;
-    case 12:
-      if (release < 50) return IGA_XE;
-      if (release < 55) return IGA_XE_HP;
-      if (release < 60) return IGA_XE_HPG;
-      if (release < 62) return IGA_XE_HPC;
-      if (release >= 70 && release < 80) return IGA_XE_HPG;
-      return IGA_GEN_INVALID;
-    case 20: return IGA_XE2;
-    case 30: return IGA_XE3;
-    case 35: return IGA_XE3P_XPC;
-    default: return IGA_GEN_INVALID;
-  }
-}
-
-// Maps a GFXCORE_FAMILY (igfxfmid.h) to an iga_gen_t.
-constexpr iga_gen_t GfxCoreFamilyToIgaGen(uint32_t gfx_core_family) {
-  switch (gfx_core_family) {
-    case IGFX_GEN8_CORE:    return IGA_GEN8;
-    case IGFX_GEN9_CORE:    return IGA_GEN9;
-    case IGFX_GEN10_CORE:
-    case IGFX_GEN10LP_CORE: return IGA_GEN10;
-    case IGFX_GEN11_CORE:
-    case IGFX_GEN11LP_CORE: return IGA_GEN11;
-    case IGFX_GEN12_CORE:
-    case IGFX_GEN12LP_CORE: return IGA_XE;
-    case IGFX_XE_HP_CORE:   return IGA_XE_HP;
-    case IGFX_XE_HPG_CORE:  return IGA_XE_HPG;
-    case IGFX_XE_HPC_CORE:  return IGA_XE_HPC;
-    case IGFX_XE2_HPG_CORE: return IGA_XE2;
-    case IGFX_XE3_CORE:     return IGA_XE3;
-    case IGFX_XE3P_CORE:    return IGA_XE3P_XPC;
-    default: {
-      std::cerr << "[WARNING] No IGA architecture found for GFXCORE_FAMILY " << gfx_core_family << std::endl;
-      return IGA_GEN_INVALID;
-    }
-  }
-}
-
-// The architecture a binary was built for: the product config if recorded, which is
-// the finer of the two, else the core family.
-constexpr iga_gen_t ArchitectureToIgaGen(const GenArchitecture& architecture) {
-  if (architecture.product_config_ != 0) {
-    const iga_gen_t gen = ProductConfigToIgaGen(architecture.product_config_);
-    if (gen != IGA_GEN_INVALID) {
-      return gen;
-    }
-  }
-  return GfxCoreFamilyToIgaGen(architecture.gfx_core_family_);
-}
-
-// ---------------------------------------------------------------------------
-// The iga64 library, loaded at runtime
-// ---------------------------------------------------------------------------
-//
-// Loaded rather than linked, so unitrace is not tied to one iga64 version.
-
-// The iga64 library and its entry points. One per process, reached through
-// KernelDisassembler(); not constructible, copyable or movable otherwise.
-class IgaDisassembler {
- public:
-  // Signatures from iga.h. status_to_string_ is optional.
-  iga_status_t (*context_create_)(const iga_context_options_t*, iga_context_t*) = nullptr;
-  iga_status_t (*context_release_)(iga_context_t) = nullptr;
-  iga_status_t (*disassemble_)(iga_context_t, const iga_disassemble_options_t*, const void*,
-                               uint32_t, const char* (*)(int32_t, void*), void*, char**) = nullptr;
-  const char* (*status_to_string_)(iga_status_t) = nullptr;
-  bool available_ = false;
-  // Why not available: no library, or missing entry points.
-  std::string load_error_;
-
-  IgaDisassembler(const IgaDisassembler&) = delete;
-  IgaDisassembler& operator=(const IgaDisassembler&) = delete;
-  IgaDisassembler(IgaDisassembler&&) = delete;
-  IgaDisassembler& operator=(IgaDisassembler&&) = delete;
-
-  // IGA's name for a status, or its number if iga64 cannot name it.
-  std::string Describe(iga_status_t status) const {
-    if (status_to_string_ != nullptr) {
-      const char* text = status_to_string_(status);
-      if (text != nullptr) {
-        return text;
-      }
-    }
-    return "IGA status " + std::to_string(static_cast<int>(status));
-  }
-
- private:
-  friend const IgaDisassembler& KernelDisassembler();
-
-  // Loads the unversioned name only, which comes with the iga64 headers this is built
-  // with; a versioned SONAME alone may be an unrelated IGA.
-  IgaDisassembler() {
-    try {
-      loader_ = LibraryLoader(kLibraryName_);
-    } catch (const std::exception& e) {
-      // iga64 not being installed is not exceptional
-      load_error_ = std::string("cannot load iga64 (") + e.what() + ")";
-      return;
-    }
-
-    Resolve(context_create_, "iga_context_create");
-    Resolve(context_release_, "iga_context_release");
-    Resolve(disassemble_, "iga_context_disassemble");
-    // optional, only for messages
-    Resolve(status_to_string_, "iga_status_to_string");
-
-    available_ = context_create_ != nullptr && context_release_ != nullptr &&
-                 disassemble_ != nullptr;
-    if (!available_) {
-      load_error_ = std::string(kLibraryName_) +
-                    " is missing the disassembly entry points this build needs";
-    }
-  }
-
-  // Resolves symbol into entry_point, typed by the member.
-  template <typename T>
-  void Resolve(T& entry_point, const char* symbol) {
-    entry_point = loader_.GetSymbol<T>(symbol);
-  }
-
-#if defined(_WIN32)
-  static constexpr const char* kLibraryName_ = "iga64.dll";
-#else
-  static constexpr const char* kLibraryName_ = "libiga64.so";
-#endif
-
-  // Kept open, since the entry points are only valid while it is.
-  LibraryLoader loader_;
-};
-
-// The process-wide handle, loaded once, thread-safely, on first use.
-inline const IgaDisassembler& KernelDisassembler() {
-  static const IgaDisassembler instance;
-  return instance;
-}
-
-// ---------------------------------------------------------------------------
-// Disassembly
-// ---------------------------------------------------------------------------
-
-// Disassembles a kernel's Gen ISA, without its padding, into IGA's listing, each
-// instruction prefixed with its kernel-relative PC ("/* [00A0] */"). gen is the
-// architecture to decode as (see ProductConfigToIgaGen()).
-//
-// with_deps (PRINT_DEPS) adds comment lines naming the registers each instruction
-// writes and reads; it roughly doubles the listing and triples the time.
-// with_defs (PRINT_DEFS) names, by "#<id>", the instructions producing each value an
-// instruction reads ("// #12{r10}, IN{r2}", IN for a live-in), and adds the id to the
-// prefix. It is a whole-kernel analysis and much slower than the plain listing.
-//
-// Returns true and fills out_text on success, including a partial listing after a
-// decode error (with a warning). On failure warns and leaves out_text alone.
-inline bool DisassembleKernelInstructions(const uint8_t* isa, size_t isa_size, iga_gen_t gen,
-                                          std::string& out_text, bool with_deps = false,
-                                          bool with_defs = false) {
-  auto fail = [](const std::string& message) {
-    std::cerr << "[WARNING] Unable to disassemble kernel: " << message << std::endl;
-    return false;
-  };
-
-  if (isa == nullptr || isa_size == 0) {
-    return fail("no ISA to disassemble");
-  }
-  if (gen == IGA_GEN_INVALID) {
-    return fail("no architecture to disassemble for");
-  }
-  // IGA takes the size as a uint32_t.
-  if (isa_size > UINT32_MAX) {
-    return fail("the ISA is too large for IGA's disassembly API");
-  }
-  const uint64_t code_size = GenCodeSize(isa, isa_size);
-  if (code_size == 0) {
-    // all padding, or not even one whole instruction
-    if (GenIsaPaddingStart(isa, isa_size) == 0) {
-      return fail("the ISA is all zeros: padding, with no code in it");
-    }
-    return fail("the ISA holds no complete instruction (is it Gen ISA?)");
-  }
-
-  const IgaDisassembler& iga = KernelDisassembler();
-  if (!iga.available_) {
-    return fail(iga.load_error_);
-  }
-
-  // One context per call: contexts are not thread-safe and own the returned text.
-  iga_context_options_t context_options = IGA_CONTEXT_OPTIONS_INIT(gen);
-  iga_context_t context = nullptr;
-  const iga_status_t created = iga.context_create_(&context_options, &context);
-  if (created != IGA_SUCCESS || context == nullptr) {
-    return fail("iga_context_create failed for this architecture: " + iga.Describe(created));
-  }
-
-  // Not IGA_DISASSEMBLE_OPTIONS_INIT(), which leaves base_pc_offset out and trips
-  // -Wextra. PRINT_BFNEXPRS matches "iga64 -d".
-  iga_disassemble_options_t options = {};
-  options.cb = sizeof(options);
-  options.formatting_opts = IGA_FORMATTING_OPTS_DEFAULT | IGA_FORMATTING_OPT_PRINT_PC |
-                            IGA_FORMATTING_OPT_PRINT_BFNEXPRS;
-  if (with_deps) {
-    options.formatting_opts |= IGA_FORMATTING_OPT_PRINT_DEPS;
-  }
-  if (with_defs) {
-    options.formatting_opts |= IGA_FORMATTING_OPT_PRINT_DEFS;
-  }
-  options.decoder_opts = IGA_DECODING_OPTS_DEFAULT;
-
-  char* text = nullptr;
-  // No label callback: IGA's labels are already kernel-relative.
-  const iga_status_t status = iga.disassemble_(
-      context, &options, isa, static_cast<uint32_t>(code_size), nullptr, nullptr, &text);
-  std::string listing = (text != nullptr) ? text : "";
-  iga.context_release_(context);
-
-  if (listing.empty()) {
-    return fail("IGA produced no disassembly: " + iga.Describe(status));
-  }
-  out_text = std::move(listing);
-  if (status != IGA_SUCCESS) {
-    std::cerr << "[WARNING] IGA did not decode the whole kernel, the listing stops early: "
-              << iga.Describe(status) << std::endl;
-  }
-  return true;
-}
-
-// As above, with the architecture from the view's product config, or its core family
-// if there is none (ArchitectureToIgaGen()). Without either it fails; a caller can put
-// the device's ipVersion, packed the same way, in architecture_.product_config_.
-inline bool DisassembleKernelInstructions(const KernelBinaryView& isa, std::string& out_text,
-                                          bool with_deps = false, bool with_defs = false) {
-  return DisassembleKernelInstructions(isa.data_, isa.size_,
-                                       ArchitectureToIgaGen(isa.architecture_),
-                                       out_text, with_deps, with_defs);
-}
-
-// ---------------------------------------------------------------------------
-// Reading the defs back out of a listing
-// ---------------------------------------------------------------------------
-
-// The offset of a def that names no instruction (0 is the first instruction).
-constexpr uint64_t kNoInstructionOffset = UINT64_MAX;
-
-// One producer of a value an instruction reads.
-struct DefinedBy {
-  // The producer's kernel-relative PC; kNoInstructionOffset for a live-in or an id
-  // with no line in the listing.
-  uint64_t offset_ = kNoInstructionOffset;
-  // The producer's "#<id>"; 0 for a live-in.
-  uint32_t id_ = 0;
-  // The value is live into the kernel ("IN"), e.g. the thread payload in r0.
-  bool live_in_ = false;
-  // The registers as the listing prints them, e.g. "r127[8-11]", "r9:2", "r32".
-  std::string registers_;
-};
-
-// One instruction and its defs.
-struct UsedBy {
-  // Its kernel-relative PC, the listing's "[<hex>]".
-  uint64_t offset_ = 0;
-  // Its "#<id>", which other instructions' defs refer to.
-  uint32_t id_ = 0;
-  // The instruction text, without the prefix or the defs comment, with whitespace runs
-  // collapsed to one space.
-  std::string text_;
-  // The producers of the values it reads, in listing order. Empty if there are none.
-  std::vector<DefinedBy> defs_;
-};
-
-// One kernel's instructions in listing (offset) order, indexed by id and by offset.
-struct DefsAndUses {
-  std::vector<UsedBy> instructions_;
-  std::map<uint32_t, size_t> index_by_id_;
-  std::map<uint64_t, size_t> index_by_offset_;
-
-  // The instruction with this id, or nullptr.
-  const UsedBy* FindById(uint32_t id) const {
-    const auto it = index_by_id_.find(id);
-    return (it == index_by_id_.end()) ? nullptr : &instructions_[it->second];
-  }
-
-  // The instruction starting at this offset, or nullptr.
-  const UsedBy* FindByOffset(uint64_t offset) const {
-    const auto it = index_by_offset_.find(offset);
-    return (it == index_by_offset_.end()) ? nullptr : &instructions_[it->second];
-  }
-
-  bool Empty() const { return instructions_.empty(); }
-};
-
-// The value of a hex digit, or -1.
-inline int HexDigit(char c) {
-  if (c >= '0' && c <= '9') {
-    return c - '0';
-  }
-  if (c >= 'a' && c <= 'f') {
-    return c - 'a' + 10;
-  }
-  if (c >= 'A' && c <= 'F') {
-    return c - 'A' + 10;
-  }
-  return -1;
-}
-
-// Reads the instructions and defs out of a DisassembleKernelInstructions() listing:
-//
-//   /*  #78 [0390]  */ (W)  send.gtwy (1|M0) ... {EOT,I@1,$7} //  #77{r127}; wr:1+0
-//   \______ PRINT_PC ______/                                  \_ PRINT_DEFS _/
-//
-// Every line with the prefix becomes a record, defs or not; other lines are skipped.
-// The prefix has a "#<id>" only with PRINT_DEFS, so a listing made without with_defs
-// gives no records.
-// The defs are "#<id>{<registers>}" or "IN{<registers>}", separated by ", "; a send's
-// commentary after ";" is dropped, as is anything unrecognised and a def naming the
-// instruction itself.
-//
-// Returns true and fills out_defs if the listing has at least one instruction;
-// otherwise warns and returns false.
-inline bool ConstructDefsAndUses(const std::string& listing, DefsAndUses& out_defs) {
-  out_defs = DefsAndUses();
-
-  size_t line_begin = 0;
-  while (line_begin < listing.size()) {
-    size_t line_end = listing.find('\n', line_begin);
-    if (line_end == std::string::npos) {
-      line_end = listing.size();
-    }
-    const std::string line = listing.substr(line_begin, line_end - line_begin);
-    line_begin = line_end + 1;
-
-    // The PRINT_PC prefix "/*  #12 [00A0]  */", first on an instruction's line.
-    const size_t prefix_begin = line.find_first_not_of(" \t");
-    if (prefix_begin == std::string::npos || line.compare(prefix_begin, 2, "/*") != 0) {
-      continue;
-    }
-    const size_t prefix_end = line.find("*/", prefix_begin);
-    if (prefix_end == std::string::npos) {
-      continue;
-    }
-
-    // The id, in decimal after "#".
-    const size_t id_begin = line.find('#', prefix_begin);
-    if (id_begin == std::string::npos || id_begin > prefix_end) {
-      continue;
-    }
-    size_t at = id_begin + 1;
-    uint32_t id = 0;
-    while (at < line.size() && line[at] >= '0' && line[at] <= '9') {
-      id = id * 10 + static_cast<uint32_t>(line[at] - '0');
-      ++at;
-    }
-    if (at == id_begin + 1) {
-      continue;
-    }
-
-    // The offset, in hex inside "[...]", with no "0x".
-    const size_t offset_begin = line.find('[', at);
-    if (offset_begin == std::string::npos || offset_begin > prefix_end) {
-      continue;
-    }
-    const size_t offset_end = line.find(']', offset_begin);
-    if (offset_end == std::string::npos || offset_end > prefix_end) {
-      continue;
-    }
-    uint64_t offset = 0;
-    bool offset_read = offset_end > offset_begin + 1;
-    for (size_t i = offset_begin + 1; i < offset_end; ++i) {
-      const int digit = HexDigit(line[i]);
-      if (digit < 0) {
-        offset_read = false;
-        break;
-      }
-      offset = (offset << 4) | static_cast<uint64_t>(digit);
-    }
-    if (!offset_read) {
-      continue;
-    }
-
-    UsedBy instruction;
-    instruction.offset_ = offset;
-    instruction.id_ = id;
-
-    // The defs comment, which also ends the instruction text.
-    const size_t comment = line.find("//", prefix_end);
-
-    // The instruction text, between the prefix and the comment.
-    const size_t text_end = (comment == std::string::npos) ? line.size() : comment;
-    for (size_t i = prefix_end + 2; i < text_end; ++i) {
-      const char c = line[i];
-      if (c == ' ' || c == '\t' || c == '\r') {
-        if (!instruction.text_.empty() && instruction.text_.back() != ' ') {
-          instruction.text_ += ' ';
-        }
-      } else {
-        instruction.text_ += c;
-      }
-    }
-    const size_t text_last = instruction.text_.find_last_not_of(' ');
-    instruction.text_.resize((text_last == std::string::npos) ? 0 : text_last + 1);
-
-    if (comment != std::string::npos) {
-      std::string defs = line.substr(comment + 2);
-      // Drop a send's commentary, after the first ";".
-      const size_t descriptor = defs.find(';');
-      if (descriptor != std::string::npos) {
-        defs.resize(descriptor);
-      }
-
-      // Each entry is a name followed by "{...}".
-      size_t brace = 0;
-      while ((brace = defs.find('{', brace)) != std::string::npos) {
-        const size_t brace_end = defs.find('}', brace);
-        if (brace_end == std::string::npos) {
-          break;
-        }
-
-        // The name: back to the previous ",", trimmed.
-        size_t name_begin = defs.rfind(',', brace);
-        name_begin = (name_begin == std::string::npos) ? 0 : name_begin + 1;
-        const size_t name_first = defs.find_first_not_of(" \t", name_begin);
-        std::string name;
-        if (name_first != std::string::npos && name_first < brace) {
-          name = defs.substr(name_first, brace - name_first);
-          const size_t name_last = name.find_last_not_of(" \t");
-          name.resize((name_last == std::string::npos) ? 0 : name_last + 1);
-        }
-
-        DefinedBy def;
-        def.registers_ = defs.substr(brace + 1, brace_end - brace - 1);
-        brace = brace_end + 1;
-
-        if (name == "IN") {
-          def.live_in_ = true;
-        } else if (name.size() > 1 && name[0] == '#') {
-          uint32_t producer_id = 0;
-          bool all_digits = true;
-          for (size_t i = 1; i < name.size(); ++i) {
-            if (name[i] < '0' || name[i] > '9') {
-              all_digits = false;
-              break;
-            }
-            producer_id = producer_id * 10 + static_cast<uint32_t>(name[i] - '0');
-          }
-          if (!all_digits) {
-            continue;
-          }
-          // A loop-carried value names this instruction itself; not a dependency.
-          if (producer_id == id) {
-            continue;
-          }
-          def.id_ = producer_id;
-        } else {
-          continue;
-        }
-        instruction.defs_.push_back(std::move(def));
-      }
-    }
-
-    const size_t index = out_defs.instructions_.size();
-    out_defs.instructions_.push_back(std::move(instruction));
-    // insert(): if an id or offset repeats, the first line wins.
-    out_defs.index_by_id_.insert({id, index});
-    out_defs.index_by_offset_.insert({offset, index});
-  }
-
-  if (out_defs.instructions_.empty()) {
-    std::cerr << "[WARNING] Unable to read the defs of a kernel: the listing names no "
-                 "instruction"
-              << std::endl;
-    return false;
-  }
-
-  // Fill the producers' offsets now: a def can name a later instruction (a loop's
-  // back edge).
-  for (UsedBy& instruction : out_defs.instructions_) {
-    for (DefinedBy& def : instruction.defs_) {
-      if (def.live_in_) {
-        continue;
-      }
-      const UsedBy* producer = out_defs.FindById(def.id_);
-      if (producer != nullptr) {
-        def.offset_ = producer->offset_;
-      }
-    }
-  }
-  return true;
-}
-
-#endif  // PTI_TOOLS_UNITRACE_UTILS_KERNEL_DISASSEMBLER_H_
diff --git a/tools/unitrace/src/utils/kernel_extractor.h b/tools/unitrace/src/utils/kernel_extractor.h
deleted file mode 100644
index fc86c19c..00000000
--- a/tools/unitrace/src/utils/kernel_extractor.h
+++ /dev/null
@@ -1,322 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Kernel ISA Extraction
-//
-// Given a module's native binary (zeModuleGetNativeBinary()), GetKernelBinary() finds a
-// named kernel's ISA and the architecture it was compiled for. The ISA is the kernel's
-// ".text.<mangled name>" section, without its padding (GenCodeSize()); the architecture
-// is in IGC's compatibility notes. Container reading is elf64_reader.h's.
-//
-// The ISA is a view into the caller's buffer, which must outlive it.
-//
-// References:
-//   Intel Graphics Compiler, the ZEBIN specification (elf.md):
-//   https://github.com/intel/intel-graphics-compiler/tree/master/IGC/ZEBinWriter/zebin/spec
-//
-//==============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_KERNEL_EXTRACTOR_H_
-#define PTI_TOOLS_UNITRACE_UTILS_KERNEL_EXTRACTOR_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "elf64_reader.h"
-
-// ---------------------------------------------------------------------------
-// Which architecture the code was built for
-// ---------------------------------------------------------------------------
-//
-// Recorded in ".note.intelgt.compat" as standard ELF notes (name size, descriptor size,
-// type, name, descriptor) with owner "IntelGT". elf.md does not specify padding; IGC pads
-// to 4 bytes, not the gABI's 8 for ELF64.
-
-constexpr const char* kIntelGtNoteSectionName = ".note.intelgt.compat";
-constexpr const char* kIntelGtNoteOwner = "IntelGT";
-constexpr uint64_t kIntelGtNoteAlignment = 4;
-
-// The NT_INTELGT_* note types from elf.md. Only the three naming an architecture are
-// decoded.
-constexpr uint32_t kIntelGtNoteProductFamily = 1;   // PRODUCT_FAMILY, u32
-constexpr uint32_t kIntelGtNoteGfxCoreFamily = 2;   // GFXCORE_FAMILY, u32
-constexpr uint32_t kIntelGtNoteTargetMetadata = 3;  // TargetMetadata bitfield, u32
-constexpr uint32_t kIntelGtNoteZebinVersion = 4;    // "<major>.<minor>", NUL-terminated
-constexpr uint32_t kIntelGtNoteVisaAbiVersion = 5;  // u32; absent unless stack calls
-constexpr uint32_t kIntelGtNoteProductConfig = 6;   // AOT product config, u32
-constexpr uint32_t kIntelGtNoteIndirectAccessDetectionVersion = 7;   // u32
-constexpr uint32_t kIntelGtNoteIndirectAccessBufferMajorVersion = 8;  // u32
-
-// What a module binary was built for, as IGC recorded it. 0 means not recorded (0 is
-// never a valid value).
-struct GenArchitecture {
-  // GFXCORE_FAMILY, e.g. IGFX_GEN12LP_CORE = 18, IGFX_XE_HPC_CORE = 0x0C08
-  // (igfxfmid.h).
-  uint32_t gfx_core_family_ = 0;
-  // PRODUCT_FAMILY, e.g. IGFX_TIGERLAKE_LP = 29, IGFX_PVC = 1271.
-  uint32_t product_family_ = 0;
-  // The AOT product config, packed like ze_device_ip_version_ext_t::ipVersion, and
-  // superseding the two above. ArchitectureToIgaGen() (kernel_disassembler.h) takes it
-  // as is, falling back to gfx_core_family_, so the binary alone picks the disassembler.
-  uint32_t product_config_ = 0;
-
-  bool Valid() const {
-    return gfx_core_family_ != 0 || product_family_ != 0 || product_config_ != 0;
-  }
-};
-
-// Decodes the compatibility notes from already-read sections. Returns true and fills
-// out_architecture if any value was recorded; otherwise returns false and leaves it
-// untouched. binary/binary_size is the buffer the sections came from, used only for
-// e_machine. warn_when_absent reports a failure on std::cerr.
-inline bool ReadGenArchitectureNotes(const uint8_t* binary, size_t binary_size,
-                                     const std::vector<Elf64Section>& sections,
-                                     GenArchitecture& out_architecture, bool warn_when_absent) {
-  auto fail = [warn_when_absent](const std::string& message) {
-    if (warn_when_absent) {
-      std::cerr << "[WARNING] Cannot read the architecture of the module binary: " << message
-                << std::endl;
-    }
-    return false;
-  };
-
-  const int64_t index = FindElf64Section(sections, kIntelGtNoteSectionName);
-  if (index < 0) {
-    // Safe: ReadElf64Sections() has checked the header is complete.
-    ByteCursor header(binary, static_cast<uint64_t>(binary_size));
-    header.Seek(kElf64MachineOffset);
-    const uint16_t machine = header.U16();
-    if (!header.Ok() || machine != kElf64MachineIntelGt) {
-      return fail("ELF container is not a ZeBin (e_machine is not EM_INTELGT)");
-    }
-    return fail(std::string("ZeBin holds no \"") + kIntelGtNoteSectionName + "\" section");
-  }
-  const Elf64Section& section = sections[index];
-  if (!section.HasContents()) {
-    return fail(section.size_ == 0
-                    ? "the compatibility note section is empty"
-                    : "the compatibility note section lies outside the module binary");
-  }
-
-  // Accumulated locally so a failure leaves the caller's value alone. The first of a
-  // repeated note wins.
-  GenArchitecture found;
-  auto keep = [](uint32_t& slot, uint32_t value) {
-    if (slot == 0) {
-      slot = value;
-    }
-  };
-
-  ByteCursor notes(section.data_, section.size_);
-  bool truncated = false;
-  while (!notes.Done()) {
-    const uint32_t name_size = notes.U32();
-    const uint32_t descriptor_size = notes.U32();
-    const uint32_t type = notes.U32();
-    // Padded in 64 bits, since rounding up a size near 2^32 overflows 32 bits.
-    const uint64_t padded_name = (static_cast<uint64_t>(name_size) + kIntelGtNoteAlignment - 1) &
-                                 ~(kIntelGtNoteAlignment - 1);
-    const uint64_t padded_descriptor =
-        (static_cast<uint64_t>(descriptor_size) + kIntelGtNoteAlignment - 1) &
-        ~(kIntelGtNoteAlignment - 1);
-    const uint8_t* name = notes.Take(padded_name);
-    const uint8_t* descriptor = notes.Take(padded_descriptor);
-    if (!notes.Ok()) {
-      // Keep the notes already read.
-      truncated = true;
-      break;
-    }
-    // The owner name is NUL-terminated and its size includes the NUL.
-    if (name_size == 0 || name[name_size - 1] != 0 ||
-        std::string(reinterpret_cast<const char*>(name), name_size - 1) != kIntelGtNoteOwner) {
-      continue;  // another owner's note
-    }
-    // The architecture notes are all u32.
-    if (descriptor_size != sizeof(uint32_t)) {
-      continue;
-    }
-    const uint32_t value = Elf64ReadU32(descriptor);
-    switch (type) {
-      case kIntelGtNoteGfxCoreFamily:
-        keep(found.gfx_core_family_, value);
-        break;
-      case kIntelGtNoteProductFamily:
-        keep(found.product_family_, value);
-        break;
-      case kIntelGtNoteProductConfig:
-        keep(found.product_config_, value);
-        break;
-      default:
-        // the other types name no architecture
-        break;
-    }
-  }
-
-  if (!found.Valid()) {
-    return fail(truncated ? "the compatibility notes are truncated"
-                          : "the compatibility notes record no architecture");
-  }
-  out_architecture = found;
-  return true;
-}
-
-// ---------------------------------------------------------------------------
-// The encoding, only as far as an instruction's length
-// ---------------------------------------------------------------------------
-
-constexpr uint32_t kGenIsaCompactedSize = 8;
-constexpr uint32_t kGenIsaUncompactedSize = 16;
-// Compaction control: bit 29 of the first dword, on every platform IGA supports.
-constexpr uint32_t kGenIsaCompactionBit = 29;
-
-// The encoded length of the instruction at 'instruction', whose first four bytes must
-// be readable. Read byte by byte, since the buffer may be unaligned.
-inline uint32_t GenIsaInstructionLength(const uint8_t* instruction) {
-  const uint32_t word = static_cast<uint32_t>(instruction[0]) |
-                        (static_cast<uint32_t>(instruction[1]) << 8) |
-                        (static_cast<uint32_t>(instruction[2]) << 16) |
-                        (static_cast<uint32_t>(instruction[3]) << 24);
-  return ((word >> kGenIsaCompactionBit) & 1u) != 0 ? kGenIsaCompactedSize
-                                                    : kGenIsaUncompactedSize;
-}
-
-// Where the trailing run of zero bytes (IGC's alignment padding) begins, or isa_size
-// if the last byte is not zero.
-inline size_t GenIsaPaddingStart(const uint8_t* isa, size_t isa_size) {
-  if (isa == nullptr) {
-    return 0;
-  }
-  size_t start = isa_size;
-  while (start > 0 && isa[start - 1] == 0) {
-    --start;
-  }
-  return start;
-}
-
-// Whether the instruction has nothing but an opcode: a bare "nop" or all zeros, which
-// after the kernel's last instruction is padding. Checked by encoding, not opcode
-// number, since opcodes differ across platforms. 'length' must be the instruction's
-// own length, with all its bytes readable.
-inline bool GenIsaIsPaddingInstruction(const uint8_t* instruction, uint32_t length) {
-  // Every bit after the opcode byte must be clear, except the compaction bit.
-  constexpr uint8_t kCompactionByteBit = 1u << (kGenIsaCompactionBit - 24);
-  if (instruction[1] != 0 || instruction[2] != 0 ||
-      (instruction[3] & static_cast<uint8_t>(~kCompactionByteBit)) != 0) {
-    return false;
-  }
-  for (uint32_t i = 4; i < length; ++i) {
-    if (instruction[i] != 0) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// The size of the code in an ISA buffer: the end of the last whole instruction that
-// is not padding. Walks instruction lengths from the start, since the zero run can
-// begin inside an instruction and a trailing nop is padding too. 0 if there is no
-// code.
-inline uint64_t GenCodeSize(const uint8_t* isa, size_t isa_size) {
-  const size_t padding_start = GenIsaPaddingStart(isa, isa_size);
-  uint64_t at = 0;
-  uint64_t code_end = 0;
-  while (at < padding_start && at + kGenIsaCompactedSize <= isa_size) {
-    const uint32_t length = GenIsaInstructionLength(isa + at);
-    if (length > isa_size - at) {
-      break;
-    }
-    if (!GenIsaIsPaddingInstruction(isa + at, length)) {
-      code_end = at + length;
-    }
-    at += length;
-  }
-  return code_end;
-}
-
-// ---------------------------------------------------------------------------
-// One kernel's code, and what decodes it
-// ---------------------------------------------------------------------------
-
-// One kernel's ISA, as a view into its module binary, with the binary's architecture.
-// Valid only while that buffer is alive and unmodified.
-struct KernelBinaryView {
-  const uint8_t* data_ = nullptr;
-  size_t size_ = 0;
-  // The section the ISA came from (".text.<mangled name>").
-  std::string section_name_;
-  // What the module was compiled for; not Valid() if the binary does not record it.
-  GenArchitecture architecture_;
-
-  // The code size in bytes (GenCodeSize()), the extent IPs are matched against. 0 if
-  // never filled, or if the section holds no code.
-  size_t Size() const { return size_; }
-};
-
-// Finds the ISA of the kernel with mangled name kernel_name in a module binary. Returns
-// true and fills out_kernel_binary on success; a missing architecture is not a failure.
-// Returns false, leaving out_kernel_binary untouched, if:
-//   - the buffer is not an ELF64 little-endian container (a pre-ZeBin binary is raw ISA)
-//   - the container is malformed or truncated
-//   - no section holds the kernel's code
-//   - the section has no bytes: SHT_NOBITS, empty, or outside the buffer
-// Failures are reported on std::cerr as "[WARNING] ...", the first two by
-// ReadElf64Sections().
-inline bool GetKernelBinary(const uint8_t* binary, size_t binary_size,
-                            const std::string& kernel_name, KernelBinaryView& out_kernel_binary) {
-  auto fail = [&kernel_name](const std::string& message) {
-    std::cerr << "[WARNING] Cannot get the binary of kernel " << kernel_name << ": " << message
-              << std::endl;
-    return false;
-  };
-
-  if (kernel_name.empty()) {
-    // not through fail(), which prints the name
-    std::cerr << "[WARNING] Cannot get a kernel's binary: no kernel name to look up" << std::endl;
-    return false;
-  }
-
-  std::vector<Elf64Section> sections;
-  const Elf64Status status = ReadElf64Sections(binary, binary_size, sections);
-  if (status != Elf64Status::kOk) {
-    // already reported by ReadElf64Sections()
-    return false;
-  }
-
-  const std::string want = Elf64KernelTextSectionName(kernel_name);
-  const int64_t index = FindElf64Section(sections, want);
-  if (index < 0) {
-    return fail("no section holds this kernel's code");
-  }
-
-  const Elf64Section& section = sections[index];
-  if (section.type_ == kElf64ShtNoBits) {
-    return fail("the kernel's section occupies no space in the module binary");
-  }
-  if (section.size_ == 0) {
-    return fail("the kernel's section is empty");
-  }
-  if (section.data_ == nullptr) {
-    return fail("the kernel's section lies outside the module binary");
-  }
-
-  // Into a local, so a binary with no architecture leaves the default rather than a
-  // reused view's old value. Silent: the architecture is optional.
-  GenArchitecture architecture;
-  (void)ReadGenArchitectureNotes(binary, binary_size, sections, architecture, false);
-
-  // The narrowing is safe: the section is inside a buffer of size_t bytes.
-  out_kernel_binary.data_ = section.data_;
-  out_kernel_binary.size_ = static_cast<size_t>(
-      GenCodeSize(section.data_, static_cast<size_t>(section.size_)));
-  out_kernel_binary.section_name_ = want;
-  out_kernel_binary.architecture_ = architecture;
-  return true;
-}
-
-#endif  // PTI_TOOLS_UNITRACE_UTILS_KERNEL_EXTRACTOR_H_
diff --git a/tools/unitrace/src/utils/library_loader.h b/tools/unitrace/src/utils/library_loader.h
deleted file mode 100644
index ef8e2549..00000000
--- a/tools/unitrace/src/utils/library_loader.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// ==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UTILS_LIBRARY_LOADER_H_
-#define UTILS_LIBRARY_LOADER_H_
-
-#include <stdexcept>
-#include <string>
-#include <system_error>
-#include <type_traits>
-#include <utility>
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-class LibraryLoader {
- public:
-  using SymHandle = void*;
-#if defined(_WIN32)
-  using Handle = HMODULE;
-#else
-  using Handle = void*;
-#endif
-  LibraryLoader() {}
-
-  explicit LibraryLoader(const std::string& lib_name) {
-#if defined(_WIN32)
-    if (!SetDllDirectoryA("")) {
-      throw std::system_error(GetLastError(), std::system_category());
-    }
-    handle_ = LoadLibraryExA(static_cast<LPCSTR>(lib_name.c_str()), nullptr,
-                             static_cast<DWORD>(0x000000000));
-#else
-    handle_ = dlopen(lib_name.c_str(), RTLD_NOW);
-#endif
-    if (!handle_) {
-#if defined(_WIN32)
-      throw std::system_error(GetLastError(), std::system_category());
-#else
-      throw std::runtime_error(dlerror());
-#endif
-    }
-  }
-
-  LibraryLoader(const LibraryLoader&) = delete;
-  LibraryLoader(LibraryLoader&& other) { std::swap(other.handle_, handle_); }
-  LibraryLoader& operator=(const LibraryLoader&) = delete;
-  LibraryLoader& operator=(LibraryLoader&& other) {
-    if (this != &other) {
-      std::swap(other.handle_, handle_);
-    }
-    return *this;
-  }
-
-  template <typename T>
-  [[nodiscard]] T GetSymbol(const char* sym_name) {
-    static_assert(std::is_pointer<T>::value);
-#if defined(_WIN32)
-    auto sym_addr = GetProcAddress(handle_, sym_name);
-#else
-    auto sym_addr = dlsym(handle_, sym_name);
-#endif
-    return reinterpret_cast<T>(reinterpret_cast<SymHandle>(sym_addr));
-  }
-
-  virtual ~LibraryLoader() {
-    if (handle_) {
-#if defined(_WIN32)
-      [[maybe_unused]] auto result = FreeLibrary(handle_);
-#else
-      [[maybe_unused]] auto result = dlclose(handle_);
-#endif
-    }
-  }
-
- private:
-  Handle handle_ = nullptr;
-};
-
-#endif
diff --git a/tools/unitrace/src/utils/logger_factory.cc b/tools/unitrace/src/utils/logger_factory.cc
deleted file mode 100644
index bb5e8872..00000000
--- a/tools/unitrace/src/utils/logger_factory.cc
+++ /dev/null
@@ -1,652 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include "logger_factory.h"
-
-#if CXX_STD_FILESYSTEM_EXPERIMENTAL
-#include <experimental/filesystem>
-#define CXX_STD_FILESYSTEM_NAMESPACE std::experimental::filesystem
-#else /* CXX_STD_FILESYSTEM_EXPERIMENTAL */
-#include <filesystem>
-#define CXX_STD_FILESYSTEM_NAMESPACE std::filesystem
-#endif /* CXX_STD_FILESYSTEM_EXPERIMENTAL */
-
-#include <cstdlib>
-#include <thread>
-
-// LoggerFactory base constructor
-LoggerFactory::LoggerFactory(uint32_t app_id)
-    : app_id_(app_id),
-      dir_path_(""),
-      app_name_(ComputeAppName()),
-      rank_((utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK"))
-{}
-
-// LoggerFactory directory creation helper
-void LoggerFactory::CreateDirectory(const std::string& dir) const {
-    if (dir.empty()) return;
-
-    try {
-        if (!CXX_STD_FILESYSTEM_NAMESPACE::exists(dir)) {
-            CXX_STD_FILESYSTEM_NAMESPACE::create_directories(dir);
-        }
-    } catch (const std::exception& e) {
-        std::cerr << "[ERROR] Failed to create directory '" << dir << "': " << e.what() << std::endl;
-    }
-}
-
-// LoggerFactory directory removal helper: remove the directory only if it exists and is empty
-void LoggerFactory::RemoveDirectoryIfEmpty(const std::string& dir) const {
-    if (dir.empty()) return;
-
-    try {
-        if (CXX_STD_FILESYSTEM_NAMESPACE::exists(dir) &&
-            CXX_STD_FILESYSTEM_NAMESPACE::is_directory(dir) &&
-            CXX_STD_FILESYSTEM_NAMESPACE::is_empty(dir)) {
-            CXX_STD_FILESYSTEM_NAMESPACE::remove(dir);
-        }
-    } catch (const std::exception& e) {
-        std::cerr << "[WARNING] Failed to remove directory '" << dir << "': " << e.what() << std::endl;
-    }
-}
-
-// Where the per-kernel assembly files are written. See the declaration for why this
-// is not under UNITRACE_DataDir.
-std::string LoggerFactory::GetDisasmDirPath() const {
-    // dir_path_ is the run's output directory: the result directory in result-dir
-    // mode, and UNITRACE_TraceOutputDir (possibly unset) in legacy mode. Fall back
-    // to the current directory, which is where legacy mode puts its other output.
-    std::string dir = dir_path_.empty() ? std::string(".") : dir_path_;
-    dir += "/asm";
-    // A result directory is already per-run (app name and pid are in its name), but
-    // a legacy output directory is shared, so qualify it there to keep concurrent
-    // runs - and the ranks of one MPI run - from writing into each other's files.
-    if (IsLegacy()) {
-        dir += "." + std::to_string(app_id_);
-        if (!rank_.empty()) {
-            dir += "." + rank_;
-        }
-    }
-    CreateDirectory(dir);
-    disasm_dir_path_ = dir;
-    return dir;
-}
-
-// See the declaration for the naming and why the pid is part of it.
-std::string LoggerFactory::GetDisasmFileName(const std::string& disasm_dir, int32_t device_id,
-                                             uint32_t pid, uint64_t kernel_id,
-                                             const std::string& ext) const {
-    return disasm_dir + "/" + std::to_string(device_id) + "." + std::to_string(pid) + "." +
-           std::to_string(kernel_id) + "." + ext;
-}
-
-// See the declaration for why this is shared and why there is no device id in it.
-std::string LoggerFactory::GetModuleBinaryFileName(uint32_t pid, uint32_t index) const {
-    return (IsLegacy() ? ".module." : "module_") + std::to_string(pid) + "." +
-           std::to_string(index) + ".bin";
-}
-
-// See the declaration for what this is the counterpart of.
-uint32_t LoggerFactory::GetFileNamePid(const std::string& path) {
-    const std::string ext = ".txt";
-    if (path.size() <= ext.size() || path.compare(path.size() - ext.size(), ext.size(), ext) != 0) {
-        return 0;
-    }
-
-    // The field before the extension, which is where the writer put its app id.
-    size_t end = path.size() - ext.size();
-    size_t begin = path.rfind('.', end - 1);
-    if (begin == std::string::npos) {
-        return 0;
-    }
-    ++begin;
-
-    // Digits only: rejecting anything else keeps a name of some other shape from
-    // yielding a pid that happens to parse, which would be read as another rank's.
-    if (begin == end) {
-        return 0;
-    }
-    for (size_t i = begin; i < end; ++i) {
-        if (path[i] < '0' || path[i] > '9') {
-            return 0;
-        }
-    }
-
-    return static_cast<uint32_t>(std::strtoul(path.substr(begin, end - begin).c_str(), nullptr, 10));
-}
-
-// LoggerFactory singleton implementation
-LoggerFactory* LoggerFactory::Create(uint32_t app_id) {
-    static std::unique_ptr<LoggerFactory> instance;
-    if (!instance) {
-        if (app_id == (std::numeric_limits<uint32_t>::max)()) {
-            app_id = utils::GetPid();
-        }
-
-        const char* env = std::getenv("UNITRACE_UseResultDirectory");
-        if (env && std::string(env) == "1") {
-            instance = std::make_unique<ResultDirLoggerFactory>(app_id);
-        } else {
-            std::string value = utils::GetEnv("UNITRACE_LogToFile");
-            std::string log_file;
-            if (!value.empty() && value == "1") {
-                log_file = utils::GetEnv("UNITRACE_LogFilename");
-                UNITRACE_ASSERT(!log_file.empty());
-            }
-            instance = std::make_unique<LegacyLoggerFactory>(app_id, log_file);
-        }
-    }
-    else {
-        if (app_id != (std::numeric_limits<uint32_t>::max)()) {
-            instance->SetAppId(app_id);
-        }
-    }
-    return instance.get();
-}
-
-std::shared_ptr<UniLogger> LoggerFactory::GetLoggerImpl(LoggerType type, int32_t device_id, bool lazy_flush, bool lock_free, bool binary) const {
-    std::lock_guard<std::mutex> guard(mutex_);
-
-    auto key = std::make_tuple(type, device_id, binary);
-    auto it = loggers_.find(key);
-    if (it != loggers_.end()) {
-        return it->second;
-    }
-    std::string filename = GenerateLogFileName(type, device_id);
-    auto logger = std::make_shared<UniLogger>(filename, lazy_flush, lock_free, binary);
-    loggers_[key] = logger;
-    return logger;
-}
-
-void LegacyLoggerFactory::AdjustLoggerTypeAndDeviceId(LoggerType& type, int32_t& device_id) const {
-    
-    if (type == LOGGER_TYPE_TRACE_HOST_TIMING ||
-        type == LOGGER_TYPE_TRACE_DEVICE_TIMING ||
-        type == LOGGER_TYPE_TRACE_DEVICE_SUBMISSION ||
-        type == LOGGER_TYPE_TRACE_CALL_LOGGING ||
-        type == LOGGER_TYPE_TRACE_DEVICE_TIMELINE ||
-        type == LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT) {
-        type = LOGGER_TYPE_LEGACY_SHARED_TRACE;
-    }
-
-    if (type == LOGGER_TYPE_METRICS_QUERY || type == LOGGER_TYPE_METRICS_SAMPLING) {
-        device_id = -1;
-    }
-}
-
-std::shared_ptr<UniLogger> LegacyLoggerFactory::GetDeviceLogger(LoggerType type, int32_t device_id, bool lazy_flush, bool lock_free, bool binary) const{
-    AdjustLoggerTypeAndDeviceId(type, device_id);
-    return GetLoggerImpl(type, device_id, lazy_flush, lock_free, binary);
-}
-
-std::string LoggerFactory::ComputeAppName(void) {
-#ifdef _WIN32
-    char str[256];
-    if (GetModuleFileNameA(nullptr, str, sizeof(str))) {
-        std::string name(str);
-        // Remove path
-        auto pos = name.find_last_of('\\');
-        if (pos != std::string::npos) {
-            name = name.substr(pos + 1);
-        }
-        // Remove .exe extension if present (case-insensitive)
-        auto ext_pos = name.find_last_of('.');
-        if (ext_pos != std::string::npos) {
-            std::string ext = name.substr(ext_pos);
-            for (auto& c : ext) c = tolower(c);
-            if (ext == ".exe") {
-                name = name.substr(0, ext_pos);
-            }
-        }
-        return name;
-    }
-#else /* _WIN32 */
-    std::ifstream comm("/proc/self/comm");
-    if (comm) {
-        std::string name;
-        std::getline(comm, name);
-        comm.close();
-        if (!name.empty()) {
-            return std::move(name);
-        }
-    }
-#endif /* _WIN32 */
-    return "unitrace";
-}
-
-// LegacyLoggerFactory constructor
-LegacyLoggerFactory::LegacyLoggerFactory(uint32_t app_id, const std::string& log_file)
-    : LoggerFactory(app_id), log_file_(log_file) {
-    std::string dir = utils::GetEnv("UNITRACE_TraceOutputDir");
-    if (!dir.empty()) {
-        CreateDirectory(dir);
-        dir_path_ = dir;
-    }
-}
-
-// LegacyLoggerFactory helpers
-std::string LegacyLoggerFactory::GetLogFileName(const std::string& logfile, uint32_t pid) const {
-    if (logfile.empty()) {
-        return logfile;
-    }
-
-    // Locate the file-extension dot to insert the pid before it. Only treat a
-    // '.' as the extension separator when it is part of the file name (i.e.
-    // after the last path separator); otherwise a dotted parent directory name
-    // (e.g. ".../applications.analyzers.profilingtoolsinterfaces.sdk/...") would
-    // be mistaken for the extension and corrupt the path.
-    size_t pos = logfile.find_last_of('.');
-    if (pos != std::string::npos &&
-        logfile.find_first_of("/\\", pos) != std::string::npos) {
-        pos = std::string::npos;
-    }
-
-    std::string result;
-    if (pos == std::string::npos) {
-        result = logfile;
-    } else {
-        result = logfile.substr(0, pos);
-    }
-
-    if (pid == (std::numeric_limits<uint32_t>::max)()) {
-        pid = utils::GetPid();
-    }
-    result += "." + std::to_string(pid);
-
-    if (!rank_.empty()) {
-        result += "." + rank_;
-    }
-
-    if (pos != std::string::npos) {
-        result += logfile.substr(pos);
-    }
-
-    return result;
-}
-
-std::string LegacyLoggerFactory::GetMetricsFileName(const std::string& log_file, uint32_t app_id) const{
-    if (log_file.empty()) {
-        return log_file;
-    }
-    // Insert ".metrics" before the file extension. Use the LAST '.' so that
-    // dots in parent directory names (e.g. a path like
-    // ".../applications.analyzers.profilingtoolsinterfaces.sdk/...") are not
-    // mistaken for the extension separator, which would produce a bogus path.
-    size_t pos = log_file.find_last_of('.');
-    // Guard against a '.' that belongs to a directory rather than the file name
-    // (i.e. there is a path separator after it).
-    if (pos != std::string::npos &&
-        log_file.find_first_of("/\\", pos) != std::string::npos) {
-        pos = std::string::npos;
-    }
-
-    std::string result;
-    if (pos == std::string::npos) {
-        result = log_file;
-    } else {
-        result = log_file.substr(0, pos);
-    }
-
-    result += ".metrics";
-
-    if (app_id == (std::numeric_limits<uint32_t>::max)()) {
-        app_id = utils::GetPid();
-    }
-    result += "." + std::to_string(app_id);
-
-    if (!rank_.empty()) {
-        result += "." + rank_;
-    }
-
-    if (pos != std::string::npos) {
-        result += log_file.substr(pos);
-    }
-
-    return result;
-}
-
-std::string LegacyLoggerFactory::GetChromeTraceFileName() const {
-    std::string filename = app_name_;
-    if (!dir_path_.empty()) {
-        filename = (dir_path_ + '/' + filename);
-    }
-
-    if (!rank_.empty()) {
-        return filename + "." + std::to_string(utils::GetPid()) + "." + rank_ + "." + TimelineTraceExt();
-    }
-    return filename + "." + std::to_string(utils::GetPid()) + "." + TimelineTraceExt();
-}
-
-// LegacyLoggerFactory::GenerateLogFileName implementation
-std::string LegacyLoggerFactory::GenerateLogFileName(LoggerType type, int32_t device_id) const {
-    switch (type) {
-        case LOGGER_TYPE_LEGACY_SHARED_TRACE:
-        case LOGGER_TYPE_TRACE_HOST_TIMING:
-        case LOGGER_TYPE_TRACE_DEVICE_TIMING:
-        case LOGGER_TYPE_TRACE_DEVICE_SUBMISSION:
-        case LOGGER_TYPE_TRACE_CALL_LOGGING:
-        case LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT:
-        case LOGGER_TYPE_TRACE_DEVICE_TIMELINE:
-            return GetLogFileName(log_file_, app_id_);
-        case LOGGER_TYPE_CHROME_TRACE_UNITRACE:
-            return GetChromeTraceFileName();
-        case LOGGER_TYPE_METRICS_QUERY:
-        case LOGGER_TYPE_METRICS_SAMPLING:
-            return GetMetricsFileName(log_file_, app_id_);
-        case LOGGER_TYPE_KPROPS:
-            return GetDataDirPath() + "/.kprops."  + std::to_string(device_id) + "." + std::to_string(app_id_) + ".txt";
-        case LOGGER_TYPE_KTIME:
-            return GetDataDirPath() + "/.ktime."  + std::to_string(device_id) + "." + std::to_string(app_id_) + ".txt";
-        case LOGGER_TYPE_METRICS_QUERY_TEMP:
-            return GetDataDirPath() + "/.metrics." + std::to_string(app_id_) + ".q";
-        case LOGGER_TYPE_METRICS_SAMPLING_TEMP:
-            {
-                std::string metric_group = utils::GetEnv("UNITRACE_MetricGroup");
-                return GetDataDirPath() + "/." + std::to_string(device_id) + "." + metric_group + "." + std::to_string(app_id_) + ".t";
-            }
-        case LOGGER_TYPE_KMD_TRACE:
-            return GetLogFileName("oskmd.json", app_id_);
-        default:
-            UNITRACE_ASSERT(false);
-            return "";
-    }
-}
-
-#ifdef _WIN32
-// For windows - father process need to find .q file that was created by child process
-// returns pair of <temporary file path, final file path>
-std::pair<std::string, std::string> LegacyLoggerFactory::SearchRawMetricFiles(uint32_t pid) const {
-    std::pair<std::string, std::string> result;
-
-    std::string temp_file = GetDataDirPath() + "/.metrics." + std::to_string(pid) + ".q";
-    std::string final_file = GetMetricsFileName(log_file_, pid);
-    result = std::make_pair(temp_file, final_file);
-    return result;
-}
-#endif // _WIN32
-
-// Father process need to find all temp files that were created by child process in order to create final metrics file
-std::vector<std::string> LegacyLoggerFactory::SearchFilesByType(LoggerType type, int32_t device_id) const {
-    std::vector<std::string> result;
-    std::string prefix;
-    switch (type)
-    {
-        case LOGGER_TYPE_KPROPS:
-            prefix = ".kprops.";
-            break;
-        // Nothing searches for .asm files: they are results, written under
-        // GetDisasmDirPath() rather than into the data directory this searches, and
-        // the process that writes them is the one that built them, so it has the
-        // paths already.
-        case LOGGER_TYPE_KTIME:
-            prefix = ".ktime.";
-            break;
-        default:
-            std::cerr << "[ERROR] LegacyLoggerFactory::SearchFilesByType Unknown invalid type: " << type << std::endl;
-            return result;
-    }
-    
-    std::string data_dir_path = GetDataDirPath(false);
-    if (!data_dir_path.empty() && CXX_STD_FILESYSTEM_NAMESPACE::exists(data_dir_path) && CXX_STD_FILESYSTEM_NAMESPACE::is_directory(data_dir_path)) {
-        for (const auto& e : CXX_STD_FILESYSTEM_NAMESPACE::directory_iterator(CXX_STD_FILESYSTEM_NAMESPACE::path(data_dir_path))) {
-            if (e.path().filename().string().find(prefix + std::to_string(device_id)) == 0) {
-                result.push_back(e.path().string());
-            }
-        }
-    }
-    return result;
-}
-
-std::shared_ptr<UniLogger> ResultDirLoggerFactory::GetDeviceLogger(LoggerType type, int32_t device_id, bool lazy_flush, bool lock_free, bool binary) const{
-    return GetLoggerImpl(type, device_id, lazy_flush, lock_free, binary);
-}
-
-// ResultDirLoggerFactory constructor
-ResultDirLoggerFactory::ResultDirLoggerFactory(uint32_t app_id)
-    : LoggerFactory(app_id) {
-    result_dir_ = utils::GetEnv("UNITRACE_ResultDirectory");
-    if (result_dir_.empty()) {
-        std::cerr << "[ERROR] Result directory is missing or not specified." << std::endl;
-        exit(-1);
-    }
-    SetResultDirPaths();
-}
-
-// Derive the per-process result directory from result_dir_, rank and app_id_,
-// and make sure it exists. Shared by the constructor and OnAppIdChanged().
-void ResultDirLoggerFactory::SetResultDirPaths() {
-    std::string dir = result_dir_;
-    dir += "/";
-    if (!rank_.empty()) {
-        dir += "rank_" + rank_ + ".";
-    }
-
-    dir += app_name_ + "." + std::to_string(app_id_);
-
-    dir_path_ = dir;
-    metrics_dir_path_ = dir + "/metrics";
-    CreateDirectory(dir_path_);
-}
-
-void ResultDirLoggerFactory::OnAppIdChanged() {
-    SetResultDirPaths();
-}
-
-// ResultDirLoggerFactory destructor: on application exit, remove the directories
-// created for this run if they are empty (i.e. nothing was actually logged).
-ResultDirLoggerFactory::~ResultDirLoggerFactory() {
-    // Release any loggers so their files are closed before we inspect the
-    // directories for emptiness.
-    loggers_.clear();
-
-    // Remove the subdirectories first so that their removal may in turn leave the
-    // parent result directory empty and eligible for removal. disasm_dir_path_ is
-    // empty unless GetDisasmDirPath() was called, and the directory it names can be
-    // empty even then: it is created before the first .asm file is written, and every
-    // file may still have failed to open.
-    RemoveDirectoryIfEmpty(metrics_dir_path_);
-    RemoveDirectoryIfEmpty(disasm_dir_path_);
-    RemoveDirectoryIfEmpty(dir_path_);
-}
-
-std::string ResultDirLoggerFactory::GetTraceLogFileName(LoggerType type) const{
-    std::string filename;
-
-    switch (type) {
-        case LOGGER_TYPE_TRACE_HOST_TIMING:
-            filename = "host_timing.txt";
-            break;
-        case LOGGER_TYPE_TRACE_DEVICE_TIMING:
-            filename = "device_timing.txt";
-            break;
-        case LOGGER_TYPE_TRACE_DEVICE_SUBMISSION:
-            filename = "device_submission.txt";
-            break;
-        case LOGGER_TYPE_TRACE_CALL_LOGGING:
-            filename = "call_logging.txt";
-            break;
-        case LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT:
-            filename = "ccl_summary_report.txt";
-            break;
-        case LOGGER_TYPE_TRACE_DEVICE_TIMELINE:
-            filename = "device_timeline.txt";
-            break;
-        case LOGGER_TYPE_KMD_TRACE:
-            filename = "oskmd.json";
-            break;
-        default:
-            std::cerr << "[ERROR] ResultDirLoggerFactory::GetTraceLogFileName Unknown logger type: " << type << std::endl;
-            break;
-    }
-
-    return dir_path_ + '/' + filename;
-}
-
-// ResultDirLoggerFactory::GenerateLogFileName implementation
-std::string ResultDirLoggerFactory::GenerateLogFileName(LoggerType type, int32_t device_id) const {
-    switch (type) {
-        case LOGGER_TYPE_CONFIG:
-            return dir_path_ + '/' + "run_config.json";
-        case LOGGER_TYPE_TRACE_HOST_TIMING:
-        case LOGGER_TYPE_TRACE_DEVICE_TIMING:
-        case LOGGER_TYPE_TRACE_DEVICE_SUBMISSION:
-        case LOGGER_TYPE_TRACE_CALL_LOGGING:
-        case LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT:
-        case LOGGER_TYPE_TRACE_DEVICE_TIMELINE:
-        case LOGGER_TYPE_KMD_TRACE:
-            return GetTraceLogFileName(type);
-        case LOGGER_TYPE_CHROME_TRACE_UNITRACE:
-            return dir_path_ + "/chrome_trace." + TimelineTraceExt();
-        case LOGGER_TYPE_METRICS_QUERY:
-            CreateDirectory(metrics_dir_path_);
-            return metrics_dir_path_ + "/metrics_" + std::to_string(device_id) + ".csv";
-        case LOGGER_TYPE_METRICS_SAMPLING:
-            CreateDirectory(metrics_dir_path_);
-            return metrics_dir_path_ + "/metrics_" + std::to_string(device_id) + ".csv";
-        case LOGGER_TYPE_KPROPS:
-            return GetDataDirPath() + "/kprops_" + std::to_string(device_id) + "." + std::to_string(app_id_) +  ".txt";
-        case LOGGER_TYPE_KTIME:
-            return GetDataDirPath() + "/ktime_" + std::to_string(device_id) + "." + std::to_string(app_id_) + ".txt";
-        case LOGGER_TYPE_METRICS_QUERY_TEMP:
-            return GetDataDirPath() + "/metrics." + std::to_string(app_id_) + ".q";
-        case LOGGER_TYPE_METRICS_SAMPLING_TEMP:
-            {
-                std::string metric_group = utils::GetEnv("UNITRACE_MetricGroup");
-                return GetDataDirPath() + "/" + std::to_string(device_id) + "." + metric_group + "." + std::to_string(app_id_) + ".t";
-            }
-        default:
-            UNITRACE_ASSERT(false);
-            return "";
-    }
-}
-
-#ifdef _WIN32
-// for windows - father process need to find .q file that was created by child process and prepare final metrics files
-std::pair<std::string, std::string> ResultDirLoggerFactory::SearchRawMetricFiles(uint32_t pid) const {
-    std::pair<std::string, std::string> result;
-    std::string temp_file = GetDataDirPath() + "/metrics." + std::to_string(pid) + ".q";
-    if (result_dir_.empty() || !CXX_STD_FILESYSTEM_NAMESPACE::exists(result_dir_) || !CXX_STD_FILESYSTEM_NAMESPACE::is_directory(result_dir_)) {
-        return result;
-    }
-
-    for (const auto& entry : CXX_STD_FILESYSTEM_NAMESPACE::directory_iterator(result_dir_)) {
-        if (entry.is_directory()) {
-            std::string dirname = entry.path().filename().string();
-            if (dirname.find(std::to_string(pid)) != std::string::npos) {
-                CXX_STD_FILESYSTEM_NAMESPACE::path metrics_path = entry.path() / "metrics";
-                CreateDirectory(metrics_path.string());
-                std::string csv_file = (metrics_path / "metrics.csv").string();
-                result = std::make_pair(temp_file, csv_file);
-                break;
-            }
-        }
-    }
-    return result;
-}
-#endif // _WIN32
-
-std::vector<std::string> ResultDirLoggerFactory::SearchFilesByType(LoggerType type, int32_t device_id) const {
-    std::vector<std::string> result;
-    std::string prefix;
-
-    switch (type)
-    {
-        case LOGGER_TYPE_KPROPS:
-            prefix = "kprops_";
-            break;
-        // No .asm search here either: see the note in the Legacy counterpart.
-        case LOGGER_TYPE_KTIME:
-            prefix = "ktime_";
-            break;
-        default:
-            std::cerr << "[ERROR] ResultDirLoggerFactory::SearchFilesByType Unknown invalid type: " << type << std::endl;
-            return result;
-    }
-
-    std::string data_dir_path = GetDataDirPath(false);
-    if (!data_dir_path.empty() && CXX_STD_FILESYSTEM_NAMESPACE::exists(data_dir_path) && CXX_STD_FILESYSTEM_NAMESPACE::is_directory(data_dir_path)) {
-        for (const auto& e : CXX_STD_FILESYSTEM_NAMESPACE::directory_iterator(CXX_STD_FILESYSTEM_NAMESPACE::path(data_dir_path))) {
-            if (e.path().filename().string().find(prefix + std::to_string(device_id)) == 0) {
-                result.push_back(e.path().string());
-            }
-        }
-    }
-    return result;
-}
-
-void LoggerFactory::CloseTraceLoggers() const {
-    std::lock_guard<std::mutex> guard(mutex_);
-    for (const auto& entry : loggers_) {
-        switch (std::get<0>(entry.first)) {
-            // Metric and temp loggers stay open: the parent process finalizes
-            // them through the metric flush handshake, not here.
-            case LOGGER_TYPE_METRICS_SAMPLING:
-            case LOGGER_TYPE_METRICS_SAMPLING_TEMP:
-            case LOGGER_TYPE_METRICS_QUERY:
-            case LOGGER_TYPE_METRICS_QUERY_TEMP:
-            case LOGGER_TYPE_KPROPS:
-            case LOGGER_TYPE_KTIME:
-                continue;
-            default:
-                if (entry.second) {
-                    entry.second->Close();
-                }
-        }
-    }
-}
-
-bool LoggerFactory::IsLegacy() const {
-    return dynamic_cast<const LegacyLoggerFactory*>(this) != nullptr;
-}
-
-#ifndef _WIN32
-void LoggerFactory::ReopenAfterFork() {
-    SetAppId(utils::GetPid());
-    OnAppIdChanged();
-    // Uncontended in the single-threaded child; keeps loggers_ access under mutex_.
-    std::lock_guard<std::mutex> guard(mutex_);
-    for (const auto& entry : loggers_) {
-        const LoggerType type = std::get<0>(entry.first);
-        switch (type) {
-            case LOGGER_TYPE_METRICS_SAMPLING:
-            case LOGGER_TYPE_METRICS_SAMPLING_TEMP:
-            case LOGGER_TYPE_METRICS_QUERY:
-            case LOGGER_TYPE_METRICS_QUERY_TEMP:
-            case LOGGER_TYPE_KPROPS:
-            case LOGGER_TYPE_KTIME:
-                continue;
-            default:
-                if (entry.second) {
-                    entry.second->ReopenAfterFork(GenerateLogFileName(type, std::get<1>(entry.first)));
-                }
-        }
-    }
-}
-
-void LoggerFactory::LockForFork() const {
-    mutex_.lock();
-    for (const auto& entry : loggers_) {
-        if (entry.second) {
-            entry.second->LockForFork();
-        }
-    }
-}
-
-void LoggerFactory::UnlockAfterFork() const {
-    // Adopt mutex_, locked in LockForFork(), so it is released on exit.
-    std::lock_guard<std::mutex> guard(mutex_, std::adopt_lock);
-    // coverity[missing_lock]
-    for (const auto& entry : loggers_) {
-        if (entry.second) {
-            entry.second->UnlockAfterFork();
-        }
-    }
-}
-#endif /* _WIN32 */
-
-bool LoggerFactory::IsResultDir() const {
-    return dynamic_cast<const ResultDirLoggerFactory*>(this) != nullptr;
-}
diff --git a/tools/unitrace/src/utils/logger_factory.h b/tools/unitrace/src/utils/logger_factory.h
deleted file mode 100644
index 4d4d5f8c..00000000
--- a/tools/unitrace/src/utils/logger_factory.h
+++ /dev/null
@@ -1,237 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#pragma once
-
-#include <map>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <tuple>
-#include <fstream>
-#include "utils/utils.h"
-#include "utils/unilogger.h"
-
-// JSON is the default; protobuf only when --output-format=protobuf and built in.
-// Resolved once (queried per record on the flush path); the format is fixed for
-// the process lifetime.
-inline bool UseProtobufOutput() {
-#if BUILD_WITH_PERFETTO
-  static const bool use_protobuf = (utils::GetEnv("UNITRACE_OutputFormat") == "protobuf");
-  return use_protobuf;
-#else  /* BUILD_WITH_PERFETTO */
-  return false;
-#endif /* BUILD_WITH_PERFETTO */
-}
-
-inline const char* TimelineTraceExt() {
-  return UseProtobufOutput() ? "pftrace" : "json";
-}
-
-enum LoggerType {
-  LOGGER_TYPE_LEGACY_SHARED_TRACE = 0,
-  LOGGER_TYPE_TRACE_HOST_TIMING,
-  LOGGER_TYPE_TRACE_DEVICE_TIMING,
-  LOGGER_TYPE_TRACE_DEVICE_SUBMISSION,
-  LOGGER_TYPE_CHROME_TRACE_UNITRACE,
-  LOGGER_TYPE_METRICS_SAMPLING,
-  LOGGER_TYPE_METRICS_SAMPLING_TEMP,
-  LOGGER_TYPE_METRICS_QUERY,
-  LOGGER_TYPE_METRICS_QUERY_TEMP,
-  // The kernel index: one record per kernel naming it, the base address the driver
-  // gave it, its command id and which dumped module binary holds its ISA. The extent
-  // is not in the record - the reader derives it from the binary. See
-  // ZeMetricProfiler::ReadModuleAndKernelProps, which documents the handoff. The
-  // binaries themselves are separate files named by the records, since there is one
-  // per module rather than one per device.
-  LOGGER_TYPE_KPROPS,
-  // No type for the disassembly artifacts: one is named after the kernel it holds,
-  // not after a device, so it never fit GenerateLogFileName's (type, device_id)
-  // shape. See GetDisasmFileName, which names them instead.
-  LOGGER_TYPE_KTIME,
-  LOGGER_TYPE_CONFIG,
-  LOGGER_TYPE_TRACE_CALL_LOGGING,
-  LOGGER_TYPE_TRACE_CCL_SUMMARY_REPORT,
-  LOGGER_TYPE_TRACE_DEVICE_TIMELINE,
-  LOGGER_TYPE_KMD_TRACE
-};
-
-class LegacyLoggerFactory;
-class ResultDirLoggerFactory;
-
-class LoggerFactory {
-public:
-    // Returns a singleton instance (do not delete the pointer)
-    static LoggerFactory* Create(uint32_t app_id = (std::numeric_limits<uint32_t>::max)());
-
-    bool IsLegacy() const;
-    bool IsResultDir() const;
-
-    // Flush and close all cached trace/report loggers. Metric and temp loggers
-    // stay open: the parent owns the metric handshake and finalizes those.
-    // Idempotent per Logger, so safe at an early stop and again at teardown.
-    void CloseTraceLoggers() const;
-
-#ifndef _WIN32
-    // Fork child: re-key to the child's pid and reopen each cached trace/report
-    // logger IN PLACE (collectors hold shared_ptrs to them). Metric/temp loggers
-    // are skipped, as in CloseTraceLoggers(): the parent finalizes those.
-    void ReopenAfterFork();
-
-    // atfork prepare/after hooks: hold mutex_ and every cached Logger's lock
-    // across fork() so none is left locked in the child by a vanished thread.
-    void LockForFork() const;
-    void UnlockAfterFork() const;
-#endif /* _WIN32 */
-
-    const std::string& GetAppName() const { return app_name_; }
-    const std::string& GetRank() const { return rank_; }
-
-    // Directory for the per-kernel assembly files, "asm" beside the run's other output.
-    //
-    // These are results, not intermediates, so they deliberately do not go to
-    // UNITRACE_DataDir: TearDown() removes that directory wholesale at exit, which
-    // would delete them before anyone could read them. They land beside the
-    // sampling report that references them instead - the same process writes both.
-    //
-    // Created on first use, so callers should hoist the call out of a per-kernel
-    // loop rather than calling it per file.
-    std::string GetDisasmDirPath() const;
-
-    // Name of one kernel's disassembly artifact in disasm_dir:
-    //   <disasm_dir>/<device_id>.<pid>.<kernel_id>.<ext>
-    //
-    // Nothing in the name says what these are, the directory they sit in saying it once
-    // for all of them. It is the same name in either mode, since the directory is already
-    // per-run in both (see GetDisasmDirPath) - there is nothing left here for a dot or an
-    // underscore to keep apart.
-    //
-    // The directory is passed in so a per-kernel loop does not re-create it per file.
-    //
-    // The pid is part of the name because the ranks of one MPI run share this directory
-    // and a kernel command id is only unique within a process. Without it one rank's
-    // artifacts would silently overwrite another's with the wrong kernel's disassembly.
-    std::string GetDisasmFileName(const std::string& disasm_dir, int32_t device_id, uint32_t pid,
-                                  uint64_t kernel_id, const std::string& ext) const;
-
-    // Base name of one dumped module binary in the data directory:
-    //   [.]module[._]<pid>.<index>.bin
-    //
-    // A base name, not a path, because the writer and the reader reach the data
-    // directory differently. Both call this rather than either building the name
-    // itself: a kernel record carries only (pid, index), so this is the whole of
-    // what turns a record into the file holding its ISA, and a disagreement between
-    // the two sides would surface as a kernel that silently cannot be disassembled.
-    //
-    // No device id in the name. The index is unique within the process that assigned
-    // it, and the pid separates the ranks of one MPI run, which is the only reason
-    // these names have to be qualified at all - so a module never has to be
-    // associated with a device just to be written.
-    std::string GetModuleBinaryFileName(uint32_t pid, uint32_t index) const;
-
-    // The pid out of a per-device file name written by another process:
-    //   [.]<type>[._]<device_id>.<pid>.txt  ->  <pid>
-    //
-    // The counterpart of the app_id_ that GenerateLogFileName puts there, for the
-    // reader of a file it did not write. A .kprops file is written by one process and
-    // its records do not repeat that process's id per kernel (see
-    // ZeMetricProfiler::ReadModuleAndKernelProps), so this is where their pid comes
-    // from - and the pid is what tells one rank's module binaries and disassembly
-    // artifacts from another's.
-    //
-    // Static and free of the naming scheme's leading punctuation: it reads only the
-    // trailing ".<pid>.txt", which both schemes share, so the caller does not have to
-    // know which factory wrote the file it found. Returns 0 if the name does not end
-    // that way, which no file this searches for can.
-    static uint32_t GetFileNamePid(const std::string& path);
-
-    std::shared_ptr<UniLogger> GetLogger(LoggerType type, bool lazy_flush = false, bool lock_free = false, bool binary = false) const {
-        int32_t device_id = -1;
-        return GetDeviceLogger(type, device_id, lazy_flush, lock_free, binary);
-    }
-
-    LoggerFactory(const LoggerFactory&) = delete;
-    LoggerFactory& operator=(const LoggerFactory&) = delete;
-    virtual ~LoggerFactory() = default;
-
-    virtual std::shared_ptr<UniLogger> GetDeviceLogger(LoggerType type, int32_t device_id, bool lazy_flush = false, bool lock_free = false, bool binary = false) const  = 0;
-    virtual std::string GenerateLogFileName(LoggerType type, int32_t device_id = -1) const = 0;
-#ifdef _WIN32
-    virtual std::pair<std::string, std::string> SearchRawMetricFiles(uint32_t pid) const = 0;
-#endif // _WIN32
-    virtual std::vector<std::string> SearchFilesByType(LoggerType type, int32_t device_id) const = 0;
-
-protected:
-    static std::string ComputeAppName(void);
-    explicit LoggerFactory(uint32_t app_id);
-    void CreateDirectory(const std::string& dir) const;
-    std::shared_ptr<UniLogger> GetLoggerImpl(LoggerType type, int32_t device_id, bool lazy_flush, bool lock_free, bool binary = false) const;
-    void RemoveDirectoryIfEmpty(const std::string& dir) const;
-    void SetAppId(uint32_t app_id) {app_id_ = app_id;}
-    // Hook for factories whose output location depends on app_id_ (see
-    // ResultDirLoggerFactory). Called by ReopenAfterFork() after SetAppId().
-    virtual void OnAppIdChanged() {}
-    std::string GetDataDirPath(bool warn = true) const {
-        std::string data_dir = utils::GetEnv("UNITRACE_DataDir");
-        if (data_dir.empty() && warn) {
-          std::cerr << "[ERROR] Data directory is missing or not specified." << std::endl;
-          exit(-1); // Bail out if data directory is not specified at this point.
-        }
-        return data_dir;
-    }
-
-    uint32_t app_id_;
-    const std::string app_name_;
-    const std::string rank_;
-    std::string dir_path_; // Directory path for output, empty by default
-    // Set by GetDisasmDirPath() to the directory it created, so that a subclass can
-    // clean it up without calling that method again and re-creating it.
-    mutable std::string disasm_dir_path_;
-    mutable std::mutex mutex_;
-    mutable std::map<std::tuple<LoggerType, int32_t, bool>, std::shared_ptr<UniLogger>> loggers_;
-};
-
-class LegacyLoggerFactory : public LoggerFactory {
-public:
-    LegacyLoggerFactory(uint32_t app_id, const std::string& log_file);
-
-    std::string GetLogFileName(const std::string& logfile, uint32_t pid = (std::numeric_limits<uint32_t>::max)()) const;
-    std::string GetMetricsFileName(const std::string& log_file, uint32_t app_id) const;
-
-    std::string GetChromeTraceFileName() const;
-    std::shared_ptr<UniLogger> GetDeviceLogger(LoggerType type, int32_t device_id, bool lazy_flush = false, bool lock_free = false, bool binary = false) const override;
-    std::string GenerateLogFileName(LoggerType type, int32_t device_id = -1) const override;
-#ifdef _WIN32
-    std::pair<std::string, std::string> SearchRawMetricFiles(uint32_t pid) const override;
-#endif // _WIN32
-    std::vector<std::string> SearchFilesByType(LoggerType type, int32_t device_id) const override;
-    void AdjustLoggerTypeAndDeviceId(LoggerType& type, int32_t& device_id) const;
-
-private:
-    const std::string log_file_;
-};
-
-class ResultDirLoggerFactory : public LoggerFactory {
-public:
-    ResultDirLoggerFactory(uint32_t app_id);
-    ~ResultDirLoggerFactory() override;
-
-    std::shared_ptr<UniLogger> GetDeviceLogger(LoggerType type, int32_t device_id, bool lazy_flush = false, bool lock_free = false, bool binary = false) const override;
-    std::string GenerateLogFileName(LoggerType type, int32_t device_id = -1) const override;
-#ifdef _WIN32
-    std::pair<std::string, std::string> SearchRawMetricFiles(uint32_t pid) const override;
-#endif // _WIN32
-    std::vector<std::string> SearchFilesByType(LoggerType type, int32_t device_id) const override;
-    std::string GetTraceLogFileName(LoggerType type) const;
-
-protected:
-    void OnAppIdChanged() override;
-
-private:
-    void SetResultDirPaths();
-    std::string result_dir_;
-    std::string metrics_dir_path_;
-};
diff --git a/tools/unitrace/src/utils/metric_config_validator.h b/tools/unitrace/src/utils/metric_config_validator.h
deleted file mode 100644
index 7b46befe..00000000
--- a/tools/unitrace/src/utils/metric_config_validator.h
+++ /dev/null
@@ -1,246 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_METRIC_CONFIG_VALIDATOR_H_
-#define PTI_TOOLS_UNITRACE_METRIC_CONFIG_VALIDATOR_H_
-
-// Structural validation of a --metric-config file (see README, "Metric Config
-// File Format"). It needs no device, so unitrace checks the file before the
-// application starts. Whether the named groups, programmables and parameter
-// values exist on a device is checked later, when the metric groups are created.
-
-#include <map>
-#include <string>
-
-#include "config_node.h"
-
-namespace metric_config {
-
-inline const char* kPredefined = "predefined";
-inline const char* kProgrammable = "programmable";
-inline const char* kParameters = "parameters";
-inline const char* kEnable = "enable";
-
-namespace detail {
-
-inline std::string Where(const std::string& filename, uint32_t line) {
-  return line != 0 ? filename + ":" + std::to_string(line) + ": " : filename + ": ";
-}
-
-// Validates the "enable" attribute and the absence of other attributes of a
-// predefined group or programmable metric entry. Sets enabled.
-inline bool CheckEntryAttributes(const ConfigNodePtr& entry, const char* kind, const std::string& filename,
-                                 bool& enabled, std::string& error) {
-  enabled = false;
-  bool seen = false;
-  for (const auto& attr : entry->getAttributes()) {
-    if (attr->getKey() != kEnable) {
-      error = Where(filename, attr->getLine()) + "unknown attribute '" + attr->getKey() + "' in " + kind +
-              " '" + entry->getName() + "' (only 'enable' is allowed" +
-              (std::string(kind) == "programmable metric" ? ", parameters go into a 'parameters' node)" : ")");
-      return false;
-    }
-    if (seen) {
-      error = Where(filename, attr->getLine()) + "duplicate 'enable' in " + kind + " '" + entry->getName() + "'";
-      return false;
-    }
-    seen = true;
-    auto bool_attr = std::dynamic_pointer_cast<BoolAttribute>(attr);
-    if (bool_attr == nullptr) {
-      error = Where(filename, attr->getLine()) + "'enable' of " + kind + " '" + entry->getName() +
-              "' must be true or false, found '" + attr->getValue() + "'";
-      return false;
-    }
-    enabled = bool_attr->getTypedValue();
-  }
-  return true;
-}
-
-inline bool CheckParameters(const ConfigNodePtr& params, const ConfigNodePtr& entry, const std::string& filename,
-                            std::string& error) {
-  if (!params->getChildren().empty()) {
-    const auto& child = params->getChildren().front();
-    error = Where(filename, child->getLine()) + "unexpected node '" + child->getName() + "' in 'parameters' of '" +
-            entry->getName() + "' (only <name>=<value> lines are allowed)";
-    return false;
-  }
-  std::map<std::string, uint32_t> keys;
-  AttributePtr range_param;
-  for (const auto& attr : params->getAttributes()) {
-    auto it = keys.find(attr->getKey());
-    if (it != keys.end()) {
-      error = Where(filename, attr->getLine()) + "duplicate parameter '" + attr->getKey() + "' of '" +
-              entry->getName() + "' (first set at line " + std::to_string(it->second) + ")";
-      return false;
-    }
-    keys[attr->getKey()] = attr->getLine();
-
-    switch (attr->getType()) {
-      case AttributeType::STRING:
-        error = Where(filename, attr->getLine()) + "parameter '" + attr->getKey() + "' of '" + entry->getName() +
-                "': string values are not supported";
-        return false;
-      case AttributeType::INT:
-        error = Where(filename, attr->getLine()) + "parameter '" + attr->getKey() + "' of '" + entry->getName() +
-                "': negative values are not supported";
-        return false;
-      case AttributeType::UNSIGNED_64_RANGE_LIST:
-        if (range_param != nullptr) {
-          error = Where(filename, attr->getLine()) + "only one parameter of '" + entry->getName() +
-                  "' can be a range list ('" + range_param->getKey() + "' at line " +
-                  std::to_string(range_param->getLine()) + " is one already)";
-          return false;
-        }
-        range_param = attr;
-        break;
-      default:
-        break;
-    }
-  }
-  return true;
-}
-
-} // namespace detail
-
-// Validates the structure of a loaded metric config:
-//   predefined{ <group>{ enable=<bool> } ... }
-//   programmable{ <metric>{ enable=<bool>  parameters{ <name>=<value> ... } } ... }
-// Both sections are optional, but at least one must be present; each may appear
-// once. Entry names must be unique within a section, "enable" defaults to false,
-// at most one parameter per metric may be a range list, and parameter values must
-// be unsigned integers, decimals, booleans or range lists. Something must be
-// selected: a group given with -g (cli_group_count) or an enabled entry.
-// Selecting more than one group is not rejected here: entries a device does not
-// support are skipped when the groups are created, so one file can serve several
-// devices; CreateMetricGroups checks that exactly one group is left per device.
-// Returns false with error = "<filename>[:<line>]: <reason>" if the config is invalid.
-inline bool Validate(const ConfigNodePtr& root, const std::string& filename, uint32_t cli_group_count,
-                     std::string& error) {
-  using detail::Where;
-  error.clear();
-
-  if (!root->getAttributes().empty()) {
-    const auto& attr = root->getAttributes().front();
-    error = Where(filename, attr->getLine()) + "'" + attr->getKey() +
-            "' must be inside a 'predefined' or 'programmable' node";
-    return false;
-  }
-
-  std::map<std::string, uint32_t> sections;
-  uint32_t enabled_entries = 0;
-
-  for (const auto& section : root->getChildren()) {
-    const std::string& sname = section->getName();
-    if (sname != kPredefined && sname != kProgrammable) {
-      error = Where(filename, section->getLine()) + "unknown node '" + sname +
-              "' (expected 'predefined' or 'programmable')";
-      return false;
-    }
-    auto sit = sections.find(sname);
-    if (sit != sections.end()) {
-      error = Where(filename, section->getLine()) + "duplicate '" + sname + "' node (first at line " +
-              std::to_string(sit->second) + ")";
-      return false;
-    }
-    sections[sname] = section->getLine();
-
-    const bool predefined = (sname == kPredefined);
-    const char* kind = predefined ? "predefined group" : "programmable metric";
-
-    if (!section->getAttributes().empty()) {
-      const auto& attr = section->getAttributes().front();
-      error = Where(filename, attr->getLine()) + "'" + attr->getKey() + "' must be inside a " + kind +
-              " node of '" + sname + "'";
-      return false;
-    }
-
-    std::map<std::string, uint32_t> entries;
-    for (const auto& entry : section->getChildren()) {
-      auto eit = entries.find(entry->getName());
-      if (eit != entries.end()) {
-        error = Where(filename, entry->getLine()) + "duplicate " + kind + " '" + entry->getName() +
-                "' (first at line " + std::to_string(eit->second) + ")";
-        return false;
-      }
-      entries[entry->getName()] = entry->getLine();
-
-      bool enabled = false;
-      if (!detail::CheckEntryAttributes(entry, kind, filename, enabled, error)) {
-        return false;
-      }
-
-      if (predefined) {
-        if (!entry->getChildren().empty()) {
-          const auto& child = entry->getChildren().front();
-          error = Where(filename, child->getLine()) + "unexpected node '" + child->getName() +
-                  "' in predefined group '" + entry->getName() + "' (only 'enable' is allowed)";
-          return false;
-        }
-      } else {
-        bool has_params = false;
-        for (const auto& child : entry->getChildren()) {
-          if (child->getName() != kParameters) {
-            error = Where(filename, child->getLine()) + "unexpected node '" + child->getName() +
-                    "' in programmable metric '" + entry->getName() + "' (only 'parameters' is allowed)";
-            return false;
-          }
-          if (has_params) {
-            error = Where(filename, child->getLine()) + "duplicate 'parameters' node in programmable metric '" +
-                    entry->getName() + "'";
-            return false;
-          }
-          has_params = true;
-          if (!detail::CheckParameters(child, entry, filename, error)) {
-            return false;
-          }
-        }
-      }
-
-      if (enabled) {
-        ++enabled_entries;
-      }
-    }
-  }
-
-  if (sections.empty()) {
-    error = Where(filename, 0) + "no 'predefined' or 'programmable' node found";
-    return false;
-  }
-
-  if (cli_group_count + enabled_entries == 0) {
-    error = Where(filename, 0) + "no metric group or programmable metric is enabled (set enable=true)";
-    return false;
-  }
-  return true;
-}
-
-// Loads and validates a metric config file. Returns nullptr with error set to
-// "<filename>[:<line>]: <reason>" on a syntax or structure error.
-inline ConfigNodePtr Load(const std::string& filename, uint32_t cli_group_count, std::string& error) {
-  ConfigNodePtr root = ConfigNode::load(filename, error);
-  if (root == nullptr || !Validate(root, filename, cli_group_count, error)) {
-    return nullptr;
-  }
-  return root;
-}
-
-// Number of groups in a comma-separated -g/--group value.
-inline uint32_t CountGroups(const std::string& groups_list) {
-  if (groups_list.empty()) {
-    return 0;
-  }
-  uint32_t count = 1;
-  for (char c : groups_list) {
-    if (c == ',') {
-      ++count;
-    }
-  }
-  return count;
-}
-
-} // namespace metric_config
-
-#endif // PTI_TOOLS_UNITRACE_METRIC_CONFIG_VALIDATOR_H_
diff --git a/tools/unitrace/src/utils/shared_memory.h b/tools/unitrace/src/utils/shared_memory.h
deleted file mode 100644
index c85ec94e..00000000
--- a/tools/unitrace/src/utils/shared_memory.h
+++ /dev/null
@@ -1,416 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_SHARED_MEMORY_H_
-#define PTI_TOOLS_UNITRACE_UTILS_SHARED_MEMORY_H_
-
-#include <cctype>
-#include <cstdio>
-#include <cstring>
-#include <memory>
-#include <string>
-
-#ifdef _WIN32
-#include <windows.h>
-#else /* _WIN32 */
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <unistd.h>
-#endif /* _WIN32 */
-
-#include <iostream>
-
-#define SHM_NAME_MAX 256
-#define SHM_NAME_PREFIX "/uctrl"
-
-// Tag that scopes every shared memory name to the invoking user, so users on a
-// shared host get separate control channels. Without it all users collide on
-// one global name: concurrently, one user's --start/--stop reaches the other's
-// run; and a segment left behind by another user's crashed launcher is fatal,
-// because /dev/shm is sticky and only the owner can unlink it (UNITRACEI-127).
-// A stale segment from the SAME user is recreated by Create(force_recreate).
-inline const std::string& GetShmUserTag() {
-    static const std::string tag = [] {
-#ifdef _WIN32
-        char name[256];
-        DWORD len = sizeof(name);
-        std::string user = GetUserNameA(name, &len) ? std::string(name, len - 1) : "unknown";
-        // The tag is part of a kernel object name: keep it to a safe subset.
-        for (char& c : user) {
-            if (!isalnum(static_cast<unsigned char>(c))) {
-                c = '_';
-            }
-        }
-        return user + "_";
-#else /* _WIN32 */
-        return std::to_string(getuid()) + "_";
-#endif /* _WIN32 */
-    }();
-    return tag;
-}
-
-enum SharedMemoryReturnStatus
-{
-    SHM_FAILED,
-    SHM_SUCCESS,
-    SHM_STOPPED,
-    SHM_ALREADY_EXISTS
-};
-
-enum SharedMemoryOpenMode {
-    SHM_OPEN_NONE,
-    SHM_OPEN_READ,
-    SHM_OPEN_WRITE
-};
-
-// Helper function to get error message in a thread-safe way
-inline std::string GetErrorMessage(int err) {
-#ifdef _WIN32
-    char buffer[256];
-    strerror_s(buffer, sizeof(buffer), err);
-    return std::string(buffer);
-#else /* _WIN32 */
-    return std::string(strerror(err));
-#endif /* _WIN32 */
-}
-
-class SharedMemory{
-private:
-    SharedMemoryOpenMode open_mode = SHM_OPEN_NONE;
-    void* p_data_ = nullptr;
-    char shm_name_[SHM_NAME_MAX] = { 0 };
-    size_t shm_size_ = 0;
-#ifndef _WIN32
-    int handle_ = -1;
-#else /* _WIN32 */
-    HANDLE hMapFile_ = nullptr;
-#endif /* _WIN32 */
-    bool ValidateSessionName(const char* session) {
-        // Prefix and user tag must leave room for at least one session
-        // character and the terminator; checked first so max_len cannot wrap.
-        const size_t fixed_len = strlen(SHM_NAME_PREFIX) + GetShmUserTag().size();
-        if (fixed_len + 2 > SHM_NAME_MAX) {
-            std::cerr << "[ERROR] User name is too long for a session identifier" << std::endl;
-            return false;
-        }
-        const size_t max_len = SHM_NAME_MAX - fixed_len - 1;
-        if (strlen(session) > max_len) {
-            std::cerr << "[ERROR] Session identifier is too long (maximum " << max_len << " }" << std::endl;
-            return false;
-        }
-        return true;
-    }
-
-    // Name layout: <prefix><uid or user name>_<session>, e.g. /uctrl1001_mysession.
-    bool SetSessionNameSize(const char* session, size_t size) {
-        if (!ValidateSessionName(session)) {
-            return false;
-        }
-
-        const int len = snprintf(shm_name_, sizeof(shm_name_), "%s%s%s",
-                                 SHM_NAME_PREFIX, GetShmUserTag().c_str(), session);
-        if (len < 0 || static_cast<size_t>(len) >= sizeof(shm_name_)) {
-            shm_name_[0] = '\0';
-            return false;
-        }
-        shm_size_ = size;
-        return true;
-    }
-
-public:
-    void* GetPtr() {
-        return p_data_;
-    }
-
-#ifndef _WIN32
-    SharedMemoryReturnStatus Create(const char* session, size_t size, bool force_recreate = false) {
-        // create shared memory object
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        bool already_existed = false;
-        handle_ = shm_open(shm_name_, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-        if (handle_ == -1) {
-            if (errno == EEXIST && force_recreate) {
-                // Stale shared memory from abnormal termination; clean up and recreate.
-                // The name is per-user, so this process owns the stale segment and
-                // may unlink it. Report if it still fails so the retry's EEXIST
-                // below is diagnosable.
-                if (shm_unlink(shm_name_) != 0 && errno != ENOENT) {
-                    std::cerr << "[WARNING] Failed to remove stale shared memory " << shm_name_ << " (" << GetErrorMessage(errno) << ")" << std::endl;
-                }
-                handle_ = shm_open(shm_name_, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-            } else if (errno == EEXIST) {
-                handle_ = shm_open(shm_name_, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-                already_existed = true;
-            }
-            if (handle_ == -1) {
-                std::cerr << "[ERROR] Failed to create shared memory for session " << session << " (" << GetErrorMessage(errno) << ")" << std::endl;
-                return SHM_FAILED;
-            }
-        }
-
-        // set size of shared memory
-        if (ftruncate(handle_, size) == -1) {
-            std::cerr << "[ERROR] Failed to set temporal control size" << std::endl;
-            return SHM_FAILED;
-        }
-
-        // map shared memory
-        p_data_ = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, handle_, 0);
-        if (p_data_ == MAP_FAILED) {
-            std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-
-        return already_existed ? SHM_ALREADY_EXISTS : SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus AttachWrite(const char* session, size_t size) {
-        if (p_data_ != nullptr) {
-            if (open_mode == SHM_OPEN_WRITE) {
-                // Already attached for writing in this process: idempotent no-op.
-                return SHM_SUCCESS;
-            }
-
-            SoftRelease();
-        }
-
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        handle_ = shm_open(shm_name_, O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-        if (handle_ == -1) {
-            std::cerr << "[WARNING] Session " << session << " is already stopped" << std::endl;
-            return SHM_STOPPED;
-        }
-
-        // map shared memory
-        p_data_ = mmap(0, shm_size_, PROT_READ | PROT_WRITE, MAP_SHARED, handle_, 0);
-        if (p_data_ == MAP_FAILED) {
-            std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-        open_mode = SHM_OPEN_WRITE;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus AttachRead(const char* session, size_t size) {
-        if (p_data_ != nullptr) {
-            if (open_mode == SHM_OPEN_READ) {
-                // Already attached for reading in this process: idempotent no-op.
-                return SHM_SUCCESS;
-            }
-
-            std::cout << "[INFO] session " << session << " is already mapped in write mode" << std::endl;
-            SoftRelease();
-        }
-
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        handle_ = shm_open(shm_name_, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-        if (handle_ == -1) {
-            std::cerr << "[WARNING] Session " << session << " is already stopped" << std::endl;
-            return SHM_STOPPED;
-        }
-
-        // map shared memory
-        p_data_ = mmap(0, shm_size_, PROT_READ, MAP_SHARED, handle_, 0);
-        if (p_data_ == MAP_FAILED) {
-            std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-        open_mode = SHM_OPEN_READ;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus SoftRelease() {
-        if (p_data_ != nullptr) {
-            // unmap shared memory
-            if (munmap((void*)p_data_, shm_size_) != 0) {
-                std::cerr << "[ERROR] Failed to unmap shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-                return SHM_FAILED;
-            }
-            p_data_ = nullptr;
-
-            if (close(handle_) != 0) {
-                std::cerr << "[ERROR] Failed to close shared memory descriptor (" << GetErrorMessage(errno) << ")" << std::endl;
-                return SHM_FAILED;
-            }
-        }
-
-        open_mode = SHM_OPEN_NONE;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus Release() {
-        if (p_data_ != nullptr) {
-            if (SoftRelease() == SHM_FAILED) {
-                return SHM_FAILED;
-            }
-
-            // unlink the shared memory (delete the memory)
-            // ENOENT is OK: the name may have been already unlinked by a stop command
-            if (shm_unlink(shm_name_) != 0 && errno != ENOENT) {
-                std::cerr << "[ERROR] Failed to unlink shared memory " << shm_name_ << " (" << GetErrorMessage(errno) << ")" << std::endl;
-                return SHM_FAILED;
-            }
-
-            p_data_ = nullptr;
-        }
-
-        open_mode = SHM_OPEN_NONE;
-        return SHM_SUCCESS;
-    }
-
-#else /* _WIN32 */
-
-    SharedMemoryReturnStatus Create(const char* session, size_t size, bool force_recreate = false) {
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        hMapFile_ = CreateFileMappingA(
-            INVALID_HANDLE_VALUE,
-            nullptr,
-            PAGE_READWRITE,
-            0,
-            static_cast<DWORD>(size),
-            shm_name_
-        );
-
-        if (!hMapFile_) {
-            std::cerr <<"[ERROR] Failed to create shared memory for session " << session << " (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-
-        bool already_exists = (GetLastError() == ERROR_ALREADY_EXISTS);
-
-        p_data_ = MapViewOfFile(hMapFile_, FILE_MAP_ALL_ACCESS, 0, 0, shm_size_);
-        if (!p_data_) {
-            CloseHandle(hMapFile_);
-            hMapFile_ = nullptr;
-            std::cerr << "[ERROR] Failed to map shared memory for session " << session << " (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-
-        if (already_exists && !force_recreate) {
-            return SHM_ALREADY_EXISTS;
-        }
-
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus AttachWrite(const char* session, size_t size) {
-        if (p_data_ != nullptr) {
-            if (open_mode == SHM_OPEN_WRITE) {
-                // Already attached for writing in this process: idempotent no-op.
-                return SHM_SUCCESS;
-            }
-
-            UnmapViewOfFile(p_data_);
-            p_data_ = MapViewOfFile(hMapFile_, FILE_MAP_WRITE, 0, 0, shm_size_);
-            if (!p_data_) {
-                std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-                CloseHandle(hMapFile_);
-                return SHM_FAILED;
-            }
-            open_mode = SHM_OPEN_WRITE;
-            return SHM_SUCCESS;
-        }
-
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        hMapFile_ = OpenFileMappingA(FILE_MAP_WRITE, FALSE, shm_name_);
-        if (!hMapFile_) {
-            std::cerr << "[ERROR] Session " << session << " does not exist or cannot be opened (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_FAILED;
-        }
-
-        p_data_ = MapViewOfFile(hMapFile_, FILE_MAP_WRITE, 0, 0, shm_size_);
-        if (!p_data_) {
-            std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-            CloseHandle(hMapFile_);
-            return SHM_FAILED;
-        }
-
-        open_mode = SHM_OPEN_WRITE;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus AttachRead(const char* session, size_t size) {
-        if (p_data_ != nullptr) {
-            if (open_mode == SHM_OPEN_READ) {
-                // Already attached for reading in this process: idempotent no-op.
-                return SHM_SUCCESS;
-            }
-
-            std::cout << "[INFO] session " << session << " is already mapped in write mode" << std::endl;
-            UnmapViewOfFile(p_data_);
-            p_data_ = MapViewOfFile(hMapFile_, FILE_MAP_READ, 0, 0, shm_size_);
-            if (!p_data_) {
-                std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-                CloseHandle(hMapFile_);
-                return SHM_FAILED;
-            }
-            open_mode = SHM_OPEN_READ;
-            return SHM_SUCCESS;
-        }
-
-        if (!SetSessionNameSize(session, size)) {
-            return SHM_FAILED;
-        }
-
-        hMapFile_ = OpenFileMappingA(FILE_MAP_READ, FALSE, shm_name_);
-        if (!hMapFile_) {
-            std::cerr << "[ERROR] Session " << session << " does not exist or cannot be opened or stopped (" << GetErrorMessage(errno) << ")" << std::endl;
-            return SHM_STOPPED;
-        }
-
-        p_data_ = MapViewOfFile(hMapFile_, FILE_MAP_READ, 0, 0, shm_size_);
-        if (!p_data_) {
-            std::cerr << "[ERROR] Failed to map shared memory (" << GetErrorMessage(errno) << ")" << std::endl;
-            CloseHandle(hMapFile_);
-            return SHM_FAILED;
-        }
-
-        open_mode = SHM_OPEN_READ;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus SoftRelease() {
-        if (p_data_ != nullptr) {
-            UnmapViewOfFile(p_data_);
-            p_data_ = nullptr;
-
-            if (hMapFile_) {
-                if (!CloseHandle(hMapFile_)) {
-                    std::cerr << "[ERROR] Failed to close shared memory handle (" << GetErrorMessage(errno) << ")" << std::endl;
-                    return SHM_FAILED;
-                }
-            }
-        }
-
-        open_mode = SHM_OPEN_NONE;
-        return SHM_SUCCESS;
-    }
-
-    SharedMemoryReturnStatus Release() {
-        return SoftRelease();
-    }
-#endif /* _WIN32 */
-};
-
-#endif // PTI_TOOLS_UNITRACE_UTILS_SHARED_MEMORY_H_
-
diff --git a/tools/unitrace/src/utils/source_resolver.h b/tools/unitrace/src/utils/source_resolver.h
deleted file mode 100644
index 3669639b..00000000
--- a/tools/unitrace/src/utils/source_resolver.h
+++ /dev/null
@@ -1,1153 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Kernel Instruction Offset -> Source Location
-//
-// Maps an instruction offset in a kernel to its source file, line and column, using
-// the DWARF line number program in the module binary's ".debug_line" (versions 2-5,
-// implemented from the spec; nothing else in the container is decoded).
-//
-// IGC emits one unit per kernel, and a unit does not name its kernel, so it is found
-// through ".rela.debug_line": the relocations against the kernel's ".text.<mangled
-// name>" section fall in its unit. In an unlinked ZeBin the row addresses are
-// placeholders, so they are normalized against their lowest, the kernel's entry.
-//
-// Building a table is the costly part and a lookup is a binary search, so build once
-// per kernel: ResolveAllKernelInstructions() returns the whole mapping, and
-// FindSourceLocation() looks offsets up in it.
-//
-// References:
-//   DWARF Debugging Information Format, Version 5, Section 6.2 (Line Number
-//   Information) https://dwarfstd.org/doc/DWARF5.pdf
-//   DWARF Debugging Information Format, Version 4, Section 6.2
-//   https://dwarfstd.org/doc/DWARF4.pdf
-//
-//==============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_UTILS_SOURCE_RESOLVER_H_
-#define PTI_TOOLS_UNITRACE_UTILS_SOURCE_RESOLVER_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <iostream>
-#include <set>
-#include <string>
-#include <vector>
-
-// ELF64 sections and ByteCursor.
-#include "elf64_reader.h"
-
-// ---------------------------------------------------------------------------
-// What a lookup produces
-// ---------------------------------------------------------------------------
-
-// Where one instruction came from, as the line table records it.
-struct SourceLocation {
-  std::string file_path_;  // As the line table spells it, directory prefix applied
-  uint32_t line_ = 0;      // 1-based; 0 means the row deliberately had no line
-  uint32_t column_ = 0;    // 1-based; 0 means "anywhere on the line"
-  // The kernel-relative range the row covers.
-  uint64_t range_offset_ = 0;
-  uint64_t range_size_ = 0;
-  // The first instruction of a statement (a recommended breakpoint).
-  bool is_statement_ = false;
-};
-
-// The relocations against ".debug_line", sorted by CollectRelocations() for binary
-// search.
-struct Relocations {
-  // Offsets of relocations naming the kernel's ".text." section, each on the
-  // DW_LNE_set_address operand of one of its sequences.
-  std::vector<uint64_t> offsets_;
-  // Every relocation as (offset patched, value), for DWARF 5 string references whose
-  // in-place value is 0.
-  std::vector<std::pair<uint64_t, uint64_t>> values_;
-
-  // Whether a relocation names the kernel's section at exactly this offset.
-  bool Names(uint64_t offset) const {
-    return std::binary_search(offsets_.begin(), offsets_.end(), offset);
-  }
-
-  // Whether any lands in [begin, end), e.g. a unit.
-  bool NamesRange(uint64_t begin, uint64_t end) const {
-    const auto it = std::lower_bound(offsets_.begin(), offsets_.end(), begin);
-    return it != offsets_.end() && *it < end;
-  }
-
-  bool Lookup(uint64_t offset, uint64_t& out_value) const {
-    const auto it = std::lower_bound(
-        values_.begin(), values_.end(), offset,
-        [](const std::pair<uint64_t, uint64_t>& entry, uint64_t at) { return entry.first < at; });
-    if (it == values_.end() || it->first != offset) {
-      return false;
-    }
-    out_value = it->second;
-    return true;
-  }
-};
-
-// Reads the relocations whose sh_info is ".debug_line". One names the kernel if its
-// symbol is in the kernel's ".text." section (text_index; an assembler's section
-// symbol) or is named after it (text_section_name; IGC's symbols, whose st_shndx is
-// the patched section).
-inline void CollectRelocations(const std::vector<Elf64Section>& sections, uint32_t debug_line_index,
-                               uint32_t text_index, const std::string& text_section_name,
-                               const Elf64Section& debug_line, Relocations& out_relocations) {
-  std::vector<uint64_t>& out_offsets = out_relocations.offsets_;
-  out_offsets.clear();
-  out_relocations.values_.clear();
-  for (const Elf64Section& relocations : sections) {
-    const bool is_rela = relocations.type_ == kElf64ShtRela;
-    const bool is_rel = relocations.type_ == kElf64ShtRel;
-    // data_ is nullptr if sh_offset/sh_size are outside the file; size_ is then
-    // unchecked and must not size the reserve below.
-    if ((!is_rela && !is_rel) || relocations.info_ != debug_line_index || relocations.data_ == nullptr) {
-      continue;
-    }
-    if (relocations.link_ >= sections.size()) {
-      continue;
-    }
-    const Elf64Section& symbols = sections[relocations.link_];
-    if (symbols.data_ == nullptr) {
-      continue;
-    }
-    // Symbol names, if present; the st_shndx test does not need them.
-    StringTableView symbol_names;
-    if (symbols.link_ < sections.size()) {
-      symbol_names.data_ = sections[symbols.link_].data_;
-      symbol_names.size_ = sections[symbols.link_].size_;
-    }
-
-    // Honour a larger sh_entsize.
-    const uint64_t abi_size = is_rela ? kElf64RelaSize : kElf64RelSize;
-    const uint64_t stride = (relocations.entry_size_ >= abi_size) ? relocations.entry_size_ : abi_size;
-
-    ByteCursor entries(relocations.data_, relocations.size_);
-    out_relocations.values_.reserve(out_relocations.values_.size() +
-                                    static_cast<size_t>(relocations.size_ / stride));
-    for (uint64_t at = 0; at + stride <= relocations.size_; at += stride) {
-      entries.Seek(at + kElf64RelOffsetOffset);
-      const uint64_t r_offset = entries.U64();
-      entries.Seek(at + kElf64RelInfoOffset);
-      const uint64_t r_info = entries.U64();
-      if (!entries.Ok()) {
-        break;
-      }
-
-      // The high half of r_info is the symbol index; the type is not needed.
-      const uint64_t symbol_index = r_info >> 32;
-      const uint64_t symbol_stride =
-          (symbols.entry_size_ >= kElf64SymSize) ? symbols.entry_size_ : kElf64SymSize;
-      const uint64_t symbol_at = symbol_index * symbol_stride;
-      if (!Elf64RangeInBounds(symbol_at, symbol_stride, symbols.size_)) {
-        continue;
-      }
-      ByteCursor symbol(symbols.data_, symbols.size_);
-      symbol.Seek(symbol_at + kElf64SymNameOffset);
-      const uint32_t name_offset = symbol.U32();
-      symbol.Seek(symbol_at + kElf64SymShndxOffset);
-      const uint16_t section_index = symbol.U16();
-      symbol.Seek(symbol_at + kElf64SymValueOffset);
-      const uint64_t symbol_value = symbol.U64();
-      if (!symbol.Ok()) {
-        continue;
-      }
-      // st_name 0 is "no name". The name is compared only if st_shndx did not match.
-      bool names_kernel = section_index == text_index;
-      if (!names_kernel && name_offset != 0 && !text_section_name.empty()) {
-        names_kernel = symbol_names.Equals(name_offset, text_section_name);
-      }
-      if (names_kernel) {
-        out_offsets.push_back(r_offset);
-      }
-
-      // SHT_RELA carries the addend; SHT_REL leaves it in the patched bytes.
-      uint64_t addend = 0;
-      if (is_rela) {
-        entries.Seek(at + kElf64RelaAddendOffset);
-        addend = entries.U64();
-        if (!entries.Ok()) {
-          break;
-        }
-      } else if (Elf64RangeInBounds(r_offset, 4, debug_line.size_) &&
-                 debug_line.data_ != nullptr) {
-        ByteCursor in_place(debug_line.data_, debug_line.size_);
-        in_place.Seek(r_offset);
-        addend = in_place.U32();
-      }
-      out_relocations.values_.push_back({r_offset, symbol_value + addend});
-    }
-  }
-
-  // Stable, so Lookup() returns the first of two relocations at one offset.
-  std::sort(out_offsets.begin(), out_offsets.end());
-  std::stable_sort(out_relocations.values_.begin(), out_relocations.values_.end(),
-                   [](const std::pair<uint64_t, uint64_t>& a,
-                      const std::pair<uint64_t, uint64_t>& b) { return a.first < b.first; });
-}
-
-// ---------------------------------------------------------------------------
-// DWARF line number program
-// ---------------------------------------------------------------------------
-
-// Standard opcodes, DWARF 5 section 6.2.5.2.
-constexpr uint8_t kDwLnsCopy = 1;
-constexpr uint8_t kDwLnsAdvancePc = 2;
-constexpr uint8_t kDwLnsAdvanceLine = 3;
-constexpr uint8_t kDwLnsSetFile = 4;
-constexpr uint8_t kDwLnsSetColumn = 5;
-constexpr uint8_t kDwLnsNegateStmt = 6;
-constexpr uint8_t kDwLnsSetBasicBlock = 7;
-constexpr uint8_t kDwLnsConstAddPc = 8;
-constexpr uint8_t kDwLnsFixedAdvancePc = 9;
-constexpr uint8_t kDwLnsSetPrologueEnd = 10;
-constexpr uint8_t kDwLnsSetEpilogueBegin = 11;
-constexpr uint8_t kDwLnsSetIsa = 12;
-
-// Extended opcodes, DWARF 5 section 6.2.5.3.
-constexpr uint8_t kDwLneEndSequence = 1;
-constexpr uint8_t kDwLneSetAddress = 2;
-constexpr uint8_t kDwLneDefineFile = 3;  // DWARF 4 and earlier only
-constexpr uint8_t kDwLneSetDiscriminator = 4;
-
-// Content type codes for the DWARF 5 directory and file tables, table 7.27.
-constexpr uint64_t kDwLnctPath = 1;
-constexpr uint64_t kDwLnctDirectoryIndex = 2;
-
-// Attribute forms, table 7.6, that a file or directory entry (including a vendor
-// content type) may use.
-constexpr uint64_t kDwFormAddr = 0x01;
-constexpr uint64_t kDwFormBlock2 = 0x03;
-constexpr uint64_t kDwFormBlock4 = 0x04;
-constexpr uint64_t kDwFormData2 = 0x05;
-constexpr uint64_t kDwFormData4 = 0x06;
-constexpr uint64_t kDwFormData8 = 0x07;
-constexpr uint64_t kDwFormString = 0x08;
-constexpr uint64_t kDwFormBlock = 0x09;
-constexpr uint64_t kDwFormBlock1 = 0x0A;
-constexpr uint64_t kDwFormData1 = 0x0B;
-constexpr uint64_t kDwFormFlag = 0x0C;
-constexpr uint64_t kDwFormSdata = 0x0D;
-constexpr uint64_t kDwFormStrp = 0x0E;
-constexpr uint64_t kDwFormUdata = 0x0F;
-constexpr uint64_t kDwFormFlagPresent = 0x19;
-constexpr uint64_t kDwFormStrx = 0x1A;
-constexpr uint64_t kDwFormData16 = 0x1E;
-constexpr uint64_t kDwFormLineStrp = 0x1F;
-constexpr uint64_t kDwFormImplicitConst = 0x21;
-constexpr uint64_t kDwFormStrx1 = 0x25;
-constexpr uint64_t kDwFormStrx2 = 0x26;
-constexpr uint64_t kDwFormStrx3 = 0x27;
-constexpr uint64_t kDwFormStrx4 = 0x28;
-
-// One row of the line table: the registers a source lookup needs.
-struct LineRow {
-  uint64_t address_ = 0;
-  uint64_t file_ = 0;
-  uint32_t line_ = 0;
-  uint32_t column_ = 0;
-  bool is_stmt_ = false;
-  // Closes a sequence: its address ends the last range but it is no range itself.
-  bool end_sequence_ = false;
-  // Where the sequence's DW_LNE_set_address operand sits, which a relocation ties to
-  // a kernel; kNoOffset if none.
-  uint64_t address_source_ = ~static_cast<uint64_t>(0);
-};
-
-constexpr uint64_t kNoOffset = ~static_cast<uint64_t>(0);
-
-// One unit of ".debug_line": the file table its rows name, and the rows themselves.
-struct LineUnit {
-  uint64_t offset_ = 0;  // Where the unit starts, which relocations point into
-  uint64_t end_ = 0;
-  uint16_t version_ = 0;
-  // Indexed as the rows index it: from 0 in DWARF 5, from 1 before (entry 0 empty).
-  std::vector<std::string> file_paths_;
-  std::vector<LineRow> rows_;
-};
-
-// Reads one value of a form, keeping a string or number and skipping anything else.
-// Returns false for a form it cannot read.
-inline bool ReadFormValue(ByteCursor& cursor, uint64_t form, uint8_t offset_size,
-                          uint8_t address_size, const StringTableView& debug_str,
-                          const StringTableView& debug_line_str, const Relocations* relocations,
-                          std::string& out_string, uint64_t& out_number, bool& out_has_string,
-                          bool& out_has_number) {
-  out_has_string = false;
-  out_has_number = false;
-  switch (form) {
-    case kDwFormString:
-      out_has_string = cursor.String(out_string);
-      return true;
-    case kDwFormLineStrp:
-    case kDwFormStrp: {
-      // In an unlinked object the offset is the relocation's, not the bytes'.
-      const uint64_t patched_at = cursor.Offset();
-      uint64_t at = (offset_size == 8) ? cursor.U64() : cursor.U32();
-      uint64_t relocated_at = 0;
-      if (relocations != nullptr && relocations->Lookup(patched_at, relocated_at)) {
-        at = relocated_at;
-      }
-      const StringTableView& table = (form == kDwFormLineStrp) ? debug_line_str : debug_str;
-      // A missing string is not fatal; only this name is lost.
-      out_has_string = table.Get(at, out_string);
-      return true;
-    }
-    case kDwFormUdata:
-      out_number = cursor.Uleb();
-      out_has_number = true;
-      return true;
-    case kDwFormSdata:
-      out_number = static_cast<uint64_t>(cursor.Sleb());
-      out_has_number = true;
-      return true;
-    case kDwFormData1:
-    case kDwFormFlag:
-      out_number = cursor.U8();
-      out_has_number = true;
-      return true;
-    case kDwFormData2:
-      out_number = cursor.U16();
-      out_has_number = true;
-      return true;
-    case kDwFormData4:
-      out_number = cursor.U32();
-      out_has_number = true;
-      return true;
-    case kDwFormData8:
-      out_number = cursor.U64();
-      out_has_number = true;
-      return true;
-    case kDwFormData16:  // An MD5 checksum, in practice
-      cursor.Skip(16);
-      return true;
-    case kDwFormAddr:
-      out_number = cursor.Address(address_size);
-      out_has_number = true;
-      return true;
-    case kDwFormFlagPresent:
-    case kDwFormImplicitConst:
-      return true;  // No bytes in the entry at all
-    case kDwFormBlock1:
-      cursor.Skip(cursor.U8());
-      return true;
-    case kDwFormBlock2:
-      cursor.Skip(cursor.U16());
-      return true;
-    case kDwFormBlock4:
-      cursor.Skip(cursor.U32());
-      return true;
-    case kDwFormBlock:
-      cursor.Skip(cursor.Uleb());
-      return true;
-    // Indexed strings need ".debug_info" for their base, so are not supported.
-    case kDwFormStrx:
-      (void)cursor.Uleb();
-      return false;
-    case kDwFormStrx1:
-      cursor.Skip(1);
-      return false;
-    case kDwFormStrx2:
-      cursor.Skip(2);
-      return false;
-    case kDwFormStrx3:
-      cursor.Skip(3);
-      return false;
-    case kDwFormStrx4:
-      cursor.Skip(4);
-      return false;
-    default:
-      return false;
-  }
-}
-
-// Joins a directory and a file name.
-inline std::string JoinPath(const std::string& directory, const std::string& name) {
-  if (name.empty()) {
-    return directory;
-  }
-  // An absolute name, POSIX or Windows, ignores the directory.
-  const bool absolute = name[0] == '/' || name[0] == '\\' ||
-                        (name.size() > 2 && name[1] == ':' && (name[2] == '/' || name[2] == '\\'));
-  if (absolute || directory.empty()) {
-    return name;
-  }
-  const char last = directory[directory.size() - 1];
-  if (last == '/' || last == '\\') {
-    return directory + name;
-  }
-  return directory + "/" + name;
-}
-
-// Parses the directory and file tables of a DWARF 2-4 header, each ended by an empty
-// entry.
-inline bool ReadLegacyFileTable(ByteCursor& cursor, LineUnit& unit) {
-  std::vector<std::string> directories;
-  // Index 0, the compilation directory, is not here: left empty.
-  directories.push_back(std::string());
-  for (;;) {
-    std::string entry;
-    if (!cursor.String(entry)) {
-      return false;
-    }
-    if (entry.empty()) {
-      break;
-    }
-    directories.push_back(std::move(entry));
-  }
-
-  // Files are numbered from 1; index 0 is a placeholder.
-  unit.file_paths_.push_back(std::string());
-  for (;;) {
-    std::string name;
-    if (!cursor.String(name)) {
-      return false;
-    }
-    if (name.empty()) {
-      break;
-    }
-    const uint64_t directory_index = cursor.Uleb();
-    (void)cursor.Uleb();  // Modification time
-    (void)cursor.Uleb();  // File length
-    if (!cursor.Ok()) {
-      return false;
-    }
-    const std::string& directory =
-        (directory_index < directories.size()) ? directories[directory_index] : std::string();
-    unit.file_paths_.push_back(JoinPath(directory, name));
-  }
-  return true;
-}
-
-// Parses the directory and file tables of a DWARF 5 header, each described by a list
-// of (content type, form) pairs.
-inline bool ReadDwarf5FileTable(ByteCursor& cursor, uint8_t offset_size, uint8_t address_size,
-                                const StringTableView& debug_str,
-                                const StringTableView& debug_line_str,
-                                const Relocations* relocations, LineUnit& unit) {
-  // Reads either table; only the file table uses a directory index.
-  auto read_table = [&](bool is_file_table, std::vector<std::string>& out_paths,
-                        const std::vector<std::string>* directories) -> bool {
-    const uint8_t format_count = cursor.U8();
-    std::vector<std::pair<uint64_t, uint64_t>> format;  // (content type, form)
-    format.reserve(format_count);
-    for (uint8_t i = 0; i < format_count; ++i) {
-      const uint64_t content_type = cursor.Uleb();
-      const uint64_t form = cursor.Uleb();
-      if (!cursor.Ok()) {
-        return false;
-      }
-      format.push_back({content_type, form});
-    }
-
-    const uint64_t entry_count = cursor.Uleb();
-    if (!cursor.Ok()) {
-      return false;
-    }
-    // Taken as malformed if larger than the bytes left, which bounds the reserve()
-    // below. Only an entry of zero-size forms alone takes no byte, and none is useful.
-    if (entry_count > cursor.Size() - cursor.Offset()) {
-      return false;
-    }
-    out_paths.reserve(static_cast<size_t>(entry_count));
-
-    for (uint64_t i = 0; i < entry_count; ++i) {
-      std::string path;
-      uint64_t directory_index = 0;
-      for (const std::pair<uint64_t, uint64_t>& field : format) {
-        std::string value_string;
-        uint64_t value_number = 0;
-        bool has_string = false;
-        bool has_number = false;
-        if (!ReadFormValue(cursor, field.second, offset_size, address_size, debug_str,
-                           debug_line_str, relocations, value_string, value_number, has_string,
-                           has_number)) {
-          return false;
-        }
-        if (!cursor.Ok()) {
-          return false;
-        }
-        if (field.first == kDwLnctPath && has_string) {
-          path = std::move(value_string);
-        } else if (field.first == kDwLnctDirectoryIndex && has_number) {
-          directory_index = value_number;
-        }
-      }
-      if (is_file_table && directories != nullptr) {
-        const std::string& directory = (directory_index < directories->size())
-                                           ? (*directories)[directory_index]
-                                           : std::string();
-        out_paths.push_back(JoinPath(directory, path));
-      } else {
-        out_paths.push_back(std::move(path));
-      }
-    }
-    return true;
-  };
-
-  std::vector<std::string> directories;
-  if (!read_table(false, directories, nullptr)) {
-    return false;
-  }
-  // Files are numbered from 0 in DWARF 5, so no placeholder.
-  return read_table(true, unit.file_paths_, &directories);
-}
-
-// Runs one unit's line number program from cursor to program_end, the state machine
-// of DWARF 5 section 6.2.5, op_index included (always 0 on Intel GPUs).
-inline bool RunLineProgram(ByteCursor& cursor, uint64_t program_end, uint8_t address_size,
-                           uint8_t minimum_instruction_length,
-                           uint8_t maximum_operations_per_instruction, bool default_is_stmt,
-                           int8_t line_base, uint8_t line_range, uint8_t opcode_base,
-                           const std::vector<uint8_t>& standard_opcode_lengths, LineUnit& unit) {
-  struct State {
-    uint64_t address_ = 0;
-    uint32_t op_index_ = 0;
-    uint64_t file_ = 1;
-    uint32_t line_ = 1;
-    uint32_t column_ = 0;
-    bool is_stmt_ = false;
-    bool end_sequence_ = false;
-    // Not a DWARF register: see LineRow::address_source_.
-    uint64_t address_source_ = kNoOffset;
-  };
-
-  State state;
-  state.is_stmt_ = default_is_stmt;
-  // The file register starts at 1 in every version, even though DWARF 5 numbers the
-  // table from 0 (section 6.2.2).
-
-  auto reset = [&]() {
-    state = State();
-    state.is_stmt_ = default_is_stmt;
-  };
-
-  auto emit = [&]() {
-    LineRow row;
-    row.address_ = state.address_;
-    row.file_ = state.file_;
-    row.line_ = state.line_;
-    row.column_ = state.column_;
-    row.is_stmt_ = state.is_stmt_;
-    row.end_sequence_ = state.end_sequence_;
-    row.address_source_ = state.address_source_;
-    unit.rows_.push_back(row);
-  };
-
-  const uint32_t max_ops =
-      (maximum_operations_per_instruction == 0) ? 1 : maximum_operations_per_instruction;
-
-  auto advance = [&](uint64_t operation_advance) {
-    const uint64_t total = state.op_index_ + operation_advance;
-    state.address_ += static_cast<uint64_t>(minimum_instruction_length) * (total / max_ops);
-    state.op_index_ = static_cast<uint32_t>(total % max_ops);
-  };
-
-  while (cursor.Ok() && cursor.Offset() < program_end) {
-    const uint8_t opcode = cursor.U8();
-    if (!cursor.Ok()) {
-      return false;
-    }
-
-    // A special opcode: advances the address and line, and emits a row.
-    if (opcode_base != 0 && opcode >= opcode_base) {
-      const uint8_t adjusted = static_cast<uint8_t>(opcode - opcode_base);
-      if (line_range == 0) {
-        return false;  // Would divide by zero; the header is malformed
-      }
-      advance(adjusted / line_range);
-      const int64_t line_advance = line_base + static_cast<int64_t>(adjusted % line_range);
-      const int64_t new_line = static_cast<int64_t>(state.line_) + line_advance;
-      // Clamp a negative line rather than reject the table.
-      state.line_ = (new_line < 0) ? 0 : static_cast<uint32_t>(new_line);
-      emit();
-      continue;
-    }
-
-    if (opcode == 0) {
-      // An extended opcode, length-prefixed so an unknown one can be stepped over.
-      const uint64_t length = cursor.Uleb();
-      if (!cursor.Ok()) {
-        return false;
-      }
-      // Checked before adding: a length from the file near 2^64 would wrap the sum to
-      // an earlier offset, and seeking back to it would loop forever.
-      if (length == 0 || cursor.Offset() > program_end ||
-          length > program_end - cursor.Offset()) {
-        return false;
-      }
-      const uint64_t after = cursor.Offset() + length;
-      const uint8_t sub_opcode = cursor.U8();
-      switch (sub_opcode) {
-        case kDwLneEndSequence:
-          state.end_sequence_ = true;
-          emit();
-          reset();
-          break;
-        case kDwLneSetAddress: {
-          // The operand width is the length's, which may be narrower than
-          // address_size.
-          const uint64_t operand_size = length - 1;
-          state.address_source_ = cursor.Offset();
-          state.address_ =
-              cursor.Address(static_cast<uint8_t>((operand_size > 8) ? address_size : operand_size));
-          state.op_index_ = 0;
-          break;
-        }
-        case kDwLneDefineFile: {
-          // DWARF 4 and earlier could append to the file table mid-program.
-          std::string name;
-          if (!cursor.String(name)) {
-            return false;
-          }
-          const uint64_t directory_index = cursor.Uleb();
-          (void)cursor.Uleb();  // Modification time
-          (void)cursor.Uleb();  // Length
-          // The directory table is gone by now, so only the name is recorded.
-          (void)directory_index;
-          unit.file_paths_.push_back(std::move(name));
-          break;
-        }
-        case kDwLneSetDiscriminator:
-          (void)cursor.Uleb();
-          break;
-        default:
-          break;  // Vendor extension: stepped over by its length
-      }
-      // The length decides where the next opcode is, not what was read.
-      cursor.Seek(after);
-      continue;
-    }
-
-    switch (opcode) {
-      case kDwLnsCopy:
-        emit();
-        break;
-      case kDwLnsAdvancePc:
-        advance(cursor.Uleb());
-        break;
-      case kDwLnsAdvanceLine: {
-        // The delta is from the file: clamp it first, so the sum cannot overflow, and
-        // the result to the 32 bits a line has.
-        constexpr int64_t kLimit = int64_t{1} << 32;
-        const int64_t delta = std::clamp<int64_t>(cursor.Sleb(), -kLimit, kLimit);
-        const int64_t new_line = static_cast<int64_t>(state.line_) + delta;
-        state.line_ = static_cast<uint32_t>(std::clamp<int64_t>(new_line, 0, UINT32_MAX));
-        break;
-      }
-      case kDwLnsSetFile:
-        state.file_ = cursor.Uleb();
-        break;
-      case kDwLnsSetColumn:
-        state.column_ = static_cast<uint32_t>(cursor.Uleb());
-        break;
-      case kDwLnsNegateStmt:
-        state.is_stmt_ = !state.is_stmt_;
-        break;
-      case kDwLnsSetBasicBlock:
-        break;  // Recorded by DWARF, not needed here
-      case kDwLnsConstAddPc:
-        // The address advance of special opcode 255, without a row.
-        if (line_range == 0) {
-          return false;
-        }
-        advance(static_cast<uint8_t>(255 - opcode_base) / line_range);
-        break;
-      case kDwLnsFixedAdvancePc:
-        // A plain byte count; resets op_index.
-        state.address_ += cursor.U16();
-        state.op_index_ = 0;
-        break;
-      case kDwLnsSetPrologueEnd:
-      case kDwLnsSetEpilogueBegin:
-        break;  // Recorded by DWARF, not needed here
-      case kDwLnsSetIsa:
-        (void)cursor.Uleb();
-        break;
-      default: {
-        // An unknown standard opcode: skip the operand count the header gives.
-        const size_t index = opcode - 1u;
-        if (index >= standard_opcode_lengths.size()) {
-          return false;
-        }
-        for (uint8_t i = 0; i < standard_opcode_lengths[index]; ++i) {
-          (void)cursor.Uleb();
-        }
-        break;
-      }
-    }
-  }
-  return cursor.Ok();
-}
-
-// Where one unit of ".debug_line" is, from its length field alone.
-struct LineUnitExtent {
-  uint64_t offset_ = 0;        // Where the unit starts, which relocations point into
-  uint64_t end_ = 0;           // Where the next unit starts
-  uint64_t header_start_ = 0;  // Just past the length field, where the version sits
-  uint8_t offset_size_ = 4;    // The width of a DWARF offset in this unit, 4 or 8
-};
-// Reads the extent of the unit at cursor and leaves cursor at the next unit, so other
-// kernels' units can be skipped cheaply. Returns false for a reserved length or one
-// past the section, when there is no next unit.
-inline bool ReadLineUnitExtent(ByteCursor& cursor, LineUnitExtent& out_extent) {
-  out_extent = LineUnitExtent();
-  out_extent.offset_ = cursor.Offset();
-
-  // The initial length; 0xFFFFFFFF means 64-bit DWARF, other values from 0xFFFFFFF0
-  // are reserved.
-  uint64_t unit_length = cursor.U32();
-  if (unit_length == 0xFFFFFFFFu) {
-    unit_length = cursor.U64();
-    out_extent.offset_size_ = 8;
-  } else if (unit_length >= 0xFFFFFFF0u) {
-    return false;
-  }
-  if (!cursor.Ok()) {
-    return false;
-  }
-  out_extent.header_start_ = cursor.Offset();
-  if (!Elf64RangeInBounds(out_extent.header_start_, unit_length, cursor.Size())) {
-    return false;  // The unit claims to run past the section
-  }
-  out_extent.end_ = out_extent.header_start_ + unit_length;
-  cursor.Seek(out_extent.end_);
-  return true;
-}
-
-// Parses the ".debug_line" unit at cursor. Unless out_fatal is set, cursor is left at
-// the next unit even if this one fails to parse.
-inline bool ParseLineUnit(ByteCursor& cursor, const StringTableView& debug_str,
-                          const StringTableView& debug_line_str, const Relocations* relocations,
-                          LineUnit& out_unit, bool& out_fatal) {
-  out_unit = LineUnit();
-  LineUnitExtent extent;
-  out_fatal = !ReadLineUnitExtent(cursor, extent);
-  if (out_fatal) {
-    return false;
-  }
-  out_unit.offset_ = extent.offset_;
-  out_unit.end_ = extent.end_;
-  const uint8_t offset_size = extent.offset_size_;
-  // From here a failure is not fatal: cursor is already at the next unit.
-  ByteCursor unit_cursor = cursor;
-  unit_cursor.Seek(extent.header_start_);
-
-  out_unit.version_ = unit_cursor.U16();
-  if (!unit_cursor.Ok()) {
-    return false;
-  }
-  // Only the known header layouts.
-  if (out_unit.version_ < 2 || out_unit.version_ > 5) {
-    return false;
-  }
-
-  uint8_t address_size = 8;
-  if (out_unit.version_ >= 5) {
-    address_size = unit_cursor.U8();
-    const uint8_t segment_selector_size = unit_cursor.U8();
-    // Segmented addresses are not supported.
-    if (segment_selector_size != 0) {
-      return false;
-    }
-  }
-
-  const uint64_t header_length = (offset_size == 8) ? unit_cursor.U64() : unit_cursor.U32();
-  if (!unit_cursor.Ok()) {
-    return false;
-  }
-  // Where the program starts, which allows header fields this does not read.
-  if (unit_cursor.Offset() > out_unit.end_ ||
-      header_length > out_unit.end_ - unit_cursor.Offset()) {
-    return false;  // Checked before adding, which a length near 2^64 would wrap
-  }
-  const uint64_t program_start = unit_cursor.Offset() + header_length;
-
-  const uint8_t minimum_instruction_length = unit_cursor.U8();
-  const uint8_t maximum_operations_per_instruction =
-      (out_unit.version_ >= 4) ? unit_cursor.U8() : 1;
-  const bool default_is_stmt = unit_cursor.U8() != 0;
-  const int8_t line_base = unit_cursor.I8();
-  const uint8_t line_range = unit_cursor.U8();
-  const uint8_t opcode_base = unit_cursor.U8();
-  if (!unit_cursor.Ok() || line_range == 0 || opcode_base == 0) {
-    return false;
-  }
-
-  std::vector<uint8_t> standard_opcode_lengths;
-  standard_opcode_lengths.reserve(opcode_base - 1u);
-  for (uint8_t i = 1; i < opcode_base; ++i) {
-    standard_opcode_lengths.push_back(unit_cursor.U8());
-  }
-  if (!unit_cursor.Ok()) {
-    return false;
-  }
-
-  const bool tables_read =
-      (out_unit.version_ >= 5)
-          ? ReadDwarf5FileTable(unit_cursor, offset_size, address_size, debug_str, debug_line_str,
-                                relocations, out_unit)
-          : ReadLegacyFileTable(unit_cursor, out_unit);
-  // A bad file table still leaves the rows useful, with lines but no names.
-  (void)tables_read;
-
-  unit_cursor.Seek(program_start);
-  if (!unit_cursor.Ok()) {
-    return false;
-  }
-  return RunLineProgram(unit_cursor, out_unit.end_, address_size, minimum_instruction_length,
-                        maximum_operations_per_instruction, default_is_stmt, line_base, line_range,
-                        opcode_base, standard_opcode_lengths, out_unit);
-}
-
-// ---------------------------------------------------------------------------
-// The public interface
-// ---------------------------------------------------------------------------
-
-// One kernel's line table. Build() does the parsing, once; Resolve() is a binary
-// search.
-class KernelLineTable {
- public:
-  // binary/binary_size is the module binary; kernel_name is the mangled name.
-  // Returns false, with a "[WARNING] ..." on std::cerr naming the kernel, if there is
-  // no line information for it (e.g. built without -g).
-  bool Build(const uint8_t* binary, size_t binary_size, const std::string& kernel_name) {
-    rows_.clear();
-    file_paths_.clear();
-    spans_.clear();
-    kernel_base_ = 0;
-
-    auto fail = [&kernel_name](const std::string& message) {
-      std::cerr << "[WARNING] No source lines for kernel " << kernel_name << ": " << message
-                << std::endl;
-      return false;
-    };
-
-    if (kernel_name.empty()) {
-      // Not through fail(): there is no name to print.
-      std::cerr << "[WARNING] No source lines for a kernel: no kernel name to look up" << std::endl;
-      return false;
-    }
-    std::vector<Elf64Section> sections;
-    if (ReadElf64Sections(binary, binary_size, sections) != Elf64Status::kOk) {
-      // ReadElf64Sections() has already reported why.
-      return false;
-    }
-
-    const int64_t debug_line_index = FindElf64Section(sections, ".debug_line");
-    if (debug_line_index < 0 || sections[debug_line_index].size_ == 0) {
-      return fail("module binary has no line number information (built without -g?)");
-    }
-    const Elf64Section& debug_line = sections[debug_line_index];
-    // Present but outside the binary, e.g. truncated.
-    if (debug_line.data_ == nullptr) {
-      return fail("line number information lies outside the module binary");
-    }
-
-    StringTableView debug_str;
-    const int64_t debug_str_index = FindElf64Section(sections, ".debug_str");
-    if (debug_str_index >= 0) {
-      debug_str.data_ = sections[debug_str_index].data_;
-      debug_str.size_ = sections[debug_str_index].size_;
-    }
-    StringTableView debug_line_str;
-    const int64_t debug_line_str_index = FindElf64Section(sections, ".debug_line_str");
-    if (debug_line_str_index >= 0) {
-      debug_line_str.data_ = sections[debug_line_str_index].data_;
-      debug_line_str.size_ = sections[debug_line_str_index].size_;
-    }
-
-    // The kernel's unit is the one its ".text." relocations point into; without them,
-    // only a sole usable unit. The section must exist, or the sole-unit case would
-    // answer from another kernel's table.
-    const std::string text_section_name = Elf64KernelTextSectionName(kernel_name);
-    const int64_t text_index = FindElf64Section(sections, text_section_name);
-    if (text_index < 0) {
-      return fail("module binary holds no section for this kernel");
-    }
-    Relocations relocations;
-    CollectRelocations(sections, static_cast<uint32_t>(debug_line_index),
-                       static_cast<uint32_t>(text_index), text_section_name, debug_line,
-                       relocations);
-    const bool relocated = !relocations.offsets_.empty();
-
-    // With relocations, units they do not point into are skipped unparsed. Without,
-    // every unit is parsed to find whether exactly one is usable.
-    LineUnit chosen;
-    size_t usable = 0;  // Units that could be this kernel's and produced rows
-    ByteCursor cursor(debug_line.data_, debug_line.size_);
-    while (!cursor.Done()) {
-      LineUnitExtent extent;
-      if (!ReadLineUnitExtent(cursor, extent)) {
-        break;  // The section's own structure is broken; there is no next unit
-      }
-      if (relocated && !relocations.NamesRange(extent.offset_, extent.end_)) {
-        continue;  // Nothing in this unit refers to the kernel, so it is another's
-      }
-
-      // From the unit's start; the outer cursor stays at the next unit.
-      ByteCursor unit_cursor(debug_line.data_, debug_line.size_);
-      unit_cursor.Seek(extent.offset_);
-      LineUnit unit;
-      bool fatal = false;  // Cannot fire: the extent above read the same length field
-      if (!ParseLineUnit(unit_cursor, debug_str, debug_line_str, &relocations, unit, fatal) ||
-          unit.rows_.empty()) {
-        continue;
-      }
-
-      ++usable;
-      if (usable > 1) {
-        break;  // Nothing named a unit and more than one could be it: ambiguous
-      }
-      chosen = std::move(unit);
-      if (relocated) {
-        break;  // A relocation names this unit; no later one can displace it
-      }
-    }
-    if (usable != 1) {
-      // To say why, check whether any unit at all is usable, skipped ones included.
-      bool any_usable = usable > 0;
-      ByteCursor rescan(debug_line.data_, debug_line.size_);
-      while (!any_usable && !rescan.Done()) {
-        LineUnit unit;
-        bool fatal = false;
-        if (ParseLineUnit(rescan, debug_str, debug_line_str, &relocations, unit, fatal)) {
-          any_usable = !unit.rows_.empty();
-        }
-        if (fatal) {
-          break;
-        }
-      }
-      if (!any_usable) {
-        return fail("line number information holds no usable line table");
-      }
-      return fail((relocated && usable == 0) ? "this kernel's line table is unusable"
-                                             : "cannot tell which line table belongs to this kernel");
-    }
-
-    file_paths_ = std::move(chosen.file_paths_);
-
-    // Keep only the kernel's sequences, for a producer that puts several functions'
-    // sequences, overlapping at address 0, in one unit.
-    for (const LineRow& row : chosen.rows_) {
-      if (row.address_source_ != kNoOffset && relocations.Names(row.address_source_)) {
-        rows_.push_back(row);
-      }
-    }
-    // No sequence matched, but the unit is still this kernel's: keep all its rows.
-    if (rows_.empty()) {
-      rows_ = std::move(chosen.rows_);
-    }
-
-    // Offsets are relative to the lowest address, the kernel's entry, whether the
-    // binary is linked or not.
-    bool have_base = false;
-    for (const LineRow& row : rows_) {
-      if (!have_base || row.address_ < kernel_base_) {
-        kernel_base_ = row.address_;
-        have_base = true;
-      }
-    }
-
-    BuildIndex();
-    return true;
-  }
-
-  // The source of the instruction at instruction_offset. On success sets every field
-  // of out_location; returns false, leaving it untouched, if no row covers the offset.
-  bool Resolve(uint64_t instruction_offset, SourceLocation& out_location) const {
-    if (spans_.empty()) {
-      return false;
-    }
-    const uint64_t target = kernel_base_ + instruction_offset;
-
-    // The last span starting at or before the target.
-    const auto it = std::upper_bound(spans_.begin(), spans_.end(), target,
-                                     [](uint64_t at, const Span& span) {
-                                       return at < span.address_;
-                                     });
-    if (it == spans_.begin()) {
-      return false;
-    }
-    const size_t winner = (it - 1)->row_;
-    if (winner == kNoRow) {
-      return false;  // A gap between sequences, or past the last of them
-    }
-    const LineRow* best = &rows_[winner];
-    const uint64_t best_end = rows_[winner + 1].address_;
-
-    // Cleared, since it is the one field not always written; keeps the buffer.
-    out_location.file_path_.clear();
-    out_location.line_ = best->line_;
-    out_location.column_ = best->column_;
-    out_location.is_statement_ = best->is_stmt_;
-    out_location.range_offset_ = best->address_ - kernel_base_;
-    out_location.range_size_ = best_end - best->address_;
-    if (best->file_ < file_paths_.size()) {
-      out_location.file_path_ = file_paths_[static_cast<size_t>(best->file_)];
-    }
-    return true;
-  }
-
-  // Every range the table maps, ascending and unique by range_offset_: what Resolve()
-  // returns for each row start, so shadowed rows are left out. Returns false, with
-  // out_locations empty, if there are none.
-  bool ResolveAll(std::vector<SourceLocation>& out_locations) const {
-    out_locations.clear();
-    if (rows_.empty()) {
-      return false;
-    }
-
-    // The unique row starts.
-    std::vector<uint64_t> starts;
-    starts.reserve(rows_.size());
-    for (const LineRow& row : rows_) {
-      if (row.end_sequence_) {
-        continue;  // Closes a sequence; describes no instruction
-      }
-      if (row.address_ < kernel_base_) {
-        continue;  // Cannot happen: the base is the lowest address
-      }
-      starts.push_back(row.address_ - kernel_base_);
-    }
-    std::sort(starts.begin(), starts.end());
-    starts.erase(std::unique(starts.begin(), starts.end()), starts.end());
-
-    for (uint64_t start : starts) {
-      SourceLocation location;
-      if (!Resolve(start, location)) {
-        continue;  // A row whose range is empty, so it covers no instruction
-      }
-      out_locations.push_back(location);
-    }
-
-    // Two starts can resolve to one range, and not always in order, so sort and
-    // deduplicate the answers.
-    std::sort(out_locations.begin(), out_locations.end(),
-              [](const SourceLocation& a, const SourceLocation& b) {
-                return a.range_offset_ < b.range_offset_;
-              });
-    out_locations.erase(std::unique(out_locations.begin(), out_locations.end(),
-                                    [](const SourceLocation& a, const SourceLocation& b) {
-                                      return a.range_offset_ == b.range_offset_;
-                                    }),
-                        out_locations.end());
-    return !out_locations.empty();
-  }
-
- private:
-  // A span's row_ when no row covers it.
-  static constexpr size_t kNoRow = static_cast<size_t>(-1);
-
-  // Addresses from address_ to the next span's, all answered by one row.
-  struct Span {
-    uint64_t address_ = 0;
-    // Never the last row, so rows_[row_ + 1] is where the row's own range ends.
-    size_t row_ = kNoRow;
-  };
-
-  // Builds spans_ by flattening overlapping row ranges, so Resolve() can binary
-  // search. A span reports its row's whole range, not just the span.
-  void BuildIndex() {
-    spans_.clear();
-
-    // Where a row's range opens and closes.
-    struct Event {
-      uint64_t at_ = 0;
-      bool open_ = false;
-      size_t row_ = 0;
-    };
-    std::vector<Event> events;
-    events.reserve(rows_.size() * 2);
-    for (size_t i = 0; i + 1 < rows_.size(); ++i) {
-      const LineRow& row = rows_[i];
-      if (row.end_sequence_) {
-        continue;  // Closes a sequence; describes no instruction
-      }
-      const uint64_t end = rows_[i + 1].address_;
-      if (end <= row.address_) {
-        continue;  // An empty range, or the start of the next sequence
-      }
-      events.push_back(Event{row.address_, true, i});
-      events.push_back(Event{end, false, i});
-    }
-    if (events.empty()) {
-      return;
-    }
-
-    // By address, closes before opens: a range does not cover its end.
-    std::sort(events.begin(), events.end(), [](const Event& a, const Event& b) {
-      if (a.at_ != b.at_) {
-        return a.at_ < b.at_;
-      }
-      return static_cast<int>(a.open_) < static_cast<int>(b.open_);
-    });
-
-    // Sweep, keeping the rows covering the point; the last row wins, as in a debugger.
-    std::set<size_t> active;
-    for (size_t i = 0; i < events.size();) {
-      const uint64_t at = events[i].at_;
-      for (; i < events.size() && events[i].at_ == at; ++i) {
-        if (events[i].open_) {
-          active.insert(events[i].row_);
-        } else {
-          active.erase(events[i].row_);
-        }
-      }
-      const size_t winner = active.empty() ? kNoRow : *active.rbegin();
-      // A span per change of answer; a gap is a kNoRow span.
-      if (spans_.empty() || spans_.back().row_ != winner) {
-        spans_.push_back(Span{at, winner});
-      }
-    }
-  }
-
-  std::vector<LineRow> rows_;
-  std::vector<std::string> file_paths_;
-  std::vector<Span> spans_;
-  uint64_t kernel_base_ = 0;
-};
-
-// One kernel's whole mapping, as KernelLineTable::ResolveAll() returns it. Returns
-// false, with out_locations empty and a "[WARNING] ..." on std::cerr, if the table
-// cannot be built or maps nothing.
-inline bool ResolveAllKernelInstructions(const uint8_t* binary, size_t binary_size,
-                                         const std::string& kernel_name,
-                                         std::vector<SourceLocation>& out_locations) {
-  out_locations.clear();
-  KernelLineTable table;
-  if (!table.Build(binary, binary_size, kernel_name)) {
-    return false;
-  }
-  if (!table.ResolveAll(out_locations)) {
-    std::cerr << "[WARNING] No source lines for kernel " << kernel_name
-              << ": the kernel's line table covers no instruction offset" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-// The location in ResolveAllKernelInstructions()'s output covering offset, or nullptr:
-// the last entry starting at or below it, if its range covers it. Where entries
-// overlap, the later one wins.
-inline const SourceLocation* FindSourceLocation(
-    const std::vector<SourceLocation>& locations, uint64_t offset) {
-  const auto above = std::upper_bound(locations.begin(), locations.end(), offset,
-                                      [](uint64_t value, const SourceLocation& location) {
-                                        return value < location.range_offset_;
-                                      });
-  if (above == locations.begin()) {
-    return nullptr;  // Below the first range
-  }
-  const SourceLocation& candidate = *(above - 1);
-  if (offset - candidate.range_offset_ >= candidate.range_size_) {
-    return nullptr;  // In a gap, or past the end of the last range
-  }
-  return &candidate;
-}
-
-#endif  // PTI_TOOLS_UNITRACE_UTILS_SOURCE_RESOLVER_H_
diff --git a/tools/unitrace/src/utils/utils_host.h b/tools/unitrace/src/utils/utils_host.h
deleted file mode 100644
index 787e5d2b..00000000
--- a/tools/unitrace/src/utils/utils_host.h
+++ /dev/null
@@ -1,195 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_UTILS_HOST_UTILS_H_
-#define PTI_UTILS_HOST_UTILS_H_
-
-#include <inttypes.h>
-#include <cstdio>
-#include <algorithm>
-#include <cctype>
-#include <cstdint>
-#include <cstdlib>
-#include <string>
-#ifdef _WIN32
-#include <windows.h>
-#else /* _WIN32 */
-#include <unistd.h>
-#endif /* _WIN32 */
-
-static inline std::string GetHostName(void) {
-  char hname[256];
-#ifdef _WIN32
-  static_assert(256 >= MAX_COMPUTERNAME_LENGTH + 1, "Buffer too small to fit hostname");
-  DWORD size = sizeof(hname);
-  GetComputerNameA(hname, &size);
-#else  /* _WIN32 */
-  gethostname(hname, sizeof(hname));
-#endif /* _WIN32 */
-  hname[255] = 0;
-  return hname;
-}
-
-// Convert pointer/handle values to hex string
-template <typename T>
-inline std::string ToHexString(T val) {
-  char buffer[32];
-  snprintf(buffer, sizeof(buffer), "0x%" PRIx64, (uintptr_t)val);
-  return std::string(buffer);
-}
-
-// The length of the valid UTF-8 sequence that starts at s[i]: 1 for ASCII, 2 to 4
-// for a multibyte character; 0 if the bytes there are not valid UTF-8 (a stray
-// continuation byte, a sequence cut short, an overlong form, a surrogate, or a code
-// point above U+10FFFF).
-inline size_t Utf8SequenceLength(const std::string& s, size_t i) {
-  const unsigned char c = static_cast<unsigned char>(s[i]);
-  if (c < 0x80) {
-    return 1;
-  }
-  size_t n = 0;
-  uint32_t cp = 0;
-  if (c >= 0xc2 && c <= 0xdf) { n = 2; cp = c & 0x1f; }
-  else if (c >= 0xe0 && c <= 0xef) { n = 3; cp = c & 0x0f; }
-  else if (c >= 0xf0 && c <= 0xf4) { n = 4; cp = c & 0x07; }
-  else { return 0; }
-  if (i + n > s.size()) {
-    return 0;
-  }
-  for (size_t k = 1; k < n; ++k) {
-    const unsigned char d = static_cast<unsigned char>(s[i + k]);
-    if ((d & 0xc0) != 0x80) {
-      return 0;
-    }
-    cp = (cp << 6) | (d & 0x3f);
-  }
-  const bool overlong = (n == 3 && cp < 0x800) || (n == 4 && cp < 0x10000);
-  if (overlong || (cp >= 0xd800 && cp <= 0xdfff) || cp > 0x10ffff) {
-    return 0;
-  }
-  return n;
-}
-
-// text as the contents of a JSON string (RFC 8259): quote and backslash escaped,
-// control characters as \b \f \n \r \t or \u00XX. Valid UTF-8 is kept as it is;
-// each byte that is not valid UTF-8 (a name cut inside a character, a lone 0xff)
-// becomes U+FFFD, so the result is always valid UTF-8 JSON.
-//   text  any bytes: a kernel, ITT or device name, a command-line argument, ...
-// Returns the escaped text, without surrounding quotes.
-inline std::string JsonEscape(const std::string& text) {
-  static const char* hex = "0123456789abcdef";
-  std::string out;
-  out.reserve(text.size());
-  for (size_t i = 0; i < text.size(); ++i) {
-    const char ch = text[i];
-    const unsigned char c = static_cast<unsigned char>(ch);
-    if (c >= 0x80) {
-      const size_t n = Utf8SequenceLength(text, i);
-      if (n == 0) {
-        out += "\\ufffd";
-      } else {
-        out.append(text, i, n);
-        i += n - 1;
-      }
-      continue;
-    }
-    switch (c) {
-      case '"':  out += "\\\""; break;
-      case '\\': out += "\\\\"; break;
-      case '\b': out += "\\b"; break;
-      case '\f': out += "\\f"; break;
-      case '\n': out += "\\n"; break;
-      case '\r': out += "\\r"; break;
-      case '\t': out += "\\t"; break;
-      default:
-        if (c < 0x20) {
-          out += "\\u00";
-          out += hex[c >> 4];
-          out += hex[c & 0xf];
-        } else {
-          out += ch;
-        }
-    }
-  }
-  return out;
-}
-
-// text as a complete JSON string: escaped by JsonEscape() and quoted.
-//   text  any bytes
-// Returns "<escaped text>", so names from the application or the driver cannot
-// break the trace or the config log.
-inline std::string JsonString(const std::string& text) {
-  return "\"" + JsonEscape(text) + "\"";
-}
-
-// true if every character of s is an ASCII decimal digit; also true for "", which
-// callers rule out themselves.
-inline bool IsDigits(const std::string& s) {
-  return std::find_if(s.begin(), s.end(), [](unsigned char c) { return !std::isdigit(c); }) ==
-         s.end();
-}
-
-// Parses s as an int.
-//   s    the text; std::stoi() rules apply (leading spaces and a sign allowed)
-//   out  receives the value; untouched on failure
-// Returns false if s is not a number, has anything after it, or does not fit an
-// int. Never throws, unlike the std::stoi() it wraps.
-inline bool ToInt(const std::string& s, int& out) {
-  try {
-    size_t used = 0;
-    const int value = std::stoi(s, &used);
-    if (used != s.size()) {
-      return false;
-    }
-    out = value;
-    return true;
-  } catch (...) {
-    return false;
-  }
-}
-
-// Parses s as a uint32_t.
-//   s    the text; decimal digits only, no sign or spaces
-//   out  receives the value; untouched on failure
-// Returns false if s is empty, not decimal digits, or larger than UINT32_MAX.
-// Leading zeros are allowed ("007" is 7), as std::stoul allowed them.
-inline bool ToUint32(const std::string& s, uint32_t& out) {
-  if (s.empty() || !IsDigits(s)) {
-    return false;
-  }
-  // At most 10 significant digits fit; checked before strtoull, which saturates.
-  const size_t first = std::min(s.find_first_not_of('0'), s.size() - 1);
-  if (s.size() - first > 10) {
-    return false;
-  }
-  const unsigned long long value = std::strtoull(s.c_str() + first, nullptr, 10);
-  if (value > UINT32_MAX) {
-    return false;
-  }
-  out = static_cast<uint32_t>(value);
-  return true;
-}
-
-// Parses UNITRACE_ChromeEventBufferSize (--chrome-event-buffer-size).
-//   value  the variable's value
-//   out    receives the size in events: -1 (unbounded) if value is empty or "-1"
-// Returns false, with out set to -1, if value is neither -1 nor a non-negative
-// number that fits an int. unitrace rejects such a value; the collector, which
-// cannot report it, falls back to unbounded.
-inline bool ParseChromeEventBufferSize(const std::string& value, int& out) {
-  out = -1;
-  if (value.empty() || value == "-1") {
-    return true;
-  }
-  int size = 0;
-  if (!IsDigits(value) || !ToInt(value, size)) {
-    return false;
-  }
-  out = size;
-  return true;
-}
-
-#endif // PTI_UTILS_HOST_UTILS_H_
diff --git a/tools/unitrace/src/utils/utils_ze.h b/tools/unitrace/src/utils/utils_ze.h
deleted file mode 100644
index 9228edfd..00000000
--- a/tools/unitrace/src/utils/utils_ze.h
+++ /dev/null
@@ -1,584 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_UTILS_ZE_UTILS_H_
-#define PTI_UTILS_ZE_UTILS_H_
-
-#include <string.h>
-
-#include <chrono>
-#include <fstream>
-#include <string>
-#include <thread>
-#include <vector>
-#include <algorithm>
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-#include "ze_loader.h"
-#include "utils/utils_host.h"
-
-#include "utils/demangle.h"
-#include "logger_factory.h"
-#include "utils/unitrace_assert.h"
-#include "utils/utils.h"
-
-inline bool InitializeL0() {
-#if BUILD_WITH_L0
-  auto status = ZE_FUNC(zeInit)(ZE_INIT_FLAG_GPU_ONLY);
-  if (status != ZE_RESULT_SUCCESS) {
-    std::cerr << "[ERROR] Failed to initialize Level Zero runtime" << std::endl;
-#ifndef _WIN32
-    std::cerr << "[INFO] Please ensure that either /proc/sys/dev/i915/perf_stream_paranoid or /proc/sys/dev/xe/observation_paranoid is set to 0." << std::endl;
-#endif /* _WIN32 */
-    return false;
-  } else {
-    return true;
-  }
-#else /* BUILD_WITH_L0 */
-  return true;
-#endif /* BUILD_WITH_L0 */
-}
-
-// Parses a comma-separated list of device ids (--devices-to-sample).
-//   list  the list, e.g. "0,2"
-//   out   receives the ids
-// Returns 0 on success; -1 if list is empty or an item is not a decimal number that
-// fits an int (an error is printed). Empty items ("0,,2") are skipped. Never
-// throws.
-inline int ParseDeviceList(const std::string& list, std::set<int>& out) {
-  if (list.empty()) {
-    return -1;
-  }
-  for (const auto& s : utils::SplitString(list, ',')) {
-    if (!s.empty()) {
-      int device = 0;
-      if (IsDigits(s) && ToInt(s, device)) {
-        out.insert(device);
-      } else {
-        std::cerr << "[ERROR] Given device to sample (" << s << ") is invalid" << std::endl;
-        return -1;
-      }
-    }
-  }
-  return 0;
-}
-
-// Parses a comma-separated list of MPI ranks (--ranks-to-sample) against the
-// launcher's environment.
-//   list      the list, e.g. "0,3"
-//   mpi_size  the job size (PMI_SIZE, PMIX_SIZE, OMPI_COMM_WORLD_SIZE, ...)
-//   mpi_rank  this process's rank (PMI_RANK or PMIX_RANK)
-//   out       receives the ranks in [0, mpi_size)
-// Returns 0 on success; -1 if list is empty, the MPI environment is missing or not
-// a number, or an item is not decimal digits (an error is printed; for an item,
-// by rank 0 only). A rank outside [0, mpi_size), including one too large for an
-// int, is ignored with a warning. Never throws.
-inline int ParseRankList(const std::string& list, const std::string& mpi_size,
-                         const std::string& mpi_rank, std::set<int>& out) {
-  if (list.empty()) {
-    return -1;
-  }
-  if (mpi_size.empty()) {
-    std::cerr << "[ERROR] PMI_SIZE or PMIX_SIZE or OMPI_COMM_WORLD_SIZE or OMPI_UNIVERSE_SIZE not set. Given --ranks-to-sample but the application does not seem to be using MPI" << std::endl;
-    return -1;
-  }
-  int32_t my_size = 0;
-  if (!ToInt(mpi_size, my_size)) {
-    std::cerr << "[ERROR] MPI size (" << mpi_size << ") is not a number" << std::endl;
-    return -1;
-  }
-  if (mpi_rank.empty()) {
-    std::cerr << "[ERROR] Given --ranks-to-sample but the application does not seem to be using MPI" << std::endl;
-    return -1;
-  }
-  int32_t my_rank = 0;
-  if (!ToInt(mpi_rank, my_rank)) {
-    std::cerr << "[ERROR] MPI rank (" << mpi_rank << ") is not a number" << std::endl;
-    return -1;
-  }
-  for (const auto& s : utils::SplitString(list, ',')) {
-    if (!s.empty()) {
-      int rank = -1;
-      if (IsDigits(s)) {
-        if (!ToInt(s, rank)) {
-          rank = -1;  // too large to be a rank: out of bounds
-        }
-        if ((0 <= rank) && (rank < my_size)) {
-          out.insert(rank);
-        } else if (my_rank == 0) {
-          std::cerr << "[WARNING] Given MPI rank to sample (" << s << ") is out of bounds for given execution. Ignoring." << std::endl;
-        }
-      } else if (my_rank == 0) {
-        std::cerr << "[ERROR] Given MPI rank to sample (" << s << ") is invalid" << std::endl;
-        return -1;
-      }
-    }
-  }
-  return 0;
-}
-
-// Parses an optional device index from the environment (UNITRACE_DeviceId,
-// PTI_DEVICE_ID, PTI_SUB_DEVICE_ID).
-//   value  the variable's value; empty means not set
-//   out    receives the index: 0 when value is empty
-// Returns false, with out untouched, if value is not decimal digits or does not fit
-// a uint32_t; the caller reports the error instead of an exception escaping into
-// the application.
-inline bool ParseDeviceIndex(const std::string& value, uint32_t& out) {
-  if (value.empty()) {
-    out = 0;
-    return true;
-  }
-  return ToUint32(value, out);
-}
-
-// The device ids of --devices-to-sample as the metric profiler reads them from its
-// environment.
-//   list  the --devices-to-sample value the profiler is created with
-//   out   receives the ids; for an invalid list, only kNoDevice
-// unitrace has already rejected an invalid list; one here (set by hand) samples no
-// device rather than throwing inside the application. An empty set would mean "all
-// devices" to the profiler, so an invalid list leaves an id no device has.
-constexpr int kNoDevice = -1;
-inline void DevicesStringToSet(const std::string& list, std::set<int>& out) {
-  if (!list.empty() && ParseDeviceList(list, out) != 0) {
-    std::cerr << "[ERROR] Devices to sample (" << list << ") are invalid; no device is sampled" << std::endl;
-    out = {kNoDevice};
-  }
-}
-
-inline std::vector<ze_driver_handle_t> GetDriverList() {
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t driver_count = 0;
-  status = ZE_FUNC(zeDriverGet)(&driver_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (driver_count == 0) {
-    return std::vector<ze_driver_handle_t>();
-  }
-
-  std::vector<ze_driver_handle_t> driver_list(driver_count);
-  status = ZE_FUNC(zeDriverGet)(&driver_count, driver_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return driver_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t device_count = 0;
-  status = ZE_FUNC(zeDeviceGet)(driver, &device_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> device_list(device_count);
-  status = ZE_FUNC(zeDeviceGet)(driver, &device_count, device_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList() {
-  std::vector<ze_device_handle_t> device_list;
-  for (auto driver : GetDriverList()) {
-    for (auto device : GetDeviceList(driver)) {
-      device_list.push_back(device);
-    }
-  }
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetSubDeviceList(
-    ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t sub_device_count = 0;
-  status = ZE_FUNC(zeDeviceGetSubDevices)(device, &sub_device_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (sub_device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> sub_device_list(sub_device_count);
-  status = ZE_FUNC(zeDeviceGetSubDevices)(
-      device, &sub_device_count, sub_device_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return sub_device_list;
-}
-
-inline ze_driver_handle_t GetGpuDriver() {
-  std::vector<ze_driver_handle_t> driver_list;
-
-  for (auto driver : GetDriverList()) {
-    for (auto device : GetDeviceList(driver)) {
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-      ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        driver_list.push_back(driver);
-      }
-    }
-  }
-
-  if (driver_list.empty()) {
-    return nullptr;
-  }
-
-  std::string value = utils::GetEnv("PTI_DEVICE_ID");
-  uint32_t device_id = 0;
-  if (!ParseDeviceIndex(value, device_id)) {
-    std::cerr << "[ERROR] PTI_DEVICE_ID (" << value << ") is invalid" << std::endl;
-    return nullptr;
-  }
-  if (device_id >= driver_list.size()) {
-    std::cerr << "[ERROR] PTI_DEVICE_ID (" << value << ") is out of range, " << driver_list.size() << " driver(s) found" << std::endl;
-    return nullptr;
-  }
-  return driver_list[device_id];
-}
-
-inline ze_device_handle_t GetGpuDevice() {
-  std::vector<ze_device_handle_t> device_list;
-
-  for (auto driver : GetDriverList()) {
-    for (auto device : GetDeviceList(driver)) {
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-      ze_result_t status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        device_list.push_back(device);
-      }
-    }
-  }
-
-  if (device_list.empty()) {
-    return nullptr;
-  }
-
-  std::string value = utils::GetEnv("PTI_DEVICE_ID");
-  uint32_t device_id = 0;
-  if (!ParseDeviceIndex(value, device_id)) {
-    std::cerr << "[ERROR] PTI_DEVICE_ID (" << value << ") is invalid" << std::endl;
-    return nullptr;
-  }
-  if (device_id >= device_list.size()) {
-    std::cerr << "[ERROR] PTI_DEVICE_ID (" << value << ") is out of range, " << device_list.size() << " GPU device(s) found" << std::endl;
-    return nullptr;
-  }
-
-  std::vector<ze_device_handle_t> sub_device_list =
-    GetSubDeviceList(device_list[device_id]);
-  if (sub_device_list.empty()) {
-    return device_list[device_id];
-  }
-
-  value = utils::GetEnv("PTI_SUB_DEVICE_ID");
-  if (value.empty()) {
-    return device_list[device_id];
-  }
-
-  uint32_t sub_device_id = 0;
-  if (!ParseDeviceIndex(value, sub_device_id)) {
-    std::cerr << "[ERROR] PTI_SUB_DEVICE_ID (" << value << ") is invalid" << std::endl;
-    return nullptr;
-  }
-  if (sub_device_id >= sub_device_list.size()) {
-    std::cerr << "[ERROR] PTI_SUB_DEVICE_ID (" << value << ") is out of range, " << sub_device_list.size() << " sub-device(s) found" << std::endl;
-    return nullptr;
-  }
-  return sub_device_list[sub_device_id];
-}
-
-inline ze_context_handle_t GetContext(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_context_handle_t context = nullptr;
-  ze_context_desc_t context_desc = {
-      ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-  status = ZE_FUNC(zeContextCreate)(driver, &context_desc, &context);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return context;
-}
-
-inline std::string GetDeviceName(ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-  status = ZE_FUNC(zeDeviceGetProperties)(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.name;
-}
-
-inline int GetMetricId(zet_metric_group_handle_t group, std::string name) {
-  UNITRACE_ASSERT(group != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  uint32_t metric_count = 0;
-  status = ZE_FUNC(zetMetricGet)(group, &metric_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (metric_count == 0) {
-    return -1;
-  }
-
-  std::vector<zet_metric_handle_t> metric_list(metric_count, nullptr);
-  status = ZE_FUNC(zetMetricGet)(group, &metric_count, metric_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  int target = -1;
-  for (uint32_t i = 0; i < metric_count; ++i) {
-    zet_metric_properties_t metric_props{};
-    status = ZE_FUNC(zetMetricGetProperties)(metric_list[i], &metric_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    if (name == metric_props.name) {
-      target = i;
-      break;
-    }
-  }
-
-  return target;
-}
-
-inline zet_metric_group_handle_t FindMetricGroup(
-    ze_device_handle_t device, std::string name,
-    zet_metric_group_sampling_type_flag_t type) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  uint32_t group_count = 0;
-  status = ZE_FUNC(zetMetricGroupGet)(device, &group_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  if (group_count == 0) {
-    return nullptr;
-  }
-
-  std::vector<zet_metric_group_handle_t> group_list(group_count, nullptr);
-  status = ZE_FUNC(zetMetricGroupGet)(device, &group_count, group_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  zet_metric_group_handle_t target = nullptr;
-  for (uint32_t i = 0; i < group_count; ++i) {
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    status = ZE_FUNC(zetMetricGroupGetProperties)(group_list[i], &group_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    if (name == group_props.name && (group_props.samplingType & type)) {
-      target = group_list[i];
-      break;
-    }
-  }
-
-  return target;
-}
-
-inline std::string GetResultType(zet_value_type_t type) {
-  switch (type) {
-    case ZET_VALUE_TYPE_UINT32:
-      return "UINT32";
-    case ZET_VALUE_TYPE_UINT64:
-      return "UINT64";
-    case ZET_VALUE_TYPE_FLOAT32:
-      return "FLOAT32";
-    case ZET_VALUE_TYPE_FLOAT64:
-      return "FLOAT64";
-    case ZET_VALUE_TYPE_BOOL8:
-      return "BOOL8";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline std::string GetMetricType(zet_metric_type_t type) {
-  switch (type) {
-    case ZET_METRIC_TYPE_DURATION:
-      return "DURATION";
-    case ZET_METRIC_TYPE_EVENT:
-      return "EVENT";
-    case ZET_METRIC_TYPE_EVENT_WITH_RANGE:
-      return "EVENT_WITH_RANGE";
-    case ZET_METRIC_TYPE_THROUGHPUT:
-      return "THROUGHPUT";
-    case ZET_METRIC_TYPE_TIMESTAMP:
-      return "TIMESTAMP";
-    case ZET_METRIC_TYPE_FLAG:
-      return "FLAG";
-    case ZET_METRIC_TYPE_RATIO:
-      return "RATIO";
-    case ZET_METRIC_TYPE_RAW:
-      return "RAW";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline size_t GetKernelMaxSubgroupSize(ze_kernel_handle_t kernel) {
-  UNITRACE_ASSERT(kernel != nullptr);
-  ze_kernel_properties_t props{};
-  ze_result_t status = ZE_FUNC(zeKernelGetProperties)(kernel, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.maxSubgroupSize;
-}
-
-inline std::string GetKernelName(
-    ze_kernel_handle_t kernel, bool demangle = false) {
-  UNITRACE_ASSERT(kernel != nullptr);
-
-  size_t size = 0;
-  ze_result_t status = ZE_FUNC(zeKernelGetName)(kernel, &size, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  UNITRACE_ASSERT(size > 0);
-
-  std::vector<char> name(size);
-  status = ZE_FUNC(zeKernelGetName)(kernel, &size, name.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  UNITRACE_ASSERT(name[size - 1] == '\0');
-
-  if (demangle) {
-    return utils::Demangle(name.data());
-  }
-  return std::string(name.begin(), name.end() - 1);
-}
-
-inline void GetDeviceTimestamps(
-    ze_device_handle_t device,
-    uint64_t* host_timestamp,
-    uint64_t* device_timestamp) {
-  UNITRACE_ASSERT(device != nullptr);
-  UNITRACE_ASSERT(host_timestamp != nullptr);
-  UNITRACE_ASSERT(device_timestamp != nullptr);
-  ze_result_t status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(
-      device, host_timestamp, device_timestamp);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-}
-
-// TODO: use zeMetricGetGlobalTimestamps
-inline void GetMetricTimestamps(
-    ze_device_handle_t device,
-    uint64_t* host_timestamp,
-    uint64_t* metric_timestamp) {
-  UNITRACE_ASSERT(device != nullptr);
-  UNITRACE_ASSERT(host_timestamp != nullptr);
-  UNITRACE_ASSERT(metric_timestamp != nullptr);
-  ze_result_t status = ZE_FUNC(zeDeviceGetGlobalTimestamps)(
-      device, host_timestamp, metric_timestamp);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-}
-
-inline ze_api_version_t GetDriverVersion(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-
-  ze_api_version_t version = ZE_API_VERSION_FORCE_UINT32;
-  ze_result_t status = ZE_FUNC(zeDriverGetApiVersion)(driver, &version);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return version;
-}
-
-inline ze_api_version_t GetZeVersion() {
-  auto driver_list = GetDriverList();
-  if (driver_list.empty()) {
-    return ZE_API_VERSION_FORCE_UINT32;
-  }
-  return GetDriverVersion(driver_list.front());
-}
-
-inline int GetZeDevicesToSample(std::set<int>& devices_to_sample) {
-  return ParseDeviceList(utils::GetEnv("UNITRACE_DevicesToSampleArg"),
-                                        devices_to_sample);
-}
-
-inline int GetZeRanksToSample(std::set<int>& ranks_to_sample) {
-  auto my_MPI_size = (utils::GetEnv("PMI_SIZE").empty()) ? utils::GetEnv("PMIX_SIZE") : utils::GetEnv("PMI_SIZE");
-  if (my_MPI_size.empty()) {
-    my_MPI_size = (utils::GetEnv("OMPI_COMM_WORLD_SIZE").empty()) ? utils::GetEnv("OMPI_UNIVERSE_SIZE") : utils::GetEnv("OMPI_COMM_WORLD_SIZE");
-  }
-  const auto my_MPI_rank = (utils::GetEnv("PMI_RANK").empty()) ? utils::GetEnv("PMIX_RANK") : utils::GetEnv("PMI_RANK");
-  return ParseRankList(utils::GetEnv("UNITRACE_RanksToSample"), my_MPI_size,
-                                      my_MPI_rank, ranks_to_sample);
-}
-
-inline void GetZeDevicesStringToSet(std::set<int>& device_ids_to_sample, std::string& devices_to_sample) {
-  DevicesStringToSet(devices_to_sample, device_ids_to_sample);
-}
-
-// Write a module's native binary verbatim - the bytes zeModuleGetNativeBinary returns -
-// as the file module_id names in data_dir, for unitrace's own process to read back. The
-// collector's whole part in the module-binary half of the kernel handoff: it never reads
-// one back, so no IGA, ELF or DWARF code is linked into the traced application. See
-// ZeMetricProfiler::ReadModuleAndKernelProps, which documents the handoff.
-//
-// The path is built here and not by the caller, which has only the id and the bytes. Its
-// counterpart, ReadBackModuleNativeBinary below, builds it from the same LoggerFactory:
-// that is the one thing the two sides have to agree about, since the bytes pass through
-// unaltered.
-inline bool WriteOutModuleNativeBinary(const LoggerFactory* logger_factory,
-                                       const std::string& data_dir, uint32_t module_id,
-                                       const uint8_t* data, size_t size) {
-  const std::string path =
-      data_dir + "/" + logger_factory->GetModuleBinaryFileName(utils::GetPid(), module_id);
-
-  std::ofstream file(path, std::ios::binary | std::ios::trunc);
-  if (!file.is_open()) {
-    std::cerr << "[ERROR] Failed to open file for writing: " << path << std::endl;
-    return false;
-  }
-
-  file.write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
-
-  // Check after close(), which flushes the last buffered write: a full disk shows
-  // up there rather than on write(), and reporting success on a short file would
-  // surface later as an undiagnosable "failed to disassemble".
-  file.close();
-  if (!file.good()) {
-    std::cerr << "[ERROR] Error writing module binary to: " << path << std::endl;
-    return false;
-  }
-
-  return true;
-}
-
-// Read back a dumped module binary.
-inline bool ReadBackModuleNativeBinary(const std::string& path,
-                                       std::vector<uint8_t>& out_binary) {
-  std::ifstream file(path, std::ios::binary | std::ios::ate);
-  if (!file.is_open()) {
-    std::cerr << "[WARNING] Failed to open module binary file: " << path << std::endl;
-    return false;
-  }
-
-  std::streampos size = file.tellg();
-  if (size <= 0) {
-    std::cerr << "[WARNING] Module binary file is empty or unreadable: " << path << std::endl;
-    return false;
-  }
-  file.seekg(0, std::ios::beg);
-
-  out_binary.resize(static_cast<size_t>(size));
-  file.read(reinterpret_cast<char*>(out_binary.data()), size);
-  if (file.gcount() != size) {
-    std::cerr << "[WARNING] Module binary file is incomplete: " << path << std::endl;
-    return false;
-  }
-
-  return true;
-}
-#endif // PTI_UTILS_ZE_UTILS_H_
diff --git a/tools/unitrace/src/version.h b/tools/unitrace/src/version.h
deleted file mode 100644
index 2978beb3..00000000
--- a/tools/unitrace/src/version.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef PTI_TOOLS_UNITRACE_VERSION_H_
-#define PTI_TOOLS_UNITRACE_VERSION_H_
-
-#define UNITRACE_VERSION  "2.4.1"
-
-std::string get_version();
-
-#if !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__))
-#define LIB_UNITRACE_TOOL_NAME  "libunitrace_tool.so"
-#define LIB_UNITRACE_MPI_NAME   "libunitrace_mpi.so"
-#else /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-#define LIB_UNITRACE_TOOL_NAME  "unitrace_tool.dll"
-#define LIB_UNITRACE_MPI_NAME   "unitrace_mpi.dll"
-#endif /* !defined(_WIN32) && (defined(__gnu_linux__) || defined(__unix__)) */
-
-#endif /* PTI_TOOLS_UNITRACE_VERSION_H_ */
diff --git a/tools/unitrace/src/xpti/xpti_collector.h b/tools/unitrace/src/xpti/xpti_collector.h
deleted file mode 100644
index a28b8847..00000000
--- a/tools/unitrace/src/xpti/xpti_collector.h
+++ /dev/null
@@ -1,323 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef PTI_TOOLS_UNITRACE_XPTI_COLLECTOR_H_
-#define PTI_TOOLS_UNITRACE_XPTI_COLLECTOR_H_
-
-#include "unicontrol.h"
-#include "unievent.h"
-#include "utils/utils.h"
-#include "xpti/xpti_trace_framework.h"
-
-#include <chrono>
-#include <cstdio>
-#include <iostream>
-#include <map>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <unordered_map>
-
-XPTI_CALLBACK_API void xptiTraceFinish(const char* stream_name);
-XPTI_CALLBACK_API void tpCallback(uint16_t TraceType,
-    xpti::trace_event_data_t* Parent,
-    xpti::trace_event_data_t* Event,
-    uint64_t Instance, const void* UserData);
-XPTI_CALLBACK_API void xptiTraceInit(unsigned int major_version,
-    unsigned int minor_version,
-    const char* version_str,
-    const char* stream_name);
-
-typedef void (*OnXptiLoggingCallback)(EVENT_TYPE etype, const char *name, uint64_t start_ts, uint64_t end_ts);
-
-class XptiCollector {
- public: // Interface
-
-  static XptiCollector *Create(OnXptiLoggingCallback xcallback = nullptr) {
-    XptiCollector* collector = new XptiCollector(xcallback);
-
-    if (collector == nullptr) {
-      std::cerr << "[WARNING] Unable to create XPTI tracer" << std::endl;
-    }
-
-    return collector;
-  }
-
-  XptiCollector(const XptiCollector& that) = delete;
-
-  XptiCollector& operator=(const XptiCollector& that) = delete;
-
-  ~XptiCollector() {
-  }
-
-  void Log(EVENT_TYPE etype, const char *name, uint64_t start_ts, uint64_t end_ts) {
-    if (!UniController::IsCollectionEnabled()) {
-      return;
-    }
-    if (xcallback_) {
-      xcallback_(etype, name, start_ts, end_ts);
-    }
-  }
- private: // Implementation
-
-  XptiCollector(OnXptiLoggingCallback xcallback) : xcallback_(xcallback) {
-  }
-
- private: // Data
-  OnXptiLoggingCallback xcallback_ = nullptr;
-};
-
-static XptiCollector *xpti_collector = nullptr;
-
-XPTI_CALLBACK_API void tpCallback(uint16_t trace_type, xpti::trace_event_data_t *parent, xpti::trace_event_data_t *event, uint64_t instance, const void *user_data);
-
-void xptiTraceInit(unsigned int /* major_version */, unsigned int /* minor_version */, const char * /* version_str */, const char *stream_name) {
-  // SYCL runtime and Unified Runtime (UR) tracing are decoupled and controlled
-  // by separate options. The SYCL runtime streams ("sycl", "sycl.pi",
-  // "sycl.experimental.*") are registered only when SYCL runtime logging is
-  // enabled; the Unified Runtime stream ("ur.call") only when UR logging is
-  // enabled. UR is the implementation layer beneath the SYCL runtime.
-  static const bool syclrt_logging =
-      (utils::GetEnv("UNITRACE_ChromeSyclRuntimeLogging") == "1");
-  static const bool ur_logging =
-      (utils::GetEnv("UNITRACE_ChromeUrLogging") == "1");
-
-  std::string stream(stream_name);
-  bool is_syclrt_stream =
-      (stream == "sycl") ||
-      (stream == "sycl.pi") ||
-      //(stream == "sycl.pi.debug") ||
-      (stream == "sycl.experimental.buffer") ||
-      (stream == "sycl.experimental.mem_alloc");
-  bool is_ur_stream = (stream == "ur.call");
-
-  if ((is_syclrt_stream && syclrt_logging) || (is_ur_stream && ur_logging)) {
-    uint8_t stream = xptiRegisterStream(stream_name);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::function_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::function_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::function_with_args_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::function_with_args_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::task_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::task_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::wait_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::wait_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::barrier_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::barrier_end, tpCallback);
-
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::graph_create, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::node_create, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::edge_create, tpCallback);
-
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::region_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::region_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::lock_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::lock_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::transfer_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::transfer_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::thread_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::thread_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::signal, tpCallback);
-
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::mem_alloc_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::mem_alloc_end, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::mem_release_begin, tpCallback);
-    xptiRegisterCallback(stream, (uint16_t)xpti::trace_point_type_t::mem_release_end, tpCallback);
-
-  } else {
-    // handle other streams;
-  }
-}
-
-std::string truncate(std::string Name) {
-  size_t Pos = Name.find_last_of(":");
-  if (Pos != std::string::npos) {
-    return Name.substr(Pos + 1);
-  } else {
-    return Name;
-  }
-}
-
-void xptiTraceFinish(const char* /* stream_name */)
-{
-  // We do nothing here
-}
-
-enum XPTI_EVENT {
-  XPTI_EVENT_FUNC,
-  XPTI_EVENT_FUNC_WITH_ARGS,
-  XPTI_EVENT_TASK,
-  XPTI_EVENT_WAIT,
-  XPTI_EVENT_BARRIER,
-  XPTI_EVENT_MEM_ALLOC,
-  XPTI_EVENT_MEM_RELEASE,
-  XPTI_EVENT_REGION,
-  XPTI_EVENT_LOCK,
-  XPTI_EVENT_THREAD,
-  XPTI_EVENT_TRANSFER,
-  XPTI_EVENT_LAST
-};
-
-constexpr static int max_xpti_trace_nesting_level = 8;  // 8 layers should be sufficient for SYCL and runtime
-static thread_local uint64_t xpti_event_start_ts[XPTI_EVENT_LAST][max_xpti_trace_nesting_level];
-static thread_local int xpti_tracing_level = 0;
-
-void tpCallback(uint16_t TraceType, xpti::trace_event_data_t * /* Parent */, xpti::trace_event_data_t * /* Event */, uint64_t /* Instance */, const void *UserData) {
-  if (xpti_collector) {
-    switch (TraceType) {
-      case (uint16_t)xpti::trace_point_type_t::function_begin:
-        xpti_event_start_ts[XPTI_EVENT_FUNC][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::function_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          const char *name = nullptr;
-          if (UserData) {
-            name = (const char *)UserData;
-          }
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, (name ? name : "unknwon"), xpti_event_start_ts[XPTI_EVENT_FUNC][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::function_with_args_begin:
-        xpti_event_start_ts[XPTI_EVENT_FUNC_WITH_ARGS][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::function_with_args_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          const char *name = nullptr;
-          if (UserData) {
-            xpti::function_with_args_t *args = (xpti::function_with_args_t *)UserData;
-            name = args->function_name;
-          }
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, name ? name : "unknwon", xpti_event_start_ts[XPTI_EVENT_FUNC_WITH_ARGS][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::task_begin:
-        xpti_event_start_ts[XPTI_EVENT_TASK][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::task_end:
-        {
-#if 0
-          // TODO: get kernel information. name is always nullptr in current implementation
-          const char *name = nullptr;
-          xpti::metadata_t *Metadata = xptiQueryMetadata(Event);
-          for (auto &item : *Metadata) {
-            const char *key = xptiLookupString(item.first);
-            if (!strcmp(key, "kernel_name") || !strcmp(key, "memory_object")) {
-              name = xptiLookupString(item.second);
-            }
-          }
-#endif /* 0 */
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, "submit", xpti_event_start_ts[XPTI_EVENT_TASK][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::wait_begin:
-        xpti_event_start_ts[XPTI_EVENT_WAIT][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::wait_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          const char *name = nullptr;
-          if (UserData) {
-            name = (const char *)UserData;
-          }
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, (name ? name : "unknown"), xpti_event_start_ts[XPTI_EVENT_WAIT][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::barrier_begin:
-        xpti_event_start_ts[XPTI_EVENT_WAIT][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::barrier_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          const char *name = nullptr;
-          if (UserData) {
-            name = (const char *)UserData;
-          }
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, (name ? name : "unknown"), xpti_event_start_ts[XPTI_EVENT_BARRIER][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::graph_create:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_collector->Log(EVENT_MARK, "graph_create", ts, 0 /* not used */);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::node_create:
-        {
-#if 0
-          // TODO: get kernel information. name is always nullptr in current implementation
-          const char *name = nullptr;
-          xpti::metadata_t *Metadata = xptiQueryMetadata(Event);
-          for (auto &item : *Metadata) {
-            const char *key = xptiLookupString(item.first);
-            if (!strcmp(key, "kernel_name") || !strcmp(key, "memory_object")) {
-              name = xptiLookupString(item.second);
-            }
-          }
-#endif /* 0 */
-
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_collector->Log(EVENT_MARK, "node_create", ts, 0);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::edge_create:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_collector->Log(EVENT_MARK, "edge_create", ts, 0);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::mem_alloc_begin:
-        xpti_event_start_ts[XPTI_EVENT_MEM_ALLOC][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::mem_alloc_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, "mem_alloc", xpti_event_start_ts[XPTI_EVENT_MEM_ALLOC][xpti_tracing_level], ts);
-        }
-        break;
-      case (uint16_t)xpti::trace_point_type_t::mem_release_begin:
-        xpti_event_start_ts[XPTI_EVENT_MEM_RELEASE][xpti_tracing_level] = UniTimer::GetHostTimestamp();
-        xpti_tracing_level++;
-        break;
-      case (uint16_t)xpti::trace_point_type_t::mem_release_end:
-        {
-          uint64_t ts = UniTimer::GetHostTimestamp();
-          xpti_tracing_level--;
-          xpti_collector->Log(EVENT_COMPLETE, "mem_release", xpti_event_start_ts[XPTI_EVENT_MEM_RELEASE][xpti_tracing_level], ts);
-        }
-        break;
-
-      case (uint16_t)xpti::trace_point_type_t::region_begin:
-      case (uint16_t)xpti::trace_point_type_t::region_end:
-      case (uint16_t)xpti::trace_point_type_t::lock_begin:
-      case (uint16_t)xpti::trace_point_type_t::lock_end:
-      case (uint16_t)xpti::trace_point_type_t::transfer_begin:
-      case (uint16_t)xpti::trace_point_type_t::transfer_end:
-      case (uint16_t)xpti::trace_point_type_t::thread_begin:
-      case (uint16_t)xpti::trace_point_type_t::thread_end:
-      case (uint16_t)xpti::trace_point_type_t::signal:
-        break;
-
-      default:
-        break;
-    }
-  }
-}
-
-#endif // PTI_TOOLS_UNITRACE_XPTI_COLLECTOR_H_
diff --git a/tools/unitrace/test/cpp_test/CMakeLists.txt b/tools/unitrace/test/cpp_test/CMakeLists.txt
deleted file mode 100644
index b6e7417c..00000000
--- a/tools/unitrace/test/cpp_test/CMakeLists.txt
+++ /dev/null
@@ -1,71 +0,0 @@
-
-cmake_minimum_required(VERSION 3.22)
-
-if(WIN32)
-  set(CMAKE_C_COMPILER "$ENV{CMPLR_ROOT}/bin/icx.exe")
-  set(CMAKE_CXX_COMPILER "$ENV{CMPLR_ROOT}/bin/icx.exe")
-else()
-  set(CMAKE_C_COMPILER "$ENV{CMPLR_ROOT}/bin/icx")
-  set(CMAKE_CXX_COMPILER "$ENV{CMPLR_ROOT}/bin/icpx")
-endif()
-
-project(UnitraceTest C CXX)
-
-# Unitrace's own cmake modules, included once so every workload can use them:
-# the pinned Level Zero headers (HeaderFetch) and, on Windows, the loader
-# import library (LevelZero).
-include("${PROJECT_SOURCE_DIR}/../../cmake/HeaderFetch.cmake")
-if(WIN32)
-  include("${PROJECT_SOURCE_DIR}/../../cmake/LevelZero.cmake")
-endif()
-
-find_package(Python 3.9 COMPONENTS Interpreter REQUIRED)
-
-# Some compiler distributions ship an IntelSYCLConfig.cmake whose SYCL
-# feature test fails even though icpx -fsycl works. With this option ON,
-# add_sycl_to_target() applies plain -fsycl instead of using the package.
-option(UNITRACE_PLAIN_SYCL
-  "Use plain -fsycl flags instead of the IntelSYCL cmake package" OFF)
-if (UNITRACE_PLAIN_SYCL)
-  function(add_sycl_to_target target)
-    target_compile_options(${target} PRIVATE -fsycl)
-    target_link_options(${target} PRIVATE -fsycl)
-  endfunction()
-else()
-  find_package(IntelSYCL REQUIRED)
-endif()
-
-# L0 version required
-set (LEVEL_ZERO_COMMIT_ID "v1.32.0")
-
-# Workloads are built here and installed (test_unitrace.py runs
-# cmake --install --prefix <unitrace build>/test) into bin/<workload>/, one
-# directory per workload, together with its data files (.spv kernels are loaded
-# from next to the executable). Install a new workload the same way:
-#   install(TARGETS <name> RUNTIME DESTINATION bin/<name> COMPONENT <name>)
-# Keep the link-time library paths so the installed binaries run like the
-# built ones.
-set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)
-
-#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
-
-
-add_subdirectory(cl_gemm)
-add_subdirectory(conditional_trace)
-add_subdirectory(dpc_gemm)
-add_subdirectory(device_and_rank_to_sample)
-add_subdirectory(event_reset)
-add_subdirectory(gemm_stall_sampling)
-add_subdirectory(graph)
-add_subdirectory(grf)
-# internal_conditional_trace exercises the in-application stop control
-# (__itt_detach / PTI_ENABLE_COLLECTION).
-add_subdirectory(internal_conditional_trace)
-add_subdirectory(metric_config)
-add_subdirectory(omp_gemm)
-add_subdirectory(omp_cpu_gemm)
-add_subdirectory(sycl_graph_with_v2_adaptor)
-add_subdirectory(temporal)
-add_subdirectory(ze_gemm)
-add_subdirectory(ze_graph_api)
-add_subdirectory(ze_counterbased_events)
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/CMakeLists.txt b/tools/unitrace/test/cpp_test/cl_gemm/CMakeLists.txt
deleted file mode 100644
index c1148950..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-project(cl_gemm CXX)
-
-add_executable(cl_gemm main.cc)
-add_sycl_to_target(cl_gemm)
-
-target_include_directories(cl_gemm PRIVATE "${PROJECT_SOURCE_DIR}/../../..")
-  
-target_link_libraries(cl_gemm PRIVATE OpenCL)
-
-install(TARGETS cl_gemm RUNTIME DESTINATION bin/cl_gemm COMPONENT cl_gemm)
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/d.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/d.txt
deleted file mode 100644
index 27dc2dd5..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/d.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):             89614076
-Total Device Time for CL GPU backend (ns):             46625120
-
-== CL GPU Backend ==
-
-              Kernel,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                GEMM,           4,            44280640,       94.97,            11070160,             9633280,            12989120
-clEnqueueWriteBuffer,           8,             1406560,        3.02,              175820,              153040,              203600
- clEnqueueReadBuffer,           4,              937920,        2.01,              234480,              222400,              240080
-
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/h.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/h.txt
deleted file mode 100644
index 03d617b7..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/h.txt
+++ /dev/null
@@ -1,45 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):             54909372
-    Total API Time for L0 backend (ns):                10394
-Total API Time for CL CPU backend (ns):                 3149
-Total API Time for CL GPU backend (ns):             16233454
-
-== L0 Backend ==
-
-                           Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-zeDriverGetExtensionFunctionAddress,            1,                 5304,     51.029442,                 5304,                 5304,                 5304
-                        zeDriverGet,            1,                 5090,     48.970558,                 5090,                 5090,                 5090
-
-== CL CPU Backend ==
-
-      Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetDeviceIDs,           2,                3149,      100.00,                1574,                 758,                2391
-
-== CL GPU Backend ==
-
-                          Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                          clFinish,           4,            11973950,       73.76,             2993487,             2929705,             3024733
-              clEnqueueWriteBuffer,           8,             1709589,       10.53,              213698,               84742,              910401
-               clEnqueueReadBuffer,           4,             1547551,        9.53,              386887,              348633,              457340
-            clEnqueueNDRangeKernel,           4,              380002,        2.34,               95000,               25415,              284353
-                    clBuildProgram,           1,              212721,        1.31,              212721,              212721,              212721
-                clReleaseMemObject,          12,              141960,        0.87,               11830,                5198,               20233
-                    clCreateBuffer,          12,               88477,        0.55,                7373,                2421,               18427
-                   clCreateContext,           1,               84020,        0.52,               84020,               84020,               84020
-                  clReleaseProgram,           1,               26458,        0.16,               26458,               26458,               26458
-           clGetEventProfilingInfo,           8,               21526,        0.13,                2690,                  74,                7643
-clCreateCommandQueueWithProperties,           1,                7637,        0.05,                7637,                7637,                7637
-                    clSetKernelArg,          16,                7361,        0.05,                 460,                  60,                2334
-                    clCreateKernel,           1,                5968,        0.04,                5968,                5968,                5968
-         clCreateProgramWithSource,           1,                5445,        0.03,                5445,                5445,                5445
-                    clReleaseEvent,           4,                4581,        0.03,                1145,                 683,                1792
-                  clReleaseContext,           1,                4476,        0.03,                4476,                4476,                4476
-             clReleaseCommandQueue,           1,                3938,        0.02,                3938,                3938,                3938
-                   clReleaseKernel,           1,                3749,        0.02,                3749,                3749,                3749
-                   clGetKernelInfo,           4,                2077,        0.01,                 519,                 290,                1125
-                   clGetDeviceInfo,           4,                1213,        0.01,                 303,                  99,                 569
-                    clGetDeviceIDs,           2,                 755,        0.00,                 377,                 308,                 447
-
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/t.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/t.txt
deleted file mode 100644
index 96e9d834..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/linux/t.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502227945603 (append) 542502228097648 (submit) 542502229029328 (start) 542502229178368 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502229036485 (append) 542502229037714 (submit) 542502229187954 (start) 542502229310914 (end)
-Thread 47110 Device 0x44e4920 : GEMM [ns] 542502230386875 (append) 542502231068451 (submit) 542502231181571 (start) 542502234039971 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueReadBuffer [ns] 542502236600357 (append) 542502236606237 (submit) 542502236654797 (start) 542502236878237 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502237391877 (append) 542502237394718 (submit) 542502237443358 (start) 542502237560398 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502237473735 (append) 542502237474486 (submit) 542502237564086 (start) 542502237682966 (end)
-Thread 47110 Device 0x44e4920 : GEMM [ns] 542502237544629 (append) 542502237552304 (submit) 542502237683664 (start) 542502240557264 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueReadBuffer [ns] 542502240701996 (append) 542502240703008 (submit) 542502240759088 (start) 542502240977408 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502241424474 (append) 542502241427262 (submit) 542502241633102 (start) 542502241751502 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502241668456 (append) 542502241669261 (submit) 542502241755181 (start) 542502241874301 (end)
-Thread 47110 Device 0x44e4920 : GEMM [ns] 542502241765604 (append) 542502241771790 (submit) 542502241875710 (start) 542502244729630 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueReadBuffer [ns] 542502244880646 (append) 542502244881711 (submit) 542502244948991 (start) 542502245164911 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502245593784 (append) 542502245596490 (submit) 542502245666810 (start) 542502245805530 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueWriteBuffer [ns] 542502245696592 (append) 542502245697409 (submit) 542502245809249 (start) 542502245926929 (end)
-Thread 47110 Device 0x44e4920 : GEMM [ns] 542502245770283 (append) 542502245775472 (submit) 542502245928352 (start) 542502248780832 (end)
-Thread 47110 Device 0x44e4920 : clEnqueueReadBuffer [ns] 542502248907592 (append) 542502248908395 (submit) 542502248985115 (start) 542502249193915 (end)
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/d.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/d.txt
deleted file mode 100644
index 91cd4d22..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/d.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           1169230000
-Total Device Time for CL GPU backend (ns):             91672091
-
-== CL GPU Backend ==
-
-              Kernel,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                GEMM,           4,            84431196,       92.10,            21107799,            20856041,            21550937
- clEnqueueReadBuffer,           4,             5139701,        5.61,             1284925,             1006200,             1493901
-clEnqueueWriteBuffer,           8,             2101194,        2.29,              262649,              199687,              366406
-
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/h.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/h.txt
deleted file mode 100644
index 462477ae..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/h.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1349818700
-    Total API Time for L0 backend (ns):                 2400
-Total API Time for CL CPU backend (ns):                49700
-Total API Time for CL GPU backend (ns):            156338400
-
-== L0 Backend ==
-
-   Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-zeDriverGet,            1,                 2400,    100.000000,                 2400,                 2400,                 2400
-
-== CL CPU Backend ==
-
-      Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetDeviceIDs,           1,               49700,      100.00,               49700,               49700,               49700
-
-== CL GPU Backend ==
-
-                          Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                          clFinish,           4,            99202300,       63.45,            24800575,            23985400,            26389000
-                  clReleaseContext,           1,            45225600,       28.93,            45225600,            45225600,            45225600
-               clEnqueueReadBuffer,           4,             5093500,        3.26,             1273375,              894700,             1929300
-                    clCreateBuffer,          12,             3411100,        2.18,              284258,               47400,              543700
-              clEnqueueWriteBuffer,           8,             1272800,        0.81,              159100,               40700,              796800
-                    clBuildProgram,           1,              984100,        0.63,              984100,              984100,              984100
-                   clCreateContext,           1,              417900,        0.27,              417900,              417900,              417900
-            clEnqueueNDRangeKernel,           4,              397900,        0.25,               99475,               12000,              235100
-                clReleaseMemObject,          12,              140300,        0.09,               11691,                1800,               65400
-                    clCreateKernel,           1,               50700,        0.03,               50700,               50700,               50700
-                  clReleaseProgram,           1,               33700,        0.02,               33700,               33700,               33700
-         clCreateProgramWithSource,           1,               19800,        0.01,               19800,               19800,               19800
-           clGetEventProfilingInfo,           8,               19600,        0.01,                2450,                 200,                4900
-                    clSetKernelArg,          16,               14700,        0.01,                 918,                 200,                3300
-                   clGetKernelInfo,           4,               12600,        0.01,                3150,                1600,                5300
-                    clReleaseEvent,           4,               12200,        0.01,                3050,                2800,                3300
-                   clReleaseKernel,           1,               10200,        0.01,               10200,               10200,               10200
-             clReleaseCommandQueue,           1,                7000,        0.00,                7000,                7000,                7000
-clCreateCommandQueueWithProperties,           1,                4800,        0.00,                4800,                4800,                4800
-                    clGetDeviceIDs,           2,                4400,        0.00,                2200,                 300,                4100
-                   clGetDeviceInfo,           3,                3200,        0.00,                1066,                 300,                1800
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/t.txt b/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/t.txt
deleted file mode 100644
index fb4b5729..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/gold/windows/t.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698898947862 (append) 201698899326162 (submit) 201698901127360 (start) 201698901362620 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698899760700 (append) 201698899788500 (submit) 201698901728812 (start) 201698902028082 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698900045680 (append) 201698900074680 (submit) 201698902466867 (start) 201698923446554 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698924652794 (append) 201698924653194 (submit) 201698924658394 (start) 201698925583294 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698934442200 (append) 201698934458300 (submit) 201698934915748 (start) 201698935153143 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698934814060 (append) 201698934821560 (submit) 201698935327445 (start) 201698935622861 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698934912858 (append) 201698934918358 (submit) 201698935703775 (start) 201698957497837 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698958241250 (append) 201698958242050 (submit) 201698958247150 (start) 201698959241250 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698967808495 (append) 201698967825495 (submit) 201698968317579 (start) 201698968555912 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698968188050 (append) 201698968195850 (submit) 201698968755329 (start) 201698969057516 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698968335873 (append) 201698968354873 (submit) 201698969131331 (start) 201698989567528 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698990254186 (append) 201698990255386 (submit) 201698990258286 (start) 201698991390086 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201699000329367 (append) 201699000344967 (submit) 201699000805800 (start) 201699001042414 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201699000616183 (append) 201699000621883 (submit) 201699001124800 (start) 201699001444122 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201699000779552 (append) 201699000786252 (submit) 201699001522190 (start) 201699023212190 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201699023895052 (append) 201699023895752 (submit) 201699023905252 (start) 201699025044852 (end)
-
diff --git a/tools/unitrace/test/cpp_test/cl_gemm/main.cc b/tools/unitrace/test/cpp_test/cl_gemm/main.cc
deleted file mode 100644
index 0982cf92..00000000
--- a/tools/unitrace/test/cpp_test/cl_gemm/main.cc
+++ /dev/null
@@ -1,222 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <math.h>
-#include <string.h>
-
-#include <chrono>
-#include <iostream>
-
-#include <CL/cl.h>
-
-#include "utils/cl_utils.h"
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-const char* kKernelSource =
-  "__kernel void GEMM(__global float* a, __global float* b,\n"
-  "                   __global float* c, unsigned size) {\n"
-  "  int j = get_global_id(0);\n"
-  "  int i = get_global_id(1);\n"
-  "  float sum = 0.0f;\n"
-  "  for (unsigned k = 0; k < size; ++k) {\n"
-  "    sum += a[i * size + k] * b[k * size + j];\n"
-  "  }\n"
-  "  c[i * size + j] = sum;\n"
-  "}";
-
-static float Check(const std::vector<float>& a, float value) {
-  UNITRACE_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-static float RunAndCheck(cl_kernel kernel, cl_command_queue queue,
-                         const std::vector<float>& a,
-                         const std::vector<float>& b,
-                         std::vector<float>& c,
-                         unsigned size, float expected_result) {
-  UNITRACE_ASSERT(kernel != nullptr && queue != nullptr);
-  
-  UNITRACE_ASSERT(size > 0);
-  UNITRACE_ASSERT(a.size() == size * size);
-  UNITRACE_ASSERT(b.size() == size * size);
-  UNITRACE_ASSERT(c.size() == size * size);
-
-  cl_int status = CL_SUCCESS;    
-  cl_context context = utils::cl::GetContext(kernel);
-  UNITRACE_ASSERT(context != nullptr);
-
-  cl_mem dev_a = clCreateBuffer(context, CL_MEM_READ_ONLY,
-                                a.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_a != nullptr);
-  cl_mem dev_b = clCreateBuffer(context, CL_MEM_READ_ONLY,
-                                b.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_b != nullptr);
-  cl_mem dev_c = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
-                                c.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_c != nullptr);
-
-  status = clEnqueueWriteBuffer(queue, dev_a, CL_FALSE, 0,
-                                a.size() * sizeof(float),
-                                a.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clEnqueueWriteBuffer(queue, dev_b, CL_FALSE, 0,
-                                b.size() * sizeof(float),
-                                b.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clSetKernelArg(kernel, 0, sizeof(cl_mem), &dev_a);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 1, sizeof(cl_mem), &dev_b);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 2, sizeof(cl_mem), &dev_c);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 3, sizeof(unsigned), &size);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  size_t global_work_size[]{size, size};
-  cl_event event = nullptr;
-  status = clEnqueueNDRangeKernel(queue, kernel, 2, nullptr, global_work_size,
-                                  nullptr, 0, nullptr, &event);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clFinish(queue);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clEnqueueReadBuffer(queue, dev_c, CL_TRUE, 0,
-                               c.size() * sizeof(float),
-                               c.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clReleaseMemObject(dev_a);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseMemObject(dev_b);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseMemObject(dev_c);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  
-  cl_ulong start = 0, end = 0;
-  status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START,
-                                   sizeof(cl_ulong), &start, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END,
-                                   sizeof(cl_ulong), &end, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clReleaseEvent(event);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  double time = static_cast<double>(end - start) / NSEC_IN_SEC;
-  std::cout << "Matrix multiplication time: " << time <<
-    " sec" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(cl_device_id device, const std::vector<float>& a,
-                    const std::vector<float>& b, std::vector<float>& c,
-                    unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  UNITRACE_ASSERT(device != nullptr);
-  cl_int status = CL_SUCCESS;
-
-  cl_context context = clCreateContext(nullptr, 1, &device, nullptr,
-                                       nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && context != nullptr);
-
-  cl_queue_properties props[] = { CL_QUEUE_PROPERTIES,
-                                  CL_QUEUE_PROFILING_ENABLE, 0 };
-  cl_command_queue queue = clCreateCommandQueueWithProperties(
-    context, device, props, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && queue != nullptr);
-
-  cl_program program = clCreateProgramWithSource(context, 1, &kKernelSource,
-                                                 nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && program != nullptr);
-  // Kernel line info comes from the runtime build options, not the host build:
-  // -gline-tables-only emits .debug_line, -s names the source built from a string.
-  status = clBuildProgram(program, 1, &device,
-                          "-gline-tables-only -s cl_gemm_kernel.cl",
-                          nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  cl_kernel kernel = clCreateKernel(program, "GEMM", &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && kernel != nullptr);
-
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    if (i == 0) { // Enable data collection for the first iteration
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "1");
-    }
-
-    float eps = RunAndCheck(kernel, queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-
-    if (i == 0) { // Disable data collection for the rest iterations
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "");
-    }
-  }
-
-  status = clReleaseKernel(kernel);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseProgram(program);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseCommandQueue(queue);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseContext(context);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-}
-
-int main(int argc, char* argv[]) {
-  cl_device_type type = CL_DEVICE_TYPE_GPU;
-  if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-    type = CL_DEVICE_TYPE_CPU;
-  }
-
-  cl_device_id device = utils::cl::GetIntelDevice(type);
-  if (device == nullptr) {
-    std::cout << "Unable to find target device" << std::endl;
-    return 0;
-  }
-
-  unsigned size = 1024;
-  if (argc > 2) {
-    size = std::stoul(argv[2]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 3) {
-    repeat_count = std::stoul(argv[3]);
-  }
-
-  std::cout << "OpenCL Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " << utils::cl::GetDeviceName(device) <<
-    std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(device, a, b, c, size, repeat_count, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  return 0;
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/CMakeLists.txt b/tools/unitrace/test/cpp_test/conditional_trace/CMakeLists.txt
deleted file mode 100644
index 6767950c..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/CMakeLists.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-project(conditional_trace CXX)
-
-add_executable(conditional_trace main.cc)
-add_sycl_to_target(conditional_trace)
-
-target_include_directories(conditional_trace PRIVATE "${PROJECT_SOURCE_DIR}/../../..")
-  
-target_link_libraries(conditional_trace PRIVATE OpenCL)
-
-install(TARGETS conditional_trace RUNTIME DESTINATION bin/conditional_trace COMPONENT conditional_trace)
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/d.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/d.txt
deleted file mode 100644
index 1a9eeb14..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/d.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            149421702
-Total Device Time for CL GPU backend (ns):              6924080
-
-== CL GPU Backend ==
-
-              Kernel,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                GEMM,           2,             5720800,       82.62,             2860400,             2850080,             2870720
-clEnqueueWriteBuffer,           4,              789760,       11.41,              197440,              196800,              198240
- clEnqueueReadBuffer,           2,              413520,        5.97,              206760,              206640,              206880
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/h.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/h.txt
deleted file mode 100644
index 652c1783..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/h.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            145765267
-Total API Time for CL CPU backend (ns):                 1145
-Total API Time for CL GPU backend (ns):              7225670
-
-== CL CPU Backend ==
-
-      Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetDeviceIDs,           1,                1145,      100.00,                1145,                1145,                1145
-
-== CL GPU Backend ==
-
-               Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-               clFinish,           2,             6492107,       89.85,             3246053,             3230099,             3262008
-    clEnqueueReadBuffer,           2,              473442,        6.55,              236721,              236264,              237178
-   clEnqueueWriteBuffer,           4,               89342,        1.24,               22335,               15038,               31214
-     clReleaseMemObject,           6,               48383,        0.67,                8063,                5161,               12865
- clEnqueueNDRangeKernel,           2,               45678,        0.63,               22839,               18259,               27419
-         clCreateBuffer,           6,               44497,        0.62,                7416,                3139,               12437
-       clReleaseProgram,           1,               13756,        0.19,               13756,               13756,               13756
-clGetEventProfilingInfo,           4,                8454,        0.12,                2113,                  74,                4157
-  clReleaseCommandQueue,           1,                2359,        0.03,                2359,                2359,                2359
-       clReleaseContext,           1,                2276,        0.03,                2276,                2276,                2276
-         clSetKernelArg,           8,                1860,        0.03,                 232,                  78,                 563
-        clReleaseKernel,           1,                1643,        0.02,                1643,                1643,                1643
-         clReleaseEvent,           2,                1346,        0.02,                 673,                 600,                 746
-        clGetKernelInfo,           2,                 527,        0.01,                 263,                 238,                 289
-
-
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/t.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/t.txt
deleted file mode 100644
index c334ab5a..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/linux/t.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-Thread 851309 Device 0x4f45710 : clEnqueueWriteBuffer [ns] 1767085596811645 (append) 1767085596814428 (submit) 1767085596832188 (start) 1767085597030028 (end)
-Thread 851309 Device 0x4f45710 : clEnqueueWriteBuffer [ns] 1767085596859687 (append) 1767085596860782 (submit) 1767085597032462 (start) 1767085597229262 (end)
-Thread 851309 Device 0x4f45710 : GEMM [ns] 1767085596880303 (append) 1767085596884855 (submit) 1767085597230295 (start) 1767085600081175 (end)
-Thread 851309 Device 0x4f45710 : clEnqueueReadBuffer [ns] 1767085600178111 (append) 1767085600179688 (submit) 1767085600187688 (start) 1767085600394008 (end)
-Thread 851309 Device 0x4f45710 : clEnqueueWriteBuffer [ns] 1767085600854796 (append) 1767085600857351 (submit) 1767085600873191 (start) 1767085601070631 (end)
-Thread 851309 Device 0x4f45710 : clEnqueueWriteBuffer [ns] 1767085600888488 (append) 1767085600889532 (submit) 1767085601072892 (start) 1767085601269532 (end)
-Thread 851309 Device 0x4f45710 : GEMM [ns] 1767085600908593 (append) 1767085600913245 (submit) 1767085601270685 (start) 1767085604120285 (end)
-Thread 851309 Device 0x4f45710 : clEnqueueReadBuffer [ns] 1767085604198888 (append) 1767085604200256 (submit) 1767085604208016 (start) 1767085604414176 (end)
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/d.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/d.txt
deleted file mode 100644
index 91cd4d22..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/d.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           1169230000
-Total Device Time for CL GPU backend (ns):             91672091
-
-== CL GPU Backend ==
-
-              Kernel,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                GEMM,           4,            84431196,       92.10,            21107799,            20856041,            21550937
- clEnqueueReadBuffer,           4,             5139701,        5.61,             1284925,             1006200,             1493901
-clEnqueueWriteBuffer,           8,             2101194,        2.29,              262649,              199687,              366406
-
-
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/h.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/h.txt
deleted file mode 100644
index 462477ae..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/h.txt
+++ /dev/null
@@ -1,43 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1349818700
-    Total API Time for L0 backend (ns):                 2400
-Total API Time for CL CPU backend (ns):                49700
-Total API Time for CL GPU backend (ns):            156338400
-
-== L0 Backend ==
-
-   Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-zeDriverGet,            1,                 2400,    100.000000,                 2400,                 2400,                 2400
-
-== CL CPU Backend ==
-
-      Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetDeviceIDs,           1,               49700,      100.00,               49700,               49700,               49700
-
-== CL GPU Backend ==
-
-                          Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-                          clFinish,           4,            99202300,       63.45,            24800575,            23985400,            26389000
-                  clReleaseContext,           1,            45225600,       28.93,            45225600,            45225600,            45225600
-               clEnqueueReadBuffer,           4,             5093500,        3.26,             1273375,              894700,             1929300
-                    clCreateBuffer,          12,             3411100,        2.18,              284258,               47400,              543700
-              clEnqueueWriteBuffer,           8,             1272800,        0.81,              159100,               40700,              796800
-                    clBuildProgram,           1,              984100,        0.63,              984100,              984100,              984100
-                   clCreateContext,           1,              417900,        0.27,              417900,              417900,              417900
-            clEnqueueNDRangeKernel,           4,              397900,        0.25,               99475,               12000,              235100
-                clReleaseMemObject,          12,              140300,        0.09,               11691,                1800,               65400
-                    clCreateKernel,           1,               50700,        0.03,               50700,               50700,               50700
-                  clReleaseProgram,           1,               33700,        0.02,               33700,               33700,               33700
-         clCreateProgramWithSource,           1,               19800,        0.01,               19800,               19800,               19800
-           clGetEventProfilingInfo,           8,               19600,        0.01,                2450,                 200,                4900
-                    clSetKernelArg,          16,               14700,        0.01,                 918,                 200,                3300
-                   clGetKernelInfo,           4,               12600,        0.01,                3150,                1600,                5300
-                    clReleaseEvent,           4,               12200,        0.01,                3050,                2800,                3300
-                   clReleaseKernel,           1,               10200,        0.01,               10200,               10200,               10200
-             clReleaseCommandQueue,           1,                7000,        0.00,                7000,                7000,                7000
-clCreateCommandQueueWithProperties,           1,                4800,        0.00,                4800,                4800,                4800
-                    clGetDeviceIDs,           2,                4400,        0.00,                2200,                 300,                4100
-                   clGetDeviceInfo,           3,                3200,        0.00,                1066,                 300,                1800
-
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/t.txt b/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/t.txt
deleted file mode 100644
index fb4b5729..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/gold/windows/t.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698898947862 (append) 201698899326162 (submit) 201698901127360 (start) 201698901362620 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698899760700 (append) 201698899788500 (submit) 201698901728812 (start) 201698902028082 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698900045680 (append) 201698900074680 (submit) 201698902466867 (start) 201698923446554 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698924652794 (append) 201698924653194 (submit) 201698924658394 (start) 201698925583294 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698934442200 (append) 201698934458300 (submit) 201698934915748 (start) 201698935153143 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698934814060 (append) 201698934821560 (submit) 201698935327445 (start) 201698935622861 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698934912858 (append) 201698934918358 (submit) 201698935703775 (start) 201698957497837 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698958241250 (append) 201698958242050 (submit) 201698958247150 (start) 201698959241250 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698967808495 (append) 201698967825495 (submit) 201698968317579 (start) 201698968555912 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201698968188050 (append) 201698968195850 (submit) 201698968755329 (start) 201698969057516 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201698968335873 (append) 201698968354873 (submit) 201698969131331 (start) 201698989567528 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201698990254186 (append) 201698990255386 (submit) 201698990258286 (start) 201698991390086 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201699000329367 (append) 201699000344967 (submit) 201699000805800 (start) 201699001042414 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueWriteBuffer [ns] 201699000616183 (append) 201699000621883 (submit) 201699001124800 (start) 201699001444122 (end)
-Thread 33448 Device 000001BD9D66C280 : GEMM [ns] 201699000779552 (append) 201699000786252 (submit) 201699001522190 (start) 201699023212190 (end)
-Thread 33448 Device 000001BD9D66C280 : clEnqueueReadBuffer [ns] 201699023895052 (append) 201699023895752 (submit) 201699023905252 (start) 201699025044852 (end)
-
diff --git a/tools/unitrace/test/cpp_test/conditional_trace/main.cc b/tools/unitrace/test/cpp_test/conditional_trace/main.cc
deleted file mode 100644
index 0c1c3a84..00000000
--- a/tools/unitrace/test/cpp_test/conditional_trace/main.cc
+++ /dev/null
@@ -1,218 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <math.h>
-#include <string.h>
-
-#include <chrono>
-#include <iostream>
-
-#include <CL/cl.h>
-
-#include "utils/cl_utils.h"
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-const char* kKernelSource =
-  "__kernel void GEMM(__global float* a, __global float* b,\n"
-  "                   __global float* c, unsigned size) {\n"
-  "  int j = get_global_id(0);\n"
-  "  int i = get_global_id(1);\n"
-  "  float sum = 0.0f;\n"
-  "  for (unsigned k = 0; k < size; ++k) {\n"
-  "    sum += a[i * size + k] * b[k * size + j];\n"
-  "  }\n"
-  "  c[i * size + j] = sum;\n"
-  "}";
-
-static float Check(const std::vector<float>& a, float value) {
-  UNITRACE_ASSERT(value > MAX_EPS);
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-static float RunAndCheck(cl_kernel kernel, cl_command_queue queue,
-                         const std::vector<float>& a,
-                         const std::vector<float>& b,
-                         std::vector<float>& c,
-                         unsigned size, float expected_result) {
-  UNITRACE_ASSERT(kernel != nullptr && queue != nullptr);
-  
-  UNITRACE_ASSERT(size > 0);
-  UNITRACE_ASSERT(a.size() == size * size);
-  UNITRACE_ASSERT(b.size() == size * size);
-  UNITRACE_ASSERT(c.size() == size * size);
-
-  cl_int status = CL_SUCCESS;    
-  cl_context context = utils::cl::GetContext(kernel);
-  UNITRACE_ASSERT(context != nullptr);
-
-  cl_mem dev_a = clCreateBuffer(context, CL_MEM_READ_ONLY,
-                                a.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_a != nullptr);
-  cl_mem dev_b = clCreateBuffer(context, CL_MEM_READ_ONLY,
-                                b.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_b != nullptr);
-  cl_mem dev_c = clCreateBuffer(context, CL_MEM_WRITE_ONLY,
-                                c.size() * sizeof(float),
-                                nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && dev_c != nullptr);
-
-  status = clEnqueueWriteBuffer(queue, dev_a, CL_FALSE, 0,
-                                a.size() * sizeof(float),
-                                a.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clEnqueueWriteBuffer(queue, dev_b, CL_FALSE, 0,
-                                b.size() * sizeof(float),
-                                b.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clSetKernelArg(kernel, 0, sizeof(cl_mem), &dev_a);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 1, sizeof(cl_mem), &dev_b);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 2, sizeof(cl_mem), &dev_c);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clSetKernelArg(kernel, 3, sizeof(unsigned), &size);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  size_t global_work_size[]{size, size};
-  cl_event event = nullptr;
-  status = clEnqueueNDRangeKernel(queue, kernel, 2, nullptr, global_work_size,
-                                  nullptr, 0, nullptr, &event);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clFinish(queue);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clEnqueueReadBuffer(queue, dev_c, CL_TRUE, 0,
-                               c.size() * sizeof(float),
-                               c.data(), 0, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clReleaseMemObject(dev_a);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseMemObject(dev_b);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseMemObject(dev_c);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  
-  cl_ulong start = 0, end = 0;
-  status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START,
-                                   sizeof(cl_ulong), &start, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END,
-                                   sizeof(cl_ulong), &end, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  status = clReleaseEvent(event);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  double time = static_cast<double>(end - start) / NSEC_IN_SEC;
-  std::cout << "Matrix multiplication time: " << time <<
-    " sec" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(cl_device_id device, const std::vector<float>& a,
-                    const std::vector<float>& b, std::vector<float>& c,
-                    unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  UNITRACE_ASSERT(device != nullptr);
-  cl_int status = CL_SUCCESS;
-
-  cl_context context = clCreateContext(nullptr, 1, &device, nullptr,
-                                       nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && context != nullptr);
-
-  cl_queue_properties props[] = { CL_QUEUE_PROPERTIES,
-                                  CL_QUEUE_PROFILING_ENABLE, 0 };
-  cl_command_queue queue = clCreateCommandQueueWithProperties(
-    context, device, props, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && queue != nullptr);
-
-  cl_program program = clCreateProgramWithSource(context, 1, &kKernelSource,
-                                                 nullptr, &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && program != nullptr);
-  status = clBuildProgram(program, 1, &device, nullptr, nullptr, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  cl_kernel kernel = clCreateKernel(program, "GEMM", &status);
-  UNITRACE_ASSERT(status == CL_SUCCESS && kernel != nullptr);
-
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    // Skip tracing for first 2 iterations to allow the system to warm up and collect more accurate data
-    // Enable trace from 3rd iteration onwards
-    if (i == 2) {
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "1");
-    }
-    float eps = RunAndCheck(kernel, queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-
-  // Disable trace collection
-  utils::SetEnv("PTI_ENABLE_COLLECTION", "");
-
-  status = clReleaseKernel(kernel);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseProgram(program);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseCommandQueue(queue);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  status = clReleaseContext(context);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-}
-
-int main(int argc, char* argv[]) {
-  cl_device_type type = CL_DEVICE_TYPE_GPU;
-  if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-    type = CL_DEVICE_TYPE_CPU;
-  }
-
-  cl_device_id device = utils::cl::GetIntelDevice(type);
-  if (device == nullptr) {
-    std::cout << "Unable to find target device" << std::endl;
-    return 0;
-  }
-
-  unsigned size = 1024;
-  if (argc > 2) {
-    size = std::stoul(argv[2]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 3) {
-    repeat_count = std::stoul(argv[3]);
-  }
-
-  std::cout << "OpenCL Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " << utils::cl::GetDeviceName(device) <<
-    std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(device, a, b, c, size, repeat_count, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  return 0;
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/CMakeLists.txt b/tools/unitrace/test/cpp_test/device_and_rank_to_sample/CMakeLists.txt
deleted file mode 100644
index 2209596b..00000000
--- a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-project(device_and_rank_to_sample CXX)
-add_executable(device_and_rank_to_sample empty.cpp empty_kernel.cpp)
-
-if (WIN32)
-    UnitraceFindL0Library(device_and_rank_to_sample)
-    UnitraceGetLevelZeroHeaders(device_and_rank_to_sample ${LEVEL_ZERO_COMMIT_ID})
-else()
-    target_link_libraries(device_and_rank_to_sample PRIVATE -lze_loader)
-endif()
-
-install(TARGETS device_and_rank_to_sample RUNTIME DESTINATION bin/device_and_rank_to_sample COMPONENT device_and_rank_to_sample)
diff --git a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty.cpp b/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty.cpp
deleted file mode 100644
index 3b4ea0f4..00000000
--- a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty.cpp
+++ /dev/null
@@ -1,356 +0,0 @@
-#include <stdio.h>
-#include <vector>
-#include <string>
-#include <string.h>
-#include <assert.h>
-#include <time.h>
-#include <level_zero/ze_api.h>
-#include "empty_kernel.h"
-
-#ifdef _WIN32
-#include <windows.h>
-struct wintimespec {
-    time_t tv_sec;  // seconds
-    long   tv_nsec; // nanoseconds
-};
-
-static int clock_getwintime(struct wintimespec* ts) {
-    LARGE_INTEGER freq, count;
-    QueryPerformanceFrequency(&freq);
-    QueryPerformanceCounter(&count);
-    ts->tv_sec = count.QuadPart / freq.QuadPart;
-    ts->tv_nsec = (long)((count.QuadPart % freq.QuadPart) * 1e9 / freq.QuadPart);
-    return 0;
-}
-#endif
-
-static bool enumAndPickDevice(ze_device_handle_t &hDev, ze_driver_handle_t &hDrv)
-{
-    uint32_t ndrivers = 0;
-    ze_result_t rc = zeDriverGet(&ndrivers, nullptr);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeDriverGet with null rc=%d\n", rc);
-        return false;
-    }
-
-    printf("ndrivers = %d\n", ndrivers);
-
-    std::vector<ze_driver_handle_t> drivers(ndrivers);
-    rc = zeDriverGet(&ndrivers, &drivers[0]);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeDriverGet rc=%d\n", rc);
-        return false;
-    }
-
-    ze_driver_handle_t driver = drivers[0];
-
-    uint32_t ndevices = 0;
-    rc = zeDeviceGet(driver, &ndevices, nullptr);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeDeviceGet with null rc=%d\n", rc);
-        return false;
-    }
-
-    printf("ndevices = %d\n", ndevices);
-
-    std::vector<ze_device_handle_t> devices(ndevices);
-    rc = zeDeviceGet(driver, &ndevices, &devices[0]);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeDeviceGet rc=%d\n", rc);
-        return false;
-    }
-
-    hDrv = driver;
-    hDev = devices[0];
-    return true;
-}
-
-bool findQueueOrdinal(ze_device_handle_t hDev, uint32_t flag_mask, uint32_t &ordinal)
-{
-    uint32_t qCount = 0;
-    ze_result_t rc = zeDeviceGetCommandQueueGroupProperties(hDev, &qCount, nullptr);
-    if (rc != ZE_RESULT_SUCCESS)
-        return false;
-
-    std::vector<ze_command_queue_group_properties_t> q_props(qCount);
-    rc = zeDeviceGetCommandQueueGroupProperties(hDev, &qCount, &q_props[0]);
-    if (rc != ZE_RESULT_SUCCESS)
-        return false;
-
-    for (ordinal = 0; ordinal < qCount; ordinal++)
-        if ((q_props[ordinal].flags & flag_mask) == flag_mask && q_props[ordinal].numQueues) {
-            printf("ordinal=%u numQueues=%u\n", ordinal, q_props[ordinal].numQueues);
-            return true;
-        }
-
-    return false;
-}
-
-#ifdef _WIN32
-static long timespec_diff_ms(struct wintimespec start, struct wintimespec end) {
-#else
-static long timespec_diff_ms(struct timespec start, struct timespec end) {
-#endif
-    long seconds_diff = end.tv_sec - start.tv_sec;
-    long nanoseconds_diff = end.tv_nsec - start.tv_nsec;
-
-    // Normalize if nanoseconds are negative
-    if (nanoseconds_diff < 0) {
-        seconds_diff -= 1;
-        nanoseconds_diff += 1000000000;
-    }
-
-    // Convert total time to milliseconds
-    return seconds_diff * 1000 + nanoseconds_diff / 1000000;
-}
-
-
-int main(int argc, char *argv[])
-{
-    size_t buf_size = 4096;
-    uint32_t n_launches = 10;
-    uint32_t cl_flags = 0;
-    uint32_t n_submits = 1;
-    uint32_t n_submit_interval_ms = 0;
-    bool infinite_submit = false;
-
-    for (uint32_t i = 1; i < argc; i++) {
-        if (!strcmp(argv[i], "-i")) {
-            cl_flags = ZE_COMMAND_LIST_FLAG_IN_ORDER;
-        }
-        else if (!strcmp(argv[i], "-r")) {
-            cl_flags = ZE_COMMAND_LIST_FLAG_RELAXED_ORDERING;
-        }
-        else if (!strcmp(argv[i], "-n") && i++ < argc) {
-            n_launches = std::stoi(argv[i]);
-        }
-        else if (!strcmp(argv[i], "-s") && i++ < argc) {
-            n_submits = std::stoi(argv[i]);
-            infinite_submit = (n_submits == 0);
-        }
-        else if (!strcmp(argv[i], "-t") && i++ < argc) {
-            n_submit_interval_ms = std::stoi(argv[i]);
-        }
-        else if (!strcmp(argv[i], "-h")) {
-            printf("Usage: %s [-i | -r] [-n <num_launches>]\n", argv[0]);
-            printf("   -i for IN_ORDER command list\n");
-            printf("   -r for RELAXED_ORDERING command list\n");
-            printf("   -n <kernel count> for number of kernelks in command list\n");
-            printf("   -s <submit count> for number of command list submit , 0 for infinite \n");
-            printf("   -t <ms> submit interval\n");
-
-            return -1;
-        }
-    }
-
-    ze_result_t rc = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeInit rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_device_handle_t hDev;
-    ze_driver_handle_t hDrv;
-    if (!enumAndPickDevice(hDev, hDrv))
-    {
-        printf("[ERROR] Failed to pick device\n");
-        return -1;
-    }
-
-    uint32_t compQ_ordinal = 0;
-    if (!findQueueOrdinal(hDev, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY|ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE, compQ_ordinal)) {
-        printf("[ERROR] Failed to find device compute queue\n");
-        return -1;
-    }
-
-    ze_context_desc_t ctx_desc = {
-        .stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC,
-        .pNext = nullptr,
-        .flags = 0
-    };
-
-    ze_context_handle_t hCtx;
-    rc = zeContextCreate(hDrv, &ctx_desc, &hCtx);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeContextCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_kernel_handle_t emptyKern = getEmptyKernel(hDev, hCtx);
-    if (!emptyKern) {
-        printf("[ERROR] Failed to create empty kernel\n");
-        return -1;
-    }
-
-    ze_event_pool_desc_t pool_desc = {
-        .stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
-        .pNext = nullptr,
-        .flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP,
-        .count = n_launches
-    };
-
-    ze_event_pool_handle_t evPool;
-    rc = zeEventPoolCreate(hCtx, &pool_desc, 1, &hDev, &evPool);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeEventPoolCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_command_queue_desc_t q_desc = {
-        .stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-        .pNext = nullptr,
-        .ordinal = compQ_ordinal,
-        .index = 0,
-        .flags = 0,
-        .mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-        .priority = ZE_COMMAND_QUEUE_PRIORITY_NORMAL
-    };
-
-    ze_command_queue_handle_t q;
-    rc = zeCommandQueueCreate(hCtx, hDev, &q_desc, &q);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeCommandQueueCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_command_list_desc_t cl_desc = {
-        .stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC,
-        .pNext = nullptr,
-        .commandQueueGroupOrdinal = compQ_ordinal,
-        .flags = cl_flags
-    };
-    ze_command_list_handle_t cl;
-
-    rc = zeCommandListCreate(hCtx, hDev, &cl_desc, &cl);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeCommandListCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    std::vector<ze_event_handle_t> ev(n_launches);
-    ze_group_count_t dim = {1, 1, 1};
-    for (unsigned i = 0; i < n_launches; i++) {
-        ze_event_desc_t ev_desc = {
-            .stype = ZE_STRUCTURE_TYPE_EVENT_DESC,
-            .pNext = nullptr,
-            .index = i,
-            .signal = ZE_EVENT_SCOPE_FLAG_DEVICE,
-            .wait = ZE_EVENT_SCOPE_FLAG_DEVICE,
-        };
-        rc = zeEventCreate(evPool, &ev_desc, &ev[i]);
-        if (rc != ZE_RESULT_SUCCESS) {
-            printf("[ERROR] zeEventCreate rc=%d\n", rc);
-            return -1;
-        }
-
-        rc = zeCommandListAppendLaunchKernel(cl, emptyKern, &dim, ev[i], 0, nullptr);
-        if (rc != ZE_RESULT_SUCCESS) {
-            printf("[ERROR] zeCommandListAppendLaunchKernel rc=%d\n", rc);
-            return -1;
-        }
-    }
-
-    rc = zeCommandListClose(cl);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeCommandListClose rc=%d\n", rc);
-        return -1;
-    }
-
-    const ze_fence_desc_t f_desc = {
-        .stype = ZE_STRUCTURE_TYPE_FENCE_DESC,
-        .pNext = nullptr,
-        .flags = 0
-    };
-
-    ze_fence_handle_t fence;
-    rc = zeFenceCreate(q, &f_desc, &fence);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("[ERROR] zeFenceCreate rc=%d\n", rc);
-        return -1;
-    }
-
-#ifdef _WIN32
-    struct wintimespec exec_time, prev_exec_time;
-#else
-    struct timespec exec_time, prev_exec_time;
-#endif
-    uint64_t prev_min_start = UINT64_MAX;
-
-    int i = 0;
-    bool paused = false;
-    while (n_submits || infinite_submit) {
-#ifdef _WIN32
-        clock_getwintime(&exec_time);
-#else
-        clock_gettime(CLOCK_REALTIME, &exec_time);
-#endif
-        if (n_submit_interval_ms != 0 && prev_min_start != UINT64_MAX) //not first submit
-        {
-            long diff = timespec_diff_ms(prev_exec_time, exec_time);
-
-            if (diff < n_submit_interval_ms)
-            {
-                continue;
-            }
-        }
-
-        rc = zeCommandQueueExecuteCommandLists(q, 1, &cl, fence);
-        assert(rc == ZE_RESULT_SUCCESS);
-    
-        rc = zeFenceHostSynchronize(fence, UINT64_MAX);
-        assert(rc == ZE_RESULT_SUCCESS);
-    
-        ze_device_properties_t devProp = {
-            .stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2,
-            .pNext = nullptr
-        };
-        rc = zeDeviceGetProperties(hDev, &devProp);
-        assert(rc == ZE_RESULT_SUCCESS);
-    
-        printf("device timestamp ticks freq: %ld n_launches=%u n_submits=%u \n", devProp.timerResolution, n_launches, n_submits);
-        double ts_to_nano = 1e9 / devProp.timerResolution;
-    
-        std::vector<ze_kernel_timestamp_result_t> ts(n_launches);
-        uint64_t min_start = UINT64_MAX;
-        uint64_t max_end = 0;
-    
-        for (unsigned i = 0; i < n_launches; i++) {
-            zeEventQueryKernelTimestamp(ev[i], &ts[i]);
-            if (ts[i].global.kernelStart < min_start) min_start = ts[i].global.kernelStart;
-            if (ts[i].global.kernelEnd > max_end) max_end = ts[i].global.kernelEnd;
-        }
-    
-        if (cl_flags == ZE_COMMAND_LIST_FLAG_IN_ORDER) {
-            for (unsigned i = 0; i < n_launches; i++) {
-                uint64_t gap = i < 1 ? 0 : ts[i].global.kernelStart - ts[i-1].global.kernelEnd;
-                uint64_t dur = ts[i].global.kernelEnd - ts[i].global.kernelStart;
-                printf("%u: start: %ld end: %ld dur: %ld (ticks) gap: %ld (ticks) dur: %lf (ns) gap: %lf (ns)\n", i, ts[i].global.kernelStart, ts[i].global.kernelEnd, dur,
-                       gap, (double)dur * ts_to_nano, (double)gap * ts_to_nano);
-            }
-        }
-    
-        uint64_t total_dur = max_end - min_start;
-        printf("Total device time: %ld (ticks)  %lf ns avg_per_lauch: %lf ns\n", total_dur, (double)total_dur * ts_to_nano, ((double)total_dur * ts_to_nano) / n_launches);
-
-        if (prev_min_start != UINT64_MAX) {
-            uint64_t prev_exec_ns = prev_exec_time.tv_sec * 1000000000 + prev_exec_time.tv_nsec;
-            uint64_t exec_ns = exec_time.tv_sec * 1000000000 + exec_time.tv_nsec;
-            uint64_t wall_dt = exec_ns - prev_exec_ns;
-            uint64_t tick_dt = min_start - prev_min_start;
-            double tick_freq = ((double)tick_dt * 1e9) / wall_dt;
-            printf("Delta time between submits: cpu: %ld ns gpu_ticks: %ld (calc tick freq: %lf)\n", wall_dt, tick_dt, tick_freq);
-        }
-
-        n_submits--;
-        if (infinite_submit || n_submits) {
-            for (unsigned i = 0; i < n_launches; i++)
-                zeEventHostReset(ev[i]);
-            prev_exec_time = exec_time;
-            prev_min_start = min_start;
-        }
-    }
-
-    zeFenceDestroy(fence);
-    zeCommandListDestroy(cl);
-    zeCommandQueueDestroy(q);
-}
diff --git a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.cpp b/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.cpp
deleted file mode 100644
index 07093f9f..00000000
--- a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-
-#include "empty_kernel.h"
-#include <array>
-#include <stdint.h>
-
-inline constexpr std::array<uint8_t, 176> kKernelBinary{
-    0x03, 0x02, 0x23, 0x07, 0x00, 0x00, 0x01, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x11, 0x00, 0x02, 0x00,
-    0x06, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x4f, 0x70, 0x65, 0x6e,
-    0x43, 0x4c, 0x2e, 0x73, 0x74, 0x64, 0x00, 0x00, 0x0e, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00,
-    0x02, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
-    0x65, 0x6d, 0x70, 0x74, 0x79, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
-    0x70, 0x8e, 0x01, 0x00, 0x05, 0x00, 0x04, 0x00, 0x05, 0x00, 0x00, 0x00, 0x65, 0x6e, 0x74, 0x72,
-    0x79, 0x00, 0x00, 0x00, 0x13, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x21, 0x00, 0x03, 0x00,
-    0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x05, 0x00, 0x02, 0x00, 0x00, 0x00,
-    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x02, 0x00,
-    0x05, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x01, 0x00, 0x38, 0x00, 0x01, 0x00};
-
-ze_kernel_handle_t getEmptyKernel(ze_device_handle_t device, ze_context_handle_t ctx)
-{
-  ze_kernel_handle_t kernel = nullptr;
-
-  ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                  nullptr,
-                                  ZE_MODULE_FORMAT_IL_SPIRV,
-                                  std::size(kKernelBinary),
-                                  std::data(kKernelBinary),
-                                  nullptr,
-                                  nullptr};
-  ze_module_handle_t module = nullptr;
-  auto status = zeModuleCreate(ctx, device, &module_desc, &module, nullptr);
-
-  if (status != ZE_RESULT_SUCCESS) {
-    return nullptr;
-  }
-
-  ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, "empty"};
-  status = zeKernelCreate(module, &kernel_desc, &kernel);
-
-  if (status != ZE_RESULT_SUCCESS) {
-    return nullptr;
-  }
-
-  return kernel;
-}
diff --git a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.h b/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.h
deleted file mode 100644
index 8d67db73..00000000
--- a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/empty_kernel.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <level_zero/ze_api.h>
-
-ze_kernel_handle_t getEmptyKernel(ze_device_handle_t device, ze_context_handle_t ctx);
diff --git a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/gold/linux/d.txt b/tools/unitrace/test/cpp_test/device_and_rank_to_sample/gold/linux/d.txt
deleted file mode 100644
index 7e3bc87a..00000000
--- a/tools/unitrace/test/cpp_test/device_and_rank_to_sample/gold/linux/d.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           8130291800
-    Total Device Time for L0 backend (ns):                 1830
-
-== L0 Backend ==
-
- Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"empty",           10,                 1830,   100.000000,                  183,                    0,                  333
-
-
-=== Kernel Properties ===
-
- Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"empty",      JIT,   32,                   0,                  0,                         0,                       0,                            16
-
-
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/CMakeLists.txt b/tools/unitrace/test/cpp_test/dpc_gemm/CMakeLists.txt
deleted file mode 100644
index 21314c22..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-project(dpc_gemm CXX)
-
-add_executable(dpc_gemm main.cc)
-add_sycl_to_target(dpc_gemm)
-
-
-# Line tables for both host and device code, so stall samples carry a source location.
-#
-# The two -g here are not the same flag and only one of them may go away:
-#
-#   -g on icpx itself is what puts debug info into the device image at all. icpx ignores
-#   -gline-tables-only for spir64 ("only supported for host compilation"), so without -g
-#   there is no line information in the SPIR-V and stall samples get no source location.
-#
-#   -g inside -Xs is what IGC reads, and it is the one that hurts. Full -g on the backend
-#   disables inlining and forces calls out of line; a callee is not a kernel, so it gets no
-#   .kprops record and its samples cannot be attributed to anything. With it, this kernel
-#   profiled as ~5 KB of argument marshalling charged to the lambda's declaration line and
-#   99% of the sampled stall counts were discarded - the arithmetic never appeared at all.
-#   -gline-tables-only asks IGC for the line table without that codegen change.
-#   -O2 is not optional. This project sets no CMAKE_BUILD_TYPE, so without it there is no
-#   optimization level at all, and icpx warns that a debug flag with no -O behaves like -O0
-#   - which is a second, independent reason for nothing to be inlined. README.md's recipe
-#   (icpx -fsycl -gline-tables-only -O2) has it for this reason.
-target_compile_options(dpc_gemm PRIVATE -O2 -g -gline-tables-only)
-target_link_options(dpc_gemm PRIVATE -O2 -g -Xs "-gline-tables-only")
-
-install(TARGETS dpc_gemm RUNTIME DESTINATION bin/dpc_gemm COMPONENT dpc_gemm)
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/d.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/d.txt
deleted file mode 100644
index df4cfec8..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/d.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            214649009
-    Total Device Time for L0 backend (ns):             97642160
-
-== L0 Backend ==
-
-                                                                                                                                                                                                                                                                                 Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM",            4,             89769760,    91.937500,             22442440,             22436320,             22454240
-                                                                                                                                                                                                                                                   "zeCommandListAppendMemoryCopy(M2D)",           12,              5238880,     5.365387,               436573,               328560,               774800
-                                                                                                                                                                                                                                                   "zeCommandListAppendMemoryCopy(D2M)",            4,              2633520,     2.697114,               658380,               581280,               864800
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                                                                                                                                                 Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM",      JIT,   32,                   4,                  0,                         0,                       0,                           128
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/h.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/h.txt
deleted file mode 100644
index b02fe226..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/h.txt
+++ /dev/null
@@ -1,70 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):             81615043
-    Total API Time for L0 backend (ns):             31476739
-Total API Time for CL CPU backend (ns):                50771
-Total API Time for CL GPU backend (ns):                23006
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-          zeCommandListHostSynchronize,            8,             19911548,     63.257973,              2488943,                 1270,              5135361
-         zeCommandListAppendMemoryCopy,           16,              6393938,     20.313215,               399621,               132844,               891555
-          zeCommandListCreateImmediate,            3,              1481024,      4.705138,               493674,                44688,              1171763
-                zeEventHostSynchronize,            8,               968394,      3.076538,               121049,                  238,               289210
-                        zeModuleCreate,            1,               813091,      2.583149,               813091,               813091,               813091
-           zeContextMakeMemoryResident,           10,               807288,      2.564713,                80728,                 7263,               372251
-       zeCommandListAppendLaunchKernel,            4,               604590,      1.920752,               151147,                 7208,               564306
-                      zeMemAllocDevice,            5,               182827,      0.580832,                36565,                13746,                56347
-                      zeMemAllocShared,            4,               107340,      0.341014,                26835,                19661,                44807
-                             zeMemFree,            7,                68858,      0.218758,                 9836,                 4453,                21910
-           zeDeviceGetGlobalTimestamps,            2,                22008,      0.069918,                11004,                10154,                11854
-                        zeMemAllocHost,            1,                15875,      0.050434,                15875,                15875,                15875
-           zeEventQueryKernelTimestamp,            8,                15227,      0.048375,                 1903,                 1033,                 3357
-                         zeEventCreate,            5,                11872,      0.037717,                 2374,                  813,                 6465
-                        zeKernelCreate,            1,                 9828,      0.031223,                 9828,                 9828,                 9828
-                     zeEventPoolCreate,            1,                 8483,      0.026950,                 8483,                 8483,                 8483
-   zeDriverGetExtensionFunctionAddress,            7,                 7824,      0.024856,                 1117,                  192,                 5686
-                      zeEventHostReset,           15,                 6865,      0.021810,                  457,                   92,                 1027
-zeDeviceGetCommandQueueGroupProperties,            4,                 6144,      0.019519,                 1536,                   46,                 4723
-              zeKernelSetArgumentValue,           16,                 4945,      0.015710,                  309,                   32,                 1209
-                           zeDriverGet,            3,                 4930,      0.015662,                 1643,                   51,                 4696
-            zeKernelSetGlobalOffsetExp,            4,                 4668,      0.014830,                 1167,                  159,                 4068
-        zeDriverGetExtensionProperties,            2,                 3569,      0.011339,                 1784,                 1723,                 1846
-              zeKernelSuggestGroupSize,            4,                 2019,      0.006414,                  504,                  204,                  929
-           zeDeviceGetModuleProperties,            2,                 1922,      0.006106,                  961,                  269,                 1653
-                 zeDeviceGetProperties,            2,                 1865,      0.005925,                  932,                  432,                 1433
-                 zeDeviceCanAccessPeer,            5,                 1378,      0.004378,                  275,                  148,                  432
-                       zeContextCreate,            1,                 1157,      0.003676,                 1157,                 1157,                 1157
-               zeMemGetAllocProperties,            7,                 1069,      0.003396,                  152,                   66,                  540
-                 zeDeviceGetRootDevice,           22,                  954,      0.003031,                   43,                   20,                  385
-                 zeKernelGetProperties,            1,                  762,      0.002421,                  762,                  762,                  762
-                           zeDeviceGet,            2,                  654,      0.002078,                  327,                  135,                  519
-                    zeEventQueryStatus,            8,                  650,      0.002065,                   81,                   23,                  226
-                  zeKernelSetGroupSize,            4,                  617,      0.001960,                  154,                   98,                  231
-                 zeDeviceGetSubDevices,           10,                  537,      0.001706,                   53,                   22,                  225
-          zeDeviceGetComputeProperties,            1,                  503,      0.001598,                  503,                  503,                  503
-                 zeDriverGetProperties,            1,                  471,      0.001496,                  471,                  471,                  471
-            zeDeviceGetImageProperties,            2,                  370,      0.001175,                  185,                   30,                  340
-                 zeModuleGetProperties,            1,                  302,      0.000959,                  302,                  302,                  302
-             zeKernelSetIndirectAccess,            1,                  294,      0.000934,                  294,                  294,                  294
-                 zeDriverGetApiVersion,            1,                   79,      0.000251,                   79,                   79,                   79
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         105,               26673,       52.54,                 254,                  98,                3986
-clGetPlatformInfo,          24,               16249,       32.00,                 677,                 186,                5758
-   clGetDeviceIDs,           9,                4763,        9.38,                 529,                 100,                2728
-  clReleaseDevice,          12,                1627,        3.20,                 135,                  77,                 424
-   clRetainDevice,           8,                1459,        2.87,                 182,                  75,                 713
-
-== CL GPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         216,               16268,       70.71,                  75,                  30,                 709
-   clGetDeviceIDs,           8,                3263,       14.18,                 407,                  96,                1612
-clGetPlatformInfo,          24,                2175,        9.45,                  90,                  36,                 633
-  clReleaseDevice,          24,                 768,        3.34,                  32,                  24,                  78
-   clRetainDevice,          16,                 532,        2.31,                  33,                  24,                  67
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/t.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/t.txt
deleted file mode 100644
index e506080d..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/linux/t.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502841453331 (append) 542502841453331 (submit) 542502841481411 (start) 542502842346371 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502842471779 (append) 542502842471779 (submit) 542502842481939 (start) 542502843356259 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502843430713 (append) 542502843430713 (submit) 542502843441113 (start) 542502844295673 (end)
-Thread 47571 Device 35747536 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502847242858 (append) 542502847242858 (submit) 542502847858138 (start) 542502850711898 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502850756675 (append) 542502850756675 (submit) 542502851484595 (start) 542502851921715 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502852461324 (append) 542502852461324 (submit) 542502852468204 (start) 542502852812524 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502852842605 (append) 542502852842605 (submit) 542502852848125 (start) 542502853171165 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502853190943 (append) 542502853190943 (submit) 542502853196463 (start) 542502853489023 (end)
-Thread 47571 Device 35747536 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502853525662 (append) 542502853525662 (submit) 542502853540702 (start) 542502856390942 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502856438812 (append) 542502856438812 (submit) 542502856513212 (start) 542502856766652 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502857189071 (append) 542502857189071 (submit) 542502857194831 (start) 542502857538511 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502857561489 (append) 542502857561489 (submit) 542502857566849 (start) 542502857883249 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502857902519 (append) 542502857902519 (submit) 542502857907959 (start) 542502858185879 (end)
-Thread 47571 Device 35747536 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502858217882 (append) 542502858217882 (submit) 542502858230122 (start) 542502861080522 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502861122160 (append) 542502861122160 (submit) 542502861194640 (start) 542502861412320 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502861817716 (append) 542502861817716 (submit) 542502861823236 (start) 542502862144036 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502862164935 (append) 542502862164935 (submit) 542502862170295 (start) 542502862475415 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502862494349 (append) 542502862494349 (submit) 542502862499709 (start) 542502862767229 (end)
-Thread 47571 Device 35747536 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502862796301 (append) 542502862796301 (submit) 542502862807181 (start) 542502865687341 (end)
-Thread 47571 Device 35747536 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502865737435 (append) 542502865737435 (submit) 542502865811755 (start) 542502866025195 (end)
-
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/d.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/d.txt
deleted file mode 100644
index cdabae09..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/d.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           5917626800
-    Total Device Time for L0 backend (ns):           4676410206
-
-== L0 Backend ==
-
-                                                                                                Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM",            4,           4675211665,    99.974365,           1168802916,           1073651562,           1219552604
-                                                                  "zeCommandListAppendMemoryCopy(H2M)",            4,              1198541,     0.025630,               299635,               281875,               337500
-
-
-=== Kernel Properties ===
-
-                                                                                                Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM",      JIT,    8,                  13,                  0,                      8320,                   11840,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/h.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/h.txt
deleted file mode 100644
index 989bc188..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/h.txt
+++ /dev/null
@@ -1,73 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           6613923100
-    Total API Time for L0 backend (ns):           5436740800
-Total API Time for CL CPU backend (ns):               164100
-Total API Time for CL GPU backend (ns):               114100
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-              zeCommandQueueSynchronize,            4,           4564054400,     99.494934,           1141013600,           1092279900,           1191643700
-                    zeCommandListReset,            8,              7358200,      0.160406,               919775,                14100,              5771100
-                zeEventHostSynchronize,            4,              4407600,      0.096084,              1101900,               673500,              2326000
-                        zeMemAllocHost,           13,              3592100,      0.078307,               276315,                39600,               481900
-                        zeModuleCreate,            1,              3216800,      0.070125,              3216800,              3216800,              3216800
-         zeCommandListAppendMemoryCopy,            4,              1733200,      0.037783,               433300,               181300,              1116000
-     zeCommandQueueExecuteCommandLists,            8,               570800,      0.012443,                71350,                48400,               104100
-                   zeCommandListCreate,            1,               395400,      0.008620,               395400,               395400,               395400
-                      zeMemAllocDevice,            1,               392300,      0.008552,               392300,               392300,               392300
-                             zeMemFree,           16,               317600,      0.006924,                19850,                 3800,                74600
-          zeCommandListCreateImmediate,            1,               265900,      0.005797,               265900,               265900,               265900
-           zeContextMakeMemoryResident,            1,               162000,      0.003532,               162000,               162000,               162000
-                  zeCommandQueueCreate,            1,               140200,      0.003056,               140200,               140200,               140200
-                 zeDeviceGetProperties,            1,               105300,      0.002296,               105300,               105300,               105300
-                        zeKernelCreate,            1,                99000,      0.002158,                99000,                99000,                99000
-       zeCommandListAppendLaunchKernel,            4,                78300,      0.001707,                19575,                18900,                20400
-                      zeMemAllocShared,            2,                59200,      0.001291,                29600,                21600,                37600
-              zeKernelSetArgumentValue,           52,                52500,      0.001144,                 1009,                    0,                 9100
-                     zeEventPoolCreate,            1,                49200,      0.001073,                49200,                49200,                49200
-           zeEventQueryKernelTimestamp,            8,                34900,      0.000761,                 4362,                  200,                14300
-                      zeEventHostReset,            6,                30000,      0.000654,                 5000,                 3100,                 5900
-                    zeFenceQueryStatus,            8,                20500,      0.000447,                 2562,                 1000,                 5400
-                         zeEventCreate,            2,                14400,      0.000314,                 7200,                 6600,                 7800
-                    zeCommandListClose,            8,                12400,      0.000270,                 1550,                  800,                 2200
-        zeDriverGetExtensionProperties,            2,                11600,      0.000253,                 5800,                 5200,                 6400
-                 zeCommandQueueDestroy,            1,                 9100,      0.000198,                 9100,                 9100,                 9100
-              zeKernelSuggestGroupSize,            4,                 6900,      0.000150,                 1725,                 1400,                 2400
-                        zeFenceDestroy,            1,                 5600,      0.000122,                 5600,                 5600,                 5600
-           zeDeviceGetModuleProperties,            1,                 4600,      0.000100,                 4600,                 4600,                 4600
-zeDeviceGetCommandQueueGroupProperties,            2,                 3700,      0.000081,                 1850,                  600,                 3100
-               zeMemGetAllocProperties,            4,                 3000,      0.000065,                  750,                  100,                 2600
-                           zeDriverGet,            3,                 2900,      0.000063,                  966,                  100,                 1400
-                  zeKernelSetGroupSize,            4,                 2600,      0.000057,                  650,                  500,                 1000
-                          zeFenceReset,            8,                 2500,      0.000054,                  312,                  200,                  500
-                       zeContextCreate,            1,                 2100,      0.000046,                 2100,                 2100,                 2100
-                         zeFenceCreate,            1,                 1700,      0.000037,                 1700,                 1700,                 1700
-                 zeDeviceGetSubDevices,            6,                 1300,      0.000028,                  216,                    0,                  600
-                 zeDriverGetProperties,            1,                 1000,      0.000022,                 1000,                 1000,                 1000
-                 zeModuleGetProperties,            1,                  600,      0.000013,                  600,                  600,                  600
-                 zeKernelGetProperties,            1,                  500,      0.000011,                  500,                  500,                  500
-                           zeDeviceGet,            2,                  400,      0.000009,                  200,                  100,                  300
-                 zeDriverGetApiVersion,            1,                  400,      0.000009,                  400,                  400,                  400
-             zeKernelSetIndirectAccess,            1,                  300,      0.000007,                  300,                  300,                  300
-            zeDeviceGetImageProperties,            1,                  200,      0.000004,                  200,                  200,                  200
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         105,              102200,       62.28,                 973,                 300,                7100
-clGetPlatformInfo,          24,               32400,       19.74,                1350,                 400,                6700
-   clGetDeviceIDs,           8,               14700,        8.96,                1837,                 300,                4700
-  clReleaseDevice,          12,               10500,        6.40,                 875,                 200,                5100
-   clRetainDevice,           8,                4300,        2.62,                 537,                 200,                1200
-
-== CL GPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         106,               80500,       70.55,                 759,                 100,                5400
-   clGetDeviceIDs,           8,               16300,       14.29,                2037,                 300,                5700
-clGetPlatformInfo,          24,               11800,       10.34,                 491,                 100,                2900
-  clReleaseDevice,          12,                3500,        3.07,                 291,                 100,                1400
-   clRetainDevice,           8,                2000,        1.75,                 250,                 100,                 500
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/t.txt b/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/t.txt
deleted file mode 100644
index 5637e097..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/gold/windows/t.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-Thread 20536 Device 1497070120 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD8 {4; 1024; 1} {256; 1; 1}]" [ns] 201702849559300 (append) 201702850356500 (submit) 201702853781343 (start) 201703731085405 (end)
-Thread 20536 Device 1497070120 : "zeCommandListAppendMemoryCopy(H2M)[4194304]" [ns] 201703733046700 (append) 201703733694000 (submit) 201703733994833 (start) 201703734303895 (end)
-Thread 20536 Device 1497070120 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD8 {4; 1024; 1} {256; 1; 1}]" [ns] 201703744877400 (append) 201703745065000 (submit) 201703745486145 (start) 201704539715624 (end)
-Thread 20536 Device 1497070120 : "zeCommandListAppendMemoryCopy(H2M)[4194304]" [ns] 201704541472200 (append) 201704541676200 (submit) 201704542055158 (start) 201704542375053 (end)
-Thread 20536 Device 1497070120 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD8 {4; 1024; 1} {256; 1; 1}]" [ns] 201704564399800 (append) 201704564696300 (submit) 201704565391247 (start) 201705576359997 (end)
-Thread 20536 Device 1497070120 : "zeCommandListAppendMemoryCopy(H2M)[4194304]" [ns] 201705576895000 (append) 201705577093100 (submit) 201705577529766 (start) 201705577775599 (end)
-Thread 20536 Device 1497070120 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD8 {4; 1024; 1} {256; 1; 1}]" [ns] 201705588923200 (append) 201705589092100 (submit) 201705589573662 (start) 201706339786682 (end)
-Thread 20536 Device 1497070120 : "zeCommandListAppendMemoryCopy(H2M)[4194304]" [ns] 201706340262700 (append) 201706340425500 (submit) 201706340734302 (start) 201706340992427 (end)
-
diff --git a/tools/unitrace/test/cpp_test/dpc_gemm/main.cc b/tools/unitrace/test/cpp_test/dpc_gemm/main.cc
deleted file mode 100644
index f4654749..00000000
--- a/tools/unitrace/test/cpp_test/dpc_gemm/main.cc
+++ /dev/null
@@ -1,144 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <string.h>
-#include <memory>
-#include <sycl/sycl.hpp>
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static float Check(const std::vector<float>& a, float value) {
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::abs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-void GEMM(const float* a, const float* b, float* c,
-          unsigned size, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned k = 0; k < size; ++k) {
-    sum += a[i * size + k] * b[k * size + j];
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue,
-                         const std::vector<float>& a,
-                         const std::vector<float>& b,
-                         std::vector<float>& c,
-                         unsigned size,
-                         float expected_result) {
-  double time = 0.0;
-
-   {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size),
-                      [=](sycl::id<2> id) {
-                        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        GEMM(a_acc_ptr.get(),
-                             b_acc_ptr.get(),
-                             c_acc_ptr.get(),
-                             size, id);
-                      });
-    });
-    queue.wait_and_throw();
-
-    auto start =
-      event.get_profiling_info<sycl::info::event_profiling::command_start>();
-    auto end =
-      event.get_profiling_info<sycl::info::event_profiling::command_end>();
-    time = static_cast<double>(end - start);
-  } /*catch (sycl::exception e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-  }*/
-
-  std::cout << "Matrix multiplication time: " << time <<
-    " ns" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue,
-                    const std::vector<float>& a,
-                    const std::vector<float>& b,
-                    std::vector<float>& c,
-                    unsigned size,
-                    unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-}
-
-int main(int argc, char* argv[]) {
-  sycl::device dev;
-  {
-    dev = sycl::device(sycl::gpu_selector_v);
-    if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-      dev = sycl::device(sycl::cpu_selector_v);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
-    }
-  } /*catch (const sycl::exception& e) {
-    std::cerr << "Error: Exception caught while executing SYCL " << e.what() << '\n';
-    std::cerr << "Unable to select valid sycl device" << '\n';
-    return EXIT_FAILURE;
-  } catch (...) {
-    std::cerr << "Unable to select valid sycl device" << '\n';
-    return EXIT_FAILURE;
-  }*/
-
-  unsigned size = 1024;
-  if (argc > 2) {
-    size = std::stoul(argv[2]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 3) {
-    repeat_count = std::stoul(argv[3]);
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::enable_profiling()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " <<
-    queue.get_info<sycl::info::queue::device>().get_info<
-        sycl::info::device::name>() << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(queue, a, b, c, size, repeat_count, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/event_reset/CMakeLists.txt b/tools/unitrace/test/cpp_test/event_reset/CMakeLists.txt
deleted file mode 100644
index b94dad0a..00000000
--- a/tools/unitrace/test/cpp_test/event_reset/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-project(event_reset CXX)
-
-add_executable(event_reset event_reset.cpp)
-
-if(WIN32)
-  UnitraceFindL0Library(event_reset)
-  UnitraceGetLevelZeroHeaders(event_reset ${LEVEL_ZERO_COMMIT_ID})
-else()
-  target_link_libraries(event_reset PRIVATE ze_loader)
-endif()
-
-install(TARGETS event_reset RUNTIME DESTINATION bin/event_reset COMPONENT event_reset)
diff --git a/tools/unitrace/test/cpp_test/event_reset/event_reset.cpp b/tools/unitrace/test/cpp_test/event_reset/event_reset.cpp
deleted file mode 100644
index 1127580c..00000000
--- a/tools/unitrace/test/cpp_test/event_reset/event_reset.cpp
+++ /dev/null
@@ -1,465 +0,0 @@
-#include <stdio.h>
-#include <vector>
-#include <string>
-#include <string.h>
-#include <assert.h>
-#include <time.h>
-#include <level_zero/ze_api.h>
-#include <iostream>
-#ifdef __linux__
-    #include <unistd.h>
-#else
-    #include <windows.h>
-#endif
-
-static bool enumAndPickDevice(ze_device_handle_t &hDev, ze_driver_handle_t &hDrv)
-{
-    uint32_t ndrivers = 0;
-    ze_result_t rc = zeDriverGet(&ndrivers, nullptr);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeDriverGet with null rc=%d\n", rc);
-        return false;
-    }
-
-    printf("ndrivers = %d\n", ndrivers);
-
-    std::vector<ze_driver_handle_t> drivers(ndrivers);
-    rc = zeDriverGet(&ndrivers, &drivers[0]);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeDriverGet rc=%d\n", rc);
-        return false;
-    }
-
-    ze_driver_handle_t driver = drivers[0];
-
-    uint32_t ndevices = 0;
-    rc = zeDeviceGet(driver, &ndevices, nullptr);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeDeviceGet with null rc=%d\n", rc);
-        return false;
-    }
-
-    printf("ndevices = %d\n", ndevices);
-
-    std::vector<ze_device_handle_t> devices(ndevices);
-    rc = zeDeviceGet(driver, &ndevices, &devices[0]);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeDeviceGet rc=%d\n", rc);
-        return false;
-    }
-
-    hDrv = driver;
-    hDev = devices[0];
-    return true;
-}
-
-bool findQueueOrdinal(ze_device_handle_t hDev, uint32_t flag_mask, uint32_t &ordinal)
-{
-    uint32_t qCount = 0;
-    ze_result_t rc = zeDeviceGetCommandQueueGroupProperties(hDev, &qCount, nullptr);
-    if (rc != ZE_RESULT_SUCCESS)
-        return false;
-
-    std::vector<ze_command_queue_group_properties_t> q_props(qCount);
-    rc = zeDeviceGetCommandQueueGroupProperties(hDev, &qCount, &q_props[0]);
-    if (rc != ZE_RESULT_SUCCESS)
-        return false;
-
-    for (ordinal = 0; ordinal < qCount; ordinal++)
-        if ((q_props[ordinal].flags & flag_mask) == flag_mask && q_props[ordinal].numQueues) {
-            printf("ordinal=%u numQueues=%u\n", ordinal, q_props[ordinal].numQueues);
-            return true;
-        }
-
-    return false;
-}
-
-int execute_immediate_cl()
-{
-    zeInit(ZE_INIT_FLAG_GPU_ONLY);
-
-    // --- Get driver, device, context ---
-    ze_driver_handle_t driver;
-    uint32_t driverCount = 1;
-    zeDriverGet(&driverCount, &driver);
-
-    ze_device_handle_t device;
-    uint32_t deviceCount = 1;
-    zeDeviceGet(driver, &deviceCount, &device);
-
-    uint32_t compQ_ordinal = 0;
-    if (!findQueueOrdinal(device, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY|ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE, compQ_ordinal)) {
-        printf("Failed to find device compute queue\n");
-        return -1;
-    }
-
-    ze_context_handle_t context;
-    ze_context_desc_t contextDesc = { ZE_STRUCTURE_TYPE_CONTEXT_DESC };
-    zeContextCreate(driver, &contextDesc, &context);
-
-    // --- Create event pool and eventX ---
-    ze_event_pool_handle_t eventPool;
-    ze_event_pool_desc_t poolDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
-        nullptr,
-        ZE_EVENT_POOL_FLAG_HOST_VISIBLE, // visible to host
-        (uint32_t)(4)
-    };
-    zeEventPoolCreate(context, &poolDesc, 1, &device, &eventPool);
-
-    ze_event_handle_t eventX;
-    ze_event_desc_t eventXDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_DESC,
-        nullptr,
-        0, // index
-        ZE_EVENT_SCOPE_FLAG_DEVICE, // signal scope
-        ZE_EVENT_SCOPE_FLAG_HOST   // wait scope
-    };
-    zeEventCreate(eventPool, &eventXDesc, &eventX);
-
-    ze_event_handle_t eventXReset;
-    ze_event_desc_t eventXResetDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_DESC,
-        nullptr,
-        1, // index
-        ZE_EVENT_SCOPE_FLAG_DEVICE, // signal scope
-        ZE_EVENT_SCOPE_FLAG_HOST   // wait scope
-    };
-    zeEventCreate(eventPool, &eventXResetDesc, &eventXReset);
-
-    ze_event_handle_t eventY;
-    ze_event_desc_t eventYDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_DESC,
-        nullptr,
-        2, // index
-        ZE_EVENT_SCOPE_FLAG_DEVICE, // signal scope
-        ZE_EVENT_SCOPE_FLAG_HOST   // wait scope
-    };
-    zeEventCreate(eventPool, &eventYDesc, &eventY);
-
-    ze_event_handle_t eventZ;
-    ze_event_desc_t eventZDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_DESC,
-        nullptr,
-        3, // index
-        ZE_EVENT_SCOPE_FLAG_DEVICE, // signal scope
-        ZE_EVENT_SCOPE_FLAG_HOST   // wait scope
-    };
-    zeEventCreate(eventPool, &eventZDesc, &eventZ);
-
-    // --- Create immediate command list ---
-    ze_command_queue_desc_t queueDesc = {
-        ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-        nullptr,
-        compQ_ordinal, 0, 0,
-        ZE_COMMAND_QUEUE_MODE_DEFAULT,
-        ZE_COMMAND_QUEUE_PRIORITY_NORMAL
-    };
-
-
-    ze_command_list_handle_t immCmdList;
-    zeCommandListCreateImmediate(context, device, &queueDesc, &immCmdList);
-
-    ze_event_handle_t kernel_event;
-
-    // --- Append a barrier that signals eventZ ---
-    zeCommandListAppendBarrier(immCmdList, eventZ, 0, nullptr);
-    printf("Barrier executed -> eventZ signaled by device\n");
-
-    // --- Append a barrier that signals eventX ---
-    zeCommandListAppendBarrier(immCmdList, eventX, 0, nullptr);
-    printf("Barrier executed -> eventX signaled by device\n");
-
-    // --- Append device-side reset of eventX ---
-    zeCommandListAppendEventReset(immCmdList, eventX);
-    printf("Device reset of eventX appended\n");
-
-    zeCommandListAppendBarrier(immCmdList, eventXReset, 0, nullptr); // signals eventDone when reset finished
-    printf("append barrier for event reset\n");
-
-    // Host waits for eventDone instead of eventX , this make sure that eventX reset was done on device 
-    zeEventHostSynchronize(eventXReset, UINT64_MAX);
-    printf("host sync for eventX reset event barrier\n");
-    
-    ze_result_t status = zeEventQueryStatus(eventX);
-    printf("query reset eventX status\n");
-    int max_check = 10;
-    int check = 0;
-    while (status == ZE_RESULT_SUCCESS && (check++ < max_check)) {
-        #ifdef __linux__
-        sleep(100);
-        #else
-        Sleep(100);
-        #endif
-        printf("check %d failed", check);
-        status = zeEventQueryStatus(eventX);
-    }
-
-    if (status == ZE_RESULT_NOT_READY)
-        printf("EventX successfully reset on device\n");
-    else
-        printf("EventX still signaled (reset failed)\n");
-     
-    status = zeEventDestroy(eventX);
-    if (status == ZE_RESULT_SUCCESS)
-        printf("eventX destroyed successfully\n");
-    else
-        printf("eventX fail to destroy\n");
-
-    zeCommandListAppendBarrier(immCmdList, eventY, 0, nullptr);
-    //unitrace should crash here since eventX was destroyed
-    printf("Host sync after append barrier for eventY , unitrace should crash here\n");
-    zeEventHostSynchronize(eventY, UINT64_MAX);
-
-    zeEventDestroy(eventXReset);
-    zeEventDestroy(eventY);
-    zeEventDestroy(eventZ);    
-    zeEventPoolDestroy(eventPool);
-    zeCommandListDestroy(immCmdList);
-    zeContextDestroy(context);
-
-    printf("immediate cl execution and cleanup ended\n");
-    return 0;
-}
-
-int execute_non_immediate_cl_single(ze_command_list_flags_t cl_flags, bool use_fence = false, bool use_barrier = false)
-{
-    ze_result_t rc = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeInit rc=%d\n", rc);
-        return -1;
-    }
-    ze_device_handle_t hDev;
-    ze_driver_handle_t hDrv;
-    if (!enumAndPickDevice(hDev, hDrv))
-        return -1;
-
-    uint32_t compQ_ordinal = 0;
-    if (!findQueueOrdinal(hDev, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY|ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE, compQ_ordinal)) {
-        printf("Failed to find device compute queue\n");
-        return -1;
-    }
-
-    ze_context_desc_t ctx_desc = {
-        .stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC,
-        .pNext = nullptr,
-        .flags = 0
-    };
-
-    ze_context_handle_t hCtx;
-    rc = zeContextCreate(hDrv, &ctx_desc, &hCtx);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeContextCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_event_pool_desc_t pool_desc = {
-        .stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
-        .pNext = nullptr,
-        .flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP,
-        .count = (use_barrier && !use_fence) ? (uint32_t)2 : (uint32_t)1
-    };
-
-    ze_event_pool_handle_t evPool;
-    rc = zeEventPoolCreate(hCtx, &pool_desc, 1, &hDev, &evPool);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeEventPoolCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_command_queue_desc_t q_desc = {
-        .stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-        .pNext = nullptr,
-        .ordinal = compQ_ordinal,
-        .index = 0,
-        .flags = 0,
-        .mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-        .priority = ZE_COMMAND_QUEUE_PRIORITY_NORMAL
-    };
-
-    ze_command_queue_handle_t q;
-    rc = zeCommandQueueCreate(hCtx, hDev, &q_desc, &q);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeCommandQueueCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_command_list_desc_t cl_desc = {
-        .stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC,
-        .pNext = nullptr,
-        .commandQueueGroupOrdinal = compQ_ordinal,
-        .flags = cl_flags
-    };
-    ze_command_list_handle_t cl;    
-    rc = zeCommandListCreate(hCtx, hDev, &cl_desc, &cl);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeCommandListCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_event_handle_t eventX;
-    ze_event_desc_t eventXDesc = {
-        ZE_STRUCTURE_TYPE_EVENT_DESC,
-        nullptr,
-        0, // index
-        ZE_EVENT_SCOPE_FLAG_DEVICE, // signal scope
-        ZE_EVENT_SCOPE_FLAG_HOST   // wait scope
-    };
-    zeEventCreate(evPool, &eventXDesc, &eventX);
-
-    ze_event_handle_t completionEvent;
-    if (use_barrier && !use_fence) {
-        ze_event_desc_t eventDesc = {
-            ZE_STRUCTURE_TYPE_EVENT_DESC,
-            nullptr,
-            1, // index
-            ZE_EVENT_SCOPE_FLAG_DEVICE,
-            ZE_EVENT_SCOPE_FLAG_HOST
-        };
-        zeEventCreate(evPool, &eventDesc, &completionEvent);
-    }
-
-    zeCommandListAppendBarrier(cl, eventX, 0, nullptr);
-    printf("Append barrier to signal eventX\n");
-
-    // --- Append device-side reset of eventX ---
-    zeCommandListAppendEventReset(cl, eventX);
-    printf("Device reset of eventX appended\n");
-
-    if (use_barrier && !use_fence) {
-        zeCommandListAppendBarrier(cl, completionEvent, 0, nullptr);
-        printf("Append barrier for synchronization\n");
-    }
-
-    rc = zeCommandListClose(cl);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeCommandListClose rc=%d\n", rc);
-        return -1;
-    }
-
-    ze_fence_handle_t fence;
-    if (use_fence && !use_barrier) {
-        const ze_fence_desc_t f_desc = {
-        .stype = ZE_STRUCTURE_TYPE_FENCE_DESC,
-        .pNext = nullptr,
-        .flags = 0
-        };
-        printf("Using fence for synchronization\n");
-        rc = zeFenceCreate(q, &f_desc, &fence);
-        if (rc != ZE_RESULT_SUCCESS) {
-            printf("zeFenceCreate rc=%d\n", rc);
-            return -1;
-        }
-    }
-
-    struct timespec exec_time, prev_exec_time;
-    uint64_t prev_min_start = UINT64_MAX;
-
-    rc = zeCommandQueueExecuteCommandLists(q, 1, &cl, use_fence? fence : nullptr);
-    assert(rc == ZE_RESULT_SUCCESS);
-
-    //unitrace should crash here since eventX was destroyed
-    if (use_fence && !use_barrier) {
-        printf("Fence Host sync, unitrace should crash here\n");
-        rc = zeFenceHostSynchronize(fence, UINT64_MAX);
-        assert(rc == ZE_RESULT_SUCCESS);
-    }
-    if (use_barrier && !use_fence) {
-        printf("Host sync for completion event, unitrace should crash here\n");
-        rc = zeEventHostSynchronize(completionEvent, UINT64_MAX);
-        assert(rc == ZE_RESULT_SUCCESS);
-    }
-    if (!use_barrier && !use_fence) {
-        printf("Queue Host sync, unitrace should crash here\n");
-        rc = zeCommandQueueSynchronize(q, UINT64_MAX);
-        assert(rc == ZE_RESULT_SUCCESS);
-    }
-
-    printf("Host reset eventX\n");
-    zeEventHostReset(eventX);
-    if (use_barrier && !use_fence) {
-        printf("Host reset completionEvent\n");
-        zeEventHostReset(completionEvent);
-    }
-    printf("Device destroy eventX\n");
-    zeEventDestroy(eventX);
-    if (use_barrier && !use_fence) {
-        printf("Device destroy completionEvent\n");
-        zeEventDestroy(completionEvent);
-    }
-    zeEventPoolDestroy(evPool);
-
-    if (use_fence && !use_barrier) {    
-        zeFenceDestroy(fence);
-    }
-    zeCommandListDestroy(cl);
-    zeCommandQueueDestroy(q);
-    return 0;
-}
-
-void print_help_message(char *name)
-{
-    printf("Usage: %s [-im | -1nicl | -2nicl | -h | -i | -r | -f | -b]\n", name);
-    printf("   -1nicl run non-immediate cl in single command queue\n");
-    printf("   -2nicl run two concurrent cl with event dependency\n");
-    printf("   -im for immediate mode\n");
-    printf("   -i for in-order command list [apply only for non-immediate]\n");
-    printf("   -r for relaxed-ordering command list [apply only for non-immediate]\n");
-    printf("   -f use fence for synchronization [apply only for non-immediate] default is queue sync\n");
-    printf("   -b use barrier between launches [apply only for non-immediate] default is queue sync\n");
-    printf("   -h print this help message\n");
-}
-
-int main(int argc, char *argv[])
-{
-    ze_command_list_flags_t cl_flags = 0;
-    bool use_fence = false;
-    bool use_barrier = false;
-    bool non_immediate_cl_single = false;
-    bool non_immediate_cl_concurrent = false;
-    bool execute_immediate = false;
-    if (argc == 1) {
-        print_help_message(argv[0]);
-        return -1;
-    }
-
-    for (uint32_t i = 1; i < argc; i++) {
-        if (!strcmp(argv[i], "-i")) {
-            std::cout << "Using in-order command list\n";
-            cl_flags = ZE_COMMAND_LIST_FLAG_IN_ORDER;
-        }
-        else if (!strcmp(argv[i], "-r")) {
-            std::cout << "Using relaxed ordering for command list\n";
-            cl_flags = ZE_COMMAND_LIST_FLAG_RELAXED_ORDERING;
-        }
-        else if (!strcmp(argv[i], "-f")) {
-            std::cout << "Using fence for synchronization\n";
-            use_fence = true;
-        }
-        else if (!strcmp(argv[i], "-b")) {
-            std::cout << "Using barrier for synchronization\n";
-            use_barrier = true;
-        }
-        else if (!strcmp(argv[i], "-1nicl")) {
-            non_immediate_cl_single = true;
-        }
-        else if (!strcmp(argv[i], "-2nicl")) {
-            non_immediate_cl_concurrent = true;
-        }
-        else if (!strcmp(argv[i], "-im")) {
-             return execute_immediate_cl();
-        }
-        else if (!strcmp(argv[i], "-h")) {
-            print_help_message(argv[0]);
-            return -1;
-        }
-    }
-
-    if (non_immediate_cl_single) {
-        std::cout << "Executing non-immediate command list in single queue mode\n";
-        if (!use_fence && !use_barrier) {
-            std::cout << "Defaulting to queue synchronization\n";
-        }
-        return execute_non_immediate_cl_single(cl_flags, use_fence, use_barrier);
-    }
-}
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/CMakeLists.txt b/tools/unitrace/test/cpp_test/gemm_stall_sampling/CMakeLists.txt
deleted file mode 100644
index 2ead1e4f..00000000
--- a/tools/unitrace/test/cpp_test/gemm_stall_sampling/CMakeLists.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-project(gemm_stall_sampling CXX)
-
-add_executable(gemm_stall_sampling main.cc)
-
-target_include_directories(gemm_stall_sampling PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../.." "${CMAKE_CURRENT_SOURCE_DIR}/../../..")
-
-if(WIN32)
-  UnitraceFindL0Library(gemm_stall_sampling)
-  UnitraceGetLevelZeroHeaders(gemm_stall_sampling ${LEVEL_ZERO_COMMIT_ID})
-else()
-  target_link_libraries(gemm_stall_sampling PRIVATE ze_loader)
-endif()
-
-# The SPIR-V modules are prebuilt, checked in, and copied next to the executable,
-# which is where the app loads them from. Their OpenCL C sources are deliberately
-# not in the repo: building them needs an OpenCL compiler toolchain that the test
-# machines are not required to have, so the .spv files are treated as the source
-# of truth here and regenerated by hand when a kernel needs to change.
-foreach(spv_module gemm_single gemm_multi gemm_aux)
-  add_custom_command(TARGET gemm_stall_sampling PRE_BUILD
-                     COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                             ${CMAKE_CURRENT_SOURCE_DIR}/${spv_module}.spv
-                             ${CMAKE_CURRENT_BINARY_DIR}/${spv_module}.spv)
-endforeach()
-
-install(TARGETS gemm_stall_sampling RUNTIME DESTINATION bin/gemm_stall_sampling COMPONENT gemm_stall_sampling)
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/gemm_single.spv
-              ${CMAKE_CURRENT_SOURCE_DIR}/gemm_multi.spv
-              ${CMAKE_CURRENT_SOURCE_DIR}/gemm_aux.spv
-        DESTINATION bin/gemm_stall_sampling COMPONENT gemm_stall_sampling)
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/check_outfiles.py b/tools/unitrace/test/cpp_test/gemm_stall_sampling/check_outfiles.py
deleted file mode 100644
index 095a2ca6..00000000
--- a/tools/unitrace/test/cpp_test/gemm_stall_sampling/check_outfiles.py
+++ /dev/null
@@ -1,687 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-"""Validate the stall-sampling output of the gemm_stall_sampling test.
-
-Checks that a metrics file was produced with the columns this script reads, that the
-Source column attributes each kernel its own source lines, and that the Offset and
-Dependency columns are internally consistent. More checks (per-scenario kernel
-coverage) are meant to be added as functions in CHECKS below, without restructuring
-anything else.
-
-Only the metrics file is checked; see CHECKS for why the .asm files are not.
-
-The report is CSV, one block per kernel (see ComputeStallMetrics): a
-"Kernel,Pid,KernelId" line, that kernel's identity, its column header, then its
-rows. Parsed with the csv module rather than by splitting on the separator, because
-a comma inside a quoted cell is data - instruction syntax is full of them.
-
-The source-attribution checks deliberately do not fail when the report carries no
-source information at all: source line mapping is an optional capability (it needs
-debug info in the module binary, which unitrace's own line-table reader
-(source_resolver.h) decodes), and a build without it is expected to report NA rather than to fail
-this test. What they do catch is source information that is present but wrong -
-some kernels attributed and others not, or two kernels handed the same lines.
-
-Every content check follows that shape, because which instructions get sampled is
-nondeterministic: such a check may only constrain values the report actually
-carries, never require a particular row, kernel or column to be populated. "The
-Dependency column is empty everywhere" is therefore reported as a count, not a
-failure - a run where sampling happened to land only on instructions with no
-tracked producer is a valid run.
-
-That shape has one cost, and check_header and check_has_data_rows exist to pay it:
-a check that only constrains what is there passes when nothing is there. Every
-content check below locates its column by index within a block's rows, so a report
-that renames a column, drops one, or stops writing blocks does not fail them -
-read_blocks recognises no block, iter_data_rows yields nothing, and all of them
-report "nothing to check" and pass. The two structural checks run first and cannot
-pass vacuously, so that failure is theirs to catch.
-
-run_test.py invokes this through its -e/--extra_test_prog hook and passes the
-output files it discovered as positional arguments. Those are NOT relied on for
-finding the metrics file: the hook collects file names by grepping unitrace's
-stderr for the literal "is stored in", but stall sampling announces its output
-as "Device metrics are stored in ..." ("are", not "is"), so the hook finds
-nothing and passes an empty list. This script therefore locates the metrics
-files itself and treats "no metrics file found" as a failure - otherwise an
-empty result would silently pass and the test would be worthless.
-"""
-
-import argparse
-import collections
-import csv
-import glob
-import os
-import re
-import sys
-
-# Unitrace derives the metrics file name from the -o value by inserting
-# ".metrics" before the extension (see LegacyLoggerFactory::GetMetricsFileName),
-# giving e.g. output_stall_sampling_gemm_stall_sampling_scenario1.metrics.12345.txt
-METRICS_GLOB = "*.metrics.*"
-
-# The kernel that calls a device function defined in another source file (see
-# gemm_helper.h). Its rows are the only ones expected to name more than one file.
-MULTI_FILE_KERNEL = "GEMM_Call"
-
-# The line that opens a kernel's block, and the header of the identity line under it.
-# Matched exactly, so a report that stops writing blocks fails check_header rather than
-# quietly reducing every content check to "nothing to check".
-KERNEL_BLOCK_HEADER = ["Kernel", "Pid", "KernelId"]
-
-# The identity line itself: the kernel, then the two values that name its .asm file
-# (see LoggerFactory::GetDisasmFileName), which is what a row is traced back through.
-KERNEL_FIELD = 0
-PID_FIELD = 1
-KERNEL_ID_FIELD = 2
-IDENTITY_FIELDS = 3
-
-# Column layout of a stall-sampling row within a block (see ComputeStallMetrics):
-#   Source  Offset  Instruction  Dependency  <one column per stall metric>
-SOURCE_COLUMN = 0
-OFFSET_COLUMN = 1
-INSTRUCTION_COLUMN = 2
-DEPENDS_ON_COLUMN = 3
-MIN_COLUMNS = 4
-
-# The header names for those columns, in order.
-EXPECTED_COLUMNS = ["Source", "Offset", "Instruction", "Dependency"]
-
-# What an unattributed row carries in the Source column. Also what a row gets when the
-# DWARF row covering it carried no source location at all - line 0, i.e. compiler-generated
-# code - so this value means "no source line", not only "no debug info".
-NO_SOURCE = "NA"
-
-# What a row with no tracked producers carries in the Dependency column.
-NO_DEPENDENCIES = "NA"
-
-# Gen/Xe instructions are 16 bytes, or 8 when compacted, so every instruction
-# address in a kernel is a multiple of 8.
-INSTRUCTION_ALIGNMENT = 8
-
-# One Dependency cell holds "<offset> (<source>)[: <text>]" per producer, joined by
-# " | " (FormatDependencies). Instruction syntax contains "|" too - the channel
-# offset in "(8|M0)" - so the separator is only recognised when what follows starts
-# like a new entry, i.e. an offset followed by a space, a colon or end of cell.
-DEPENDS_ON_SPLIT_RE = re.compile(r" \| (?=0x[0-9a-fA-F]+(?:[ :]|$))")
-
-# One such entry, taken apart. The source parenthetical is present only when the
-# producer had one, and the ": <text>" only when the producer was found in the
-# disassembly at all.
-DEPENDS_ON_ENTRY_RE = re.compile(
-    r"^(?P<offset>0x[0-9a-fA-F]+)"
-    r"(?: \((?P<source>[^)]*)\))?"
-    r"(?:: (?P<text>.*))?$")
-
-# One kernel's block. kernel, pid and kernel_id are what its identity line said, the
-# two numbers parsed, or None where it said nothing usable there; identity and columns
-# are the raw lines, kept so that check_header can quote what was wrong with them
-# (columns is None when the block ended before its column header). rows holds only the
-# lines wide enough to read a column out of, which drops the blank line between blocks.
-KernelBlock = collections.namedtuple(
-    "KernelBlock", ["kernel", "pid", "kernel_id", "identity", "columns", "rows"])
-
-
-def metrics_glob_from_cmd(cmd):
-    """Derive the exact metrics file pattern from the unitrace command line.
-
-    run_test.py passes the command it ran after --cmd, which contains
-    "-o <dir>/output_stall_sampling_<test>.txt". Unitrace turns that into
-    "<same>.metrics.<pid>.txt" (LegacyLoggerFactory::GetMetricsFileName inserts
-    ".metrics" before the extension).
-
-    Deriving the pattern from -o matters because all scenarios write into the
-    same results directory: a bare "*.metrics.*" glob would also match files left
-    by other scenarios, so a run that produced nothing could pass on a previous
-    run's output. Returns None if -o is absent, leaving the caller on the broad
-    glob.
-    """
-    if not cmd:
-        return None
-    for i, arg in enumerate(cmd):
-        if arg == "-o" and i + 1 < len(cmd):
-            out_file = os.path.basename(cmd[i + 1])
-            pos = out_file.rfind(".")
-            if pos == -1:
-                return out_file + ".metrics.*"
-            return out_file[:pos] + ".metrics.*"
-    return None
-
-
-def results_dir_from_cmd(cmd):
-    """Directory of the unitrace -o argument, or None if -o is absent."""
-    if not cmd:
-        return None
-    for i, arg in enumerate(cmd):
-        if arg == "-o" and i + 1 < len(cmd):
-            return os.path.dirname(os.path.abspath(cmd[i + 1]))
-    return None
-
-
-def find_metrics_files(candidates, search_dirs, pattern):
-    """Collect metrics files from the passed-in list and by searching directories.
-
-    Both sources are used: whatever run_test.py managed to pass is honoured, and
-    the directory search covers the stall-sampling case the hook misses.
-    """
-    found = []
-
-    for path in candidates:
-        if ".metrics." in os.path.basename(path) and os.path.isfile(path):
-            found.append(path)
-
-    for directory in search_dirs:
-        if not directory or not os.path.isdir(directory):
-            continue
-        for path in glob.glob(os.path.join(directory, pattern)):
-            if os.path.isfile(path):
-                found.append(path)
-        # Also one level down. This does not cover --result-dir, which names its
-        # metrics files metrics/metrics_<n>.csv rather than <-o name>.metrics.<pid>.
-        for path in glob.glob(os.path.join(directory, "*", pattern)):
-            if os.path.isfile(path):
-                found.append(path)
-
-    # Preserve discovery order while removing duplicates, so the report reads
-    # predictably when a file is both passed in and found by the search.
-    unique = []
-    seen = set()
-    for path in found:
-        key = os.path.normcase(os.path.abspath(path))
-        if key not in seen:
-            seen.add(key)
-            unique.append(path)
-    return unique
-
-
-def read_blocks(path):
-    """Parse the report into its per-kernel blocks, in file order.
-
-    One place decides what a block and a data row are, so every check below agrees on
-    it. A block opens with KERNEL_BLOCK_HEADER; the next row is its identity and the
-    one after that its column header, whatever they turn out to say - a malformed one
-    is kept rather than dropped so that check_header can report what was wrong with it.
-    Anything before the first block header is skipped, which is the blank lines and the
-    "=== Device #N Metrics ===" banner.
-
-    Returns a list of KernelBlock. pid and kernel_id are None when the identity line
-    did not carry integers there.
-    """
-    blocks = []
-    opened = False
-    identity = []
-    columns = None
-    rows = []
-    # What the block just opened is still waiting for: its identity line, then its
-    # column header. None once both have been read and the rest is rows.
-    pending = None
-
-    def flush():
-        if not opened:
-            return
-        kernel = identity[KERNEL_FIELD] if len(identity) > KERNEL_FIELD else None
-        values = []
-        for index in (PID_FIELD, KERNEL_ID_FIELD):
-            text = identity[index] if len(identity) > index else ""
-            values.append(int(text) if text.isdigit() else None)
-        blocks.append(KernelBlock(kernel, values[0], values[1], identity, columns, rows))
-
-    with open(path, "r", errors="replace", newline="") as handle:
-        for fields in csv.reader(handle):
-            if fields == KERNEL_BLOCK_HEADER:
-                flush()
-                opened, identity, columns, rows, pending = True, [], None, [], "identity"
-                continue
-            if pending == "identity":
-                identity, pending = fields, "columns"
-                continue
-            if pending == "columns":
-                columns, pending = fields, None
-                continue
-            if opened and len(fields) >= MIN_COLUMNS:
-                rows.append(fields)
-    flush()
-    return blocks
-
-
-_BLOCKS_CACHE = {}
-
-
-def kernel_blocks(path):
-    """read_blocks, parsed once per file however many checks ask for it."""
-    key = os.path.normcase(os.path.abspath(path))
-    if key not in _BLOCKS_CACHE:
-        _BLOCKS_CACHE[key] = read_blocks(path)
-    return _BLOCKS_CACHE[key]
-
-
-def block_label(block):
-    """How a failure message names a block: the kernel, plus what tells it apart from a
-    same-named one and points at its .asm file."""
-    if block.pid is None or block.kernel_id is None:
-        return block.kernel or "<unnamed kernel>"
-    return f"{block.kernel} (pid {block.pid}, kernel id {block.kernel_id})"
-
-
-def check_header(path):
-    """Every block must carry the identity and the columns the checks below read.
-
-    The one check here that cannot pass vacuously, and so the one that catches a
-    report whose columns were renamed or dropped, or that stopped writing blocks
-    altogether. Runs first for that reason: without it, such a report fails nothing.
-
-    Returns (passed, message).
-    """
-    blocks = kernel_blocks(path)
-    if not blocks:
-        return False, f"no block header (no {','.join(KERNEL_BLOCK_HEADER)} line)"
-    stall_columns = None
-    for block in blocks:
-        if len(block.identity) != IDENTITY_FIELDS:
-            return False, (f"identity line has {len(block.identity)} field(s), need "
-                           f"{IDENTITY_FIELDS}: {block.identity}")
-        if block.pid is None or block.kernel_id is None:
-            return False, f"identity line has a non-integer Pid or KernelId: {block.identity}"
-        columns = block.columns or []
-        if len(columns) < MIN_COLUMNS:
-            return False, (f"{block_label(block)} has a {len(columns)}-column header, need at "
-                           f"least {MIN_COLUMNS}: {columns}")
-        if columns[:MIN_COLUMNS] != EXPECTED_COLUMNS:
-            return False, (f"{block_label(block)} header columns are {columns[:MIN_COLUMNS]}, "
-                           f"expected {EXPECTED_COLUMNS}")
-        # The rest are the stall metrics, whose names and number are the metric group's,
-        # and so the same for every block of the report.
-        if stall_columns is None:
-            stall_columns = columns[MIN_COLUMNS:]
-        elif columns[MIN_COLUMNS:] != stall_columns:
-            return False, (f"{block_label(block)} reports stall columns "
-                           f"{columns[MIN_COLUMNS:]}, expected {stall_columns}")
-    return True, (f"{len(blocks)} block(s), each {', '.join(EXPECTED_COLUMNS)} + "
-                  f"{len(stall_columns)} stall column(s)")
-
-
-def split_source(value):
-    """Split a Source cell, "<file>:<line>[:<column>]", into (file, position).
-
-    The file name is reduced to its base name on purpose. One report can spell the
-    same file two ways: a line table can name one file with its directory and another
-    as the compiler wrote it, so "/where/it/was/built/gemm_multi.cl:36" and "gemm_multi.cl:36" can both
-    appear and mean the same line. Comparing base names sees through that, and
-    nothing here needs the directory.
-
-    Returns (None, None) if the cell does not look like a source location.
-    """
-    parts = value.split(":")
-    position = []
-    # Line, and column if present, taken from the right. At most two, so a
-    # directory that happens to be all digits is not read as a line number.
-    while len(parts) > 1 and len(position) < 2 and parts[-1].isdigit():
-        position.insert(0, parts.pop())
-    if not position:
-        return None, None
-    return os.path.basename(":".join(parts)), ":".join(position)
-
-
-def iter_data_rows(path):
-    """Yield (kernel_name, fields) for each stall-sample row, in file order.
-
-    The kernel name is the one its block's identity line carried, already unquoted by
-    the csv reader. Use kernel_blocks() instead where a check needs to keep a block's
-    rows apart from a same-named block's.
-    """
-    for block in kernel_blocks(path):
-        for fields in block.rows:
-            yield block.kernel, fields
-
-
-def check_has_data_rows(path):
-    """There must be at least one block, and every block must have rows under it.
-
-    A block with no rows cannot happen - a block exists only because a sample was
-    attributed to that kernel, and that sample's row went into it - so one means the
-    writer emitted a header it had nothing to put under.
-
-    No block at all is the case worth being deliberate about, and it is a failure here
-    for the same reason the header-with-no-rows it replaces was: a run whose samples all
-    fell in code no .kprops record covers writes no block, and treating that as a pass
-    would make this check - and with it every content check, which has nothing to
-    constrain - satisfied by a file that says nothing about any kernel. Stall sampling is
-    per device, so that can happen when another process is busy on the same GPU;
-    test_unitrace.py runs one test at a time, which is what keeps it rare.
-
-    Returns (passed, message).
-    """
-    blocks = kernel_blocks(path)
-    if not blocks:
-        return False, "no kernel blocks in the report"
-    empty = [block_label(block) for block in blocks if not block.rows]
-    if empty:
-        return False, f"block(s) with no data rows under them: {', '.join(empty)}"
-    rows = sum(len(block.rows) for block in blocks)
-    return True, f"{rows} row(s) across {len(blocks)} kernel block(s)"
-
-
-def read_kernel_sources(path):
-    """Map kernel name -> set of (file, position) pairs its rows reported.
-
-    Rows with no source location contribute nothing to the set, so a kernel that was
-    sampled but never attributed ends up with an empty set - which is what tells it
-    apart from a kernel that was not sampled at all and so is absent entirely.
-
-    Kernels are keyed by name, which merges the same name in two modules (scenario 3
-    has GEMM in both gemm_single and gemm_multi) into one entry. Harmless for the source
-    checks - they only ever ask which files a name was attributed, and both modules
-    compile the same file - and deliberate, because check_distinct_sources and
-    check_kernel_source_files both name the kernels they are about. A check that needs
-    the two apart has kernel_blocks(), whose blocks carry the pid and kernel id.
-    """
-    sources = {}
-    for kernel, fields in iter_data_rows(path):
-        entry = sources.setdefault(kernel, set())
-        if fields[SOURCE_COLUMN] == NO_SOURCE:
-            continue
-        name, position = split_source(fields[SOURCE_COLUMN])
-        if name is not None:
-            entry.add((name, position))
-    return sources
-
-
-_SOURCE_CACHE = {}
-
-
-def kernel_sources(path):
-    """read_kernel_sources, parsed once per file however many checks ask for it."""
-    key = os.path.normcase(os.path.abspath(path))
-    if key not in _SOURCE_CACHE:
-        _SOURCE_CACHE[key] = read_kernel_sources(path)
-    return _SOURCE_CACHE[key]
-
-
-def check_source_attribution(path):
-    """Either every sampled kernel got source lines, or none of them did.
-
-    A kernel whose rows carry no source location while its siblings' do is the
-    signature of source lines reaching the wrong kernel: a multi-kernel module's
-    line-number program holds one unit per kernel, and a reader that mis-associates
-    units leaves some kernels with nothing and gives others two kernels' worth.
-
-    "None of them did" is a pass, not a failure - see the module docstring.
-    """
-    sources = kernel_sources(path)
-    if not sources:
-        return True, "no kernel rows to attribute"
-    attributed = sorted(name for name, lines in sources.items() if lines)
-    unattributed = sorted(name for name, lines in sources.items() if not lines)
-    if not attributed:
-        return True, f"no source information at all ({len(sources)} kernels, every row NA)"
-    if unattributed:
-        return False, (f"{', '.join(attributed)} got source lines but "
-                       f"{', '.join(unattributed)} did not")
-    return True, f"{len(attributed)} kernel(s), all with source lines"
-
-
-def check_distinct_sources(path):
-    """No two kernels may report an identical set of source lines.
-
-    Cheap, GPU independent, and aimed at the failure that looks most ordinary in the
-    report: every kernel of a module handed the first kernel's line table. Each
-    kernel of gemm_multi.cl covers its own region of the file, so identical sets
-    cannot arise by accident, however the sampling happened to land.
-    """
-    attributed = {name: lines for name, lines in kernel_sources(path).items() if lines}
-    if len(attributed) < 2:
-        return True, f"{len(attributed)} attributed kernel(s), nothing to compare"
-    owner_of = {}
-    for kernel in sorted(attributed):
-        lines = frozenset(attributed[kernel])
-        if lines in owner_of:
-            return False, (f"{kernel} and {owner_of[lines]} report the same "
-                           f"{len(lines)} source line(s)")
-        owner_of[lines] = kernel
-    return True, f"{len(attributed)} kernels, all with distinct source lines"
-
-
-def parse_offset(value):
-    """Parse an Offset cell, "0x" plus hex digits (HexOffset writes at least 8).
-
-    Returns None if the cell is not one, which a check reports rather than crashes on.
-    """
-    if not value.startswith("0x") or len(value) <= 2:
-        return None
-    try:
-        return int(value[2:], 16)
-    except ValueError:
-        return None
-
-
-def parse_depends_on(value):
-    """Split a Dependency cell into a list of (offset_text, producer_text) pairs.
-
-    producer_text is None when the entry carries no ": <text>" part, which happens
-    when the producer offset named no instruction in the disassembly. An entry that
-    does not match the expected shape at all yields (raw_entry, None) with an
-    offset_text that parse_offset will reject, so the caller reports it as malformed
-    instead of silently skipping it.
-    """
-    if value == NO_DEPENDENCIES or not value:
-        return []
-    entries = []
-    for entry in DEPENDS_ON_SPLIT_RE.split(value):
-        match = DEPENDS_ON_ENTRY_RE.match(entry)
-        if match is None:
-            entries.append((entry, None))
-            continue
-        entries.append((match.group("offset"), match.group("text")))
-    return entries
-
-
-def check_offsets_aligned(path):
-    """Every Offset, and every offset named in Dependency, must be 8-byte aligned.
-
-    The Offset column is 8-aligned by construction - a raw stall sample carries the
-    address in 8-byte units and ComputeStallMetrics shifts it left by 3 - so what this
-    really pins down is that the kernel base subtracted from it is aligned too, and,
-    more usefully, the Dependency offsets. Those are not sample addresses: they are
-    read out of the disassembly's own instruction table, so a mis-sized or
-    mis-attributed instruction record surfaces here as an offset landing mid-encoding.
-
-    Cannot depend on which instructions were sampled: it only inspects offsets the
-    report already contains.
-    """
-    checked = 0
-    for block in kernel_blocks(path):
-        for fields in block.rows:
-            cells = [("Offset", fields[OFFSET_COLUMN])]
-            cells += [("Dependency", text)
-                      for text, _ in parse_depends_on(fields[DEPENDS_ON_COLUMN])]
-            for column, text in cells:
-                offset = parse_offset(text)
-                if offset is None:
-                    return False, (f"{block_label(block)} has an unparsable {column} "
-                                   f"value '{text}'")
-                if offset % INSTRUCTION_ALIGNMENT != 0:
-                    return False, (f"{block_label(block)} {column} {text} is not a multiple of "
-                                   f"{INSTRUCTION_ALIGNMENT}")
-                checked += 1
-    if not checked:
-        return True, "no sampled rows to check"
-    return True, f"{checked} offset(s), all {INSTRUCTION_ALIGNMENT}-byte aligned"
-
-
-def check_depends_on_wellformed(path):
-    """Every Dependency entry must parse, and must quote the right producer.
-
-    Where an entry names an offset that another row of the same block also reports as
-    its own Offset, the instruction text quoted in the entry must be that row's
-    Instruction text. The two come from separate lookups into the same table (the
-    row's own, and FormatDependencies' lookup of the producer), so a disagreement
-    means the table maps one offset to two different instructions.
-
-    Compared within a block and never across two, which is what makes it safe when one
-    name belongs to two kernels. Scenario 3 launches a GEMM from gemm_single.cl and
-    another from gemm_multi.cl: the two are separate compilations of the same algorithm,
-    so offset 0x1b8 holds a "macl" in both but with a different destination register, and
-    comparing one against the other would make correct output look self-contradictory.
-
-    An entry naming its own row is not an error. A loop counter reads the register it
-    writes - "add r3.8:d r3.8:d 1:w" - so IGA's defs analysis lists the instruction as
-    its own producer, and that back edge is the dependency a stall on the increment is
-    explained by.
-
-    Requires no particular row to have been sampled: producers are frequently not
-    sampled themselves, so the text comparison is only made for offsets that do
-    appear, and the count of rows carrying dependencies is reported rather than
-    required to be non-zero.
-    """
-    rows_with_deps = 0
-    total_deps = 0
-    for block in kernel_blocks(path):
-        # Offset -> Instruction text, for this kernel's sampled rows only.
-        text_at = {}
-        for fields in block.rows:
-            offset = parse_offset(fields[OFFSET_COLUMN])
-            if offset is not None:
-                text_at[offset] = fields[INSTRUCTION_COLUMN]
-
-        for fields in block.rows:
-            entries = parse_depends_on(fields[DEPENDS_ON_COLUMN])
-            if not entries:
-                continue
-            rows_with_deps += 1
-            total_deps += len(entries)
-            for offset_text, producer_text in entries:
-                producer_offset = parse_offset(offset_text)
-                if producer_offset is None:
-                    return False, (f"{block_label(block)} has an unparsable Dependency "
-                                   f"entry '{offset_text}'")
-                expected = text_at.get(producer_offset)
-                if expected is None or producer_text is None:
-                    continue  # Producer not sampled, or quoted without its text.
-                if producer_text != expected:
-                    return False, (f"{block_label(block)} offset {offset_text} is reported as "
-                                   f"'{expected}' in its own row but quoted as "
-                                   f"'{producer_text}' as a producer")
-    if not rows_with_deps:
-        return True, "no row reported dependencies"
-    return True, f"{total_deps} dependency/ies over {rows_with_deps} row(s), all well formed"
-
-
-def check_multi_file_kernel(path):
-    """GEMM_Call's rows must name at least two source files.
-
-    It is the one kernel whose accumulation step is a call into another file, so its
-    line program covers gemm_helper.h as well as gemm_multi.cl. One file means
-    either the device compiler inlined the call away or the reader dropped the rows
-    belonging to the called file, and in both cases the multi-file coverage this
-    kernel exists for is gone without anything else looking wrong.
-
-    Scenarios that do not launch GEMM_Call have nothing to check here.
-    """
-    lines = kernel_sources(path).get(MULTI_FILE_KERNEL)
-    if not lines:
-        return True, f"{MULTI_FILE_KERNEL} reported no source lines here"
-    files = sorted({name for name, _ in lines})
-    if len(files) < 2:
-        return False, (f"{MULTI_FILE_KERNEL} names only {files[0]}; expected the "
-                       "called file as well")
-    return True, f"{MULTI_FILE_KERNEL} names {', '.join(files)}"
-
-
-# Checks run against every metrics file found. Each entry is (name, function),
-# where the function takes a path and returns (passed, message). Add new checks
-# here.
-#
-# Only the metrics file is checked. The per-kernel .asm files the run also writes are
-# deliberately left alone: their layout is not settled yet, and a test pinning it would
-# have to be rewritten with every change to it.
-#
-# header and has-data-rows come first: they are the two that cannot pass when the
-# report is unreadable, so they diagnose it before the rest report "nothing to check".
-CHECKS = [
-    ("header", check_header),
-    ("has-data-rows", check_has_data_rows),
-    ("source-attribution", check_source_attribution),
-    ("distinct-sources", check_distinct_sources),
-    ("multi-file-kernel", check_multi_file_kernel),
-    ("offsets-aligned", check_offsets_aligned),
-    ("depends-on-wellformed", check_depends_on_wellformed),
-]
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Validate gemm_stall_sampling stall-sampling output.")
-    parser.add_argument('output_files', nargs='*', help='output files from run_test.py')
-    parser.add_argument('--results-dir', type=str, default=None,
-                        help='directory to search for metrics files')
-    # run_test.py appends the unitrace command it ran; the -o and the flags in it
-    # tell us which file to look for and whether metrics were collected at all.
-    parser.add_argument('--cmd', type=str, nargs=argparse.REMAINDER,
-                        help='unitrace command that was run')
-    args = parser.parse_args()
-
-    # There is nothing to validate if the run never sampled. Only bail out when
-    # the command line is known: with no --cmd, a missing file is still a failure.
-    if args.cmd and "--stall-sampling" not in args.cmd:
-        print("[INFO] Not a stall-sampling run, nothing to check.")
-        return 0
-
-    search_dirs = []
-    if args.results_dir:
-        search_dirs.append(args.results_dir)
-    else:
-        # run_test.py writes the results next to the unitrace -o file, so
-        # search the directory of the -o path in the command it ran.
-        results_dir = results_dir_from_cmd(args.cmd)
-        if results_dir:
-            search_dirs.append(results_dir)
-    # Also look beside any file that was passed in, in case the layout differs.
-    for path in args.output_files:
-        parent = os.path.dirname(os.path.abspath(path))
-        if parent not in search_dirs:
-            search_dirs.append(parent)
-
-    # Prefer the exact pattern derived from the unitrace -o argument; fall back to
-    # the broad glob only when it cannot be determined.
-    pattern = metrics_glob_from_cmd(args.cmd) or METRICS_GLOB
-    print(f"[INFO] Looking for metrics files matching '{pattern}'")
-
-    metrics_files = find_metrics_files(args.output_files, search_dirs, pattern)
-
-    if not metrics_files:
-        print("[ERROR] No metrics file found. Searched:", file=sys.stderr)
-        for directory in search_dirs:
-            print(f"[ERROR]   {directory} (pattern {pattern})", file=sys.stderr)
-        if args.output_files:
-            print("[ERROR] Files passed in by run_test.py:", file=sys.stderr)
-            for path in args.output_files:
-                print(f"[ERROR]   {path}", file=sys.stderr)
-        else:
-            print("[ERROR] run_test.py passed no output files.", file=sys.stderr)
-        return 1
-
-    failed = False
-    for path in metrics_files:
-        print(f"[INFO] Checking {path}")
-        for name, check in CHECKS:
-            try:
-                passed, message = check(path)
-            except OSError as e:
-                passed, message = False, f"could not read file: {e}"
-            if passed:
-                print(f"[INFO]   {name}: OK ({message})")
-            else:
-                print(f"[ERROR]  {name}: FAILED ({message})", file=sys.stderr)
-                failed = True
-
-    if failed:
-        return 1
-    print(f"[INFO] All checks passed on {len(metrics_files)} metrics file(s).")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_aux.spv b/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_aux.spv
deleted file mode 100644
index 9f05bbf5..00000000
Binary files a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_aux.spv and /dev/null differ
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_multi.spv b/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_multi.spv
deleted file mode 100644
index 16f2e140..00000000
Binary files a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_multi.spv and /dev/null differ
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_single.spv b/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_single.spv
deleted file mode 100644
index 9c30a6df..00000000
Binary files a/tools/unitrace/test/cpp_test/gemm_stall_sampling/gemm_single.spv and /dev/null differ
diff --git a/tools/unitrace/test/cpp_test/gemm_stall_sampling/main.cc b/tools/unitrace/test/cpp_test/gemm_stall_sampling/main.cc
deleted file mode 100644
index 6648f80c..00000000
--- a/tools/unitrace/test/cpp_test/gemm_stall_sampling/main.cc
+++ /dev/null
@@ -1,580 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// GEMM test application covering the module/kernel layouts that matter for
-// per-kernel analysis (kernel disassembly, EU stall sampling attribution).
-//
-// Level Zero is used directly rather than SYCL because the scenarios are about
-// how kernels are grouped into modules and which of them are created and
-// launched. SYCL hides all of that behind its own module management, so it
-// cannot express "five kernels in the binary, three created, two launched".
-//
-// Scenarios (one per run, selected with --scenario):
-//
-//   1  one module, 1 kernel in the binary,  1 created, 1 launched
-//   2  one module, 6 kernels in the binary, 6 created, 6 launched
-//   3  three modules, 9 kernels total,      9 created, 9 launched
-//   4  one module, 6 kernels in the binary, 3 created, 2 launched
-//
-// Scenario 4 is the interesting one for attribution: it keeps three populations
-// deliberately different in size - kernels present in the module binary (6),
-// kernels handed to zeKernelCreate (3), and kernels actually launched (2). That
-// distinguishes a tool that disassembles module contents from one that only
-// covers created kernels, and shows whether a created-but-never-launched kernel
-// still gets an entry.
-//
-// One kernel of gemm_multi.spv, GEMM_Call, calls a device function defined in
-// another source file, so its line-number program spans two files while its
-// siblings' span one. Scenarios 2 and 3 launch it. That is the shape a real SYCL
-// kernel has - a body interleaved with rows from the headers it calls into - and
-// it is what catches a tool that hands every kernel of a module the same source
-// lines: the mistake is invisible when each kernel's line table names one file.
-
-#include <math.h>
-#include <string.h>
-
-#include <chrono>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "utils/ze_utils.h"
-
-#define ALIGN 64
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define BIAS_VALUE 0.5f
-#define MAX_EPS 1.0e-4f
-
-#define TILE_SIZE 16
-
-// Module binaries. Scenario 1 needs a module whose binary holds exactly one
-// kernel, which is why gemm_single.spv exists separately from gemm_multi.spv.
-static const char* kSingleModule = "gemm_single.spv";
-static const char* kMultiModule = "gemm_multi.spv";
-static const char* kAuxModule = "gemm_aux.spv";
-
-// How a kernel is launched and what it should produce. Kept as data so adding a
-// kernel does not mean adding another branch to the launch path.
-struct KernelSpec {
-  const char* name;
-  // Multiple of the plain GEMM result this kernel is expected to produce.
-  float result_scale;
-  // Adds BIAS_VALUE to every output element and takes the bias buffer as an
-  // extra (4th) argument, shifting 'size' to index 4.
-  bool has_bias;
-  // Needs a fixed TILE_SIZE x TILE_SIZE work group and size % TILE_SIZE == 0,
-  // rather than whatever zeKernelSuggestGroupSize returns.
-  bool needs_tile_group;
-};
-
-static const KernelSpec kGemm = {"GEMM", 1.0f, false, false};
-static const KernelSpec kGemmTiled = {"GEMM_Tiled", 1.0f, false, true};
-static const KernelSpec kGemmScaled = {"GEMM_Scaled", 2.0f, false, false};
-static const KernelSpec kGemmBias = {"GEMM_Bias", 1.0f, true, false};
-static const KernelSpec kGemmAux = {"GEMM_Aux", 3.0f, false, false};
-static const KernelSpec kGemmAuxScaled = {"GEMM_AuxScaled", 4.0f, false, false};
-// Launched by scenarios 2 and 3; scenario 4 never creates it, leaving it present
-// in the module binary but untouched by the run.
-static const KernelSpec kGemmExtra = {"GEMM_Extra", 5.0f, false, false};
-// The only kernel that calls a device function instead of being self-contained,
-// which is what makes its line-number program span two source files. Its scale
-// comes from GEMM_HELPER_SCALE in gemm_helper.h, so a wrong result here also means
-// the call was not made.
-static const KernelSpec kGemmCall = {"GEMM_Call", 7.0f, false, false};
-
-// A kernel that has been created and is ready to launch.
-struct LiveKernel {
-  ze_kernel_handle_t handle;
-  const KernelSpec* spec;
-};
-
-// A module that has been created, plus the kernels created from it.
-struct LiveModule {
-  ze_module_handle_t handle;
-  std::string source;  // .spv file name, for diagnostics
-  std::vector<LiveKernel> kernels;
-};
-
-static float Check(const std::vector<float>& a, float value) {
-  // A zero expected value would make the relative error undefined; no scenario
-  // produces one, but guard rather than silently returning inf.
-  if (value == 0.0f) {
-    return 1.0f;
-  }
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-  return eps / a.size();
-}
-
-// Load a .spv next to the executable and create a module from it. Returns
-// nullptr (after printing why) if the file is missing or the driver rejects it.
-static ze_module_handle_t CreateModule(ze_context_handle_t context, ze_device_handle_t device,
-                                       const char* module_name) {
-  std::vector<uint8_t> binary = utils::LoadBinaryFile(utils::GetExecutablePath() + module_name);
-  if (binary.size() == 0) {
-    std::cout << "[ERROR] Unable to find module " << module_name
-              << ". The prebuilt .spv files are checked in beside this test's source and"
-                 " copied next to the executable at build time." << std::endl;
-    return nullptr;
-  }
-
-  ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                 nullptr,
-                                 ZE_MODULE_FORMAT_IL_SPIRV,
-                                 static_cast<uint32_t>(binary.size()),
-                                 binary.data(),
-                                 nullptr,
-                                 nullptr};
-  ze_module_handle_t module = nullptr;
-  ze_module_build_log_handle_t build_log = nullptr;
-  ze_result_t status = zeModuleCreate(context, device, &module_desc, &module, &build_log);
-  if (status != ZE_RESULT_SUCCESS) {
-    std::cout << "[ERROR] zeModuleCreate failed for " << module_name << " (status 0x" << std::hex
-              << status << std::dec << ")" << std::endl;
-    // The build log usually says exactly what the compiler disliked.
-    if (build_log != nullptr) {
-      size_t log_size = 0;
-      if (zeModuleBuildLogGetString(build_log, &log_size, nullptr) == ZE_RESULT_SUCCESS &&
-          log_size > 0) {
-        std::vector<char> log(log_size);
-        if (zeModuleBuildLogGetString(build_log, &log_size, log.data()) == ZE_RESULT_SUCCESS) {
-          std::cout << "[ERROR] Build log: " << log.data() << std::endl;
-        }
-      }
-    }
-  }
-  if (build_log != nullptr) {
-    zeModuleBuildLogDestroy(build_log);
-  }
-  return module;
-}
-
-// Create one kernel from an already-created module.
-static bool CreateKernel(ze_module_handle_t module, const KernelSpec* spec, LiveModule& out) {
-  ze_kernel_desc_t kernel_desc = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, spec->name};
-  ze_kernel_handle_t kernel = nullptr;
-  ze_result_t status = zeKernelCreate(module, &kernel_desc, &kernel);
-  if (status != ZE_RESULT_SUCCESS || kernel == nullptr) {
-    std::cout << "[ERROR] zeKernelCreate failed for " << spec->name << " (status 0x" << std::hex
-              << status << std::dec << ")" << std::endl;
-    return false;
-  }
-  out.kernels.push_back({kernel, spec});
-  return true;
-}
-
-// Run one kernel once and return the mean relative error of its output.
-// Returns a negative value if the launch could not be attempted.
-static float RunAndCheck(const LiveKernel& lk, ze_device_handle_t device,
-                         ze_context_handle_t context, const std::vector<float>& a,
-                         const std::vector<float>& b, std::vector<float>& c,
-                         const std::vector<float>& bias, unsigned size, float base_result) {
-  const KernelSpec* spec = lk.spec;
-  ze_kernel_handle_t kernel = lk.handle;
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t group_size[3] = {0, 0, 0};
-  if (spec->needs_tile_group) {
-    // The tiled kernel indexes fixed-size local arrays, so the group size is
-    // dictated by the kernel, not suggested by the driver.
-    group_size[0] = TILE_SIZE;
-    group_size[1] = TILE_SIZE;
-    group_size[2] = 1;
-  } else {
-    status = zeKernelSuggestGroupSize(kernel, size, size, 1, &(group_size[0]), &(group_size[1]),
-                                      &(group_size[2]));
-    if (status != ZE_RESULT_SUCCESS) {
-      std::cout << "[ERROR] zeKernelSuggestGroupSize failed for " << spec->name << std::endl;
-      return -1.0f;
-    }
-  }
-
-  if (group_size[0] == 0 || group_size[1] == 0 ||
-      (size % group_size[0]) != 0 || (size % group_size[1]) != 0) {
-    std::cout << "Non-uniform workgroups are not supported (kernel " << spec->name << ")"
-              << std::endl;
-    return -1.0f;
-  }
-
-  const size_t matrix_bytes = static_cast<size_t>(size) * size * sizeof(float);
-
-  ze_device_mem_alloc_desc_t alloc_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr, 0, 0};
-  void* dev_a = nullptr;
-  void* dev_b = nullptr;
-  void* dev_c = nullptr;
-  void* dev_bias = nullptr;
-  status = zeMemAllocDevice(context, &alloc_desc, matrix_bytes, ALIGN, device, &dev_a);
-  if (status == ZE_RESULT_SUCCESS) {
-    status = zeMemAllocDevice(context, &alloc_desc, matrix_bytes, ALIGN, device, &dev_b);
-  }
-  if (status == ZE_RESULT_SUCCESS) {
-    status = zeMemAllocDevice(context, &alloc_desc, matrix_bytes, ALIGN, device, &dev_c);
-  }
-  if (status == ZE_RESULT_SUCCESS && spec->has_bias) {
-    status = zeMemAllocDevice(context, &alloc_desc, size * sizeof(float), ALIGN, device, &dev_bias);
-  }
-  if (status != ZE_RESULT_SUCCESS) {
-    std::cout << "[ERROR] Device allocation failed for " << spec->name << std::endl;
-    // Free whatever did get allocated before bailing out.
-    if (dev_a != nullptr) zeMemFree(context, dev_a);
-    if (dev_b != nullptr) zeMemFree(context, dev_b);
-    if (dev_c != nullptr) zeMemFree(context, dev_c);
-    if (dev_bias != nullptr) zeMemFree(context, dev_bias);
-    return -1.0f;
-  }
-
-  status = zeKernelSetGroupSize(kernel, group_size[0], group_size[1], group_size[2]);
-
-  // Argument index 3 is either the bias buffer (then size moves to 4) or size.
-  status = zeKernelSetArgumentValue(kernel, 0, sizeof(dev_a), &dev_a);
-  status = zeKernelSetArgumentValue(kernel, 1, sizeof(dev_b), &dev_b);
-  status = zeKernelSetArgumentValue(kernel, 2, sizeof(dev_c), &dev_c);
-  if (spec->has_bias) {
-    status = zeKernelSetArgumentValue(kernel, 3, sizeof(dev_bias), &dev_bias);
-    status = zeKernelSetArgumentValue(kernel, 4, sizeof(size), &size);
-  } else {
-    status = zeKernelSetArgumentValue(kernel, 3, sizeof(size), &size);
-  }
-
-  ze_command_list_desc_t cmd_list_desc = {ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-  ze_command_list_handle_t cmd_list = nullptr;
-  status = zeCommandListCreate(context, device, &cmd_list_desc, &cmd_list);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_a, a.data(), matrix_bytes, nullptr, 0,
-                                         nullptr);
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_b, b.data(), matrix_bytes, nullptr, 0,
-                                         nullptr);
-  if (spec->has_bias) {
-    status = zeCommandListAppendMemoryCopy(cmd_list, dev_bias, bias.data(), size * sizeof(float),
-                                           nullptr, 0, nullptr);
-  }
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 0, nullptr);
-
-  ze_event_pool_desc_t event_pool_desc = {
-      ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-      ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE, 1};
-  ze_event_pool_handle_t event_pool = nullptr;
-  status = zeEventPoolCreate(context, &event_pool_desc, 0, nullptr, &event_pool);
-
-  ze_event_desc_t event_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0, ZE_EVENT_SCOPE_FLAG_HOST,
-                                ZE_EVENT_SCOPE_FLAG_HOST};
-  ze_event_handle_t event = nullptr;
-  zeEventCreate(event_pool, &event_desc, &event);
-
-  ze_group_count_t dim = {size / group_size[0], size / group_size[1], 1};
-  status = zeCommandListAppendLaunchKernel(cmd_list, kernel, &dim, event, 0, nullptr);
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 0, nullptr);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, c.data(), dev_c, matrix_bytes, nullptr, 0,
-                                         nullptr);
-
-  status = zeCommandListClose(cmd_list);
-
-  ze_command_queue_desc_t cmd_queue_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,     nullptr, 0, 0, 0,
-      ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,       ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-  ze_command_queue_handle_t cmd_queue = nullptr;
-  status = zeCommandQueueCreate(context, device, &cmd_queue_desc, &cmd_queue);
-
-  status = zeCommandQueueExecuteCommandLists(cmd_queue, 1, &cmd_list, nullptr);
-  status = zeCommandQueueSynchronize(cmd_queue, UINT32_MAX);
-
-  status = zeCommandQueueDestroy(cmd_queue);
-  status = zeCommandListDestroy(cmd_list);
-
-  status = zeMemFree(context, dev_a);
-  status = zeMemFree(context, dev_b);
-  status = zeMemFree(context, dev_c);
-  if (dev_bias != nullptr) {
-    status = zeMemFree(context, dev_bias);
-  }
-
-  ze_device_properties_t props{};
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  status = zeDeviceGetProperties(device, &props);
-
-  ze_kernel_timestamp_result_t timestamp{};
-  status = zeEventQueryKernelTimestamp(event, &timestamp);
-  status = zeEventDestroy(event);
-  status = zeEventPoolDestroy(event_pool);
-
-  double time = 0.0;
-  if (props.timerResolution != 0) {
-    time = static_cast<double>(timestamp.global.kernelEnd - timestamp.global.kernelStart) /
-           props.timerResolution;
-  }
-  std::cout << "  " << spec->name << ": " << time << " ns" << std::endl;
-
-  // Each kernel scales the plain GEMM result differently, so a wrong-kernel
-  // launch shows up as an accuracy failure rather than passing unnoticed.
-  float expected = base_result * spec->result_scale;
-  if (spec->has_bias) {
-    expected += BIAS_VALUE;
-  }
-  return Check(c, expected);
-}
-
-// Which modules a scenario builds, and which kernels it creates from each.
-struct ScenarioPlan {
-  const char* description;
-  // Per module: the .spv to load and the kernels to create from it.
-  struct ModulePlan {
-    const char* module;
-    std::vector<const KernelSpec*> create;
-    // Kernels created but intentionally not launched.
-    std::vector<const KernelSpec*> skip_launch;
-  };
-  std::vector<ModulePlan> modules;
-};
-
-static ScenarioPlan GetScenarioPlan(int scenario) {
-  switch (scenario) {
-    case 1:
-      // Simplest case: a module whose binary contains exactly one kernel.
-      return {"1 module, 1 kernel in binary, 1 created, 1 launched",
-              {{kSingleModule, {&kGemm}, {}}}};
-    case 2:
-      // All six kernels of one module created and launched, GEMM_Call among them.
-      return {"1 module, 6 kernels in binary, 6 created, 6 launched",
-              {{kMultiModule,
-                {&kGemm, &kGemmTiled, &kGemmScaled, &kGemmBias, &kGemmExtra, &kGemmCall},
-                {}}}};
-    case 3:
-      // Three modules live at once, spanning both a single-kernel and two
-      // multi-kernel binaries. Every kernel is created and launched.
-      return {"3 modules, 9 kernels in binaries, 9 created, 9 launched",
-              {{kSingleModule, {&kGemm}, {}},
-               {kMultiModule,
-                {&kGemm, &kGemmTiled, &kGemmScaled, &kGemmBias, &kGemmExtra, &kGemmCall},
-                {}},
-               {kAuxModule, {&kGemmAux, &kGemmAuxScaled}, {}}}};
-    case 4:
-      // Three populations, all deliberately different in size: 6 kernels in the
-      // binary, 3 created, 2 launched. GEMM_Bias, GEMM_Extra and GEMM_Call are
-      // never created; GEMM_Tiled is created but never launched.
-      return {"1 module, 6 kernels in binary, 3 created, 2 launched",
-              {{kMultiModule, {&kGemm, &kGemmScaled, &kGemmTiled}, {&kGemmTiled}}}};
-    default:
-      return {nullptr, {}};
-  }
-}
-
-static void PrintScenarios() {
-  std::cout << "Scenarios:" << std::endl;
-  for (int i = 1; i <= 4; ++i) {
-    ScenarioPlan plan = GetScenarioPlan(i);
-    std::cout << "  " << i << "  " << plan.description << std::endl;
-  }
-}
-
-static bool IsLaunchSkipped(const ScenarioPlan::ModulePlan& mp, const KernelSpec* spec) {
-  for (size_t i = 0; i < mp.skip_launch.size(); ++i) {
-    if (mp.skip_launch[i] == spec) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Returns true if every launched kernel produced the expected result.
-static bool RunScenario(int scenario, ze_device_handle_t device, ze_driver_handle_t driver,
-                        unsigned size, unsigned iterations) {
-  ScenarioPlan plan = GetScenarioPlan(scenario);
-  if (plan.description == nullptr) {
-    std::cout << "[ERROR] Unknown scenario " << scenario << std::endl;
-    return false;
-  }
-
-  std::cout << "Scenario " << scenario << ": " << plan.description << std::endl;
-
-  ze_context_handle_t context = utils::ze::GetContext(driver);
-  if (context == nullptr) {
-    std::cout << "[ERROR] Unable to create context" << std::endl;
-    return false;
-  }
-
-  std::vector<float> a(static_cast<size_t>(size) * size, A_VALUE);
-  std::vector<float> b(static_cast<size_t>(size) * size, B_VALUE);
-  std::vector<float> c(static_cast<size_t>(size) * size, 0.0f);
-  std::vector<float> bias(size, BIAS_VALUE);
-  const float base_result = A_VALUE * B_VALUE * size;
-
-  // Create every module and kernel up front, so all modules in a
-  // multiple-module scenario are alive at the same time. Creating and
-  // destroying them one at a time would not exercise that.
-  std::vector<LiveModule> live_modules;
-  bool setup_ok = true;
-  for (size_t m = 0; m < plan.modules.size() && setup_ok; ++m) {
-    const ScenarioPlan::ModulePlan& mp = plan.modules[m];
-    ze_module_handle_t module = CreateModule(context, device, mp.module);
-    if (module == nullptr) {
-      setup_ok = false;
-      break;
-    }
-
-    LiveModule lm;
-    lm.handle = module;
-    lm.source = mp.module;
-    for (size_t k = 0; k < mp.create.size(); ++k) {
-      if (!CreateKernel(module, mp.create[k], lm)) {
-        setup_ok = false;
-        break;
-      }
-    }
-    live_modules.push_back(lm);
-  }
-
-  bool all_correct = setup_ok;
-  if (setup_ok) {
-    for (unsigned it = 0; it < iterations; ++it) {
-      std::cout << "Iteration " << (it + 1) << " of " << iterations << std::endl;
-      for (size_t m = 0; m < live_modules.size(); ++m) {
-        const ScenarioPlan::ModulePlan& mp = plan.modules[m];
-        LiveModule& lm = live_modules[m];
-        for (size_t k = 0; k < lm.kernels.size(); ++k) {
-          const LiveKernel& lk = lm.kernels[k];
-          if (IsLaunchSkipped(mp, lk.spec)) {
-            // Created on purpose but never launched.
-            continue;
-          }
-          // The tiled kernel needs the matrix to divide into whole tiles.
-          if (lk.spec->needs_tile_group && (size % TILE_SIZE) != 0) {
-            std::cout << "  " << lk.spec->name << ": skipped (size " << size
-                      << " is not a multiple of " << TILE_SIZE << ")" << std::endl;
-            continue;
-          }
-          float eps = RunAndCheck(lk, device, context, a, b, c, bias, size, base_result);
-          if (eps < 0.0f) {
-            all_correct = false;
-            continue;
-          }
-          if (eps >= MAX_EPS) {
-            std::cout << "[ERROR] " << lk.spec->name << " in " << lm.source
-                      << " produced INCORRECT results, accuracy: " << eps << std::endl;
-            all_correct = false;
-          }
-        }
-      }
-    }
-  }
-
-  // Tear down in reverse: kernels before their module.
-  for (size_t m = 0; m < live_modules.size(); ++m) {
-    for (size_t k = 0; k < live_modules[m].kernels.size(); ++k) {
-      zeKernelDestroy(live_modules[m].kernels[k].handle);
-    }
-    zeModuleDestroy(live_modules[m].handle);
-  }
-  zeContextDestroy(context);
-
-  return all_correct;
-}
-
-static void PrintUsage() {
-  std::cout << "Usage: gemm_stall_sampling [options]" << std::endl
-            << "  --scenario N     scenario to run, 1-4 (default 1)" << std::endl
-            << "  --size N         matrix dimension, N x N (default 256)" << std::endl
-            << "  --iterations N   repeats of the whole scenario (default 4)" << std::endl
-            << "  --list           list the scenarios and exit" << std::endl
-            << "  --help           show this message and exit" << std::endl;
-}
-
-// Parse a positive integer option value. Returns false (after printing) if the
-// value is missing or not a usable number, so a typo fails loudly instead of
-// silently running the default.
-static bool ParseUnsigned(int argc, char* argv[], int& i, const char* option, unsigned& out) {
-  if (i + 1 >= argc) {
-    std::cout << "[ERROR] " << option << " requires a value" << std::endl;
-    return false;
-  }
-  ++i;
-  try {
-    unsigned long value = std::stoul(argv[i]);
-    if (value == 0) {
-      std::cout << "[ERROR] " << option << " must be greater than 0" << std::endl;
-      return false;
-    }
-    out = static_cast<unsigned>(value);
-  } catch (const std::exception&) {
-    std::cout << "[ERROR] " << option << " expects a number, got '" << argv[i] << "'" << std::endl;
-    return false;
-  }
-  return true;
-}
-
-int main(int argc, char* argv[]) {
-  unsigned scenario = 1;
-  unsigned size = 256;
-  unsigned iterations = 4;
-
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "--scenario") == 0) {
-      if (!ParseUnsigned(argc, argv, i, "--scenario", scenario)) {
-        return 1;
-      }
-    } else if (strcmp(argv[i], "--size") == 0) {
-      if (!ParseUnsigned(argc, argv, i, "--size", size)) {
-        return 1;
-      }
-    } else if (strcmp(argv[i], "--iterations") == 0) {
-      if (!ParseUnsigned(argc, argv, i, "--iterations", iterations)) {
-        return 1;
-      }
-    } else if (strcmp(argv[i], "--list") == 0) {
-      PrintScenarios();
-      return 0;
-    } else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
-      PrintUsage();
-      return 0;
-    } else {
-      std::cout << "[ERROR] Unknown option '" << argv[i] << "'" << std::endl;
-      PrintUsage();
-      return 1;
-    }
-  }
-
-  if (scenario < 1 || scenario > 4) {
-    std::cout << "[ERROR] --scenario must be 1-4, got " << scenario << std::endl;
-    PrintScenarios();
-    return 1;
-  }
-
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-  if (status != ZE_RESULT_SUCCESS) {
-    std::cout << "[ERROR] Failed to initialize Level Zero" << std::endl;
-    return 1;
-  }
-
-  ze_device_handle_t device = utils::ze::GetGpuDevice();
-  ze_driver_handle_t driver = utils::ze::GetGpuDriver();
-  if (device == nullptr || driver == nullptr) {
-    std::cout << "Unable to find GPU device" << std::endl;
-    return 0;
-  }
-
-  std::cout << "Level Zero GEMM scenarios (matrix " << size << " x " << size << ", " << iterations
-            << " iterations)" << std::endl;
-  std::cout << "Target device: " << utils::ze::GetDeviceName(device) << std::endl;
-
-  auto start = std::chrono::steady_clock::now();
-  bool ok = RunScenario(static_cast<int>(scenario), device, driver, size, iterations);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " s" << std::endl;
-  if (!ok) {
-    std::cout << "[ERROR] Scenario " << scenario << " failed" << std::endl;
-    return 1;
-  }
-  std::cout << "Scenario " << scenario << " completed successfully" << std::endl;
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/graph/CMakeLists.txt b/tools/unitrace/test/cpp_test/graph/CMakeLists.txt
deleted file mode 100644
index 0b9ddb66..00000000
--- a/tools/unitrace/test/cpp_test/graph/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-project(graph CXX)
-
-add_executable(graph graph.cpp)
-add_sycl_to_target(graph)
-
-install(TARGETS graph RUNTIME DESTINATION bin/graph COMPONENT graph)
diff --git a/tools/unitrace/test/cpp_test/graph/check_outfiles.py b/tools/unitrace/test/cpp_test/graph/check_outfiles.py
deleted file mode 100644
index 40730230..00000000
--- a/tools/unitrace/test/cpp_test/graph/check_outfiles.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import os
-import re
-import sys
-import argparse
-
-
-def get_kernels_names(log_file_path):
-    kernels = []
-    with open(log_file_path) as f:
-        lines = f.readlines()
-
-    # Find the line with '=== Kernel Properties ==='
-    for i, line in enumerate(lines):
-        if line.strip() == "=== Kernel Properties ===":
-            start_idx = i + 3  # Skip the header line after the marker
-            break
-    else:
-        start_idx = None
-
-    if start_idx is not None:
-        for line in lines[start_idx:]:
-            line = line.strip()
-            
-            # skip empty or section lines
-            if not line or line.startswith('='):
-                continue  
-            match = re.match(r'"([^"]+)"', line)
-            if match:
-                kernel = match.group(1)
-                kernels.append(kernel)
-    return kernels
-
-def verify_kernels_num(kernel_names, include_kernels_values, exclude_kernels_values):
-    first_include_pattern = include_kernels_values[0] if include_kernels_values else None
-    first_exclude_pattern = exclude_kernels_values[0] if exclude_kernels_values else None
-    second_exclude_pattern = exclude_kernels_values[1] if len(exclude_kernels_values) > 1 else None
-    expected_kernels_num = -1
-    
-    # verify number of included kernels
-    if first_include_pattern == "not_exists":
-        expected_kernels_num = 0
-    elif first_include_pattern == "sycl" and not exclude_kernels_values:
-        expected_kernels_num = 3
-    elif first_exclude_pattern == "sycl":
-        expected_kernels_num = 0
-    elif (first_include_pattern == "sycl" and
-          first_exclude_pattern == "2}" and
-          second_exclude_pattern == "EE1_"):
-        expected_kernels_num = 2
-
-    if len(kernel_names) != expected_kernels_num:
-        print(f"[ERROR] should be {expected_kernels_num} kernels, but found {len(kernel_names)} kernels")
-        sys.exit(-1)
-        
-def main():
-    parser = argparse.ArgumentParser(description="Check timeline stats in JSON trace files.")
-    parser.add_argument('output_files', nargs='+', help='output files')
-    parser.add_argument('--cmd', type=str, nargs=argparse.REMAINDER, help='command argument') 
-    args = parser.parse_args()
-
-    include_kernels_values = []
-    exclude_kernels_values = []
-   
-   
-    if args.output_files is None or len(args.output_files) != 1:
-        print(f"[ERROR] should be one output file")
-        sys.exit(-1)
-
-    kernel_names = get_kernels_names(args.output_files[0])
-    
-
-    if args.cmd:
-        if '--include-kernels' in args.cmd:
-            idx = args.cmd.index('--include-kernels') + 1
-            include_kernels_values = args.cmd[idx].split(',')
-
-        if '--exclude-kernels' in args.cmd:
-            idx = args.cmd.index('--exclude-kernels') + 1
-            exclude_kernels_values = args.cmd[idx].split(',')
-
-    verify_kernels_num(kernel_names, include_kernels_values, exclude_kernels_values)
-    
-    for kernel_name in kernel_names:
-                    
-        # verify that no excluded kernels were handled
-        for exclude_kernel in exclude_kernels_values:
-            if exclude_kernel in kernel_name:
-                print(f"[ERROR] kernel {kernel_name}, exclude_kernel value : {exclude_kernel}")
-                sys.exit(-1)
-        if include_kernels_values:
-            
-            # verify that all handled kernels should have been included
-            kernel_included = False
-            for include_kernel in include_kernels_values:
-                if include_kernel in kernel_name:
-                    kernel_included = True
-                    break
-            if not kernel_included:
-                print(f"[ERROR] kernel {kernel_name} not in include_kernels values: {include_kernels_values}")
-                sys.exit(-1)
-
-if __name__ == "__main__":
-  main()
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/graph/gold/linux/d.txt b/tools/unitrace/test/cpp_test/graph/gold/linux/d.txt
deleted file mode 100644
index 443f64a1..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/linux/d.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):             93803157
-    Total Device Time for L0 backend (ns):               585600
-
-== L0 Backend ==
-
-                                                                                                                                                                      Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                                                                                                                                        "zeCommandListAppendMemoryCopy(D2M)",            1,               166400,    28.415300,               166400,               166400,               166400
-                                                                                                                                        "zeCommandListAppendMemoryCopy(M2D)",            1,               122800,    20.969946,               122800,               122800,               122800
-                                                                                                                                             "zeCommandListAppendEventReset",           36,               116720,    19.931694,                 3242,                 2240,                 3840
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",            6,                59680,    10.191257,                 9946,                 9440,                11840
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",            6,                41120,     7.021858,                 6853,                 6720,                 6880
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",            6,                40960,     6.994535,                 6826,                 6720,                 6880
-                                                                                                                                                "zeCommandListAppendBarrier",           19,                37920,     6.475410,                 1995,                 1440,                 3200
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                                      Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
-"run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/graph/gold/linux/h.txt b/tools/unitrace/test/cpp_test/graph/gold/linux/h.txt
deleted file mode 100644
index 403dada5..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/linux/h.txt
+++ /dev/null
@@ -1,81 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            100225286
-    Total API Time for L0 backend (ns):              5820402
-Total API Time for CL CPU backend (ns):                33296
-Total API Time for CL GPU backend (ns):                17980
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                zeEventHostSynchronize,            8,              1184530,     20.351343,               148066,               120467,               288158
-          zeCommandListCreateImmediate,            1,              1129446,     19.404949,              1129446,              1129446,              1129446
-                        zeModuleCreate,            1,              1054980,     18.125551,              1054980,              1054980,              1054980
-           zeContextMakeMemoryResident,           12,               961035,     16.511490,                80086,                 3785,               459136
-     zeCommandQueueExecuteCommandLists,           21,               346927,      5.960533,                16520,                 1102,               139742
-                  zeCommandQueueCreate,            2,               253266,      4.351349,               126633,                48205,               205061
-                      zeMemAllocShared,            4,               233695,      4.015100,                58423,                28487,               123136
-                      zeMemAllocDevice,            6,               147336,      2.531372,                24556,                12128,                62406
-                             zeMemFree,            7,               104958,      1.803277,                14994,                 5317,                36792
-                   zeCommandListCreate,            5,                93345,      1.603755,                18669,                13256,                26235
-         zeCommandListAppendMemoryCopy,            2,                80624,      1.385196,                40312,                21849,                58775
-                     zeEventPoolCreate,            2,                43602,      0.749124,                21801,                18219,                25383
-                         zeEventCreate,            9,                30305,      0.520669,                 3367,                  189,                16522
-                        zeMemAllocHost,            1,                23226,      0.399045,                23226,                23226,                23226
-         zeCommandListAppendEventReset,           16,                21224,      0.364648,                 1326,                   76,                11842
-                    zeCommandListReset,            9,                20848,      0.358188,                 2316,                   65,                 9815
-       zeCommandListAppendLaunchKernel,            3,                17042,      0.292798,                 5680,                  498,                15341
-            zeCommandListAppendBarrier,            9,                10486,      0.180159,                 1165,                  118,                 4323
-                        zeKernelCreate,            3,                 8578,      0.147378,                 2859,                  561,                 6968
-                  zeCommandListDestroy,            2,                 6386,      0.109718,                 3193,                 1322,                 5064
-                    zeCommandListClose,           11,                 5661,      0.097261,                  514,                   76,                 3315
-                           zeDriverGet,            3,                 5006,      0.086008,                 1668,                   72,                 4569
-                    zeFenceQueryStatus,           18,                 4691,      0.080596,                  335,                   65,                 1888
-        zeDriverGetExtensionProperties,            2,                 3515,      0.060391,                 1757,                 1455,                 2060
-              zeKernelSetArgumentValue,            6,                 3382,      0.058106,                  563,                  119,                 1874
-               zeMemGetAllocProperties,           10,                 2876,      0.049412,                  287,                   63,                  846
-     zeDeviceGetMemoryAccessProperties,            1,                 1899,      0.032627,                 1899,                 1899,                 1899
-zeDeviceGetCommandQueueGroupProperties,            4,                 1852,      0.031819,                  463,                   79,                  769
-                 zeDeviceGetProperties,            2,                 1811,      0.031115,                  905,                  455,                 1356
-           zeDeviceGetModuleProperties,            2,                 1803,      0.030977,                  901,                  258,                 1545
-              zeKernelSuggestGroupSize,            3,                 1660,      0.028520,                  553,                   58,                 1475
-                         zeFenceCreate,            9,                 1424,      0.024466,                  158,                   27,                  913
-                 zeDeviceCanAccessPeer,            6,                 1260,      0.021648,                  210,                   39,                  509
-        zeCommandListAppendSignalEvent,            1,                 1201,      0.020634,                 1201,                 1201,                 1201
-                      zeEventHostReset,            5,                 1084,      0.018624,                  216,                   54,                  844
-                     zeEventHostSignal,            5,                 1069,      0.018366,                  213,                  110,                  589
-                 zeDeviceGetSubDevices,           14,                  900,      0.015463,                   64,                   23,                  424
-                       zeContextCreate,            1,                  897,      0.015411,                  897,                  897,                  897
-          zeDeviceGetComputeProperties,            1,                  866,      0.014879,                  866,                  866,                  866
-                 zeCommandQueueDestroy,            2,                  862,      0.014810,                  431,                  262,                  600
-                 zeModuleGetProperties,            1,                  711,      0.012216,                  711,                  711,                  711
-                        zeFenceDestroy,            9,                  646,      0.011099,                   71,                   29,                  368
-                 zeKernelGetProperties,            3,                  606,      0.010412,                  202,                   42,                  489
-                           zeDeviceGet,            2,                  601,      0.010326,                  300,                  163,                  438
-                  zeKernelSetGroupSize,            3,                  520,      0.008934,                  173,                   46,                  391
-                          zeFenceReset,            9,                  481,      0.008264,                   53,                   19,                  219
-             zeKernelSetIndirectAccess,            3,                  470,      0.008075,                  156,                   29,                  401
-                 zeDriverGetApiVersion,            1,                  272,      0.004673,                  272,                  272,                  272
-            zeDeviceGetImageProperties,            2,                  271,      0.004656,                  135,                   30,                  241
-                 zeDriverGetProperties,            1,                  266,      0.004570,                  266,                  266,                  266
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,          52,               19174,       57.59,                 368,                 135,                4196
-clGetPlatformInfo,          12,               10488,       31.50,                 874,                 241,                5671
-   clGetDeviceIDs,           4,                1513,        4.54,                 378,                 138,                 815
-  clReleaseDevice,           6,                1078,        3.24,                 179,                 115,                 379
-   clRetainDevice,           4,                1043,        3.13,                 260,                 123,                 591
-
-== CL GPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         108,               12097,       67.28,                 112,                  53,                 982
-   clGetDeviceIDs,           4,                2722,       15.14,                 680,                 150,                2142
-clGetPlatformInfo,          12,                2120,       11.79,                 176,                  53,                 816
-  clReleaseDevice,          12,                 628,        3.49,                  52,                  42,                  86
-   clRetainDevice,           8,                 413,        2.30,                  51,                  42,                  78
-
-
diff --git a/tools/unitrace/test/cpp_test/graph/gold/linux/t.txt b/tools/unitrace/test/cpp_test/graph/gold/linux/t.txt
deleted file mode 100644
index 52192719..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/linux/t.txt
+++ /dev/null
@@ -1,76 +0,0 @@
-Thread 46879 Device 57759440 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542501901701579 (append) 542501902170259 (submit) 542501902373059 (start) 542501902512579 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501910228607 (append) 542501910243574 (submit) 542501910347734 (start) 542501910350294 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501910316577 (submit) 542501910355937 (start) 542501910358257 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501910316577 (submit) 542501910359377 (start) 542501910361377 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501910316577 (submit) 542501910362497 (start) 542501910364737 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501910316577 (submit) 542501910365857 (start) 542501910368177 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501910350931 (submit) 542501910402211 (start) 542501910403491 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501910350931 (submit) 542501910432931 (start) 542501910435011 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501910350931 (submit) 542501910424611 (start) 542501910431331 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501910350931 (submit) 542501910403651 (start) 542501910415011 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501910350931 (submit) 542501910416131 (start) 542501910423011 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910487847 (append) 542501910519747 (submit) 542501910533427 (start) 542501910537027 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910494218 (append) 542501910519747 (submit) 542501910538627 (start) 542501910541747 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501910502847 (append) 542501910519747 (submit) 542501910543507 (start) 542501910545267 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501910573038 (submit) 542501910579278 (start) 542501910582878 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501910573038 (submit) 542501910584558 (start) 542501910587678 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501910573038 (submit) 542501910589198 (start) 542501910592238 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501910573038 (submit) 542501910593758 (start) 542501910597118 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501910586387 (submit) 542501910607907 (start) 542501910609987 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501910586387 (submit) 542501910636227 (start) 542501910638307 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501910586387 (submit) 542501910610147 (start) 542501910619267 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501910586387 (submit) 542501910620387 (start) 542501910627107 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501910586387 (submit) 542501910628387 (start) 542501910634947 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910608106 (append) 542501910648421 (submit) 542501910660581 (start) 542501910664261 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910613888 (append) 542501910648421 (submit) 542501910665861 (start) 542501910669061 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501910620134 (append) 542501910648421 (submit) 542501910670821 (start) 542501910672421 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501910708060 (submit) 542501910713820 (start) 542501910717100 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501910708060 (submit) 542501910718700 (start) 542501910721900 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501910708060 (submit) 542501910723580 (start) 542501910726620 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501910708060 (submit) 542501910728060 (start) 542501910731260 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501910721746 (submit) 542501910743026 (start) 542501910744946 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501910721746 (submit) 542501910770866 (start) 542501910773106 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501910721746 (submit) 542501910745106 (start) 542501910754226 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501910721746 (submit) 542501910755346 (start) 542501910761906 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501910721746 (submit) 542501910763026 (start) 542501910769586 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910741568 (append) 542501910784683 (submit) 542501910796523 (start) 542501910800043 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910747249 (append) 542501910784683 (submit) 542501910801643 (start) 542501910804923 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501910772002 (append) 542501910784683 (submit) 542501910806923 (start) 542501910808523 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501910837718 (submit) 542501910843798 (start) 542501910847238 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501910837718 (submit) 542501910848758 (start) 542501910851798 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501910837718 (submit) 542501910853238 (start) 542501910856438 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501910837718 (submit) 542501910857878 (start) 542501910860998 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501910850870 (submit) 542501910871910 (start) 542501910873830 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501910850870 (submit) 542501910900070 (start) 542501910902150 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501910850870 (submit) 542501910873990 (start) 542501910883110 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501910850870 (submit) 542501910884390 (start) 542501910890950 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501910850870 (submit) 542501910892390 (start) 542501910898950 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910870830 (append) 542501910914218 (submit) 542501910926058 (start) 542501910929658 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910876351 (append) 542501910914218 (submit) 542501910931338 (start) 542501910934538 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501910901812 (append) 542501910914218 (submit) 542501910936298 (start) 542501910937898 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501910966787 (submit) 542501910972707 (start) 542501910976067 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501910966787 (submit) 542501910977827 (start) 542501910980707 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501910966787 (submit) 542501910982307 (start) 542501910985427 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501910966787 (submit) 542501910986947 (start) 542501910989987 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501910979670 (submit) 542501911000870 (start) 542501911002790 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501910979670 (submit) 542501911029350 (start) 542501911031590 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501910979670 (submit) 542501911002950 (start) 542501911012070 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501910979670 (submit) 542501911013510 (start) 542501911020070 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501910979670 (submit) 542501911021670 (start) 542501911028230 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501910997912 (append) 542501911038948 (submit) 542501911050468 (start) 542501911053988 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501911003572 (append) 542501911038948 (submit) 542501911055428 (start) 542501911058628 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501911026603 (append) 542501911038948 (submit) 542501911060548 (start) 542501911062148 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501906695550 (append) 542501911092179 (submit) 542501911098099 (start) 542501911101459 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909795251 (append) 542501911092179 (submit) 542501911103219 (start) 542501911106259 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909802762 (append) 542501911092179 (submit) 542501911107699 (start) 542501911110579 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501909808855 (append) 542501911092179 (submit) 542501911112099 (start) 542501911115299 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501906706557 (append) 542501911105311 (submit) 542501911126271 (start) 542501911128191 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#3}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909787314 (append) 542501911105311 (submit) 542501911146271 (start) 542501911152831 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501909816222 (append) 542501911105311 (submit) 542501911153951 (start) 542501911156191 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909734710 (append) 542501911105311 (submit) 542501911128351 (start) 542501911137471 (end)
-Thread 46879 Device 57759440 : "run1(sycl::_V1::queue&, float*, float*, float*, float*, int)::{lambda(sycl::_V1::handler&)#2}::operator()(sycl::_V1::handler&) const::{lambda(sycl::_V1::item<1, true>)#1}[SIMD32 {1024; 1; 1} {1024; 1; 1}]" [ns] 542501909771304 (append) 542501911105311 (submit) 542501911138591 (start) 542501911144991 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501911128981 (append) 542501911175454 (submit) 542501911186654 (start) 542501911190174 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendEventReset" [ns] 542501911134544 (append) 542501911175454 (submit) 542501911191774 (start) 542501911194814 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendBarrier" [ns] 542501911157854 (append) 542501911175454 (submit) 542501911196574 (start) 542501911198174 (end)
-Thread 46879 Device 57759440 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542501911224853 (append) 542501911257849 (submit) 542501911337209 (start) 542501911564569 (end)
-
diff --git a/tools/unitrace/test/cpp_test/graph/gold/windows/d.txt b/tools/unitrace/test/cpp_test/graph/gold/windows/d.txt
deleted file mode 100644
index 6a8e747c..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/windows/d.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           1153236900
-    Total Device Time for L0 backend (ns):             52754824
-
-== L0 Backend ==
-
-                                                                                          Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
- "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_",            6,             52172185,    98.895576,              8695364,              8350104,              8907395
-                                                            "zeCommandListAppendMemoryCopy(D2M)",            1,               290312,     0.550304,               290312,               290312,               290312
-                                                            "zeCommandListAppendMemoryCopy(M2D)",            1,               249375,     0.472706,               249375,               249375,               249375
-                                                                 "zeCommandListAppendEventReset",           30,                29420,     0.055767,                  980,                  625,                 2916
-                                                                    "zeCommandListAppendBarrier",           18,                13532,     0.025651,                  751,                  416,                 1145
-"_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_",            6,                    0,     0.000000,                    0,                    0,                    0
-"_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_",            6,                    0,     0.000000,                    0,                    0,                    0
-
-
-=== Kernel Properties ===
-
-                                                                                          Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
- "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_",      JIT,    8,                   2,                  0,                      3264,                    3200,                           128
-"_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_",      JIT,    8,                   2,                  0,                      3264,                    3200,                           128
-"_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_",      JIT,    8,                   2,                  0,                      3264,                    3200,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/graph/gold/windows/h.txt b/tools/unitrace/test/cpp_test/graph/gold/windows/h.txt
deleted file mode 100644
index 6d724e7e..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/windows/h.txt
+++ /dev/null
@@ -1,79 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1803287500
-    Total API Time for L0 backend (ns):            710757500
-Total API Time for CL CPU backend (ns):                69200
-Total API Time for CL GPU backend (ns):                25900
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                        zeModuleCreate,            1,            557648000,     78.458267,            557648000,            557648000,            557648000
-                zeEventHostSynchronize,            8,            144353400,     20.309797,             18044175,              1014200,             25239400
-           zeContextMakeMemoryResident,            5,              2004000,      0.281953,               400800,               208900,               462900
-                   zeCommandListCreate,            4,              1750700,      0.246315,               437675,               303600,               640900
-         zeCommandListAppendMemoryCopy,            2,              1313400,      0.184789,               656700,               267100,              1046300
-     zeCommandQueueExecuteCommandLists,           21,               906800,      0.127582,                43180,                 7000,               142400
-                    zeCommandListReset,            9,               814200,      0.114554,                90466,                 2300,               509000
-                      zeMemAllocDevice,            5,               403300,      0.056742,                80660,                37100,               242400
-          zeCommandListCreateImmediate,            1,               345600,      0.048624,               345600,               345600,               345600
-                        zeKernelCreate,            3,               299000,      0.042068,                99666,                72900,               122100
-                  zeCommandQueueCreate,            1,               158000,      0.022230,               158000,               158000,               158000
-                 zeDeviceGetProperties,            1,               139400,      0.019613,               139400,               139400,               139400
-                      zeMemAllocShared,            2,               121300,      0.017066,                60650,                33600,                87700
-                     zeEventPoolCreate,            2,                95500,      0.013436,                47750,                33600,                61900
-                             zeMemFree,            4,                83300,      0.011720,                20825,                 8100,                28000
-                         zeEventCreate,            9,                44600,      0.006275,                 4955,                  400,                21300
-                        zeMemAllocHost,            1,                30700,      0.004319,                30700,                30700,                30700
-         zeCommandListAppendEventReset,           16,                29100,      0.004094,                 1818,                  200,                 7700
-       zeCommandListAppendLaunchKernel,            3,                25700,      0.003616,                 8566,                 3800,                17000
-                    zeFenceQueryStatus,           10,                22700,      0.003194,                 2270,                  600,                 4200
-            zeCommandListAppendBarrier,            9,                22000,      0.003095,                 2444,                 1000,                 3500
-                         zeFenceCreate,            8,                13600,      0.001913,                 1700,                  600,                 3000
-                  zeCommandListDestroy,            2,                13400,      0.001885,                 6700,                 3700,                 9700
-                    zeCommandListClose,           11,                12900,      0.001815,                 1172,                  200,                 1900
-                     zeEventHostSignal,            5,                12200,      0.001716,                 2440,                 1400,                 4700
-                      zeEventHostReset,            5,                11700,      0.001646,                 2340,                 1700,                 3800
-zeDeviceGetCommandQueueGroupProperties,            2,                10700,      0.001505,                 5350,                 3600,                 7100
-              zeKernelSetArgumentValue,            6,                 9800,      0.001379,                 1633,                  500,                 4700
-        zeDriverGetExtensionProperties,            2,                 9700,      0.001365,                 4850,                 1400,                 8300
-               zeMemGetAllocProperties,            7,                 6700,      0.000943,                  957,                  200,                 2200
-                  zeKernelSetGroupSize,            3,                 5400,      0.000760,                 1800,                 1200,                 2900
-                       zeContextCreate,            1,                 4600,      0.000647,                 4600,                 4600,                 4600
-           zeDeviceGetModuleProperties,            1,                 4100,      0.000577,                 4100,                 4100,                 4100
-              zeKernelSuggestGroupSize,            3,                 3600,      0.000507,                 1200,                  800,                 2000
-                           zeDriverGet,            3,                 3200,      0.000450,                 1066,                  100,                 1900
-                        zeFenceDestroy,            8,                 2800,      0.000394,                  350,                  100,                  900
-                 zeCommandQueueDestroy,            1,                 2800,      0.000394,                 2800,                 2800,                 2800
-     zeDeviceGetMemoryAccessProperties,            1,                 2700,      0.000380,                 2700,                 2700,                 2700
-                           zeDeviceGet,            2,                 2600,      0.000366,                 1300,                  500,                 2100
-                 zeDeviceGetSubDevices,           10,                 2500,      0.000352,                  250,                  100,                  600
-        zeCommandListAppendSignalEvent,            1,                 2500,      0.000352,                 2500,                 2500,                 2500
-                          zeFenceReset,            9,                 2000,      0.000281,                  222,                  100,                  300
-                 zeDriverGetProperties,            1,                 2000,      0.000281,                 2000,                 2000,                 2000
-                 zeKernelGetProperties,            3,                 1800,      0.000253,                  600,                  500,                  800
-                 zeModuleGetProperties,            1,                 1700,      0.000239,                 1700,                 1700,                 1700
-             zeKernelSetIndirectAccess,            3,                  800,      0.000113,                  266,                  200,                  300
-            zeDeviceGetImageProperties,            1,                  500,      0.000070,                  500,                  500,                  500
-                 zeDriverGetApiVersion,            1,                  500,      0.000070,                  500,                  500,                  500
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetPlatformInfo,           4,               31400,       45.38,                7850,                 800,               28300
-  clGetDeviceInfo,          20,               27100,       39.16,                1355,                 500,                6600
-   clGetDeviceIDs,           4,                6700,        9.68,                1675,                 800,                2900
-  clReleaseDevice,           4,                2400,        3.47,                 600,                 500,                 800
-   clRetainDevice,           2,                1600,        2.31,                 800,                 600,                1000
-
-== CL GPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,          21,               16500,       63.71,                 785,                 300,                1200
-   clGetDeviceIDs,           4,                5500,       21.24,                1375,                 400,                2500
-clGetPlatformInfo,           4,                2300,        8.88,                 575,                 200,                1500
-  clReleaseDevice,           4,                1100,        4.25,                 275,                 200,                 400
-   clRetainDevice,           2,                 500,        1.93,                 250,                 200,                 300
-
-
diff --git a/tools/unitrace/test/cpp_test/graph/gold/windows/t.txt b/tools/unitrace/test/cpp_test/graph/gold/windows/t.txt
deleted file mode 100644
index 87270aab..00000000
--- a/tools/unitrace/test/cpp_test/graph/gold/windows/t.txt
+++ /dev/null
@@ -1,76 +0,0 @@
-Thread 18988 Device 2938372120 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201696767465500 (append) 201696774249100 (submit) 201696775666027 (start) 201696775986131 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696801804300 (append) 201696801927300 (submit) 201696802169747 (start) 201696802170684 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696802131300 (submit) 201696802393070 (start) 201696802394476 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696802131300 (submit) 201696802394789 (start) 201696802395414 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696802131300 (submit) 201696802395727 (start) 201696802396404 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696802131300 (submit) 201696802396716 (start) 201696802397341 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696802310100 (submit) 201696804779891 (start) 201696804780828 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696802310100 (submit) 201696804781037 (start) 201696813000828 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696802310100 (submit) 201696813001350 (start) 201696821368641 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696802310100 (submit) 201696821369162 (start) 201696829513537 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696802310100 (submit) 201696829514370 (start) 201696829514682 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696803428000 (append) 201696803703200 (submit) 201696829558200 (start) 201696829559137 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696803468000 (append) 201696803703200 (submit) 201696829559450 (start) 201696829560022 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696803584700 (append) 201696803703200 (submit) 201696829560804 (start) 201696829561637 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696830468300 (submit) 201696830747883 (start) 201696830749341 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696830468300 (submit) 201696830749654 (start) 201696830750279 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696830468300 (submit) 201696830750591 (start) 201696830751216 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696830468300 (submit) 201696830751529 (start) 201696830752154 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696830695300 (submit) 201696830831393 (start) 201696830832018 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696830695300 (submit) 201696830832227 (start) 201696839237435 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696830695300 (submit) 201696839238372 (start) 201696847773476 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696830695300 (submit) 201696847773997 (start) 201696856301288 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696830695300 (submit) 201696856302018 (start) 201696856302330 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696830999800 (append) 201696831414100 (submit) 201696856353579 (start) 201696856354881 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696831058500 (append) 201696831414100 (submit) 201696856355193 (start) 201696856355765 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696831094400 (append) 201696831414100 (submit) 201696856356183 (start) 201696856357120 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696857041300 (submit) 201696857303800 (start) 201696857305206 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696857041300 (submit) 201696857305466 (start) 201696857306038 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696857041300 (submit) 201696857306352 (start) 201696857306924 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696857041300 (submit) 201696857307185 (start) 201696857307757 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696857292100 (submit) 201696857399860 (start) 201696857400485 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696857292100 (submit) 201696857400589 (start) 201696865840693 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696857292100 (submit) 201696865841527 (start) 201696874209964 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696857292100 (submit) 201696874210797 (start) 201696882692463 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696857292100 (submit) 201696882693402 (start) 201696882693714 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696857566200 (append) 201696857870900 (submit) 201696882748504 (start) 201696882749441 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696857603900 (append) 201696857870900 (submit) 201696882749754 (start) 201696882750431 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696857839200 (append) 201696857870900 (submit) 201696882750952 (start) 201696882751889 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696883533100 (submit) 201696883745964 (start) 201696883747370 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696883533100 (submit) 201696883747631 (start) 201696883748256 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696883533100 (submit) 201696883748516 (start) 201696883749141 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696883533100 (submit) 201696883749454 (start) 201696883750026 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696883734100 (submit) 201696883832381 (start) 201696883833006 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696883734100 (submit) 201696883833214 (start) 201696891979568 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696883734100 (submit) 201696891980922 (start) 201696900598317 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696883734100 (submit) 201696900598839 (start) 201696908974672 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696883734100 (submit) 201696908975506 (start) 201696908975818 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696883929800 (append) 201696884232400 (submit) 201696909067035 (start) 201696909068024 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696883983200 (append) 201696884232400 (submit) 201696909068337 (start) 201696909068909 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696884182100 (append) 201696884232400 (submit) 201696909069379 (start) 201696909070420 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696909934200 (submit) 201696910148679 (start) 201696910150397 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696909934200 (submit) 201696910150710 (start) 201696910151387 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696909934200 (submit) 201696910151700 (start) 201696910152377 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696909934200 (submit) 201696910152689 (start) 201696910153366 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696910129400 (submit) 201696910205910 (start) 201696910206639 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696910129400 (submit) 201696910206847 (start) 201696918707472 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696910129400 (submit) 201696918708306 (start) 201696926837056 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696910129400 (submit) 201696926837681 (start) 201696935330597 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696910129400 (submit) 201696935331431 (start) 201696935331743 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696910535500 (append) 201696910877600 (submit) 201696935399527 (start) 201696935400516 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696910583800 (append) 201696910877600 (submit) 201696935400829 (start) 201696935401401 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696910829000 (append) 201696910877600 (submit) 201696935401922 (start) 201696935402859 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696782320400 (append) 201696936089100 (submit) 201696936576860 (start) 201696936578422 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799919100 (append) 201696936089100 (submit) 201696936578735 (start) 201696936579360 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799948600 (append) 201696936089100 (submit) 201696936579620 (start) 201696936580245 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696799987200 (append) 201696936089100 (submit) 201696936580558 (start) 201696936581183 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696783159400 (append) 201696936422700 (submit) 201696936592075 (start) 201696936592700 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799150100 (append) 201696936422700 (submit) 201696936592908 (start) 201696944985512 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE0_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799519200 (append) 201696936422700 (submit) 201696944986345 (start) 201696953525928 (end)
-Thread 18988 Device 2938372120 : "_ZTSZZ4run1RN4sycl3_V15queueEPfS3_S3_S3_iENKUlRNS0_7handlerEE1_clES5_EUlNS0_4itemILi1ELb1EEEE_[SIMD8 {4096; 1; 1} {256; 1; 1}]" [ns] 201696799791200 (append) 201696936422700 (submit) 201696953526450 (start) 201696962464575 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696800005200 (append) 201696936422700 (submit) 201696962465304 (start) 201696962465616 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696936716400 (append) 201696936986200 (submit) 201696962521200 (start) 201696962522189 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendEventReset" [ns] 201696936753100 (append) 201696936986200 (submit) 201696962522502 (start) 201696962523127 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendBarrier" [ns] 201696936953300 (append) 201696936986200 (submit) 201696962523595 (start) 201696962524532 (end)
-Thread 18988 Device 2938372120 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 201696963148400 (append) 201696963475300 (submit) 201696963941654 (start) 201696964234674 (end)
-
diff --git a/tools/unitrace/test/cpp_test/graph/graph.cpp b/tools/unitrace/test/cpp_test/graph/graph.cpp
deleted file mode 100644
index 8c96441c..00000000
--- a/tools/unitrace/test/cpp_test/graph/graph.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <iostream>
-#include <sycl/sycl.hpp>
-
-void run1(sycl::queue& q, float* dst, float* src, float* tmp1, float* tmp2, int count)
-{
-    sycl::event ek1 = q.submit([&](sycl::handler& h) {
-        h.parallel_for(count, [=](sycl::item<1> item) {
-            int idx = item.get_id(0);
-            tmp1[idx] = src[idx] * 2;
-            });
-        });
-    sycl::event ek2 = q.submit([&](sycl::handler& h) {
-        h.parallel_for(count, [=](sycl::item<1> item) {
-            int idx = item.get_id(0);
-            tmp2[idx] = tmp1[idx] * 3;
-            });
-        });
-    sycl::event ek3 = q.submit([&](sycl::handler& h) {
-        h.parallel_for(count, [=](sycl::item<1> item) {
-            int idx = item.get_id(0);
-            dst[idx] = tmp2[idx] + 11;
-            });
-        });
-}
-
-int test0()
-{
-    sycl::queue q{ sycl::gpu_selector_v, {sycl::property::queue::in_order()}};
-    int count = 128 * 128;
-    float* inp = sycl::malloc_device<float>(count, q);
-    float* outp = sycl::malloc_device<float>(count, q);
-    float* tmp1 = sycl::malloc_device<float>(count, q);
-    float* tmp2 = sycl::malloc_device<float>(count, q);
-    float* inp_h = new float[count];
-    float* outp_h = new float[count];
-    for (size_t i = 0; i < count; ++i) {
-        inp_h[i] = i / 4;
-        outp_h[i] = -1;
-    }
-
-    q.memcpy(inp, inp_h, count * sizeof(float)).wait();
-
-    // record graph
-    sycl::ext::oneapi::experimental::command_graph g{ q.get_context(), q.get_device() };
-    g.begin_recording(q);
-    run1(q, outp, inp, tmp1, tmp2, count);
-    g.end_recording();
-    auto execGraph = g.finalize();
-    q.ext_oneapi_graph(execGraph).wait();
-    q.ext_oneapi_graph(execGraph).wait();
-    q.ext_oneapi_graph(execGraph).wait();
-    q.ext_oneapi_graph(execGraph).wait();
-    q.ext_oneapi_graph(execGraph).wait();
-    q.ext_oneapi_graph(execGraph).wait();
-
-    q.memcpy(outp_h, outp, count * sizeof(float)).wait();
-
-    std::cout << "test finished." << std::endl;
-    return 0;
-}
-
-int main(int argc, char** argv)
-{
-    test0();
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/grf/CMakeLists.txt b/tools/unitrace/test/cpp_test/grf/CMakeLists.txt
deleted file mode 100644
index d3a228fe..00000000
--- a/tools/unitrace/test/cpp_test/grf/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-project(grf CXX)
-
-add_executable(grf grf.cpp)
-add_sycl_to_target(grf)
-
-install(TARGETS grf RUNTIME DESTINATION bin/grf COMPONENT grf)
diff --git a/tools/unitrace/test/cpp_test/grf/gold/linux/d.txt b/tools/unitrace/test/cpp_test/grf/gold/linux/d.txt
deleted file mode 100644
index dd32f1c9..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/linux/d.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):             94801836
-    Total Device Time for L0 backend (ns):              2360080
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-          "main::{lambda(auto:1)#4}",            5,              2091520,    88.620728,               418304,               405280,               466400
-          "main::{lambda(auto:1)#1}",            5,               163840,     6.942138,                32768,                30080,                42720
-          "main::{lambda(auto:1)#3}",            5,                44320,     1.877902,                 8864,                 6560,                17760
-          "main::{lambda(auto:1)#2}",            5,                42400,     1.796549,                 8480,                 8160,                 9440
-"zeCommandListAppendMemoryCopy(H2H)",            1,                18000,     0.762686,                18000,                18000,                18000
-
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-          "main::{lambda(auto:1)#4}",      JIT,   32,                   3,                  0,                         0,                       0,                           256
-          "main::{lambda(auto:1)#1}",      JIT,   32,                   1,                  0,                         0,                       0,                           128
-          "main::{lambda(auto:1)#3}",      JIT,   32,                   3,                  0,                         0,                       0,                           128
-          "main::{lambda(auto:1)#2}",      JIT,   32,                   1,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/grf/gold/linux/h.txt b/tools/unitrace/test/cpp_test/grf/gold/linux/h.txt
deleted file mode 100644
index 64c8ad04..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/linux/h.txt
+++ /dev/null
@@ -1,64 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            103099062
-    Total API Time for L0 backend (ns):             11725615
-Total API Time for CL CPU backend (ns):                31183
-Total API Time for CL GPU backend (ns):                21827
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                zeEventHostSynchronize,           21,              5073570,     43.269115,               241598,                21032,               739787
-       zeCommandListAppendLaunchKernel,           20,              2062609,     17.590626,               103130,                 1681,              1305067
-          zeCommandListCreateImmediate,            3,              1574113,     13.424566,               524704,                88487,              1200091
-           zeContextMakeMemoryResident,            4,               877404,      7.482797,               219351,                 8285,               463170
-                        zeModuleCreate,            1,               862202,      7.353149,               862202,               862202,               862202
-         zeCommandListAppendMemoryCopy,            1,               697712,      5.950323,               697712,               697712,               697712
-                             zeMemFree,           10,               206590,      1.761869,                20659,                 3417,                79034
-                      zeMemAllocShared,            7,               191542,      1.633535,                27363,                18660,                48951
-                      zeMemAllocDevice,            2,                81321,      0.693533,                40660,                12807,                68514
-                        zeMemAllocHost,            3,                35866,      0.305877,                11955,                10112,                14631
-                        zeKernelCreate,            4,                11732,      0.100054,                 2933,                  770,                 5001
-                     zeEventPoolCreate,            1,                 7094,      0.060500,                 7094,                 7094,                 7094
-              zeKernelSetArgumentValue,           40,                 5150,      0.043921,                  128,                   29,                 1392
-                           zeDriverGet,            3,                 4435,      0.037823,                 1478,                   65,                 4039
-        zeDriverGetExtensionProperties,            2,                 4328,      0.036911,                 2164,                 2064,                 2264
-               zeMemGetAllocProperties,            8,                 4263,      0.036356,                  532,                   49,                 2870
-                         zeEventCreate,            2,                 4127,      0.035196,                 2063,                 1015,                 3112
-                      zeEventHostReset,           19,                 3401,      0.029005,                  179,                   55,                 1361
-            zeDeviceGetImageProperties,            2,                 3355,      0.028613,                 1677,                   55,                 3300
-zeDeviceGetCommandQueueGroupProperties,            4,                 3073,      0.026208,                  768,                  211,                 1593
-                 zeDeviceGetProperties,            2,                 2657,      0.022660,                 1328,                  862,                 1795
-           zeDeviceGetModuleProperties,            2,                 1928,      0.016443,                  964,                  424,                 1504
-                  zeKernelSetGroupSize,           20,                 1150,      0.009808,                   57,                   20,                  308
-                       zeContextCreate,            1,                 1108,      0.009449,                 1108,                 1108,                 1108
-     zeDeviceGetMemoryAccessProperties,            1,                  962,      0.008204,                  962,                  962,                  962
-                 zeDeviceGetSubDevices,           16,                  868,      0.007403,                   54,                   20,                  253
-                           zeDeviceGet,            2,                  632,      0.005390,                  316,                  134,                  498
-                 zeDeviceCanAccessPeer,            2,                  599,      0.005108,                  299,                  270,                  329
-                 zeModuleGetProperties,            1,                  512,      0.004367,                  512,                  512,                  512
-             zeKernelSetIndirectAccess,            4,                  473,      0.004034,                  118,                   23,                  304
-                 zeDriverGetProperties,            1,                  439,      0.003744,                  439,                  439,                  439
-          zeDeviceGetComputeProperties,            1,                  350,      0.002985,                  350,                  350,                  350
-                 zeDriverGetApiVersion,            1,                   50,      0.000426,                   50,                   50,                   50
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,          52,               16457,       52.78,                 316,                 135,                3064
-clGetPlatformInfo,          12,               11068,       35.49,                 922,                 257,                6103
-   clGetDeviceIDs,           4,                1413,        4.53,                 353,                 150,                 742
-  clReleaseDevice,           6,                1319,        4.23,                 219,                 121,                 481
-   clRetainDevice,           4,                 926,        2.97,                 231,                 120,                 504
-
-== CL GPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-  clGetDeviceInfo,         108,               16992,       77.85,                 157,                  49,                5048
-   clGetDeviceIDs,           4,                2104,        9.64,                 526,                 195,                1427
-clGetPlatformInfo,          12,                1615,        7.40,                 134,                  48,                 472
-  clReleaseDevice,          12,                 680,        3.12,                  56,                  42,                 105
-   clRetainDevice,           8,                 436,        2.00,                  54,                  44,                  85
-
-
diff --git a/tools/unitrace/test/cpp_test/grf/gold/linux/t.txt b/tools/unitrace/test/cpp_test/grf/gold/linux/t.txt
deleted file mode 100644
index d9d839c4..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/linux/t.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#1}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503185894802 (append) 542503185894802 (submit) 542503186746002 (start) 542503186755442 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#2}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503186853892 (append) 542503186853892 (submit) 542503186866052 (start) 542503186868132 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#3}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503186895542 (append) 542503186895542 (submit) 542503187069462 (start) 542503187073302 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#4}[SIMD32 {256; 1; 1} {128; 1; 1}]" [ns] 542503187090347 (append) 542503187090347 (submit) 542503187099067 (start) 542503187203387 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#1}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187215507 (append) 542503187215507 (submit) 542503187223027 (start) 542503187229907 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#2}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187240306 (append) 542503187240306 (submit) 542503187245426 (start) 542503187247346 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#3}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187257906 (append) 542503187257906 (submit) 542503187263266 (start) 542503187264866 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#4}[SIMD32 {256; 1; 1} {128; 1; 1}]" [ns] 542503187274471 (append) 542503187274471 (submit) 542503187281831 (start) 542503187370471 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#1}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187380248 (append) 542503187380248 (submit) 542503187387528 (start) 542503187394408 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#2}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187403667 (append) 542503187403667 (submit) 542503187408627 (start) 542503187410547 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#3}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187420394 (append) 542503187420394 (submit) 542503187425674 (start) 542503187427274 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#4}[SIMD32 {256; 1; 1} {128; 1; 1}]" [ns] 542503187436407 (append) 542503187436407 (submit) 542503187443527 (start) 542503187532967 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#1}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187542126 (append) 542503187542126 (submit) 542503187548846 (start) 542503187555886 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#2}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187565219 (append) 542503187565219 (submit) 542503187570099 (start) 542503187572019 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#3}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187581964 (append) 542503187581964 (submit) 542503187587164 (start) 542503187588444 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#4}[SIMD32 {256; 1; 1} {128; 1; 1}]" [ns] 542503187597903 (append) 542503187597903 (submit) 542503187604863 (start) 542503187693663 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#1}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187703278 (append) 542503187703278 (submit) 542503187710158 (start) 542503187717198 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#2}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187726390 (append) 542503187726390 (submit) 542503187731350 (start) 542503187733270 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#3}[SIMD32 {512; 1; 1} {64; 1; 1}]" [ns] 542503187743216 (append) 542503187743216 (submit) 542503187748336 (start) 542503187749936 (end)
-Thread 47800 Device 35083984 : "main::{lambda(auto:1)#4}[SIMD32 {256; 1; 1} {128; 1; 1}]" [ns] 542503187759107 (append) 542503187759107 (submit) 542503187765987 (start) 542503187854787 (end)
-Thread 47800 Device 35083984 : "zeCommandListAppendMemoryCopy(H2H)[32768]" [ns] 542503188250621 (append) 542503188250621 (submit) 542503188935021 (start) 542503188941581 (end)
-
diff --git a/tools/unitrace/test/cpp_test/grf/gold/windows/d.txt b/tools/unitrace/test/cpp_test/grf/gold/windows/d.txt
deleted file mode 100644
index 17411324..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/windows/d.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            737455200
-    Total Device Time for L0 backend (ns):            489201137
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                "_ZTSZ4mainEUlT_E2_",            5,            488855103,    99.929260,             97771020,             88786875,            111671354
-                "_ZTSZ4mainEUlT_E1_",            5,               140727,     0.028767,                28145,                17187,                62187
-                "_ZTSZ4mainEUlT_E0_",            5,                82706,     0.016906,                16541,                 3541,                42916
-                 "_ZTSZ4mainEUlT_E_",            5,                75206,     0.015373,                15041,                 4583,                48020
-"zeCommandListAppendMemoryCopy(H2H)",            1,                47395,     0.009688,                47395,                47395,                47395
-
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-                "_ZTSZ4mainEUlT_E2_",      JIT,   32,                   3,                  0,                         0,                       0,                           128
-                "_ZTSZ4mainEUlT_E1_",      JIT,   32,                   3,                  0,                         0,                       0,                           128
-                "_ZTSZ4mainEUlT_E0_",      JIT,   32,                   1,                  0,                         0,                       0,                           128
-                 "_ZTSZ4mainEUlT_E_",      JIT,   32,                   1,                  0,                         0,                       0,                           128
-
diff --git a/tools/unitrace/test/cpp_test/grf/gold/windows/h.txt b/tools/unitrace/test/cpp_test/grf/gold/windows/h.txt
deleted file mode 100644
index 1a866ab1..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/windows/h.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1113239300
-    Total API Time for L0 backend (ns):            802260600
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                zeEventHostSynchronize,           20,            494674600,     61.660084,             24733730,               127700,            114105000
-                        zeModuleCreate,            1,            302878400,     37.753117,            302878400,            302878400,            302878400
-                             zeMemFree,            9,               650100,      0.081034,                72233,                 4800,               280500
-                      zeMemAllocShared,            5,               581300,      0.072458,               116260,                16300,               257900
-         zeCommandListAppendMemoryCopy,            1,               549600,      0.068506,               549600,               549600,               549600
-     zeCommandQueueExecuteCommandLists,           21,               498700,      0.062162,                23747,                 4700,               121700
-          zeCommandListCreateImmediate,            1,               446300,      0.055630,               446300,               446300,               446300
-                   zeCommandListCreate,            1,               338800,      0.042231,               338800,               338800,               338800
-                        zeMemAllocHost,            3,               239000,      0.029791,                79666,                53900,               108300
-                      zeMemAllocDevice,            1,               186600,      0.023259,               186600,               186600,               186600
-           zeContextMakeMemoryResident,            1,               177200,      0.022088,               177200,               177200,               177200
-       zeCommandListAppendLaunchKernel,           20,               174300,      0.021726,                 8715,                 1600,                96800
-                    zeCommandListReset,           21,               167700,      0.020903,                 7985,                  600,                90200
-             zeCommandQueueSynchronize,            4,               165500,      0.020629,                41375,                 2000,               154200
-                  zeCommandQueueCreate,            1,               125900,      0.015693,               125900,               125900,               125900
-                 zeDeviceGetProperties,            1,                96100,      0.011979,                96100,                96100,                96100
-                     zeEventPoolCreate,            1,                69800,      0.008700,                69800,                69800,                69800
-                       zeModuleDestroy,            1,                49100,      0.006120,                49100,                49100,                49100
-                        zeKernelCreate,            4,                26600,      0.003316,                 6650,                 1500,                20300
-                      zeEventHostReset,           19,                26500,      0.003303,                 1394,                  400,                 5500
-              zeKernelSetArgumentValue,           40,                22600,      0.002817,                  565,                    0,                 3400
-                    zeFenceQueryStatus,           21,                20600,      0.002568,                  980,                  200,                 6000
-                  zeCommandListDestroy,            2,                12600,      0.001571,                 6300,                 2400,                10200
-        zeDriverGetExtensionProperties,            2,                10500,      0.001309,                 5250,                 5000,                 5500
-                    zeCommandListClose,           21,                 9000,      0.001122,                  428,                  200,                 1300
-                    zeEventPoolDestroy,            1,                 7600,      0.000947,                 7600,                 7600,                 7600
-                         zeEventCreate,            2,                 7100,      0.000885,                 3550,                 1000,                 6100
-               zeMemGetAllocProperties,            5,                 5400,      0.000673,                 1080,                  300,                 2300
-                       zeContextCreate,            1,                 4700,      0.000586,                 4700,                 4700,                 4700
-                       zeKernelDestroy,            4,                 4600,      0.000573,                 1150,                  700,                 1500
-                  zeKernelSetGroupSize,           20,                 4500,      0.000561,                  225,                    0,                  800
-           zeDeviceGetModuleProperties,            1,                 4100,      0.000511,                 4100,                 4100,                 4100
-zeDeviceGetCommandQueueGroupProperties,            2,                 3500,      0.000436,                 1750,                  500,                 3000
-                        zeEventDestroy,            2,                 3400,      0.000424,                 1700,                  400,                 3000
-                      zeContextDestroy,            1,                 3000,      0.000374,                 3000,                 3000,                 3000
-                           zeDriverGet,            3,                 2600,      0.000324,                  866,                  100,                 1400
-                 zeCommandQueueDestroy,            1,                 2100,      0.000262,                 2100,                 2100,                 2100
-                          zeFenceReset,           21,                 1700,      0.000212,                   80,                    0,                  100
-                 zeDeviceGetSubDevices,           10,                 1600,      0.000199,                  160,                    0,                  600
-               zeModuleBuildLogDestroy,            1,                 1500,      0.000187,                 1500,                 1500,                 1500
-             zeKernelSetIndirectAccess,            4,                 1300,      0.000162,                  325,                    0,                  700
-                        zeFenceDestroy,            1,                  900,      0.000112,                  900,                  900,                  900
-          zeDeviceGetComputeProperties,            1,                  800,      0.000100,                  800,                  800,                  800
-                 zeDriverGetProperties,            1,                  800,      0.000100,                  800,                  800,                  800
-                         zeFenceCreate,            1,                  700,      0.000087,                  700,                  700,                  700
-                           zeDeviceGet,            2,                  400,      0.000050,                  200,                  100,                  300
-                 zeDriverGetApiVersion,            1,                  400,      0.000050,                  400,                  400,                  400
-            zeDeviceGetImageProperties,            1,                  300,      0.000037,                  300,                  300,                  300
-                 zeModuleGetProperties,            1,                  200,      0.000025,                  200,                  200,                  200
-
diff --git a/tools/unitrace/test/cpp_test/grf/gold/windows/t.txt b/tools/unitrace/test/cpp_test/grf/gold/windows/t.txt
deleted file mode 100644
index 42ad57d8..00000000
--- a/tools/unitrace/test/cpp_test/grf/gold/windows/t.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708116686000 (append) 201708117159500 (submit) 201708118998510 (start) 201708119927676 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E0_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708120708500 (append) 201708120901100 (submit) 201708121683287 (start) 201708122747037 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E1_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708123227200 (append) 201708123396000 (submit) 201708124235218 (start) 201708125307093 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 201708126211800 (append) 201708126484500 (submit) 201708127394552 (start) 201708320393406 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708325422800 (append) 201708325690900 (submit) 201708325947618 (start) 201708327754701 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E0_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708327185300 (append) 201708327394900 (submit) 201708327704952 (start) 201708328727556 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E1_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708328919500 (append) 201708329023500 (submit) 201708329146312 (start) 201708330060166 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 201708330232100 (append) 201708330324400 (submit) 201708330434868 (start) 201708557014138 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708557452000 (append) 201708557709200 (submit) 201708558140970 (start) 201708559188886 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E0_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708559428800 (append) 201708559521100 (submit) 201708560094589 (start) 201708561138859 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E1_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708561309800 (append) 201708561415500 (submit) 201708561616750 (start) 201708562528625 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 201708562700500 (append) 201708563006100 (submit) 201708563159537 (start) 201708753492870 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708754061100 (append) 201708754273600 (submit) 201708754494120 (start) 201708755623390 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E0_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708755840000 (append) 201708755937900 (submit) 201708756129722 (start) 201708757334513 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E1_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708757168900 (append) 201708757259100 (submit) 201708757495662 (start) 201708758583578 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 201708758739700 (append) 201708758833400 (submit) 201708759057410 (start) 201708954429493 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708955976700 (append) 201708956291700 (submit) 201708956518939 (start) 201708957525293 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E0_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708957759300 (append) 201708957927200 (submit) 201708958063241 (start) 201708959025532 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E1_[SIMD8 {512; 1; 1} {64; 1; 1}]" [ns] 201708959290900 (append) 201708959471100 (submit) 201708959619172 (start) 201708960873130 (end)
-Thread 25856 Device 3341683576 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 201708961210900 (append) 201708961373900 (submit) 201708961612337 (start) 201709152848482 (end)
-Thread 25856 Device 3341683576 : "zeCommandListAppendMemoryCopy(H2H)[32768]" [ns] 201709207512200 (append) 201709208163600 (submit) 201709208451829 (start) 201709208458391 (end)
-
diff --git a/tools/unitrace/test/cpp_test/grf/grf.cpp b/tools/unitrace/test/cpp_test/grf/grf.cpp
deleted file mode 100644
index 534b4545..00000000
--- a/tools/unitrace/test/cpp_test/grf/grf.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <CL/sycl.hpp>
-#include <iostream>
-#ifdef __linux__
-#include <unistd.h>
-#endif
-
-using namespace sycl;
-int main(){
-    int GLOBAL_SIZE = 64 * 512;
-    queue q{gpu_selector(), {property::queue::in_order()}};
-    float *a = (float *)malloc_shared(sizeof(float) * GLOBAL_SIZE, q);
-    float *b = (float *)malloc_shared(sizeof(float) * GLOBAL_SIZE, q);
-    float *c = (float *)malloc_shared(sizeof(float) * GLOBAL_SIZE, q);
-    float *d = (float *)malloc_host(sizeof(float) * GLOBAL_SIZE, q);
-    float *e = (float *)malloc_host(sizeof(float) * GLOBAL_SIZE, q);
-    for (int i = 0; i < GLOBAL_SIZE; i++) {
-        a[i] = i;
-        b[i] = i;
-        c[i] = 0;
-    }
-    for (int m = 0; m < 5; m++) {
-        int WORKGROUP_SIZE = 64;
-        q.parallel_for(nd_range<1>(GLOBAL_SIZE, WORKGROUP_SIZE), [=](auto i) {
-            int index = i.get_local_id();
-            c[0] = index;
-        }).wait();
-
-        q.parallel_for(nd_range<1>(GLOBAL_SIZE, WORKGROUP_SIZE), [=](auto i) {
-            int index = i.get_group_linear_id();
-            c[0] = index;
-        }).wait();
-
-        q.parallel_for(nd_range<1>(GLOBAL_SIZE, WORKGROUP_SIZE), [=](auto i) {
-            int index = i.get_global_id();
-            c[index] = a[index] + b[index];
-        }).wait();
-
-        //setenv("PTI_ENABLE_COLLECTION", "0", 1);
-
-        WORKGROUP_SIZE = WORKGROUP_SIZE * 2;
-        q.parallel_for(nd_range<1>(GLOBAL_SIZE, WORKGROUP_SIZE), [=](auto i) {
-            int index = i.get_global_id();
-            float f[128];
-
-            float x = a[index];
-            float y = b[index];
-
-            for (int k = 0; k < 20; k++) {
-                for (int i = 0; i < 64; i++) {
-                    f[i] = x + y + i;
-                }
-
-                for (int i = 0; i < 8; i++) {
-                    for (int j = 0; j < 64; j++) {
-                        x = x * f[j];
-                        y = y * f[j];
-                    }
-                }
-                c[index] = x + y;
-            }
-        }).wait();
-    }
-
-    d[0] = -1;
-    e[0] = 0;
-    q.wait();
-
-    q.submit([&](sycl::handler &cgh) {
-        cgh.host_task([=] { std::memcpy(e, d, GLOBAL_SIZE); });
-    });
-    q.wait();
-    q.memcpy(e, d, GLOBAL_SIZE);
-    q.wait();
-
-    q.wait();
-
-    free((void *)a, q);
-    free((void *)b, q);
-    free((void *)c, q);
-
-    return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/CMakeLists.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/CMakeLists.txt
deleted file mode 100644
index f89a34be..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/CMakeLists.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-project(internal_conditional_trace CXX)
-
-add_executable(internal_conditional_trace conditional.cc)
-add_sycl_to_target(internal_conditional_trace)
-
-# Reuse the ITT headers and static library produced by the main unitrace build,
-# so the workload can emit __itt_resume / __itt_pause / __itt_detach.
-# UNITRACE_BUILD_ROOT (forwarded by test_unitrace.py --unitrace-build-dir) takes
-# precedence, so builds outside the standalone tools/unitrace layout (e.g. the
-# repository's top-level build) can point at their unitrace build directory.
-if(DEFINED UNITRACE_BUILD_ROOT)
-  set(UNITRACE_BUILD_DIR "${UNITRACE_BUILD_ROOT}")
-else()
-  set(UNITRACE_BUILD_DIR "${CMAKE_SOURCE_DIR}/../../build")
-endif()
-
-target_include_directories(internal_conditional_trace PRIVATE "${UNITRACE_BUILD_DIR}/ittapi/include")
-
-# The ittnotify static library name/location differs by platform:
-#   Linux:   ${UNITRACE_BUILD_DIR}/libittnotify.a   (also ittapi/bin/libittnotify.a)
-#   Windows: ${UNITRACE_BUILD_DIR}/ittapi/bin/libittnotify.lib
-if(WIN32 AND EXISTS "${UNITRACE_BUILD_DIR}/ittapi/bin/libittnotify.lib")
-  set(ITTNOTIFY_LIB "${UNITRACE_BUILD_DIR}/ittapi/bin/libittnotify.lib")
-elseif(EXISTS "${UNITRACE_BUILD_DIR}/libittnotify.a")
-  set(ITTNOTIFY_LIB "${UNITRACE_BUILD_DIR}/libittnotify.a")
-elseif(EXISTS "${UNITRACE_BUILD_DIR}/ittapi/bin/libittnotify.a")
-  set(ITTNOTIFY_LIB "${UNITRACE_BUILD_DIR}/ittapi/bin/libittnotify.a")
-else()
-  message(FATAL_ERROR "internal_conditional_trace: ittnotify library not found under ${UNITRACE_BUILD_DIR}")
-endif()
-target_link_libraries(internal_conditional_trace PRIVATE "${ITTNOTIFY_LIB}")
-
-if(NOT WIN32)
-  target_link_libraries(internal_conditional_trace PRIVATE dl)
-endif()
-
-# Env-var control path (PTI_ENABLE_COLLECTION = 1/0/-1): works on Linux AND
-# Windows. The "env" argument selects this path; -t points the gold lookup at
-# internal_conditional_trace so it reuses the same gold file.
-
-# ITT-API control path (__itt_resume/pause/detach): works on Linux AND Windows.
-# unitrace_tool.dll exports its __itt_* collector symbols (see
-# WINDOWS_EXPORT_ALL_SYMBOLS in the main CMakeLists), so the statically-linked
-# ittnotify in the app resolves the collector and the control takes effect.
-
-install(TARGETS internal_conditional_trace RUNTIME DESTINATION bin/internal_conditional_trace COMPONENT internal_conditional_trace)
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/conditional.cc b/tools/unitrace/test/cpp_test/internal_conditional_trace/conditional.cc
deleted file mode 100755
index 0f3f4ff9..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/conditional.cc
+++ /dev/null
@@ -1,226 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <string.h>
-#include <cstdlib>
-#include <memory>
-#include <sycl/sycl.hpp>
-#include <ittnotify.h>
-
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-// Collection-control mechanism. By default the test drives unitrace through the
-// ITT API (__itt_resume/__itt_pause/__itt_detach). With the "env" command-line
-// option it instead writes the PTI_ENABLE_COLLECTION environment variable, the
-// env-based form of the same in-application control:
-//   resume -> "1"   pause -> "0"   stop/detach -> "-1"
-// Both produce the same captured kernel count, so they share the -d gold file.
-static bool g_use_env = false;
-
-static void SetCollectionEnv(const char* value) {
-#if defined(_WIN32)
-  _putenv_s("PTI_ENABLE_COLLECTION", value);
-#else
-  setenv("PTI_ENABLE_COLLECTION", value, 1);
-#endif
-}
-
-static void CollectionResume() {
-  if (g_use_env) { SetCollectionEnv("1"); } else { __itt_resume(); }
-}
-
-static void CollectionPause() {
-  if (g_use_env) { SetCollectionEnv("0"); } else { __itt_pause(); }
-}
-
-static void CollectionStop() {
-  if (g_use_env) { SetCollectionEnv("-1"); } else { __itt_detach(); }
-}
-
-static float Check(const std::vector<float>& a, float value) {
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += std::abs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-// iterations is a runtime value (threaded down from main via a kernel argument)
-// so the JIT compiler cannot elide the outer loop. Each pass recomputes the
-// exact same dot product and only the last one is written out, so the numeric
-// result is identical to a single pass -- this lengthens the kernel's device
-// execution time without changing its result, launch dimensions or call count.
-void GEMM(const float* a, const float* b, float* c,
-          unsigned size, unsigned iterations, sycl::id<2> id) {
-  int i = id.get(0);
-  int j = id.get(1);
-  float sum = 0.0f;
-  for (unsigned it = 0; it < iterations; ++it) {
-    sum = 0.0f;
-    for (unsigned k = 0; k < size; ++k) {
-      sum += a[i * size + k] * b[k * size + j];
-    }
-  }
-  c[i * size + j] = sum;
-}
-
-static float RunAndCheck(sycl::queue queue,
-                         const std::vector<float>& a,
-                         const std::vector<float>& b,
-                         std::vector<float>& c,
-                         unsigned size,
-                         unsigned iterations,
-                         float expected_result) {
-  double time = 0.0;
-
-   {
-    sycl::buffer<float, 1> a_buf(a.data(), a.size());
-    sycl::buffer<float, 1> b_buf(b.data(), b.size());
-    sycl::buffer<float, 1> c_buf(c.data(), c.size());
-
-    sycl::event event = queue.submit([&](sycl::handler& cgh) {
-      auto a_acc = a_buf.get_access<sycl::access::mode::read>(cgh);
-      auto b_acc = b_buf.get_access<sycl::access::mode::read>(cgh);
-      auto c_acc = c_buf.get_access<sycl::access::mode::write>(cgh);
-
-      cgh.parallel_for<class __GEMM>(sycl::range<2>(size, size),
-                      [=](sycl::id<2> id) {
-                        auto a_acc_ptr = a_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        auto b_acc_ptr = b_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        auto c_acc_ptr = c_acc.get_multi_ptr<sycl::access::decorated::no>();
-                        GEMM(a_acc_ptr.get(),
-                             b_acc_ptr.get(),
-                             c_acc_ptr.get(),
-                             size, iterations, id);
-                      });
-    });
-    queue.wait_and_throw();
-
-    auto start =
-      event.get_profiling_info<sycl::info::event_profiling::command_start>();
-    auto end =
-      event.get_profiling_info<sycl::info::event_profiling::command_end>();
-    time = static_cast<double>(end - start);
-  } /*catch (sycl::exception e) {
-    std::cout << "[ERROR] " << e.what() << std::endl;
-  }*/
-
-  std::cout << "Matrix multiplication time: " << time <<
-    " ns" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(sycl::queue queue,
-                    const std::vector<float>& a,
-                    const std::vector<float>& b,
-                    std::vector<float>& c,
-                    unsigned size,
-                    unsigned repeat_count,
-                    unsigned iterations,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, iterations, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-  CollectionResume();
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, iterations, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-  CollectionPause();
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, iterations, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-  CollectionResume();
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, iterations, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-  CollectionStop();
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    float eps = RunAndCheck(queue, a, b, c, size, iterations, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-}
-
-int main(int argc, char* argv[]) {
-  // Scan for the "env" option anywhere on the command line: it selects the
-  // PTI_ENABLE_COLLECTION env-var control path instead of the ITT API. Scanning
-  // (rather than consuming a fixed position) keeps the existing positional
-  // device/size/repeat arguments intact.
-  for (int i = 1; i < argc; ++i) {
-    if (strcmp(argv[i], "env") == 0) {
-      g_use_env = true;
-    }
-  }
-  std::cout << "Collection control: " << (g_use_env ? "PTI_ENABLE_COLLECTION env"
-                                                    : "ITT API") << std::endl;
-
-  sycl::device dev;
-  {
-    dev = sycl::device(sycl::gpu_selector_v);
-    if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-      dev = sycl::device(sycl::cpu_selector_v);
-    } else if (argc > 1 && strcmp(argv[1], "host") == 0) {
-      dev = sycl::device(sycl::default_selector_v);
-    }
-  }
-
-  unsigned size = 1024;
-  if (argc > 2) {
-    size = std::stoul(argv[2]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 3) {
-    repeat_count = std::stoul(argv[3]);
-  }
-
-  // Number of times each GEMM work-item recomputes its dot product. This
-  // lengthens the on-device execution time of every __GEMM kernel without
-  // altering the kernel launch dimensions, the number of kernels, or the
-  // numeric result, so the existing device timing/timeline gold files stay
-  // valid. Overridable as the 4th positional argument. Note the "env"
-  // control option is scanned for separately above, so it does not shift
-  // these positional slots.
-  unsigned iterations = 16;
-  if (argc > 4 && strcmp(argv[4], "env") != 0) {
-    iterations = std::stoul(argv[4]);
-  }
-
-  sycl::property_list prop_list{sycl::property::queue::enable_profiling()};
-  sycl::queue queue(dev, sycl::async_handler{}, prop_list);
-
-  std::cout << "DPC++ Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " <<
-    queue.get_info<sycl::info::queue::device>().get_info<
-        sycl::info::device::name>() << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(queue, a, b, c, size, repeat_count, iterations, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " sec" << std::endl;
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/d.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/d.txt
deleted file mode 100644
index f3bd1e22..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/d.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            191099798
-    Total Device Time for L0 backend (ns):             43633469
-
-== L0 Backend ==
-
-                                                                                                                                                                                                                                                                                 Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM",            8,             33509788,    76.798363,              4188723,              4182083,              4192187
-                                                                                                                                                                                                                                                   "zeCommandListAppendMemoryCopy(M2D)",           24,              7754934,    17.772903,               323122,               307708,               339062
-                                                                                                                                                                                                                                                   "zeCommandListAppendMemoryCopy(D2M)",            8,              2368747,     5.428739,               296093,               295625,               297239
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/h.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/h.txt
deleted file mode 100644
index c161fca6..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/h.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            187638212
-    Total API Time for L0 backend (ns):             51318209
-
-== L0 Backend ==
-
-                                    Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                zeCommandListHostSynchronize,           32,             33523572,     65.324905,              1047611,                  178,              4192905
-               zeCommandListAppendMemoryCopy,           32,             11401225,     22.216724,               356288,               326331,               406947
-                      zeEventHostSynchronize,           96,              6120355,     11.926284,                63753,                   59,               657146
-                 zeDeviceGetGlobalTimestamps,            8,               155557,      0.303122,                19444,                17054,                24260
-zeCommandListAppendLaunchKernelWithArguments,            8,                71899,      0.140104,                 8987,                 5865,                10457
-                 zeEventQueryKernelTimestamp,           16,                35494,      0.069165,                 2218,                 1996,                 2626
-                    zeKernelSuggestGroupSize,            8,                 4457,      0.008685,                  557,                  404,                  605
-       zeCommandListIsGraphCaptureEnabledExp,           40,                 3928,      0.007654,                   98,                   26,                  292
-                        zeKernelSetGroupSize,            8,                 1722,      0.003356,                  215,                  139,                  241
-
-
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/t.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/t.txt
deleted file mode 100644
index 6a4738a3..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/linux/t.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839156517731 (append) 4839156517731 (submit) 4839156673095 (start) 4839156989292 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839156866652 (append) 4839156866652 (submit) 4839157034881 (start) 4839157348526 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839157217105 (append) 4839157217105 (submit) 4839157407365 (start) 4839157742365 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839157771653 (append) 4839157771653 (submit) 4839157786757 (start) 4839161983632 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839162037306 (append) 4839162037306 (submit) 4839162529024 (start) 4839162824961 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839163680319 (append) 4839163680319 (submit) 4839163853496 (start) 4839164177037 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839164047350 (append) 4839164047350 (submit) 4839164219537 (start) 4839164532974 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839164400566 (append) 4839164400566 (submit) 4839164577961 (start) 4839164894158 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839164920873 (append) 4839164920873 (submit) 4839164935664 (start) 4839169124414 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839169163315 (append) 4839169163315 (submit) 4839169523471 (start) 4839169819304 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839170553836 (append) 4839170553836 (submit) 4839170708575 (start) 4839171029356 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839170899869 (append) 4839170899869 (submit) 4839171083566 (start) 4839171402941 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839171271577 (append) 4839171271577 (submit) 4839171441785 (start) 4839171749753 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839171777114 (append) 4839171777114 (submit) 4839171791853 (start) 4839175982165 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839176028184 (append) 4839176028184 (submit) 4839176406725 (start) 4839176702662 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839177276434 (append) 4839177276434 (submit) 4839177427059 (start) 4839177755079 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839177622804 (append) 4839177622804 (submit) 4839177794522 (start) 4839178102647 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839177974713 (append) 4839177974713 (submit) 4839178152369 (start) 4839178459869 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839178485866 (append) 4839178485866 (submit) 4839178499720 (start) 4839182685345 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839182775619 (append) 4839182775619 (submit) 4839183181660 (start) 4839183477285 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839210705096 (append) 4839210705096 (submit) 4839210889731 (start) 4839211250356 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839211123278 (append) 4839211123278 (submit) 4839211293225 (start) 4839211606818 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839211475521 (append) 4839211475521 (submit) 4839211648489 (start) 4839211964426 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839211990336 (append) 4839211990336 (submit) 4839212006533 (start) 4839216200283 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839216245296 (append) 4839216245296 (submit) 4839216812379 (start) 4839217108420 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839217961538 (append) 4839217961538 (submit) 4839218152840 (start) 4839218494037 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839218367447 (append) 4839218367447 (submit) 4839218543905 (start) 4839218862863 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839218732855 (append) 4839218732855 (submit) 4839218902282 (start) 4839219218323 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839219242633 (append) 4839219242633 (submit) 4839219258310 (start) 4839223453830 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839223504666 (append) 4839223504666 (submit) 4839224012478 (start) 4839224308988 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839225071930 (append) 4839225071930 (submit) 4839225263700 (start) 4839225622450 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839225497408 (append) 4839225497408 (submit) 4839225688918 (start) 4839226021834 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839225890909 (append) 4839225890909 (submit) 4839226083148 (start) 4839226397314 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839226422896 (append) 4839226422896 (submit) 4839226439510 (start) 4839230636593 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839230680317 (append) 4839230680317 (submit) 4839231094587 (start) 4839231391045 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839232156332 (append) 4839232156332 (submit) 4839232336436 (start) 4839232683519 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839232557022 (append) 4839232557022 (submit) 4839232750928 (start) 4839233070823 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 4839232940030 (append) 4839232940030 (submit) 4839233113363 (start) 4839233425967 (end)
-Thread 17368 Device 1020122840 : "RunAndCheck(sycl::_V1::queue, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> > const&, std::vector<float, std::allocator<float> >&, unsigned int, float)::{lambda(sycl::_V1::handler&)#1}::operator()(sycl::_V1::handler&) const::__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 4839233450887 (append) 4839233450887 (submit) 4839233467032 (start) 4839237656927 (end)
-Thread 17368 Device 1020122840 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 4839237701790 (append) 4839237701790 (submit) 4839238115175 (start) 4839238411216 (end)
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/d.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/d.txt
deleted file mode 100644
index 23be89bd..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/d.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            268117100
-    Total Device Time for L0 backend (ns):             39227224
-
-== L0 Backend ==
-
-                                                                                                Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM",            8,             29395725,    74.937050,              3674465,              3670625,              3679062
-                                                                  "zeCommandListAppendMemoryCopy(M2D)",           24,              7396397,    18.855265,               308183,               306093,               311041
-                                                                  "zeCommandListAppendMemoryCopy(D2M)",            8,              2435102,     6.207684,               304387,               304270,               304479
diff --git a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/t.txt b/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/t.txt
deleted file mode 100644
index d7cc54e0..00000000
--- a/tools/unitrace/test/cpp_test/internal_conditional_trace/gold/windows/t.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114128289800 (append) 2114128289800 (submit) 2114128417612 (start) 2114128736570 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114128583000 (append) 2114128583000 (submit) 2114128740187 (start) 2114129050447 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114128776000 (append) 2114128776000 (submit) 2114129052145 (start) 2114129360634 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114129404800 (append) 2114129404800 (submit) 2114129434383 (start) 2114133110841 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114142112900 (append) 2114142112900 (submit) 2114142380139 (start) 2114142685139 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114143238100 (append) 2114143238100 (submit) 2114143328620 (start) 2114143640495 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114143420400 (append) 2114143420400 (submit) 2114143643837 (start) 2114143964462 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114143642300 (append) 2114143642300 (submit) 2114143968289 (start) 2114144513341 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114144945800 (append) 2114144945800 (submit) 2114145045279 (start) 2114148736737 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114149037600 (append) 2114149037600 (submit) 2114149690464 (start) 2114149994839 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114150894200 (append) 2114150894200 (submit) 2114150997793 (start) 2114151307011 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114151101400 (append) 2114151101400 (submit) 2114151310202 (start) 2114151619577 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114151310500 (append) 2114151310500 (submit) 2114151622895 (start) 2114151929405 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114151964100 (append) 2114151964100 (submit) 2114151991391 (start) 2114155670453 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114155741600 (append) 2114155741600 (submit) 2114156116183 (start) 2114156420662 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114157199500 (append) 2114157199500 (submit) 2114157440072 (start) 2114157750072 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114157597600 (append) 2114157597600 (submit) 2114157753120 (start) 2114158060724 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114157910500 (append) 2114157910500 (submit) 2114158064145 (start) 2114158371332 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114158422800 (append) 2114158422800 (submit) 2114158462279 (start) 2114162138216 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114162195600 (append) 2114162195600 (submit) 2114162571433 (start) 2114162875755 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114187494500 (append) 2114187494500 (submit) 2114187609031 (start) 2114187919031 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114187762700 (append) 2114187762700 (submit) 2114187921970 (start) 2114188230563 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114187920800 (append) 2114187920800 (submit) 2114188232206 (start) 2114188540747 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114188586300 (append) 2114188586300 (submit) 2114188611977 (start) 2114192280935 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114192391600 (append) 2114192391600 (submit) 2114192864256 (start) 2114193168474 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114193797300 (append) 2114193797300 (submit) 2114193907820 (start) 2114194217507 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114194010900 (append) 2114194010900 (submit) 2114194220847 (start) 2114194531003 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114194219400 (append) 2114194219400 (submit) 2114194534347 (start) 2114194841065 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114194873500 (append) 2114194873500 (submit) 2114194905270 (start) 2114198575061 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114198660200 (append) 2114198660200 (submit) 2114198966293 (start) 2114199270511 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114199815000 (append) 2114199815000 (submit) 2114199904791 (start) 2114200215468 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114199983800 (append) 2114199983800 (submit) 2114200218539 (start) 2114200527966 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114200215700 (append) 2114200215700 (submit) 2114200531116 (start) 2114200837730 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114200860400 (append) 2114200860400 (submit) 2114200897743 (start) 2114204571805 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114204631700 (append) 2114204631700 (submit) 2114204979668 (start) 2114205284199 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114205867800 (append) 2114205867800 (submit) 2114205969258 (start) 2114206279674 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114206069700 (append) 2114206069700 (submit) 2114206283137 (start) 2114206592199 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 2114206281500 (append) 2114206281500 (submit) 2114206595354 (start) 2114206924937 (end)
-Thread 6704 Device 549800075240 : "_ZTSZZL11RunAndCheckN4sycl3_V15queueERKSt6vectorIfSaIfEES6_RS4_jfENKUlRNS0_7handlerEE_clES9_E6__GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 2114207003100 (append) 2114207003100 (submit) 2114207041902 (start) 2114210717318 (end)
-Thread 6704 Device 549800075240 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 2114210818400 (append) 2114210818400 (submit) 2114211339650 (start) 2114211643972 (end)
diff --git a/tools/unitrace/test/cpp_test/metric_config/CMakeLists.txt b/tools/unitrace/test/cpp_test/metric_config/CMakeLists.txt
deleted file mode 100644
index c29a9234..00000000
--- a/tools/unitrace/test/cpp_test/metric_config/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-project(config_node_test CXX)
-
-# Unit test of the --metric-config file parser; needs no GPU.
-add_executable(config_node_test config_node_test.cpp)
-target_compile_features(config_node_test PRIVATE cxx_std_17)
-target_include_directories(config_node_test PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils")
-# The shipped example must stay valid.
-target_compile_definitions(config_node_test PRIVATE
-  EXAMPLE_METRIC_CONFIG="${CMAKE_CURRENT_SOURCE_DIR}/../../../examples/metricconfig/metric_config.txt")
-
-install(TARGETS config_node_test RUNTIME DESTINATION bin/metric_config COMPONENT config_node_test)
diff --git a/tools/unitrace/test/cpp_test/metric_config/check_config_node.py b/tools/unitrace/test/cpp_test/metric_config/check_config_node.py
deleted file mode 100644
index 90c6862b..00000000
--- a/tools/unitrace/test/cpp_test/metric_config/check_config_node.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Run the --metric-config parser unit test (config_node_test). No GPU needed.
-
-import os
-import platform
-import subprocess
-import sys
-
-
-def main():
-    if len(sys.argv) != 2:
-        print(f"[ERROR] usage: {sys.argv[0]} <test-bin-dir>", file=sys.stderr)
-        return 1
-    name = "config_node_test.exe" if platform.system() == "Windows" else "config_node_test"
-    binary = os.path.join(sys.argv[1], "metric_config", name)
-    if not os.path.exists(binary):
-        print(f"[ERROR] {binary} not found", file=sys.stderr)
-        return 1
-    return subprocess.run([binary]).returncode
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/test/cpp_test/metric_config/config_node_test.cpp b/tools/unitrace/test/cpp_test/metric_config/config_node_test.cpp
deleted file mode 100644
index ca1ba5fc..00000000
--- a/tools/unitrace/test/cpp_test/metric_config/config_node_test.cpp
+++ /dev/null
@@ -1,353 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-// Unit test of the --metric-config file parser (config_node.h).
-
-#include <cstdio>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "config_node.h"
-#include "metric_config_validator.h"
-
-static int failures = 0;
-
-#define CHECK(cond)                                                              \
-  do {                                                                           \
-    if (!(cond)) {                                                               \
-      std::cerr << "[FAILED] " << __FILE__ << ":" << __LINE__ << ": " #cond      \
-                << std::endl;                                                    \
-      ++failures;                                                                \
-    }                                                                            \
-  } while (0)
-
-static std::string TempPath(const std::string& name) {
-  return (std::filesystem::temp_directory_path() / ("unitrace_config_node_test_" + name)).string();
-}
-
-static std::string WriteText(const std::string& text) {
-  std::string path = TempPath("load.txt");
-  std::ofstream out(path, std::ios::trunc);
-  out << text;
-  return path;
-}
-
-static ConfigNodePtr LoadText(const std::string& text, std::string* error = nullptr) {
-  std::string path = WriteText(text);
-  std::string err;
-  ConfigNodePtr node = ConfigNode::load(path, err);
-  std::filesystem::remove(path);
-  if (error != nullptr) {
-    *error = err;
-  }
-  return node;
-}
-
-// Loads and validates text; returns the error with the temp file name replaced by "F".
-static std::string ValidateText(const std::string& text, uint32_t cli_groups = 0) {
-  std::string path = WriteText(text);
-  std::string error;
-  ConfigNodePtr node = metric_config::Load(path, cli_groups, error);
-  std::filesystem::remove(path);
-  if (node != nullptr) {
-    return "";
-  }
-  if (error.compare(0, path.size(), path) == 0) {
-    error = "F" + error.substr(path.size());
-  }
-  return error;
-}
-
-static bool StartsWith(const std::string& s, const std::string& prefix) {
-  return s.compare(0, prefix.size(), prefix) == 0;
-}
-
-static std::vector<uint64_t> Values(const U64RangeListAttribute& attr) {
-  std::vector<uint64_t> values;
-  uint64_t v = attr.getMin();
-  do {
-    values.push_back(v);
-  } while (attr.getNext(v, v) && values.size() < 1000);
-  return values;
-}
-
-static std::vector<uint64_t> RangeValues(const std::string& str) {
-  auto ranges = U64Range::fromString(str);
-  if (ranges.empty()) {
-    return {};
-  }
-  return Values(U64RangeListAttribute("x", ranges));
-}
-
-static void TestValidConfig() {
-  ConfigNodePtr root = LoadText(
-      "# full-line comment\n"
-      "predefined{\n"
-      "    ComputeBasic{\n"
-      "        enable=true   # inline comment\n"
-      "    }\n"
-      "}\n"
-      "programmable{\n"
-      "    METRIC_A{\n"
-      "        enable = false\n"
-      "        parameters{\n"
-      "            Count=7\n"
-      "            Ratio=0.5\n"
-      "            Offset=-3\n"
-      "            Label='a # b'\n"
-      "            Disaggregation=[0,1,2,10:12]\n"
-      "        }\n"
-      "    }\n"
-      "}\n");
-  CHECK(root != nullptr);
-  if (root == nullptr) {
-    return;
-  }
-  CHECK(root->getChildren().size() == 2);
-
-  auto predef = root->findChildByName("predefined");
-  CHECK(predef != nullptr);
-  auto group = predef->findChildByName("ComputeBasic");
-  CHECK(group != nullptr);
-  auto enable = std::dynamic_pointer_cast<BoolAttribute>(group->findAttributeByKey("enable"));
-  CHECK(enable != nullptr && enable->getTypedValue());
-
-  auto metric = root->findChildByName("programmable")->findChildByName("METRIC_A");
-  CHECK(metric != nullptr);
-  auto disabled = std::dynamic_pointer_cast<BoolAttribute>(metric->findAttributeByKey("enable"));
-  CHECK(disabled != nullptr && !disabled->getTypedValue());
-
-  auto params = metric->findChildByName("parameters");
-  CHECK(params != nullptr);
-  CHECK(params->getAttributes().size() == 5);
-  CHECK(params->findAttributeByKey("Count")->getType() == AttributeType::UNSIGNED_64);
-  CHECK(params->findAttributeByKey("Count")->getValue() == "7");
-  CHECK(params->findAttributeByKey("Ratio")->getType() == AttributeType::DOUBLE);
-  CHECK(params->findAttributeByKey("Offset")->getType() == AttributeType::INT);
-  CHECK(params->findAttributeByKey("Label")->getType() == AttributeType::STRING);
-  CHECK(params->findAttributeByKey("Label")->getValue() == "a # b");
-
-  auto range = std::dynamic_pointer_cast<U64RangeListAttribute>(params->findAttributeByKey("Disaggregation"));
-  CHECK(range != nullptr);
-  if (range != nullptr) {
-    CHECK(Values(*range) == (std::vector<uint64_t>{0, 1, 2, 10, 11, 12}));
-    CHECK(range->getValue() == "[0,1,2,10:12]");
-  }
-}
-
-static void TestInvalidConfig() {
-  CHECK(LoadText("a{\n") == nullptr);                    // unmatched opening bracket
-  CHECK(LoadText("}\n") == nullptr);                     // unmatched closing bracket
-  CHECK(LoadText("a{\n  novalue\n}\n") == nullptr);      // no '='
-  CHECK(LoadText("a{\n  x=\n}\n") == nullptr);           // empty value
-  CHECK(LoadText("a{\n  =1\n}\n") == nullptr);           // empty key
-  CHECK(LoadText("a{\n  x=12abc\n}\n") == nullptr);      // trailing garbage
-  CHECK(LoadText("a{\n  x=1.5abc\n}\n") == nullptr);
-  CHECK(LoadText("a{\n  x=-4x\n}\n") == nullptr);
-  CHECK(LoadText("a{\n  x=[1,,2]\n}\n") == nullptr);     // empty range item
-  CHECK(LoadText("a{\n  x=[]\n}\n") == nullptr);
-  CHECK(LoadText("a{\n  x=[3:1]\n}\n") == nullptr);      // min > max
-  CHECK(LoadText("a{\n  x=[0:4:0]\n}\n") == nullptr);    // zero step
-  CHECK(LoadText("a{\n  x=[0:5,3]\n}\n") == nullptr);    // overlapping
-  CHECK(LoadText("a{\n  x=[-1]\n}\n") == nullptr);       // negative
-  CHECK(LoadText("a{\n  x=[1:2:3:4]\n}\n") == nullptr);  // too many fields
-  CHECK(ConfigNode::load(TempPath("does_not_exist.txt")) == nullptr);
-}
-
-static void TestErrorMessages() {
-  std::string error;
-  CHECK(LoadText("a{\n  x=12abc\n}\n", &error) == nullptr);
-  CHECK(error.find(":2: invalid value '12abc' for 'x'") != std::string::npos);
-  CHECK(LoadText("a{\n b{\n }\n", &error) == nullptr);
-  CHECK(error.find(":1: 'a{' is not closed") != std::string::npos);
-  CHECK(LoadText("}\n", &error) == nullptr);
-  CHECK(error.find(":1: '}' without a matching '{'") != std::string::npos);
-  CHECK(LoadText("a b{\n}\n", &error) == nullptr);
-  CHECK(error.find(":1: invalid node name 'a b'") != std::string::npos);
-  CHECK(LoadText("a{\n x=[1:3\n}\n", &error) == nullptr);
-  CHECK(error.find(":2: invalid range list '[1:3' for 'x'") != std::string::npos);
-  CHECK(ConfigNode::load(TempPath("does_not_exist.txt"), error) == nullptr);
-  CHECK(error.find("cannot open file") != std::string::npos);
-
-  // Line numbers are recorded.
-  ConfigNodePtr root = LoadText("\n# c\nprogrammable{\n  M{\n    enable=true\n  }\n}\n");
-  CHECK(root != nullptr);
-  if (root != nullptr) {
-    auto m = root->findChildByName("programmable")->findChildByName("M");
-    CHECK(m->getLine() == 4);
-    CHECK(m->findAttributeByKey("enable")->getLine() == 5);
-  }
-}
-
-static void TestValidation() {
-  const std::string ok_prog = "programmable{\n M{\n  enable=true\n  parameters{\n   P=[0:3]\n   Q=1\n  }\n }\n}\n";
-  CHECK(ValidateText(ok_prog) == "");
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n }\n H{\n  enable=false\n }\n}\n") == "");
-  CHECK(ValidateText("predefined{\n G{\n }\n}\n", 1) == "");  // -g group, nothing enabled in file
-  // Several programmable metrics are collected as one group.
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n }\n N{\n  enable=true\n }\n}\n") == "");
-
-  CHECK(ValidateText("") == "F: no 'predefined' or 'programmable' node found");
-  CHECK(ValidateText("x=1\n") == "F:1: 'x' must be inside a 'predefined' or 'programmable' node");
-  CHECK(ValidateText("metrics{\n}\n") == "F:1: unknown node 'metrics' (expected 'predefined' or 'programmable')");
-  CHECK(ValidateText("predefined{\n}\npredefined{\n}\n") == "F:3: duplicate 'predefined' node (first at line 1)");
-  CHECK(ValidateText("predefined{\n enable=true\n}\n") ==
-        "F:2: 'enable' must be inside a predefined group node of 'predefined'");
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n }\n G{\n }\n}\n") ==
-        "F:5: duplicate predefined group 'G' (first at line 2)");
-  CHECK(ValidateText("predefined{\n G{\n  enable=1\n }\n}\n") ==
-        "F:3: 'enable' of predefined group 'G' must be true or false, found '1'");
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n  enable=true\n }\n}\n") ==
-        "F:4: duplicate 'enable' in predefined group 'G'");
-  CHECK(ValidateText("predefined{\n G{\n  enabled=true\n }\n}\n") ==
-        "F:3: unknown attribute 'enabled' in predefined group 'G' (only 'enable' is allowed)");
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n  parameters{\n  }\n }\n}\n") ==
-        "F:4: unexpected node 'parameters' in predefined group 'G' (only 'enable' is allowed)");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  P=1\n }\n}\n") ==
-        "F:4: unknown attribute 'P' in programmable metric 'M' (only 'enable' is allowed, parameters go into a 'parameters' node)");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  params{\n  }\n }\n}\n") ==
-        "F:4: unexpected node 'params' in programmable metric 'M' (only 'parameters' is allowed)");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n  }\n  parameters{\n  }\n }\n}\n") ==
-        "F:6: duplicate 'parameters' node in programmable metric 'M'");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n   P=1\n   P=2\n  }\n }\n}\n") ==
-        "F:6: duplicate parameter 'P' of 'M' (first set at line 5)");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n   P=[0:1]\n   Q=[2,3]\n  }\n }\n}\n") ==
-        "F:6: only one parameter of 'M' can be a range list ('P' at line 5 is one already)");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n   P='x'\n  }\n }\n}\n") ==
-        "F:5: parameter 'P' of 'M': string values are not supported");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n   P=-1\n  }\n }\n}\n") ==
-        "F:5: parameter 'P' of 'M': negative values are not supported");
-  CHECK(ValidateText("programmable{\n M{\n  enable=true\n  parameters{\n   S{\n   }\n  }\n }\n}\n") ==
-        "F:5: unexpected node 'S' in 'parameters' of 'M' (only <name>=<value> lines are allowed)");
-
-  CHECK(ValidateText("predefined{\n G{\n  enable=false\n }\n}\n") ==
-        "F: no metric group or programmable metric is enabled (set enable=true)");
-  // Several enabled groups are accepted here (one file can serve several devices);
-  // CreateMetricGroups checks that exactly one is left per device.
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n }\n H{\n  enable=true\n }\n}\n") == "");
-  CHECK(ValidateText("predefined{\n G{\n  enable=true\n }\n}\n" + ok_prog) == "");
-  CHECK(ValidateText(ok_prog, 1) == "");
-
-  // Syntax errors are reported by Load as well.
-  CHECK(StartsWith(ValidateText("predefined{\n"), "F:1: 'predefined{' is not closed"));
-
-  CHECK(metric_config::CountGroups("") == 0);
-  CHECK(metric_config::CountGroups("A") == 1);
-  CHECK(metric_config::CountGroups("A,B") == 2);
-}
-
-static void TestExampleFile() {
-  std::string error;
-  ConfigNodePtr root = metric_config::Load(EXAMPLE_METRIC_CONFIG, 0, error);
-  if (root == nullptr) {
-    std::cerr << "[FAILED] example: " << error << std::endl;
-  }
-  CHECK(root != nullptr);
-}
-
-static void TestRanges() {
-  CHECK(RangeValues("5") == (std::vector<uint64_t>{5}));
-  CHECK(RangeValues("0:3") == (std::vector<uint64_t>{0, 1, 2, 3}));
-  CHECK(RangeValues("0:16:4") == (std::vector<uint64_t>{0, 4, 8, 12, 16}));
-  // The end of a stepped range is not a value unless it is on the step.
-  CHECK(RangeValues("0:9:4") == (std::vector<uint64_t>{0, 4, 8}));
-  CHECK(RangeValues("0:9:4,20") == (std::vector<uint64_t>{0, 4, 8, 20}));
-  CHECK(RangeValues(" 1 , 3 : 4 ") == (std::vector<uint64_t>{1, 3, 4}));
-  CHECK(RangeValues("18446744073709551614:18446744073709551615") ==
-        (std::vector<uint64_t>{18446744073709551614ull, 18446744073709551615ull}));
-  CHECK(RangeValues("0:18446744073709551615:18446744073709551615") ==
-        (std::vector<uint64_t>{0, 18446744073709551615ull}));
-  CHECK(U64Range::fromString("18446744073709551616").empty());  // overflow
-  CHECK(U64Range::fromString("1,").empty());
-  CHECK(U64Range::fromString("+1").empty());
-}
-
-// Decimals must survive save/load exactly: generated defaults are compared exactly
-// against the values the driver reports.
-static void TestDoubleRoundTrip() {
-  const std::vector<double> values = {1.0 / 3, 1e-7, static_cast<double>(0.1f), 0.1, 1.0, 0.0, -0.5,
-                                      1e20, 123456789.125, 2.5e-300, 1.7976931348623157e308};
-  ConfigNodePtr root = std::make_shared<ConfigNode>("");
-  ConfigNodePtr node = std::make_shared<ConfigNode>("n");
-  root->addChild(node);
-  for (size_t i = 0; i < values.size(); ++i) {
-    auto attr = std::make_shared<DoubleAttribute>("v" + std::to_string(i), values[i]);
-    CHECK(attr->getValue().find('.') != std::string::npos);  // read back as a decimal
-    node->addAttribute(attr);
-  }
-  CHECK(DoubleAttribute("x", 1.0 / 3).getValue() == "0.3333333333333333");
-  CHECK(DoubleAttribute("x", 0.5).getValue() == "0.5");
-  CHECK(DoubleAttribute("x", 1.0).getValue() == "1.0");
-  CHECK(DoubleAttribute("x", 1e20).getValue() == "1.0e+20");
-
-  std::string path = TempPath("doubles.txt");
-  CHECK(ConfigNode::save(root, path));
-  std::string error;
-  ConfigNodePtr loaded = ConfigNode::load(path, error);
-  std::filesystem::remove(path);
-  CHECK(loaded != nullptr);
-  if (loaded == nullptr) {
-    std::cerr << error << std::endl;
-    return;
-  }
-  auto lnode = loaded->findChildByName("n");
-  for (size_t i = 0; i < values.size(); ++i) {
-    auto attr = std::dynamic_pointer_cast<DoubleAttribute>(lnode->findAttributeByKey("v" + std::to_string(i)));
-    CHECK(attr != nullptr && attr->getTypedValue() == values[i]);
-  }
-}
-
-static void TestSaveLoadRoundTrip() {
-  ConfigNodePtr root = std::make_shared<ConfigNode>("");
-  ConfigNodePtr prog = std::make_shared<ConfigNode>("programmable");
-  ConfigNodePtr metric = std::make_shared<ConfigNode>("METRIC_B");
-  ConfigNodePtr params = std::make_shared<ConfigNode>("parameters");
-  root->addChild(prog);
-  prog->addChild(metric);
-  metric->addAttribute(std::make_shared<BoolAttribute>("enable", true, "Supported sampling types: time_based"));
-  metric->addChild(params);
-  params->addAttribute(std::make_shared<UInt64Attribute>("Count", 3, "Valid values: 0:19"));
-  params->addAttribute(std::make_shared<StringAttribute>("Label", "x#y"));
-  params->addAttribute(std::make_shared<U64RangeListAttribute>("Range", U64Range::fromString("0:8:2")));
-
-  std::string path = TempPath("roundtrip.txt");
-  CHECK(ConfigNode::save(root, path));
-  ConfigNodePtr loaded = ConfigNode::load(path);
-  std::filesystem::remove(path);
-  CHECK(loaded != nullptr);
-  if (loaded == nullptr) {
-    return;
-  }
-  auto lmetric = loaded->findChildByName("programmable")->findChildByName("METRIC_B");
-  CHECK(lmetric != nullptr);
-  auto lparams = lmetric->findChildByName("parameters");
-  CHECK(lparams->findAttributeByKey("Count")->getValue() == "3");
-  CHECK(lparams->findAttributeByKey("Label")->getValue() == "x#y");
-  CHECK(lparams->findAttributeByKey("Range")->getValue() == "[0:8:2]");
-
-  std::string bad_path = (std::filesystem::temp_directory_path() / "no_such_dir_unitrace" / "x.txt").string();
-  CHECK(!ConfigNode::save(root, bad_path));
-}
-
-int main() {
-  TestValidConfig();
-  TestInvalidConfig();
-  TestErrorMessages();
-  TestValidation();
-  TestExampleFile();
-  TestRanges();
-  TestSaveLoadRoundTrip();
-  TestDoubleRoundTrip();
-  if (failures != 0) {
-    std::cerr << "[ERROR] " << failures << " check(s) failed" << std::endl;
-    return 1;
-  }
-  std::cout << "[INFO] All config node tests passed" << std::endl;
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/omp_cpu_gemm/CMakeLists.txt b/tools/unitrace/test/cpp_test/omp_cpu_gemm/CMakeLists.txt
deleted file mode 100644
index a5f8f7c5..00000000
--- a/tools/unitrace/test/cpp_test/omp_cpu_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-if(WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qopenmp")
-else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -qopenmp")
-endif()
-
-project(omp_cpu_gemm CXX)
-
-add_executable(omp_cpu_gemm main.cc)
-
-install(TARGETS omp_cpu_gemm RUNTIME DESTINATION bin/omp_cpu_gemm COMPONENT omp_cpu_gemm)
diff --git a/tools/unitrace/test/cpp_test/omp_cpu_gemm/main.cc b/tools/unitrace/test/cpp_test/omp_cpu_gemm/main.cc
deleted file mode 100644
index 026144a0..00000000
--- a/tools/unitrace/test/cpp_test/omp_cpu_gemm/main.cc
+++ /dev/null
@@ -1,92 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <math.h>
-#include <chrono>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <string.h>
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static float Check(const std::vector<float>& a, float value) {
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-float ComputeOnCPU(const std::vector<float>& a,
-                   const std::vector<float>& b,
-                   std::vector<float>& c,
-                   unsigned size, float expected_result) {
-
-  memset(c.data(), 0, c.size() * sizeof(float));
-
-  #pragma omp parallel for
-  for (unsigned i = 0; i < size; ++i) {
-    for (unsigned k = 0; k < size; ++k) {
-      for (unsigned j = 0; j < size; ++j) {
-        c[i * size + j] += a[i * size + k] * b[k * size  + j];
-      }
-    }
-  }
-
-  return Check(c, expected_result);
-}
-
-static void Compute(const std::vector<float>& a,
-                    const std::vector<float>& b,
-                    std::vector<float>& c,
-                    unsigned size, unsigned repeat_count,
-                    float expected_result) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    auto start = std::chrono::steady_clock::now();
-    float eps = ComputeOnCPU(a, b, c, size, expected_result);
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    std::cout << "Matrix multiplication time: " << time.count() <<
-      " ns" << std::endl;
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-}
-
-int main(int argc, char* argv[]) {
-  unsigned size = 1024;
-  if (argc > 1) {
-    size = std::stoul(argv[1]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 2) {
-    repeat_count = std::stoul(argv[2]);
-  }
-
-  std::cout << "OpenMP Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: CPU" << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(a, b, c, size, repeat_count, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " ns" << std::endl;
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/CMakeLists.txt b/tools/unitrace/test/cpp_test/omp_gemm/CMakeLists.txt
deleted file mode 100644
index 2c6bc92d..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-if(WIN32)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qiopenmp -Qopenmp-targets=spir64")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /Qopenmp /Qopenmp-targets=spir64")
-else()
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fiopenmp -fopenmp-targets=spir64")
-endif()
-
-project(omp_gemm CXX) 
-
-add_executable(omp_gemm main.cc)
-
-if(WIN32)
-  target_link_libraries(omp_gemm PRIVATE "$ENV{ONEAPI_ROOT}/compiler/latest/lib/libiomp5md.lib")
-endif()
-
-install(TARGETS omp_gemm RUNTIME DESTINATION bin/omp_gemm COMPONENT omp_gemm)
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/d.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/d.txt
deleted file mode 100644
index 735a8a3f..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/d.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            187924698
-    Total Device Time for L0 backend (ns):             22891200
-
-== L0 Backend ==
-
-                                                                         Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"__omp_offloading_802_69e222e__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l71",            4,             17027040,    74.382469,              4256760,              4147040,              4380320
-                                           "zeCommandListAppendMemoryCopy(M2D)",           16,              5420320,    23.678619,               338770,                   80,               764720
-                                           "zeCommandListAppendMemoryCopy(D2M)",            9,               443840,     1.938911,                49315,                 1600,               111120
-
-
-=== Kernel Properties ===
-
-                                                                         Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"__omp_offloading_802_69e222e__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l71",      JIT,   32,                  10,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/h.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/h.txt
deleted file mode 100644
index dbf990db..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/h.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            171136371
-    Total API Time for L0 backend (ns):             76961357
-Total API Time for CL CPU backend (ns):                 8794
-Total API Time for CL GPU backend (ns):                10732
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                        zeModuleCreate,            1,             54340301,     70.607254,             54340301,             54340301,             54340301
-                zeEventHostSynchronize,           21,             11035542,     14.339068,               525502,                   42,              2968529
-         zeCommandListAppendMemoryCopy,           25,              7328840,      9.522753,               293153,                  443,               863186
-          zeCommandListCreateImmediate,            2,              1108989,      1.440969,               554494,                38057,              1070932
-           zeContextMakeMemoryResident,           18,               975820,      1.267935,                54212,                 5194,               424353
-       zeCommandListAppendLaunchKernel,            4,               589163,      0.765531,               147290,                 7474,               561932
-                  zeCommandQueueCreate,            2,               585970,      0.761382,               292985,               237873,               348097
-                      zeMemAllocDevice,           18,               479206,      0.622658,                26622,                 9604,                57755
-                             zeMemFree,           17,               297520,      0.386584,                17501,                 4995,                31412
-                      zeMemAllocShared,            2,                79432,      0.103210,                39716,                31128,                48304
-           zeDeviceGetMemoryProperties,            2,                45188,      0.058715,                22594,                20901,                24287
-                        zeMemAllocHost,            1,                17057,      0.022163,                17057,                17057,                17057
-                         zeEventCreate,           64,                13117,      0.017044,                  204,                  102,                 3150
-               zeMemGetAllocProperties,           41,                11532,      0.014984,                  281,                   60,                 3982
-              zeKernelSetArgumentValue,           40,                 7581,      0.009850,                  189,                   28,                 1323
-                     zeEventPoolCreate,            1,                 6817,      0.008858,                 6817,                 6817,                 6817
-                       zeContextCreate,            1,                 6515,      0.008465,                 6515,                 6515,                 6515
-                           zeDriverGet,            3,                 5092,      0.006616,                 1697,                   49,                 4705
-                        zeKernelCreate,            2,                 4547,      0.005908,                 2273,                  667,                 3880
-                 zeDeviceGetProperties,           12,                 4232,      0.005499,                  352,                  131,                  980
-                      zeEventHostReset,           29,                 4123,      0.005357,                  142,                   52,                  668
-        zeDriverGetExtensionProperties,            2,                 3783,      0.004915,                 1891,                 1430,                 2353
-zeDeviceGetCommandQueueGroupProperties,           16,                 3143,      0.004084,                  196,                   27,                  765
-              zeModuleGetGlobalPointer,            5,                 2170,      0.002820,                  434,                  145,                  703
-                           zeDeviceGet,            2,                  970,      0.001260,                  485,                  263,                  707
-                zeModuleGetKernelNames,            3,                  703,      0.000913,                  234,                   85,                  362
-                       zeKernelDestroy,            1,                  635,      0.000825,                  635,                  635,                  635
-                  zeKernelSetGroupSize,            1,                  600,      0.000780,                  600,                  600,                  600
-                 zeKernelGetProperties,            1,                  566,      0.000735,                  566,                  566,                  566
-          zeDeviceGetComputeProperties,            2,                  515,      0.000669,                  257,                  217,                  298
-                 zeModuleGetProperties,            1,                  364,      0.000473,                  364,                  364,                  364
-               zeModuleBuildLogDestroy,            1,                  350,      0.000455,                  350,                  350,                  350
-            zeDeviceGetCacheProperties,            2,                  322,      0.000418,                  161,                   56,                  266
-                 zeDeviceGetSubDevices,            2,                  239,      0.000311,                  119,                   31,                  208
-                 zeDriverGetApiVersion,            1,                  222,      0.000288,                  222,                  222,                  222
-             zeKernelSetIndirectAccess,            1,                  191,      0.000248,                  191,                  191,                  191
-
-== CL CPU Backend ==
-
-         Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetPlatformInfo,           2,                5901,       67.10,                2950,                 655,                5246
-   clGetDeviceIDs,           1,                2893,       32.90,                2893,                2893,                2893
-
-== CL GPU Backend ==
-
-                                Function,       Calls,           Time (ns),    Time (%),        Average (ns),            Min (ns),            Max (ns)
-clGetExtensionFunctionAddressForPlatform,          12,                7716,       71.90,                 643,                 209,                3484
-                          clGetDeviceIDs,           2,                2185,       20.36,                1092,                 317,                1868
-                       clGetPlatformInfo,           2,                 831,        7.74,                 415,                 132,                 699
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/t.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/t.txt
deleted file mode 100644
index 105fe047..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/linux/t.txt
+++ /dev/null
@@ -1,30 +0,0 @@
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[8]" [ns] 542503661614525 (append) 542503661614525 (submit) 542503661646045 (start) 542503661648525 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[40]" [ns] 542503661741212 (append) 542503661741212 (submit) 542503661746412 (start) 542503661748652 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[78]" [ns] 542503661759829 (append) 542503661759829 (submit) 542503661764789 (start) 542503661768389 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4096]" [ns] 542503661870870 (append) 542503661870870 (submit) 542503661878630 (start) 542503661881110 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 542503661911736 (append) 542503661911736 (submit) 542503661918456 (start) 542503661919576 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 542503662559972 (append) 542503662559972 (submit) 542503662564932 (start) 542503662565012 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4]" [ns] 542503662575052 (append) 542503662575052 (submit) 542503662579852 (start) 542503662579932 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[8]" [ns] 542503662589358 (append) 542503662589358 (submit) 542503662594158 (start) 542503662594238 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4]" [ns] 542503662603868 (append) 542503662603868 (submit) 542503662608668 (start) 542503662608748 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[472]" [ns] 542503662635743 (append) 542503662635743 (submit) 542503662642143 (start) 542503662643343 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 542503662653901 (append) 542503662653901 (submit) 542503662658781 (start) 542503662658861 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[8]" [ns] 542503662670229 (append) 542503662670229 (submit) 542503662675109 (start) 542503662677509 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[112]" [ns] 542503662687336 (append) 542503662687336 (submit) 542503662692136 (start) 542503662695736 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503662738308 (append) 542503662738308 (submit) 542503662745508 (start) 542503663574308 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503663637757 (append) 542503663637757 (submit) 542503663648717 (start) 542503664486157 (end)
-Thread 48030 Device 51518672 : "__omp_offloading_802_68e1f09__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD32 {16; 1024; 1} {64; 1; 1}]" [ns] 542503664606571 (append) 542503664606571 (submit) 542503665311211 (start) 542503669952011 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542503665246798 (append) 542503665246798 (submit) 542503669958238 (start) 542503670199038 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503670941670 (append) 542503670941670 (submit) 542503670955910 (start) 542503671790070 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503671842894 (append) 542503671842894 (submit) 542503671853854 (start) 542503672692574 (end)
-Thread 48030 Device 51518672 : "__omp_offloading_802_68e1f09__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD32 {16; 1024; 1} {64; 1; 1}]" [ns] 542503672749550 (append) 542503672749550 (submit) 542503672765070 (start) 542503677332270 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542503672769135 (append) 542503672769135 (submit) 542503677337775 (start) 542503677529615 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503678208078 (append) 542503678208078 (submit) 542503678220318 (start) 542503678957598 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503679004602 (append) 542503679004602 (submit) 542503679015082 (start) 542503679756442 (end)
-Thread 48030 Device 51518672 : "__omp_offloading_802_68e1f09__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD32 {16; 1024; 1} {64; 1; 1}]" [ns] 542503679808778 (append) 542503679808778 (submit) 542503679821338 (start) 542503684325018 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542503679825047 (append) 542503679825047 (submit) 542503684328727 (start) 542503684500807 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503685168866 (append) 542503685168866 (submit) 542503685181266 (start) 542503685911186 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542503685959671 (append) 542503685959671 (submit) 542503685969911 (start) 542503686697751 (end)
-Thread 48030 Device 51518672 : "__omp_offloading_802_68e1f09__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD32 {16; 1024; 1} {64; 1; 1}]" [ns] 542503686748950 (append) 542503686748950 (submit) 542503686761110 (start) 542503691111510 (end)
-Thread 48030 Device 51518672 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542503686764175 (append) 542503686764175 (submit) 542503691117295 (start) 542503691287375 (end)
-
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/d.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/d.txt
deleted file mode 100644
index cf065933..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/d.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           1918571400
-    Total Device Time for L0 backend (ns):            722573953
-
-== L0 Backend ==
-
-                                                                               Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"__omp_offloading_e4ea70a0_ae24e1b9__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59",            4,            722469582,    99.985558,            180617395,            175209375,            188006250
-                                                 "zeCommandListAppendMemoryCopy(M2D)",            8,                64894,     0.008981,                 8111,                 4479,                20104
-                                                 "zeCommandListAppendMemoryCopy(D2M)",            5,                39477,     0.005463,                 7895,                 4270,                13958
-
-
-=== Kernel Properties ===
-
-                                                                               Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"__omp_offloading_e4ea70a0_ae24e1b9__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59",      JIT,   16,                  10,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/h.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/h.txt
deleted file mode 100644
index c621e5ab..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/h.txt
+++ /dev/null
@@ -1,47 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1685327000
-    Total API Time for L0 backend (ns):            931098600
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-             zeCommandQueueSynchronize,           17,            683068400,     73.361557,             40180494,                62000,            171103400
-                        zeModuleCreate,            1,            240291500,     25.807310,            240291500,            240291500,            240291500
-                    zeCommandListReset,           17,              2756400,      0.296037,               162141,                11900,               388800
-                      zeMemAllocDevice,            5,              1037200,      0.111395,               207440,                26400,               856800
-         zeCommandListAppendMemoryCopy,           13,              1025100,      0.110096,                78853,                22800,               517800
-           zeContextMakeMemoryResident,            5,               805900,      0.086554,               161180,                33700,               315800
-     zeCommandQueueExecuteCommandLists,           17,               558400,      0.059972,                32847,                14600,                91700
-                   zeCommandListCreate,            1,               505400,      0.054280,               505400,               505400,               505400
-                 zeDeviceGetProperties,            7,               421300,      0.045248,                60185,                40700,                80900
-                      zeMemAllocShared,            2,               254500,      0.027333,               127250,                47200,               207300
-                             zeMemFree,            3,               103700,      0.011137,                34566,                11700,                75400
-                  zeCommandQueueCreate,            1,                68000,      0.007303,                68000,                68000,                68000
-       zeCommandListAppendLaunchKernel,            4,                47100,      0.005059,                11775,                 6800,                14700
-                        zeMemAllocHost,            1,                40400,      0.004339,                40400,                40400,                40400
-               zeMemGetAllocProperties,           39,                35400,      0.003802,                  907,                  100,                 3100
-              zeKernelSetArgumentValue,           40,                15900,      0.001708,                  397,                    0,                 3000
-                    zeCommandListClose,           17,                10900,      0.001171,                  641,                  300,                 2300
-                        zeKernelCreate,            2,                10200,      0.001095,                 5100,                 1700,                 8500
-        zeDriverGetExtensionProperties,            2,                 8200,      0.000881,                 4100,                  600,                 7600
-              zeModuleGetGlobalPointer,            5,                 8000,      0.000859,                 1600,                 1000,                 2500
-                       zeContextCreate,            1,                 6300,      0.000677,                 6300,                 6300,                 6300
-zeDeviceGetCommandQueueGroupProperties,            8,                 5600,      0.000601,                  700,                    0,                 3100
-                           zeDriverGet,            3,                 2900,      0.000311,                  966,                    0,                 1500
-               zeModuleBuildLogDestroy,            1,                 2700,      0.000290,                 2700,                 2700,                 2700
-                           zeDeviceGet,            2,                 1800,      0.000193,                  900,                  100,                 1700
-                zeModuleGetKernelNames,            2,                 1400,      0.000150,                  700,                  500,                  900
-                       zeKernelDestroy,            1,                 1300,      0.000140,                 1300,                 1300,                 1300
-                  zeKernelSetGroupSize,            1,                 1200,      0.000129,                 1200,                 1200,                 1200
-                 zeKernelGetProperties,            1,                  800,      0.000086,                  800,                  800,                  800
-           zeDeviceGetMemoryProperties,            1,                  800,      0.000086,                  800,                  800,                  800
-                 zeModuleGetProperties,            1,                  700,      0.000075,                  700,                  700,                  700
-            zeDeviceGetCacheProperties,            1,                  300,      0.000032,                  300,                  300,                  300
-          zeDeviceGetComputeProperties,            1,                  300,      0.000032,                  300,                  300,                  300
-                 zeDeviceGetSubDevices,            1,                  300,      0.000032,                  300,                  300,                  300
-             zeKernelSetIndirectAccess,            1,                  200,      0.000021,                  200,                  200,                  200
-                 zeDriverGetApiVersion,            1,                  100,      0.000011,                  100,                  100,                  100
-
-
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/t.txt b/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/t.txt
deleted file mode 100644
index 538ae0cb..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/gold/windows/t.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(D2M)[8]" [ns] 201710939974300 (append) 201710940709500 (submit) 201710945395437 (start) 201710945408770 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(D2M)[40]" [ns] 201710946189200 (append) 201710946408200 (submit) 201710946706377 (start) 201710946713668 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(D2M)[84]" [ns] 201710947239200 (append) 201710947457200 (submit) 201710947710481 (start) 201710947716522 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[4096]" [ns] 201710948689200 (append) 201710948888100 (submit) 201710949201485 (start) 201710949207735 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 201710955289100 (append) 201710955446100 (submit) 201710955720266 (start) 201710955725995 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 201710956136300 (append) 201710956345700 (submit) 201710956625335 (start) 201710956631376 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[4]" [ns] 201710957210500 (append) 201710957480400 (submit) 201710957751597 (start) 201710957758367 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[8]" [ns] 201710958228300 (append) 201710958429300 (submit) 201710958722216 (start) 201710958728466 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[4]" [ns] 201710959029500 (append) 201710959174200 (submit) 201710959453783 (start) 201710959460241 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[472]" [ns] 201710960139400 (append) 201710960302200 (submit) 201710960509543 (start) 201710960518813 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(M2D)[64]" [ns] 201710960741200 (append) 201710960824500 (submit) 201710961085906 (start) 201710961094031 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(D2M)[8]" [ns] 201710961503300 (append) 201710961686300 (submit) 201710961933018 (start) 201710961939476 (end)
-Thread 33852 Device 1787424600 : "zeCommandListAppendMemoryCopy(D2M)[112]" [ns] 201710962257000 (append) 201710962480500 (submit) 201710962761229 (start) 201710962766333 (end)
-Thread 33852 Device 1787424600 : "__omp_offloading_e4ea70a0_efbeb191__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD16 {32; 1024; 1} {32; 1; 1}]" [ns] 201710966054200 (append) 201710966560000 (submit) 201710968045677 (start) 201711138552864 (end)
-Thread 33852 Device 1787424600 : "__omp_offloading_e4ea70a0_efbeb191__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD16 {32; 1024; 1} {32; 1; 1}]" [ns] 201711148465100 (append) 201711148683200 (submit) 201711148880804 (start) 201711316992366 (end)
-Thread 33852 Device 1787424600 : "__omp_offloading_e4ea70a0_efbeb191__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD16 {32; 1024; 1} {32; 1; 1}]" [ns] 201711327511700 (append) 201711327736400 (submit) 201711327953014 (start) 201711502719264 (end)
-Thread 33852 Device 1787424600 : "__omp_offloading_e4ea70a0_efbeb191__Z12ComputeOnGPURKSt6vectorIfSaIfEES3_RS1_jf_l59[SIMD16 {32; 1024; 1} {32; 1; 1}]" [ns] 201711515017700 (append) 201711515325300 (submit) 201711515623581 (start) 201711686204831 (end)
-
diff --git a/tools/unitrace/test/cpp_test/omp_gemm/main.cc b/tools/unitrace/test/cpp_test/omp_gemm/main.cc
deleted file mode 100644
index 04c6a02d..00000000
--- a/tools/unitrace/test/cpp_test/omp_gemm/main.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <math.h>
-#include <chrono>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <string.h>
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static float Check(const std::vector<float>& a, float value) {
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-float ComputeOnCPU(const std::vector<float>& a,
-                   const std::vector<float>& b,
-                   std::vector<float>& c,
-                   unsigned size, float expected_result) {
-
-  memset(c.data(), 0, c.size() * sizeof(float));
-
-  #pragma omp parallel for
-  for (unsigned i = 0; i < size; ++i) {
-    for (unsigned k = 0; k < size; ++k) {
-      for (unsigned j = 0; j < size; ++j) {
-        c[i * size + j] += a[i * size + k] * b[k * size  + j];
-      }
-    }
-  }
-
-  return Check(c, expected_result);
-}
-
-float ComputeOnGPU(const std::vector<float>& a,
-                   const std::vector<float>& b,
-                   std::vector<float>& c,
-                   unsigned size, float expected_result) {
-
-  memset(c.data(), 0, c.size() * sizeof(float));
-
-  const float* a_data = a.data();
-  const float* b_data = b.data();
-  float* c_data = c.data();
-  int size2 = size * size;
-
-  #pragma omp target teams distribute parallel for collapse(2)\
-    map(to: a_data[0:size2], b_data[0:size2]) map(from: c_data[0:size2])
-  for (unsigned i = 0; i < size; ++i) {
-    for (unsigned j = 0; j < size; ++j) {
-      float sum = 0.0f;
-      for (unsigned k = 0; k < size; ++k) {
-        sum += a_data[i * size + k] * b_data[k * size  + j];
-      }
-      c_data[i * size + j] = sum;
-    }
-  }
-
-  return Check(c, expected_result);
-}
-
-static void Compute(const std::vector<float>& a,
-                    const std::vector<float>& b,
-                    std::vector<float>& c,
-                    unsigned size, unsigned repeat_count,
-                    float expected_result, bool cpu) {
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    auto start = std::chrono::steady_clock::now();
-    float eps = (cpu ? ComputeOnCPU(a, b, c, size, expected_result) :
-      ComputeOnGPU(a, b, c, size, expected_result));
-    auto end = std::chrono::steady_clock::now();
-    std::chrono::duration<float> time = end - start;
-
-    std::cout << "Matrix multiplication time: " << time.count() <<
-      " ns" << std::endl;
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-  }
-}
-
-int main(int argc, char* argv[]) {
-  bool cpu = false;
-  if (argc > 1 && strcmp(argv[1], "cpu") == 0) {
-    cpu = true;
-  }
-
-  unsigned size = 1024;
-  if (argc > 2) {
-    size = std::stoul(argv[2]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 3) {
-    repeat_count = std::stoul(argv[3]);
-  }
-
-  std::cout << "OpenMP Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " << (cpu ? "CPU" : "GPU") << std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(a, b, c, size, repeat_count, expected_result, cpu);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() << " ns" << std::endl;
-  return 0;
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/print_options_schema/check_options_schema.py b/tools/unitrace/test/cpp_test/print_options_schema/check_options_schema.py
deleted file mode 100644
index ef1197e3..00000000
--- a/tools/unitrace/test/cpp_test/print_options_schema/check_options_schema.py
+++ /dev/null
@@ -1,96 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Validate `unitrace --print-options-schema`: the output must be well-formed JSON
-# carrying the schema the VS Code extension consumes. This is a no-GPU test --
-# --print-options-schema prints and exits before any Level Zero initialization.
-
-import json
-import subprocess
-import sys
-
-
-def fail(msg):
-    print(f"[ERROR] {msg}", file=sys.stderr)
-    sys.exit(1)
-
-
-def main():
-    if len(sys.argv) != 2:
-        fail(f"usage: {sys.argv[0]} <path-to-unitrace>")
-    unitrace = sys.argv[1]
-
-    proc = subprocess.run(
-        [unitrace, "--print-options-schema"],
-        capture_output=True, text=True)
-    if proc.returncode != 0:
-        fail(f"unitrace --print-options-schema exited {proc.returncode}\n{proc.stderr}")
-
-    try:
-        schema = json.loads(proc.stdout)
-    except json.JSONDecodeError as e:
-        fail(f"output is not valid JSON: {e}\n--- output ---\n{proc.stdout}")
-
-    # Required top-level keys.
-    for key in ("schemaVersion", "unitraceVersion", "build", "groups", "flags"):
-        if key not in schema:
-            fail(f"missing top-level key: {key!r}")
-
-    if not isinstance(schema["flags"], list) or not schema["flags"]:
-        fail("'flags' must be a non-empty array")
-
-    if not isinstance(schema["build"], dict):
-        fail("'build' must be an object")
-
-    # Groups carry the form's section labels; collect their ids so each flag can
-    # be checked against them.
-    if not isinstance(schema["groups"], list) or not schema["groups"]:
-        fail("'groups' must be a non-empty array")
-    group_ids = set()
-    for group in schema["groups"]:
-        for field in ("id", "label"):
-            if field not in group:
-                fail(f"group {group.get('id', '?')!r} missing field {field!r}")
-        group_ids.add(group["id"])
-
-    # Every flag must carry the mechanical fields the extension relies on.
-    valid_types = {"bool", "int", "float", "string", "enum", "path", "action"}
-    names = set()
-    for flag in schema["flags"]:
-        for field in ("name", "type", "group", "help"):
-            if field not in flag:
-                fail(f"flag {flag.get('name', '?')!r} missing field {field!r}")
-        if flag["type"] not in valid_types:
-            fail(f"flag {flag['name']!r} has unknown type {flag['type']!r}")
-        if flag["group"] not in group_ids:
-            fail(f"flag {flag['name']!r} references group {flag['group']!r} "
-                 f"with no label in 'groups'")
-        if flag["name"] in names:
-            fail(f"duplicate flag name: {flag['name']!r}")
-        names.add(flag["name"])
-
-    # Relation fields (conflictsWith/requires) must reference real flags.
-    for flag in schema["flags"]:
-        for rel in ("conflictsWith", "requires"):
-            for target in flag.get(rel, []):
-                if target not in names:
-                    fail(f"flag {flag['name']!r} {rel} references unknown flag {target!r}")
-
-    # --help is always present; spot-check that a known flag survived the dump.
-    if "--help" not in names:
-        fail("expected --help in the flag list")
-
-    # SchemaOmit()ted flags stay in --help/dispatch but must NOT leak into the schema.
-    for omitted in ("--pause", "--resume", "--stop"):
-        if omitted in names:
-            fail(f"{omitted!r} is SchemaOmit()ted and must not appear in the schema")
-
-    print(f"[OK] --print-options-schema produced {len(schema['flags'])} valid flags "
-          f"in {len(group_ids)} groups")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/CMakeLists.txt b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/CMakeLists.txt
deleted file mode 100644
index 40fe6049..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-project(sycl_graph_with_v2_adaptor CXX)
-
-add_executable(sycl_graph_with_v2_adaptor main.cpp)
-add_sycl_to_target(sycl_graph_with_v2_adaptor)
-
-install(TARGETS sycl_graph_with_v2_adaptor RUNTIME DESTINATION bin/sycl_graph_with_v2_adaptor COMPONENT sycl_graph_with_v2_adaptor)
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/d.txt b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/d.txt
deleted file mode 100644
index e6d7a6fc..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/d.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            148321936
-    Total Device Time for L0 backend (ns):                32000
-
-== L0 Backend ==
-
-                                                                        Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                                          "zeCommandListAppendMemoryCopy(D2M)",            1,                15520,    48.500000,                15520,                15520,                15520
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}",            1,                 6400,    20.000000,                 6400,                 6400,                 6400
-                                            "zeCommandListAppendMemoryFill(D)",            1,                 5760,    18.000000,                 5760,                 5760,                 5760
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}",            1,                 4320,    13.500000,                 4320,                 4320,                 4320
-
-
-=== Kernel Properties ===
-
-                                                                        Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/t.txt b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/t.txt
deleted file mode 100644
index 70d26cd3..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/linux/t.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-Thread 39224 Device 65891704 : "zeCommandListAppendMemoryFill(D)[1024]" [ns] 79214258842135 (append) 79214258842135 (submit) 79214259240855 (start) 79214259246935 (end)
-Thread 39224 Device 65891704 : "run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}[SIMD32 {4; 1; 1} {64; 1; 1}]" [ns] 79214263167449 (append) 79214263479657 (submit) 79214263576857 (start) 79214263583257 (end)
-Thread 39224 Device 65891704 : "run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}[SIMD32 {4; 1; 1} {64; 1; 1}]" [ns] 79214263269089 (append) 79214263479657 (submit) 79214263586937 (start) 79214263591097 (end)
-Thread 39224 Device 65891704 : "zeCommandListAppendMemoryCopy(D2M)[1024]" [ns] 79214263670766 (append) 79214263670766 (submit) 79214263683566 (start) 79214263699006 (end)
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/d.txt b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/d.txt
deleted file mode 100644
index e6d7a6fc..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/d.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            148321936
-    Total Device Time for L0 backend (ns):                32000
-
-== L0 Backend ==
-
-                                                                        Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                                          "zeCommandListAppendMemoryCopy(D2M)",            1,                15520,    48.500000,                15520,                15520,                15520
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}",            1,                 6400,    20.000000,                 6400,                 6400,                 6400
-                                            "zeCommandListAppendMemoryFill(D)",            1,                 5760,    18.000000,                 5760,                 5760,                 5760
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}",            1,                 4320,    13.500000,                 4320,                 4320,                 4320
-
-
-=== Kernel Properties ===
-
-                                                                        Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
-"run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}",      JIT,   32,                   2,                  0,                         0,                       0,                           128
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/t.txt b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/t.txt
deleted file mode 100644
index 70d26cd3..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/gold/windows/t.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-Thread 39224 Device 65891704 : "zeCommandListAppendMemoryFill(D)[1024]" [ns] 79214258842135 (append) 79214258842135 (submit) 79214259240855 (start) 79214259246935 (end)
-Thread 39224 Device 65891704 : "run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#1}[SIMD32 {4; 1; 1} {64; 1; 1}]" [ns] 79214263167449 (append) 79214263479657 (submit) 79214263576857 (start) 79214263583257 (end)
-Thread 39224 Device 65891704 : "run_kernels(sycl::_V1::queue*, int*, int)::{lambda(sycl::_V1::nd_item<1>)#2}[SIMD32 {4; 1; 1} {64; 1; 1}]" [ns] 79214263269089 (append) 79214263479657 (submit) 79214263586937 (start) 79214263591097 (end)
-Thread 39224 Device 65891704 : "zeCommandListAppendMemoryCopy(D2M)[1024]" [ns] 79214263670766 (append) 79214263670766 (submit) 79214263683566 (start) 79214263699006 (end)
diff --git a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/main.cpp b/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/main.cpp
deleted file mode 100644
index 8c4f9a95..00000000
--- a/tools/unitrace/test/cpp_test/sycl_graph_with_v2_adaptor/main.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <sycl/sycl.hpp>
-#include <sycl/ext/oneapi/experimental/graph.hpp>
-#include <vector>
-#include <iostream>
-
-constexpr size_t N = 256;
-constexpr size_t GROUP_SIZE = 64;
-
-namespace syclex = sycl::ext::oneapi::experimental;
-
-void run_kernels(sycl::queue *q, int *d_data, int v) {
-    q->parallel_for(sycl::nd_range<1>(N, GROUP_SIZE), [d_data, v](sycl::nd_item<1> i) {
-        d_data[i.get_global_id()] = v;
-    });
-    q->parallel_for(sycl::nd_range<1>(N, GROUP_SIZE), [d_data, v](sycl::nd_item<1> i) {
-        d_data[i.get_global_id()] += v;
-    });
-}
-
-int main() {
-    int v = 2;
-    std::vector<int> data(N, 0);
-
-    sycl::queue q{sycl::property::queue::in_order{}};
-    int *d_data = (int *) sycl::malloc_device(N * sizeof(int), q);
-    q.memset(d_data, 0, N * sizeof(int)).wait();
-
-    syclex::command_graph g{q.get_context(), q.get_device()};
-
-    // Record our two kernels
-    g.begin_recording(q);
-    run_kernels(&q, d_data, v);
-    g.end_recording();
-
-    auto eg = g.finalize();
-    q.ext_oneapi_graph(eg);
-    q.wait_and_throw();
-
-    q.memcpy(data.data(), d_data, sizeof(int) * N).wait();
-    sycl::free(d_data, q);
-
-    for (int i = 0; i < N; ++i) {
-        if (data[i] != 4) {
-            std::cerr << "Test failed at idx: " << i << std::endl;
-            return 1;
-        }
-    }
-    std::cerr << "Test passed" << std::endl;
-    return 0;
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/temporal/CMakeLists.txt b/tools/unitrace/test/cpp_test/temporal/CMakeLists.txt
deleted file mode 100644
index f1d4ccae..00000000
--- a/tools/unitrace/test/cpp_test/temporal/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-project(temporal CXX)
-
-add_executable(temporal temporal.cpp)
-add_sycl_to_target(temporal)
-
-install(TARGETS temporal RUNTIME DESTINATION bin/temporal COMPONENT temporal)
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/linux/d.txt b/tools/unitrace/test/cpp_test/temporal/gold/linux/d.txt
deleted file mode 100644
index 848e2267..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/linux/d.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):             91428339
-    Total Device Time for L0 backend (ns):               842395
-
-== L0 Backend ==
-
-                    Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"main::{lambda(auto:1)#4}",            1,               842395,   100.000008,               842395,               842395,               842395
-
-
-=== Kernel Properties ===
-
-                    Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"main::{lambda(auto:1)#4}",      JIT,    8,                   3,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/linux/h.txt b/tools/unitrace/test/cpp_test/temporal/gold/linux/h.txt
deleted file mode 100644
index a72e8eaf..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/linux/h.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):             95833972
-    Total API Time for L0 backend (ns):              2579912
-
-== L0 Backend ==
-
-                         Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-           zeEventHostSynchronize,            1,              2472199,     95.824936,              2472199,              2472199,              2472199
-zeCommandQueueExecuteCommandLists,            1,                88615,      3.434807,                88615,                88615,                88615
-                   zeKernelCreate,            1,                 4898,      0.189851,                 4898,                 4898,                 4898
-  zeCommandListAppendLaunchKernel,            1,                 4615,      0.178882,                 4615,                 4615,                 4615
-               zeCommandListReset,            1,                 3319,      0.128648,                 3319,                 3319,                 3319
-         zeKernelSetArgumentValue,            3,                 2511,      0.097329,                  837,                  242,                 1835
-               zeFenceQueryStatus,            1,                 1005,      0.038955,                 1005,                 1005,                 1005
-                 zeEventHostReset,            1,                  865,      0.033528,                  865,                  865,                  865
-             zeKernelSetGroupSize,            1,                  522,      0.020233,                  522,                  522,                  522
-               zeCommandListClose,            1,                  412,      0.015970,                  412,                  412,                  412
-            zeKernelGetProperties,            1,                  304,      0.011783,                  304,                  304,                  304
-            zeDeviceGetSubDevices,            2,                  214,      0.008295,                  107,                   26,                  188
-       zeKernelSetGlobalOffsetExp,            1,                  189,      0.007326,                  189,                  189,                  189
-        zeKernelSetIndirectAccess,            1,                  170,      0.006589,                  170,                  170,                  170
-                     zeFenceReset,            1,                   74,      0.002868,                   74,                   74,                   74
-
-
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/linux/t.txt b/tools/unitrace/test/cpp_test/temporal/gold/linux/t.txt
deleted file mode 100644
index f5f7951d..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/linux/t.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Thread 57894 Device 466787824 : "main::{lambda(auto:1)#4}[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 14421741736655 (append) 14421744915991 (submit) 14421745440938 (start) 14421747047708 (end)
-
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/windows/d.txt b/tools/unitrace/test/cpp_test/temporal/gold/windows/d.txt
deleted file mode 100644
index 1c6ee261..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/windows/d.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            983061100
-    Total Device Time for L0 backend (ns):            167994062
-
-== L0 Backend ==
-
-              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"_ZTSZ4mainEUlT_E2_",            1,            167994062,   100.000000,            167994062,            167994062,            167994062
-
-
-=== Kernel Properties ===
-
-              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"_ZTSZ4mainEUlT_E2_",      JIT,    8,                   3,                  0,                      7744,                  131072,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/windows/h.txt b/tools/unitrace/test/cpp_test/temporal/gold/windows/h.txt
deleted file mode 100644
index 3c980bef..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/windows/h.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           1078924300
-    Total API Time for L0 backend (ns):            172929900
-
-== L0 Backend ==
-
-                       Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-         zeEventHostSynchronize,            1,            171795400,     99.343948,            171795400,            171795400,            171795400
-                 zeKernelCreate,            1,              1006100,      0.581796,              1006100,              1006100,              1006100
-zeCommandListAppendLaunchKernel,            1,                80100,      0.046319,                80100,                80100,                80100
-       zeKernelSetArgumentValue,            3,                17100,      0.009888,                 5700,                 3900,                 8000
-               zeEventHostReset,            1,                 9700,      0.005609,                 9700,                 9700,                 9700
-          zeDeviceGetSubDevices,            2,                 6900,      0.003990,                 3450,                 3400,                 3500
-          zeKernelGetProperties,            1,                 6200,      0.003585,                 6200,                 6200,                 6200
-           zeKernelSetGroupSize,            1,                 5100,      0.002949,                 5100,                 5100,                 5100
-      zeKernelSetIndirectAccess,            1,                 3300,      0.001908,                 3300,                 3300,                 3300
-
-
diff --git a/tools/unitrace/test/cpp_test/temporal/gold/windows/t.txt b/tools/unitrace/test/cpp_test/temporal/gold/windows/t.txt
deleted file mode 100644
index 8b57da87..00000000
--- a/tools/unitrace/test/cpp_test/temporal/gold/windows/t.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Thread 11980 Device 2774985259688 : "_ZTSZ4mainEUlT_E2_[SIMD8 {256; 1; 1} {128; 1; 1}]" [ns] 258055298358500 (append) 258055298358500 (submit) 258055299270375 (start) 258055468151625 (end)
-
diff --git a/tools/unitrace/test/cpp_test/temporal/temporal.cpp b/tools/unitrace/test/cpp_test/temporal/temporal.cpp
deleted file mode 100644
index 6b912185..00000000
--- a/tools/unitrace/test/cpp_test/temporal/temporal.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <sycl/sycl.hpp>
-#include <iostream>
-#ifdef _WIN32
-#include <windows.h>
-#endif /* _WIN32 */
-
-using namespace sycl;
-int main(int argc, char *argv[]) {
-    std::string session;
-    std::string unitrace_path;
-    auto session_env = std::getenv("UNITRACE_Session");
-    if (session_env != nullptr) {
-        session = session_env;
-    }
-#ifndef _WIN32
-    auto preload_env = std::getenv("LD_PRELOAD");
-    if (preload_env != nullptr) {
-        unitrace_path = preload_env;
-        auto pos = unitrace_path.find("libunitrace_tool");
-        if (pos != std::string::npos) {
-            unitrace_path.replace(pos, sizeof("libunitrace_tool.so"), "unitrace"); 
-            unsetenv("LD_PRELOAD");
-        }
-    }
-#else /* _WIN32 */
-    HMODULE hModule = GetModuleHandleW(L"unitrace_tool.dll");
-    if (hModule != nullptr) {
-        wchar_t module_path[MAX_PATH];
-        if (GetModuleFileNameW(hModule, module_path, MAX_PATH) > 0) {
-            std::wstring wide_path(module_path);
-            std::string path(wide_path.begin(), wide_path.end());
-            auto pos = path.find_last_of("\\/");
-            if (pos != std::string::npos) {
-                unitrace_path = path.substr(0, pos + 1) + "unitrace.exe";
-            }
-        }
-    }
-#endif /* _WIN32 */
-    int GLOBAL_SIZE = 64 * 512;
-    queue q{gpu_selector(), {property::queue::in_order()}};
-    float *a = (float *)malloc_shared(sizeof(float)*GLOBAL_SIZE,q);
-    float *b = (float *)malloc_shared(sizeof(float)*GLOBAL_SIZE,q);
-    float *c = (float *)malloc_shared(sizeof(float)*GLOBAL_SIZE,q);
-    for(int i = 0; i < GLOBAL_SIZE; i++) {
-        a[i] = i;
-        b[i] = i;
-        c[i] = 0;
-    }
-    int WORKGROUP_SIZE = 64;
-    q.parallel_for(nd_range<1>(GLOBAL_SIZE,WORKGROUP_SIZE),[=](auto i) {
-        int index = i.get_local_id();
-        c[0] = index;
-    }).wait();
-
-    q.parallel_for(nd_range<1>(GLOBAL_SIZE,WORKGROUP_SIZE),[=](auto i) {
-        int index = i.get_group_linear_id();
-        c[0] = index;
-    }).wait();
-
-    q.parallel_for(nd_range<1>(GLOBAL_SIZE,WORKGROUP_SIZE),[=](auto i) {
-        int index = i.get_global_id();
-        c[index] = a[index] + b[index];
-    }).wait();
-
-    if (!unitrace_path.empty() && !session.empty()) {
-        auto command = unitrace_path + " --resume " + session;
-        if (system(command.c_str()) != 0) {
-            std::cerr << "[ERROR] Failed to resume session " << session << std::endl;
-        }
-    }
-
-    WORKGROUP_SIZE = WORKGROUP_SIZE * 2;
-    q.parallel_for(nd_range<1>(GLOBAL_SIZE,WORKGROUP_SIZE),[=](auto i) {
-        int index = i.get_global_id();
-        float f[128];
-        
-        float x = a[index];
-        float y = b[index];
-
-        for (int k = 0; k < 20; k++) {
-            for (int i = 0; i < 64; i++) {
-                f[i] = x + y + i;
-            }
-
-            for (int i = 0; i < 8; i++) {
-                for (int j = 0; j < 64; j++) {
-                    x  = x * f[j];
-                    y  = y * f[j];
-                }
-            }
-            c[index] = x + y;
-        }
-    }).wait();
-
-    if (!unitrace_path.empty() && !session.empty()) {
-        auto command = unitrace_path + " --pause " + session;
-        if (system(command.c_str()) != 0) {
-            std::cerr << "[ERROR] Failed to pause session " << session << std::endl;
-		}
-    }
-
-    q.wait();
-
-    free((void *)a, q);
-    free((void *)b, q);
-    free((void *)c, q);
-
-    if (!unitrace_path.empty() && !session.empty()) {
-        auto command = unitrace_path + " --stop " + session;
-        if (system(command.c_str()) != 0) {
-            std::cerr << "[ERROR] Failed to stop session " << session << std::endl;
-        }
-    }
-
-    return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/ze_counterbased_events/CMakeLists.txt b/tools/unitrace/test/cpp_test/ze_counterbased_events/CMakeLists.txt
deleted file mode 100644
index fcd9377a..00000000
--- a/tools/unitrace/test/cpp_test/ze_counterbased_events/CMakeLists.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-project(ze_counterbased_events CXX)
-
-add_executable(ze_counterbased_events main.cpp)
-
-target_include_directories(ze_counterbased_events PRIVATE "${PROJECT_SOURCE_DIR}/../.." "${PROJECT_SOURCE_DIR}/../../..")
-
-if(WIN32)
-  UnitraceFindL0Library(ze_counterbased_events)
-  UnitraceGetLevelZeroHeaders(ze_counterbased_events ${LEVEL_ZERO_COMMIT_ID})
-else()
-  target_link_libraries(ze_counterbased_events PRIVATE ze_loader)
-endif()
-
-install(TARGETS ze_counterbased_events RUNTIME DESTINATION bin/ze_counterbased_events COMPONENT ze_counterbased_events)
diff --git a/tools/unitrace/test/cpp_test/ze_counterbased_events/check_outfiles.py b/tools/unitrace/test/cpp_test/ze_counterbased_events/check_outfiles.py
deleted file mode 100644
index 9f7285df..00000000
--- a/tools/unitrace/test/cpp_test/ze_counterbased_events/check_outfiles.py
+++ /dev/null
@@ -1,36 +0,0 @@
-
-import os
-import sys
-import argparse
-
-# Shared trace parsers live in tools/unitrace/test/trace_utils/trace_compare.py
-# (this file is tools/unitrace/test/cpp_test/ze_counterbased_events/...).
-sys.path.insert(0, os.path.normpath(
-    os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "trace_utils")))
-from trace_compare import parse_timeline_stats, parse_timeline_stats_perfetto
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Check timeline stats in trace files (JSON or Perfetto protobuf).")
-  parser.add_argument('output_files', nargs='+', help='output files')
-  parser.add_argument('--cmd', type=str, nargs=argparse.REMAINDER, help='command argument')
-  args = parser.parse_args()
-
-  for filename in args.output_files:
-    if filename.endswith(".json") and os.path.exists(filename):
-      stats = parse_timeline_stats(filename)
-    elif filename.endswith(".pftrace") and os.path.exists(filename):
-      stats = parse_timeline_stats_perfetto(filename)
-    else:
-      continue
-    if len(stats) < 1:
-      print(f"[ERROR] No timelines found in: {filename}")
-      exit(-1)
-    for stat in stats:
-      if stat["min_gap"] < 0 or stat["overlaps"] > 0:
-        print(f"[ERROR] overlapping execution found in {filename}:\n {stat}\n")
-        exit(-1)
-  exit(0)
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/test/cpp_test/ze_counterbased_events/main.cpp b/tools/unitrace/test/cpp_test/ze_counterbased_events/main.cpp
deleted file mode 100644
index dc8ccb73..00000000
--- a/tools/unitrace/test/cpp_test/ze_counterbased_events/main.cpp
+++ /dev/null
@@ -1,159 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-
-#include <stdio.h>
-#include <string.h>
-#include <string>
-#include "utils/ze_utils.h"
-
-static void *allocSharedMem(ze_context_handle_t hCtx, ze_device_handle_t hDev, size_t size)
-{
-    ze_host_mem_alloc_desc_t h_desc = {
-        .stype = ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC,
-        .pNext = nullptr,
-        .flags = ZE_HOST_MEM_ALLOC_FLAG_BIAS_UNCACHED
-    };
-    ze_device_mem_alloc_desc_t d_desc = {
-        .stype = ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC,
-        .pNext = nullptr,
-        .flags = ZE_DEVICE_MEM_ALLOC_FLAG_BIAS_UNCACHED,
-        .ordinal = 0
-    };
-
-    void *buf = nullptr;
-
-    ze_result_t rc = zeMemAllocShared(hCtx, &d_desc, &h_desc, size, 4096, hDev, &buf);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeMemAllocDevice rc=%d\n", rc);
-        return nullptr;
-    }
-
-    return buf;
-}
-
-int main(int argc, char* argv[])
-{
-  uint32_t buf_size = 1024 * 1024;
-  uint32_t niters = 4;
-
-  for (int i = 0; i < argc; i++) {
-    if (!strcmp(argv[i], "-size") && i+1 < argc) {
-      buf_size = std::stoi(argv[++i]);
-    }
-  }
-
-  ze_result_t rc = ZE_RESULT_SUCCESS;
-  rc = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-  if (rc != ZE_RESULT_SUCCESS) {
-      printf("[ERROR] Failed to init GPU device: 0x%x\n", rc);
-      return -1;
-  }
-
-  ze_device_handle_t device = utils::ze::GetGpuDevice();
-  ze_driver_handle_t driver = utils::ze::GetGpuDriver();
-  if (device == nullptr || driver == nullptr) {
-      printf("[ERROR] Unable to find GPU device\n");
-      return -1;
-  }
-
-  ze_context_handle_t context = utils::ze::GetContext(driver);
-
-  float *in_buf = (float *)allocSharedMem(context, device, buf_size * sizeof(float));
-  float *out_buf = (float *)allocSharedMem(context, device, buf_size * sizeof(float));
-
-  for (uint32_t i = 0; i < buf_size; i++) {
-      in_buf[i] = (float)(i & 100);
-      out_buf[i] = 255.0f;
-  }
-
-  _ze_event_pool_counter_based_exp_desc_t cbased = {
-    .stype = ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC,
-	.pNext = nullptr,
-	.flags = ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE
-  };
-
-  ze_event_pool_desc_t ctr_pool_desc = {
-      .stype = ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
-      .pNext = &cbased,
-      .flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-      .count = niters
-  };
-
-  ze_event_pool_handle_t ctr_evPool;
-  rc = zeEventPoolCreate(context, &ctr_pool_desc, 1, &device, &ctr_evPool);
-  if (rc != ZE_RESULT_SUCCESS) {
-      printf("zeEventPoolCreate rc=%d\n", rc);
-      return -1;
-  }
-
-  ze_command_queue_desc_t q_desc = {
-      .stype = ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
-      .pNext = nullptr,
-      .ordinal = 0,
-      .index = 0,
-      .flags = ZE_COMMAND_QUEUE_FLAG_IN_ORDER,
-      .mode = ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-      .priority = ZE_COMMAND_QUEUE_PRIORITY_NORMAL
-  };
-
-  ze_command_list_handle_t cl;
-
-  rc = zeCommandListCreateImmediate(context, device, &q_desc, &cl);
-  if (rc != ZE_RESULT_SUCCESS) {
-      printf("zeCommandListCreateImmediate rc=%d\n", rc);
-      return -1;
-  }
-
-  std::vector<ze_event_handle_t> ev(niters);
-  for (unsigned int i = 0; i < niters; i++) {
-      ze_event_desc_t ev_desc = {
-          .stype = ZE_STRUCTURE_TYPE_EVENT_DESC,
-          .pNext = nullptr,
-          .index = i,
-          .signal = ZE_EVENT_SCOPE_FLAG_DEVICE,
-          .wait = ZE_EVENT_SCOPE_FLAG_HOST,
-      };
-      rc = zeEventCreate(ctr_evPool, &ev_desc, &ev[i]);
-      if (rc != ZE_RESULT_SUCCESS) {
-          printf("zeEventCreate rc=%d\n", rc);
-          return -1;
-      }
-  }
-
-  uint32_t chunkSize = buf_size / niters;
-  uint32_t start = 0;
-  for (unsigned int i = 0; i < niters; i++) {
-    uint32_t size = start + chunkSize > buf_size ? buf_size - start : chunkSize;
-
-    rc = zeCommandListAppendMemoryCopy(cl,
-                                      &out_buf[start], &in_buf[start],
-                                       size * sizeof(float),
-                                       ev[0], 0, nullptr);
-    if (rc != ZE_RESULT_SUCCESS) {
-        printf("zeEventCreate rc=%d\n", rc);
-        return -1;
-    }
-
-    start += chunkSize;
-  }
-
-  zeEventHostSynchronize(ev[0], UINT64_MAX);
-
-  for (uint32_t i = 1; i < 128 && i <= buf_size; i++) {
-    if (out_buf[buf_size - i] != in_buf[buf_size - i]) {
-      printf("[ERROR] Mismatch at index %u %f expected: %f\n", buf_size - i, out_buf[buf_size - i], in_buf[buf_size - i]);
-    }
-  }
-
-  zeCommandListDestroy(cl);
-  for (unsigned int i = 0; i < niters; i++)
-    zeEventDestroy(ev[i]);
-  zeEventPoolDestroy(ctr_evPool);
-  zeContextDestroy(context);
-
-  return 0;
-}
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/CMakeLists.txt b/tools/unitrace/test/cpp_test/ze_gemm/CMakeLists.txt
deleted file mode 100644
index d2e21a33..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-project(ze_gemm CXX)
-
-add_executable(ze_gemm main.cc)
-
-target_include_directories(ze_gemm PRIVATE "${PROJECT_SOURCE_DIR}/../.." "${PROJECT_SOURCE_DIR}/../../..")
-
-if(WIN32)
-  UnitraceFindL0Library(ze_gemm)
-  UnitraceGetLevelZeroHeaders(ze_gemm ${LEVEL_ZERO_COMMIT_ID})
-else()
-  target_link_libraries(ze_gemm PRIVATE ze_loader)
-endif()
-
-add_custom_command(TARGET ze_gemm PRE_BUILD
-                   COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PROJECT_SOURCE_DIR}/gemm.spv ${CMAKE_BINARY_DIR}/ze_gemm/gemm.spv)
-
-install(TARGETS ze_gemm RUNTIME DESTINATION bin/ze_gemm COMPONENT ze_gemm)
-install(FILES ${PROJECT_SOURCE_DIR}/gemm.spv
-        DESTINATION bin/ze_gemm COMPONENT ze_gemm)
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gemm.spv b/tools/unitrace/test/cpp_test/ze_gemm/gemm.spv
deleted file mode 100644
index b31c2d35..00000000
Binary files a/tools/unitrace/test/cpp_test/ze_gemm/gemm.spv and /dev/null differ
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/d.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/d.txt
deleted file mode 100644
index e97dced0..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/d.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            179716136
-    Total Device Time for L0 backend (ns):            185907840
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-        "zeCommandListAppendBarrier",            8,             90681120,    48.777458,             11335140,               773920,             22420800
-                              "GEMM",            4,             87518240,    47.076141,             21879560,             20304800,             22409280
-"zeCommandListAppendMemoryCopy(M2D)",            8,              6118720,     3.291265,               764840,               756160,               779840
-"zeCommandListAppendMemoryCopy(D2M)",            4,              1589760,     0.855133,               397440,               334240,               419840
-
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-                              "GEMM",      JIT,   32,                   4,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/h.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/h.txt
deleted file mode 100644
index b6a2b315..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/h.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):            111841982
-    Total API Time for L0 backend (ns):             31574184
-
-== L0 Backend ==
-
-                         Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-        zeCommandQueueSynchronize,            4,             29482351,     93.374870,              7370587,              7041115,              7765931
-    zeCommandListAppendMemoryCopy,           12,               559285,      1.771336,                46607,                17622,               299110
-             zeCommandQueueCreate,            4,               315793,      1.000162,                78948,                 1036,               310970
-zeCommandQueueExecuteCommandLists,            4,               269158,      0.852462,                67289,                45852,               107015
-                 zeMemAllocDevice,           12,               240766,      0.762541,                20063,                 9234,                48728
-                   zeModuleCreate,            1,               223270,      0.707128,               223270,               223270,               223270
-             zeCommandListDestroy,            4,               123743,      0.391912,                30935,                27187,                38191
-                        zeMemFree,           12,               117610,      0.372488,                 9800,                 5683,                13997
-               zeEventPoolDestroy,            4,                63648,      0.201582,                15912,                13391,                18636
-                zeEventPoolCreate,            4,                47747,      0.151222,                11936,                 9342,                16554
-              zeCommandListCreate,            4,                35251,      0.111645,                 8812,                 2391,                24894
-                    zeEventCreate,            4,                21035,      0.066621,                 5258,                 4583,                 5665
-      zeEventQueryKernelTimestamp,            4,                19090,      0.060461,                 4772,                 3861,                 6278
-               zeCommandListClose,            4,                 6857,      0.021717,                 1714,                  896,                 3705
-         zeKernelSetArgumentValue,           16,                 6844,      0.021676,                  427,                  111,                 1926
-  zeCommandListAppendLaunchKernel,            4,                 6770,      0.021442,                 1692,                 1030,                 2484
-                      zeDriverGet,            5,                 5274,      0.016704,                 1054,                   46,                 4994
-                  zeModuleDestroy,            1,                 4584,      0.014518,                 4584,                 4584,                 4584
-            zeDeviceGetProperties,            9,                 4349,      0.013774,                  483,                  268,                  804
-         zeKernelSuggestGroupSize,            4,                 4006,      0.012688,                 1001,                  796,                 1264
-                   zeKernelCreate,            1,                 3750,      0.011877,                 3750,                 3750,                 3750
-       zeCommandListAppendBarrier,            8,                 2937,      0.009302,                  367,                   55,                 1164
-                  zeContextCreate,            1,                 1943,      0.006154,                 1943,                 1943,                 1943
-            zeCommandQueueDestroy,            4,                 1852,      0.005866,                  463,                  346,                  667
-                  zeKernelDestroy,            1,                 1744,      0.005524,                 1744,                 1744,                 1744
-                   zeEventDestroy,            4,                 1621,      0.005134,                  405,                  344,                  489
-             zeKernelSetGroupSize,            4,                 1037,      0.003284,                  259,                  173,                  482
-                 zeContextDestroy,            1,                  789,      0.002499,                  789,                  789,                  789
-                      zeDeviceGet,            4,                  754,      0.002388,                  188,                   88,                  348
-            zeDeviceGetSubDevices,            1,                  326,      0.001032,                  326,                  326,                  326
-
-
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/t.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/t.txt
deleted file mode 100644
index 55fbd12b..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/linux/t.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502530448638 (append) 542502531368221 (submit) 542502531551501 (start) 542502531790701 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502530801031 (append) 542502531368221 (submit) 542502531552141 (start) 542502531790221 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502530838026 (append) 542502531368221 (submit) 542502531552621 (start) 542502531793581 (end)
-Thread 47342 Device 59736512 : "GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502530868354 (append) 542502531368221 (submit) 542502531793741 (start) 542502534645101 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502530880434 (append) 542502531368221 (submit) 542502531794221 (start) 542502534647341 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502530888053 (append) 542502531368221 (submit) 542502534647341 (start) 542502534809421 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502536862354 (append) 542502537060946 (submit) 542502537137506 (start) 542502537374466 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502536905268 (append) 542502537060946 (submit) 542502537138146 (start) 542502537373986 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502536933726 (append) 542502537060946 (submit) 542502537138466 (start) 542502537376706 (end)
-Thread 47342 Device 59736512 : "GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502536967850 (append) 542502537060946 (submit) 542502537376866 (start) 542502540247266 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502536977196 (append) 542502537060946 (submit) 542502537377666 (start) 542502540249666 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502536984693 (append) 542502537060946 (submit) 542502540249826 (start) 542502540464066 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502540996341 (append) 542502541182066 (submit) 542502541236786 (start) 542502541478226 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502541035107 (append) 542502541182066 (submit) 542502541237426 (start) 542502541477746 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502541061038 (append) 542502541182066 (submit) 542502541237746 (start) 542502541480466 (end)
-Thread 47342 Device 59736512 : "GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502541089738 (append) 542502541182066 (submit) 542502541480626 (start) 542502544354226 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502541099358 (append) 542502541182066 (submit) 542502541481266 (start) 542502544356466 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502541106335 (append) 542502541182066 (submit) 542502544356626 (start) 542502544539346 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502545055713 (append) 542502545227918 (submit) 542502545289438 (start) 542502545528478 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 542502545093031 (append) 542502545227918 (submit) 542502545290238 (start) 542502545528958 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502545116920 (append) 542502545227918 (submit) 542502545290558 (start) 542502545531038 (end)
-Thread 47342 Device 59736512 : "GEMM[SIMD32 {1; 1024; 1} {1024; 1; 1}]" [ns] 542502545144739 (append) 542502545227918 (submit) 542502545531198 (start) 542502548381278 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendBarrier" [ns] 542502545153426 (append) 542502545227918 (submit) 542502545531998 (start) 542502548383518 (end)
-Thread 47342 Device 59736512 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 542502545160332 (append) 542502545227918 (submit) 542502548383678 (start) 542502548565918 (end)
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/d.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/d.txt
deleted file mode 100644
index d013e39c..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/d.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):            992160800
-    Total Device Time for L0 backend (ns):             83297594
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                              "GEMM",            4,             79457185,    95.389534,             19864296,             19411770,             20667604
-"zeCommandListAppendMemoryCopy(M2D)",            8,              2482081,     2.979775,               310260,               226875,               430208
-"zeCommandListAppendMemoryCopy(D2M)",            4,              1353853,     1.625321,               338463,               250833,               473750
-        "zeCommandListAppendBarrier",            8,                 4475,     0.005372,                  559,                  520,                  625
-
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-                              "GEMM",      JIT,   32,                   4,                  0,                         0,                       0,                           128
-
-
-
-
-
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/h.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/h.txt
deleted file mode 100644
index 40ab33c5..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/h.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           2434158600
-    Total API Time for L0 backend (ns):            338787300
-
-== L0 Backend ==
-
-                         Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                   zeModuleCreate,            1,            142387600,     42.028614,            142387600,            142387600,            142387600
-        zeCommandQueueSynchronize,            4,            122545900,     36.171928,             30636475,             21946600,             54812000
-             zeCommandListDestroy,            4,             61531100,     18.162163,             15382775,               645000,             59494900
-                  zeModuleDestroy,            1,              6569000,      1.938975,              6569000,              6569000,              6569000
-    zeCommandListAppendMemoryCopy,           12,              1645300,      0.485644,               137108,                35600,              1045600
-            zeDeviceGetProperties,            7,              1350800,      0.398716,               192971,                64100,               314100
-                 zeMemAllocDevice,           12,               723300,      0.213497,                60275,                17800,               134700
-               zeEventPoolDestroy,            4,               480000,      0.141682,               120000,                66000,               162900
-              zeCommandListCreate,            4,               407500,      0.120282,               101875,                18400,               347000
-                zeEventPoolCreate,            4,               233600,      0.068952,                58400,                39700,                98700
-zeCommandQueueExecuteCommandLists,            4,               232200,      0.068539,                58050,                42700,                85100
-                        zeMemFree,           12,               203400,      0.060038,                16950,                 5800,                37200
-             zeCommandQueueCreate,            4,               191400,      0.056496,                47850,                 5900,               171900
-      zeEventQueryKernelTimestamp,            4,                34500,      0.010183,                 8625,                 4400,                16500
-                    zeEventCreate,            4,                31700,      0.009357,                 7925,                 3400,                12600
-  zeCommandListAppendLaunchKernel,            4,                30200,      0.008914,                 7550,                 4500,                13600
-         zeKernelSetArgumentValue,           16,                27600,      0.008147,                 1725,                  300,                 6500
-            zeCommandQueueDestroy,            4,                25800,      0.007615,                 6450,                 5200,                 7200
-         zeKernelSuggestGroupSize,            4,                23700,      0.006996,                 5925,                 4100,                 6700
-                   zeEventDestroy,            4,                22500,      0.006641,                 5625,                 4300,                 8800
-                   zeKernelCreate,            1,                20300,      0.005992,                20300,                20300,                20300
-                  zeContextCreate,            1,                16400,      0.004841,                16400,                16400,                16400
-                 zeContextDestroy,            1,                16100,      0.004752,                16100,                16100,                16100
-                  zeKernelDestroy,            1,                15000,      0.004428,                15000,                15000,                15000
-               zeCommandListClose,            4,                 7200,      0.002125,                 1800,                 1100,                 2600
-             zeKernelSetGroupSize,            4,                 4400,      0.001299,                 1100,                  700,                 1800
-       zeCommandListAppendBarrier,            8,                 4300,      0.001269,                  537,                  200,                 1200
-                      zeDriverGet,            5,                 3400,      0.001004,                  680,                  100,                 2100
-                      zeDeviceGet,            4,                 2600,      0.000767,                  650,                  100,                 1800
-            zeDeviceGetSubDevices,            1,                  500,      0.000148,                  500,                  500,                  500
-
-
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/t.txt b/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/t.txt
deleted file mode 100644
index 29868554..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/gold/windows/t.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700718001400 (append) 201700719593300 (submit) 201700721908560 (start) 201700722192935 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700718626400 (append) 201700719593300 (submit) 201700722193143 (start) 201700722548872 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700718700700 (append) 201700719593300 (submit) 201700722548977 (start) 201700722549706 (end)
-Thread 28500 Device 1720661544 : "GEMM[SIMD32 {2; 1024; 1} {512; 1; 1}]" [ns] 201700718839100 (append) 201700719593300 (submit) 201700722549810 (start) 201700744200122 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700718919400 (append) 201700719593300 (submit) 201700744200331 (start) 201700744200956 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 201700718948000 (append) 201700719593300 (submit) 201700744201060 (start) 201700744789393 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700756259600 (append) 201700756952200 (submit) 201700758678918 (start) 201700758925897 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700756449200 (append) 201700756952200 (submit) 201700758926106 (start) 201700759254647 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700756557100 (append) 201700756952200 (submit) 201700759254752 (start) 201700759255377 (end)
-Thread 28500 Device 1720661544 : "GEMM[SIMD32 {2; 1024; 1} {512; 1; 1}]" [ns] 201700756668200 (append) 201700756952200 (submit) 201700759255585 (start) 201700781066418 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700756706100 (append) 201700756952200 (submit) 201700781066627 (start) 201700781067147 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 201700756731700 (append) 201700756952200 (submit) 201700781067356 (start) 201700781325897 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700791118500 (append) 201700791820100 (submit) 201700793374370 (start) 201700793644682 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700791308200 (append) 201700791820100 (submit) 201700793644891 (start) 201700793979578 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700791420200 (append) 201700791820100 (submit) 201700793979787 (start) 201700793980412 (end)
-Thread 28500 Device 1720661544 : "GEMM[SIMD32 {2; 1024; 1} {512; 1; 1}]" [ns] 201700791551400 (append) 201700791820100 (submit) 201700793980620 (start) 201700815488015 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700791579300 (append) 201700791820100 (submit) 201700815488120 (start) 201700815488745 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 201700791605800 (append) 201700791820100 (submit) 201700815488954 (start) 201700815952495 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700825896200 (append) 201700826699300 (submit) 201700828372425 (start) 201700828616591 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(M2D)[4194304]" [ns] 201700826131800 (append) 201700826699300 (submit) 201700828616800 (start) 201700828951487 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700826228100 (append) 201700826699300 (submit) 201700828951695 (start) 201700828952320 (end)
-Thread 28500 Device 1720661544 : "GEMM[SIMD32 {2; 1024; 1} {512; 1; 1}]" [ns] 201700826367500 (append) 201700826699300 (submit) 201700828952529 (start) 201700850874924 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendBarrier" [ns] 201700826411400 (append) 201700826699300 (submit) 201700850875029 (start) 201700850875758 (end)
-Thread 28500 Device 1720661544 : "zeCommandListAppendMemoryCopy(D2M)[4194304]" [ns] 201700826457900 (append) 201700826699300 (submit) 201700850875862 (start) 201700851215237 (end)
-
diff --git a/tools/unitrace/test/cpp_test/ze_gemm/main.cc b/tools/unitrace/test/cpp_test/ze_gemm/main.cc
deleted file mode 100644
index 122d1575..00000000
--- a/tools/unitrace/test/cpp_test/ze_gemm/main.cc
+++ /dev/null
@@ -1,242 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <math.h>
-#include <string.h>
-
-#include <chrono>
-#include <iostream>
-
-#include "utils/ze_utils.h"
-
-#define ALIGN 64
-
-#define A_VALUE 0.128f
-#define B_VALUE 0.256f
-#define MAX_EPS 1.0e-4f
-
-static float Check(const std::vector<float>& a, float value) {
-
-  float eps = 0.0f;
-  for (size_t i = 0; i < a.size(); ++i) {
-    eps += fabs((a[i] - value) / value);
-  }
-
-  return eps / a.size();
-}
-
-static float RunAndCheck(ze_kernel_handle_t kernel,
-                         ze_device_handle_t device,
-                         ze_context_handle_t context,
-                         const std::vector<float>& a,
-                         const std::vector<float>& b,
-                         std::vector<float>& c,
-                         unsigned size,
-                         float expected_result) {
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t group_size[3] = { 0 };
-  status = zeKernelSuggestGroupSize(kernel, size, size, 1,
-    &(group_size[0]), &(group_size[1]), &(group_size[2]));
-
-  if ((size % group_size[0]) != 0 || (size % group_size[1]) != 0) {
-    std::cout << "Non-uniform workgroups are not supported" << std::endl;
-    return 0.0f;
-  }
-
-  void* dev_a = nullptr;
-  ze_device_mem_alloc_desc_t alloc_desc = {
-      ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr, 0, 0};
-  status = zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float),
-                            ALIGN, device, &dev_a);
-  void* dev_b = nullptr;
-  status = zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float),
-                            ALIGN, device, &dev_b);
-  void* dev_c = nullptr;
-  status = zeMemAllocDevice(context, &alloc_desc, size * size * sizeof(float),
-                            ALIGN, device, &dev_c);
-
-  status = zeKernelSetGroupSize(
-      kernel, group_size[0], group_size[1], group_size[2]);
-
-  status = zeKernelSetArgumentValue(kernel, 0, sizeof(dev_a), &dev_a);
-  status = zeKernelSetArgumentValue(kernel, 1, sizeof(dev_a), &dev_b);
-  status = zeKernelSetArgumentValue(kernel, 2, sizeof(dev_a), &dev_c);
-  status = zeKernelSetArgumentValue(kernel, 3, sizeof(size), &size);
-
-  ze_command_list_desc_t cmd_list_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC, nullptr, 0, 0};
-  ze_command_list_handle_t cmd_list = nullptr;
-  status = zeCommandListCreate(context, device, &cmd_list_desc, &cmd_list);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_a, a.data(),
-                                         size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-  status = zeCommandListAppendMemoryCopy(cmd_list, dev_b, b.data(),
-                                         size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 0, nullptr);
-
-  ze_event_pool_desc_t event_pool_desc = {
-      ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-      ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP | ZE_EVENT_POOL_FLAG_HOST_VISIBLE,
-      1};
-  ze_event_pool_handle_t event_pool = nullptr;
-  status = zeEventPoolCreate(context, &event_pool_desc,
-                             0, nullptr, &event_pool);
-
-  ze_event_desc_t event_desc = {
-      ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, 0,
-      ZE_EVENT_SCOPE_FLAG_HOST, ZE_EVENT_SCOPE_FLAG_HOST};
-  ze_event_handle_t event = nullptr;
-  zeEventCreate(event_pool, &event_desc, &event);
-
-  ze_group_count_t dim = { size / group_size[0],
-                           size / group_size[1],
-                           1 };
-  status = zeCommandListAppendLaunchKernel(cmd_list, kernel, &dim,
-                                           event, 0, nullptr);
-
-  status = zeCommandListAppendBarrier(cmd_list, nullptr, 0, nullptr);
-
-  status = zeCommandListAppendMemoryCopy(cmd_list, c.data(), dev_c,
-                                         size * size * sizeof(float),
-                                         nullptr, 0, nullptr);
-
-  status = zeCommandListClose(cmd_list);
-
-  ze_command_queue_desc_t cmd_queue_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0,
-      ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS, ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-  ze_command_queue_handle_t cmd_queue = nullptr;
-  status = zeCommandQueueCreate(context, device, &cmd_queue_desc, &cmd_queue);
-
-  status = zeCommandQueueExecuteCommandLists(
-      cmd_queue, 1, &cmd_list, nullptr);
-
-  status = zeCommandQueueSynchronize(cmd_queue, UINT32_MAX);
-
-  status = zeCommandQueueDestroy(cmd_queue);
-
-  status = zeCommandListDestroy(cmd_list);
-
-  status = zeMemFree(context, dev_a);
-  status = zeMemFree(context, dev_b);
-  status = zeMemFree(context, dev_c);
-
-  ze_device_properties_t props{};
-  props.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2;
-  status = zeDeviceGetProperties(device, &props);
-
-  ze_kernel_timestamp_result_t timestamp{};
-  status = zeEventQueryKernelTimestamp(event, &timestamp);
-  status = zeEventDestroy(event);
-  status = zeEventPoolDestroy(event_pool);
-
-  double time = static_cast<double>(
-      timestamp.global.kernelEnd - timestamp.global.kernelStart) /
-      props.timerResolution;
-  std::cout << "Matrix multiplication time: " << time <<
-    " ns" << std::endl;
-
-  return Check(c, expected_result);
-}
-
-static void Compute(ze_device_handle_t device,
-                    ze_driver_handle_t driver,
-                    const std::vector<float>& a,
-                    const std::vector<float>& b,
-                    std::vector<float>& c,
-                    unsigned size, unsigned repeat_count,
-                    float expected_result) {
-
-  std::string module_name = "gemm.spv";
-  std::vector<uint8_t> binary = utils::LoadBinaryFile(
-    utils::GetExecutablePath() + module_name);
-  if (binary.size() == 0) {
-    std::cout << "Unable to find module " << module_name << std::endl;
-    return;
-  }
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_context_handle_t context = utils::ze::GetContext(driver);
-
-  ze_module_desc_t module_desc = {
-      ZE_STRUCTURE_TYPE_MODULE_DESC, nullptr,
-      ZE_MODULE_FORMAT_IL_SPIRV, static_cast<uint32_t>(binary.size()),
-      binary.data(), nullptr, nullptr};
-  ze_module_handle_t module = nullptr;
-  status = zeModuleCreate(context, device, &module_desc, &module, nullptr);
-
-  ze_kernel_desc_t kernel_desc = {
-      ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, "GEMM"};
-  ze_kernel_handle_t kernel = nullptr;
-  status = zeKernelCreate(module, &kernel_desc, &kernel);
-
-  for (unsigned i = 0; i < repeat_count; ++i) {
-    if (i == 0) { // Enable data collection for the first iteration
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "1");
-    }
-
-    float eps = RunAndCheck(kernel, device, context, a, b, c,
-                            size, expected_result);
-    std::cout << "Results are " << ((eps < MAX_EPS) ? "" : "IN") <<
-      "CORRECT with accuracy: " << eps << std::endl;
-
-    if (i == 0) { // Disable data collection for the rest iterations
-      utils::SetEnv("PTI_ENABLE_COLLECTION", "");
-    }
-  }
-
-  status = zeKernelDestroy(kernel);
-
-  status = zeModuleDestroy(module);
-
-  status = zeContextDestroy(context);
-}
-
-int main(int argc, char* argv[]) {
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
-
-  ze_device_handle_t device = utils::ze::GetGpuDevice();
-  ze_driver_handle_t driver = utils::ze::GetGpuDriver();
-  if (device == nullptr || driver == nullptr) {
-      std::cout << "Unable to find GPU device" << std::endl;
-      return 0;
-  }
-
-  unsigned size = 1024;
-  if (argc > 1) {
-    size = std::stoul(argv[1]);
-  }
-
-  unsigned repeat_count = 4;
-  if (argc > 2) {
-    repeat_count = std::stoul(argv[2]);
-  }
-
-  std::cout << "Level Zero Matrix Multiplication (matrix size: " << size <<
-    " x " << size << ", repeats " << repeat_count << " times)" << std::endl;
-  std::cout << "Target device: " << utils::ze::GetDeviceName(device) <<
-    std::endl;
-
-  std::vector<float> a(size * size, A_VALUE);
-  std::vector<float> b(size * size, B_VALUE);
-  std::vector<float> c(size * size, 0.0f);
-
-  auto start = std::chrono::steady_clock::now();
-  float expected_result = A_VALUE * B_VALUE * size;
-  Compute(device, driver, a, b, c, size, repeat_count, expected_result);
-  auto end = std::chrono::steady_clock::now();
-  std::chrono::duration<float> time = end - start;
-
-  std::cout << "Total execution time: " << time.count() <<
-    " ns" << std::endl;
-  return 0;
-}
\ No newline at end of file
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/CMakeLists.txt b/tools/unitrace/test/cpp_test/ze_graph_api/CMakeLists.txt
deleted file mode 100644
index 92621220..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/CMakeLists.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-project(ze_graph_api CXX)
-
-add_executable(ze_graph_api main.cc)
-
-target_compile_features(ze_graph_api PRIVATE cxx_std_17)
-
-target_include_directories(ze_graph_api PRIVATE "${PROJECT_SOURCE_DIR}/../.." "${PROJECT_SOURCE_DIR}/../../..")
-
-# Include Level Zero headers with Graph extension from unitrace build
-# The headers are in two locations - check both.
-# UNITRACE_BUILD_ROOT (forwarded by test_unitrace.py --unitrace-build-dir) takes
-# precedence over the standalone tools/unitrace build location.
-if(DEFINED UNITRACE_BUILD_ROOT)
-  set(_unitrace_build "${UNITRACE_BUILD_ROOT}")
-else()
-  set(_unitrace_build "${PROJECT_SOURCE_DIR}/../../../build")
-endif()
-target_include_directories(ze_graph_api PRIVATE
-    "${_unitrace_build}/level-zero/include"
-    "${_unitrace_build}"
-    "${_unitrace_build}/compute-runtime/level_zero/include")
-
-if(WIN32)
-  UnitraceFindL0Library(ze_graph_api)
-  UnitraceGetLevelZeroHeaders(ze_graph_api ${LEVEL_ZERO_COMMIT_ID})
-else()
-  target_link_libraries(ze_graph_api PRIVATE ze_loader ${CMAKE_DL_LIBS})
-endif()
-
-# Copy the graph_kernels SPV (add_one, multiply_two)
-add_custom_command(TARGET ze_graph_api POST_BUILD
-                   COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PROJECT_SOURCE_DIR}/graph_kernels.spv ${CMAKE_CURRENT_BINARY_DIR}/graph_kernels.spv)
-
-install(TARGETS ze_graph_api RUNTIME DESTINATION bin/ze_graph_api COMPONENT ze_graph_api)
-install(FILES ${PROJECT_SOURCE_DIR}/graph_kernels.spv
-        DESTINATION bin/ze_graph_api COMPONENT ze_graph_api)
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/d.txt b/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/d.txt
deleted file mode 100644
index 76a6560e..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/d.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns): *
-    Total Device Time for L0 backend (ns): *
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                           "add_one",            6,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(D2D)",            6,                    *,             *,                   *,                    *,                     *
-                      "multiply_two",            3,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(H2D)",            3,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(D2H)",            3,                    *,             *,                   *,                    *,                     *
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-                           "add_one",      JIT,   32,                   2,                  0,                         0,                       0,                       unknown
-                      "multiply_two",      JIT,   32,                   2,                  0,                         0,                       0,                       unknown
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/t.txt b/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/t.txt
deleted file mode 100644
index 8a5c541e..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/gold/linux/t.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93197784740668 (submit) 93197784753751 (start) 93197784754584 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93197784740668 (submit) 93197784753917 (start) 93197784754750 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93197784740668 (submit) 93197784765751 (start) 93197784766417 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93197784740668 (submit) 93197784767417 (start) 93197784768083 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93197784740668 (submit) 93197784769584 (start) 93197784770250 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93197784740668 (submit) 93197784772084 (start) 93197784772750 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93197784740668 (submit) 93197784772084 (start) 93197784773083 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93198369172732 (submit) 93198369182648 (start) 93198369183314 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93198369172732 (submit) 93198369182815 (start) 93198369183648 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93198369172732 (submit) 93198369185981 (start) 93198369186647 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93198369172732 (submit) 93198369187648 (start) 93198369188314 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93198369172732 (submit) 93198369189815 (start) 93198369190481 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93198369172732 (submit) 93198369192148 (start) 93198369192981 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93198369172732 (submit) 93198369192315 (start) 93198369193148 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93198976658394 (submit) 93198976668393 (start) 93198976669059 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93198976658394 (submit) 93198976668393 (start) 93198976669226 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93198976658394 (submit) 93198976671560 (start) 93198976672226 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93198976658394 (submit) 93198976673393 (start) 93198976674059 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93198976658394 (submit) 93198976675560 (start) 93198976676226 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93198976658394 (submit) 93198976677893 (start) 93198976678559 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93198976658394 (submit) 93198976677893 (start) 93198976678726 (end)
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/d.txt b/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/d.txt
deleted file mode 100644
index 76a6560e..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/d.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns): *
-    Total Device Time for L0 backend (ns): *
-
-== L0 Backend ==
-
-                              Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-                           "add_one",            6,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(D2D)",            6,                    *,             *,                   *,                    *,                     *
-                      "multiply_two",            3,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(H2D)",            3,                    *,             *,                   *,                    *,                     *
-"zeCommandListAppendMemoryCopy(D2H)",            3,                    *,             *,                   *,                    *,                     *
-
-=== Kernel Properties ===
-
-                              Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-                           "add_one",      JIT,   32,                   2,                  0,                         0,                       0,                       unknown
-                      "multiply_two",      JIT,   32,                   2,                  0,                         0,                       0,                       unknown
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/t.txt b/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/t.txt
deleted file mode 100644
index 8a5c541e..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/gold/windows/t.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93197784740668 (submit) 93197784753751 (start) 93197784754584 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93197784740668 (submit) 93197784753917 (start) 93197784754750 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93197784740668 (submit) 93197784765751 (start) 93197784766417 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93197784740668 (submit) 93197784767417 (start) 93197784768083 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93197784740668 (submit) 93197784769584 (start) 93197784770250 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93197784740668 (submit) 93197784772084 (start) 93197784772750 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93197784740668 (submit) 93197784772084 (start) 93197784773083 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93198369172732 (submit) 93198369182648 (start) 93198369183314 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93198369172732 (submit) 93198369182815 (start) 93198369183648 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93198369172732 (submit) 93198369185981 (start) 93198369186647 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93198369172732 (submit) 93198369187648 (start) 93198369188314 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93198369172732 (submit) 93198369189815 (start) 93198369190481 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93198369172732 (submit) 93198369192148 (start) 93198369192981 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93198369172732 (submit) 93198369192315 (start) 93198369193148 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(H2D)[256]" [ns] 93197364641889 (append) 93198976658394 (submit) 93198976668393 (start) 93198976669059 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197441558760 (append) 93198976658394 (submit) 93198976668393 (start) 93198976669226 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197509930839 (append) 93198976658394 (submit) 93198976671560 (start) 93198976672226 (end)
-Thread 128420 Device 409162968 : "add_one[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197579239292 (append) 93198976658394 (submit) 93198976673393 (start) 93198976674059 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2D)[256]" [ns] 93197630032009 (append) 93198976658394 (submit) 93198976675560 (start) 93198976676226 (end)
-Thread 128420 Device 409162968 : "multiply_two[SIMD32 {64; 1; 1} {1; 1; 1}]" [ns] 93197680465429 (append) 93198976658394 (submit) 93198976677893 (start) 93198976678559 (end)
-Thread 128420 Device 409162968 : "zeCommandListAppendMemoryCopy(D2H)[256]" [ns] 93197730766657 (append) 93198976658394 (submit) 93198976677893 (start) 93198976678726 (end)
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/graph_kernels.spv b/tools/unitrace/test/cpp_test/ze_graph_api/graph_kernels.spv
deleted file mode 100644
index b9775479..00000000
Binary files a/tools/unitrace/test/cpp_test/ze_graph_api/graph_kernels.spv and /dev/null differ
diff --git a/tools/unitrace/test/cpp_test/ze_graph_api/main.cc b/tools/unitrace/test/cpp_test/ze_graph_api/main.cc
deleted file mode 100644
index 528ecb47..00000000
--- a/tools/unitrace/test/cpp_test/ze_graph_api/main.cc
+++ /dev/null
@@ -1,559 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#include <level_zero/driver_experimental/zex_graph.h>
-
-#include <chrono>
-#include <cstdint>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "utils/shared_library.h"
-#include "utils/ze_utils.h"
-
-// Test configuration constants
-constexpr int GRAPH_EXECUTION_COUNT = 3;
-constexpr int MIN_CLI_ARGS = 2;  // program name + optional graph exec count
-constexpr int DATA_SIZE = 64;    // number of int elements
-
-// Graph extension function pointer typedefs
-typedef ze_result_t(ZE_APICALL* pfn_zeGraphCreateExp)(ze_context_handle_t, ze_graph_handle_t*,
-                                                      void*);
-typedef ze_result_t(ZE_APICALL* pfn_zeGraphDestroyExp)(ze_graph_handle_t);
-typedef ze_result_t(ZE_APICALL* pfn_zeExecutableGraphDestroyExp)(ze_executable_graph_handle_t);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListBeginCaptureIntoGraphExp)(ze_command_list_handle_t,
-                                                                           ze_graph_handle_t,
-                                                                           void*);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListEndGraphCaptureExp)(ze_command_list_handle_t,
-                                                                     ze_graph_handle_t*, void*);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListInstantiateGraphExp)(ze_graph_handle_t,
-                                                                      ze_executable_graph_handle_t*,
-                                                                      void*);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListAppendGraphExp)(ze_command_list_handle_t,
-                                                                 ze_executable_graph_handle_t,
-                                                                 void*, ze_event_handle_t, uint32_t,
-                                                                 ze_event_handle_t*);
-
-// Global function pointers for graph extension
-static pfn_zeGraphCreateExp p_zeGraphCreateExp = nullptr;
-static pfn_zeGraphDestroyExp p_zeGraphDestroyExp = nullptr;
-static pfn_zeExecutableGraphDestroyExp p_zeExecutableGraphDestroyExp = nullptr;
-static pfn_zeCommandListBeginCaptureIntoGraphExp p_zeCommandListBeginCaptureIntoGraphExp = nullptr;
-static pfn_zeCommandListEndGraphCaptureExp p_zeCommandListEndGraphCaptureExp = nullptr;
-static pfn_zeCommandListInstantiateGraphExp p_zeCommandListInstantiateGraphExp = nullptr;
-static pfn_zeCommandListAppendGraphExp p_zeCommandListAppendGraphExp = nullptr;
-
-#define ZE_CHECK(call)                                                               \
-  do {                                                                               \
-    ze_result_t _res = (call);                                                       \
-    if (_res != ZE_RESULT_SUCCESS) {                                                 \
-      std::cerr << "ERROR: " << #call << " failed with error 0x" << std::hex << _res \
-                << std::dec << std::endl;                                            \
-      return false;                                                                  \
-    }                                                                                \
-  } while (0)
-
-#define LOAD_GRAPH_EXTENSION_FUNCTION(driver, func_name) \
-  ZE_CHECK(zeDriverGetExtensionFunctionAddress(driver, #func_name, (void**)(&p_##func_name)))
-
-// Stable graph API: core entry points exported by the loader, so unlike the Exp
-// ones they cannot be resolved with zeDriverGetExtensionFunctionAddress.
-typedef ze_result_t(ZE_APICALL* pfn_zeGraphCreateExt)(ze_context_handle_t, const void*,
-                                                      ze_graph_handle_t*);
-typedef ze_result_t(ZE_APICALL* pfn_zeGraphDestroyExt)(ze_graph_handle_t);
-typedef ze_result_t(ZE_APICALL* pfn_zeExecutableGraphDestroyExt)(ze_executable_graph_handle_t);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListBeginCaptureIntoGraphExt)(ze_command_list_handle_t,
-                                                                           ze_graph_handle_t,
-                                                                           const void*);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListEndGraphCaptureExt)(ze_command_list_handle_t,
-                                                                     const void*,
-                                                                     ze_graph_handle_t*);
-typedef ze_result_t(ZE_APICALL* pfn_zeGraphInstantiateExt)(ze_graph_handle_t, const void*,
-                                                           ze_executable_graph_handle_t*);
-typedef ze_result_t(ZE_APICALL* pfn_zeCommandListAppendGraphExt)(ze_command_list_handle_t,
-                                                                 ze_executable_graph_handle_t,
-                                                                 const void*, ze_event_handle_t,
-                                                                 uint32_t, ze_event_handle_t*);
-
-static pfn_zeGraphCreateExt p_zeGraphCreateExt = nullptr;
-static pfn_zeGraphDestroyExt p_zeGraphDestroyExt = nullptr;
-static pfn_zeExecutableGraphDestroyExt p_zeExecutableGraphDestroyExt = nullptr;
-static pfn_zeCommandListBeginCaptureIntoGraphExt p_zeCommandListBeginCaptureIntoGraphExt = nullptr;
-static pfn_zeCommandListEndGraphCaptureExt p_zeCommandListEndGraphCaptureExt = nullptr;
-static pfn_zeGraphInstantiateExt p_zeGraphInstantiateExt = nullptr;
-static pfn_zeCommandListAppendGraphExt p_zeCommandListAppendGraphExt = nullptr;
-
-#define STABLE_GRAPH_FUNCTION(func_name) \
-  { #func_name, reinterpret_cast<void**>(&p_##func_name) }
-
-/// True when the driver reports the stable graph extension, which is what makes
-/// SYCL use it in preference to the experimental one.
-static bool HasStableGraphExtension(ze_driver_handle_t driver) {
-  // Spelled out, not ZE_RECORD_REPLAY_GRAPH_EXT_NAME, to keep building with older headers.
-  const char* extension_name = "ZE_extension_record_replay_graph";
-
-  uint32_t count = 0;
-  if (zeDriverGetExtensionProperties(driver, &count, nullptr) != ZE_RESULT_SUCCESS) {
-    return false;
-  }
-  std::vector<ze_driver_extension_properties_t> extensions(count);
-  if (zeDriverGetExtensionProperties(driver, &count, extensions.data()) != ZE_RESULT_SUCCESS) {
-    return false;
-  }
-  for (const auto& extension : extensions) {
-    if (strcmp(extension.name, extension_name) == 0) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/// Resolves the stable graph API from the Level Zero loader. Returns false when
-/// the loader predates it, in which case the caller falls back to Exp.
-static bool LoadStableGraphApi() {
-  // Kept open for the process: the resolved pointers have to stay valid.
-#if defined(_WIN32)
-  static SharedLibrary* lib = SharedLibrary::Create("ze_loader.dll");
-#else
-  static SharedLibrary* lib = SharedLibrary::Create("libze_loader.so.1");
-#endif
-  if (lib == nullptr) {
-    return false;
-  }
-
-  const std::pair<const char*, void**> functions[] = {
-      STABLE_GRAPH_FUNCTION(zeGraphCreateExt),
-      STABLE_GRAPH_FUNCTION(zeGraphDestroyExt),
-      STABLE_GRAPH_FUNCTION(zeExecutableGraphDestroyExt),
-      STABLE_GRAPH_FUNCTION(zeCommandListBeginCaptureIntoGraphExt),
-      STABLE_GRAPH_FUNCTION(zeCommandListEndGraphCaptureExt),
-      STABLE_GRAPH_FUNCTION(zeGraphInstantiateExt),
-      STABLE_GRAPH_FUNCTION(zeCommandListAppendGraphExt)};
-
-  bool complete = true;
-  for (const auto& [name, address] : functions) {
-    *address = lib->GetSym<void*>(name);
-    complete = complete && (*address != nullptr);
-  }
-
-  if (!complete) {
-    // Take the Exp path as a whole rather than mixing the two APIs.
-    for (const auto& [name, address] : functions) {
-      *address = nullptr;
-    }
-  }
-  return complete;
-}
-
-/// Loads graph function pointers, preferring the stable API over Exp.
-static bool LoadGraphExtension(ze_driver_handle_t driver) {
-  if (HasStableGraphExtension(driver) && LoadStableGraphApi()) {
-    std::cout << "Stable graph API loaded successfully" << std::endl;
-    return true;
-  }
-
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeGraphCreateExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeGraphDestroyExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeExecutableGraphDestroyExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeCommandListBeginCaptureIntoGraphExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeCommandListEndGraphCaptureExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeCommandListInstantiateGraphExp);
-  LOAD_GRAPH_EXTENSION_FUNCTION(driver, zeCommandListAppendGraphExp);
-
-  std::cout << "Graph extension loaded successfully" << std::endl;
-  return true;
-}
-
-// Dispatch helpers: call whichever variant was loaded.
-
-static ze_result_t GraphCreate(ze_context_handle_t context, ze_graph_handle_t* graph) {
-  return (p_zeGraphCreateExt != nullptr) ? p_zeGraphCreateExt(context, nullptr, graph)
-                                         : p_zeGraphCreateExp(context, graph, nullptr);
-}
-
-static ze_result_t BeginCaptureIntoGraph(ze_command_list_handle_t cmdlist,
-                                         ze_graph_handle_t graph) {
-  return (p_zeCommandListBeginCaptureIntoGraphExt != nullptr)
-             ? p_zeCommandListBeginCaptureIntoGraphExt(cmdlist, graph, nullptr)
-             : p_zeCommandListBeginCaptureIntoGraphExp(cmdlist, graph, nullptr);
-}
-
-static ze_result_t EndGraphCapture(ze_command_list_handle_t cmdlist, ze_graph_handle_t* graph) {
-  return (p_zeCommandListEndGraphCaptureExt != nullptr)
-             ? p_zeCommandListEndGraphCaptureExt(cmdlist, nullptr, graph)
-             : p_zeCommandListEndGraphCaptureExp(cmdlist, graph, nullptr);
-}
-
-static ze_result_t GraphInstantiate(ze_graph_handle_t graph,
-                                    ze_executable_graph_handle_t* exec_graph) {
-  return (p_zeGraphInstantiateExt != nullptr)
-             ? p_zeGraphInstantiateExt(graph, nullptr, exec_graph)
-             : p_zeCommandListInstantiateGraphExp(graph, exec_graph, nullptr);
-}
-
-static ze_result_t AppendGraph(ze_command_list_handle_t cmdlist,
-                               ze_executable_graph_handle_t exec_graph) {
-  return (p_zeCommandListAppendGraphExt != nullptr)
-             ? p_zeCommandListAppendGraphExt(cmdlist, exec_graph, nullptr, nullptr, 0, nullptr)
-             : p_zeCommandListAppendGraphExp(cmdlist, exec_graph, nullptr, nullptr, 0, nullptr);
-}
-
-static ze_result_t GraphDestroy(ze_graph_handle_t graph) {
-  return (p_zeGraphDestroyExt != nullptr) ? p_zeGraphDestroyExt(graph)
-                                          : p_zeGraphDestroyExp(graph);
-}
-
-static ze_result_t ExecutableGraphDestroy(ze_executable_graph_handle_t exec_graph) {
-  return (p_zeExecutableGraphDestroyExt != nullptr) ? p_zeExecutableGraphDestroyExt(exec_graph)
-                                                    : p_zeExecutableGraphDestroyExp(exec_graph);
-}
-
-/// Captures a graph with sequential fork/join pattern using 3 command lists.
-/// Primary: H2D -> add_one -[fork1]-> wait[join1] -[fork2]-> wait[join2] -> multiply_two -> D2H
-/// Fork1:   wait[fork1] -> D2D(dev->staging) -> D2D(staging->dev) -[join1]
-/// Fork2:   wait[fork2] -> add_one(dev_buf) -[join2]
-/// Both forks join back to primary (no nesting per spec).
-/// Result: (i + 1 + 1) * 2 = 2i + 4
-static bool CaptureGraphWithForks(
-    ze_kernel_handle_t kernel_add_one,
-    ze_kernel_handle_t kernel_multiply_two,
-    ze_kernel_handle_t kernel_add_one_fork,
-    ze_context_handle_t context,
-    ze_command_list_handle_t primary_cmdlist,
-    ze_command_list_handle_t fork1_cmdlist,
-    ze_command_list_handle_t fork2_cmdlist,
-    void* dev_buf, void* host_input, void* staging_buf, void* host_output,
-    size_t buf_size,
-    ze_event_handle_t fork_event1, ze_event_handle_t join_event1,
-    ze_event_handle_t fork_event2, ze_event_handle_t join_event2,
-    uint32_t group_count_x,
-    ze_graph_handle_t& out_graph,
-    ze_executable_graph_handle_t& out_exec_graph) {
-
-  ze_graph_handle_t graph = nullptr;
-  ZE_CHECK(GraphCreate(context, &graph));
-
-  // Begin capture on primary cmdlist
-  ZE_CHECK(BeginCaptureIntoGraph(primary_cmdlist, graph));
-
-  // PRIMARY: H2D copy
-  ZE_CHECK(zeCommandListAppendMemoryCopy(primary_cmdlist, dev_buf, host_input, buf_size,
-                                         nullptr, 0, nullptr));
-
-  // PRIMARY: add_one on dev_buf, signal fork_event1 (first fork point)
-  ze_group_count_t dim = {group_count_x, 1, 1};
-  ZE_CHECK(zeCommandListAppendLaunchKernel(primary_cmdlist, kernel_add_one, &dim,
-                                           fork_event1, 0, nullptr));
-
-  // FORK1: wait fork_event1, D2D round-trip (dev->staging->dev), signal join_event1
-  ZE_CHECK(zeCommandListAppendMemoryCopy(fork1_cmdlist, staging_buf, dev_buf, buf_size,
-                                         nullptr, 1, &fork_event1));
-  ZE_CHECK(zeCommandListAppendMemoryCopy(fork1_cmdlist, dev_buf, staging_buf, buf_size,
-                                         join_event1, 0, nullptr));
-
-  // PRIMARY: wait join_event1 (join fork1), signal fork_event2 (second fork point)
-  ZE_CHECK(zeCommandListAppendWaitOnEvents(primary_cmdlist, 1, &join_event1));
-  ZE_CHECK(zeCommandListAppendSignalEvent(primary_cmdlist, fork_event2));
-
-  // FORK2: wait fork_event2, add_one on dev_buf, signal join_event2
-  ZE_CHECK(zeCommandListAppendLaunchKernel(fork2_cmdlist, kernel_add_one_fork, &dim,
-                                           join_event2, 1, &fork_event2));
-
-  // PRIMARY: wait join_event2 (join fork2), multiply_two, D2H copy
-  ZE_CHECK(zeCommandListAppendLaunchKernel(primary_cmdlist, kernel_multiply_two, &dim,
-                                           nullptr, 1, &join_event2));
-  ZE_CHECK(zeCommandListAppendMemoryCopy(primary_cmdlist, host_output, dev_buf, buf_size,
-                                         nullptr, 0, nullptr));
-
-  // End capture on primary
-  ZE_CHECK(EndGraphCapture(primary_cmdlist, &graph));
-
-  // Instantiate executable graph
-  ze_executable_graph_handle_t exec_graph = nullptr;
-  ZE_CHECK(GraphInstantiate(graph, &exec_graph));
-
-  out_graph = graph;
-  out_exec_graph = exec_graph;
-  return true;
-}
-
-/// Runs graph with fork/join pattern: 3 command lists (primary + 2 forks)
-static bool RunGraphPipeline(ze_kernel_handle_t kernel_add_one,
-                              ze_kernel_handle_t kernel_multiply_two,
-                              ze_kernel_handle_t kernel_add_one_fork,
-                              ze_context_handle_t context,
-                              ze_device_handle_t device,
-                              int graph_exec_count) {
-  const size_t buf_size = DATA_SIZE * sizeof(int);
-
-  // Allocate buffers
-  void* host_input = nullptr;
-  void* host_output = nullptr;
-  void* dev_buf = nullptr;
-  void* staging_buf = nullptr;
-
-  ze_host_mem_alloc_desc_t host_desc = {ZE_STRUCTURE_TYPE_HOST_MEM_ALLOC_DESC, nullptr, 0};
-  ze_device_mem_alloc_desc_t dev_desc = {ZE_STRUCTURE_TYPE_DEVICE_MEM_ALLOC_DESC, nullptr, 0, 0};
-
-  ZE_CHECK(zeMemAllocHost(context, &host_desc, buf_size, 0, &host_input));
-  ZE_CHECK(zeMemAllocHost(context, &host_desc, buf_size, 0, &host_output));
-  ZE_CHECK(zeMemAllocDevice(context, &dev_desc, buf_size, 0, device, &dev_buf));
-  ZE_CHECK(zeMemAllocDevice(context, &dev_desc, buf_size, 0, device, &staging_buf));
-
-  // Initialize input data: [0, 1, 2, ..., DATA_SIZE-1]
-  int* input = static_cast<int*>(host_input);
-  for (int i = 0; i < DATA_SIZE; ++i) {
-    input[i] = i;
-  }
-  memset(host_output, 0, buf_size);
-
-  // Set kernel arguments - each kernel instance gets its own buffer binding
-  int count = DATA_SIZE;
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_add_one, 0, sizeof(void*), &dev_buf));
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_add_one, 1, sizeof(int), &count));
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_multiply_two, 0, sizeof(void*), &dev_buf));
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_multiply_two, 1, sizeof(int), &count));
-  // Fork2 kernel operates on dev_buf (sequential fork, runs after fork1 completes)
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_add_one_fork, 0, sizeof(void*), &dev_buf));
-  ZE_CHECK(zeKernelSetArgumentValue(kernel_add_one_fork, 1, sizeof(int), &count));
-
-  // Create 3 immediate command lists: primary + 2 forks
-  ze_command_queue_desc_t cmd_queue_desc = {
-      ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC, nullptr, 0, 0, 0, ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
-      ZE_COMMAND_QUEUE_PRIORITY_NORMAL};
-
-  ze_command_list_handle_t primary_cmdlist = nullptr;
-  ze_command_list_handle_t fork1_cmdlist = nullptr;
-  ze_command_list_handle_t fork2_cmdlist = nullptr;
-
-  ZE_CHECK(zeCommandListCreateImmediate(context, device, &cmd_queue_desc, &primary_cmdlist));
-  ZE_CHECK(zeCommandListCreateImmediate(context, device, &cmd_queue_desc, &fork1_cmdlist));
-  ZE_CHECK(zeCommandListCreateImmediate(context, device, &cmd_queue_desc, &fork2_cmdlist));
-
-  // Create 4 events: fork1, join1, fork2, join2
-  constexpr uint32_t EVENT_POOL_SIZE = 4;
-  ze_event_pool_desc_t pool_desc = {ZE_STRUCTURE_TYPE_EVENT_POOL_DESC, nullptr,
-                                    ZE_EVENT_POOL_FLAG_HOST_VISIBLE, EVENT_POOL_SIZE};
-  ze_event_pool_handle_t event_pool = nullptr;
-  ZE_CHECK(zeEventPoolCreate(context, &pool_desc, 1, &device, &event_pool));
-
-  ze_event_handle_t events[EVENT_POOL_SIZE];
-  for (uint32_t i = 0; i < EVENT_POOL_SIZE; ++i) {
-    ze_event_desc_t evt_desc = {ZE_STRUCTURE_TYPE_EVENT_DESC, nullptr, i,
-                                ZE_EVENT_SCOPE_FLAG_SUBDEVICE, ZE_EVENT_SCOPE_FLAG_SUBDEVICE};
-    ZE_CHECK(zeEventCreate(event_pool, &evt_desc, &events[i]));
-  }
-
-  ze_event_handle_t fork_event1 = events[0];
-  ze_event_handle_t join_event1 = events[1];
-  ze_event_handle_t fork_event2 = events[2];
-  ze_event_handle_t join_event2 = events[3];
-
-  // Capture graph with fork/join
-  ze_graph_handle_t graph = nullptr;
-  ze_executable_graph_handle_t exec_graph = nullptr;
-
-  // Use group_size=1 so group_count=DATA_SIZE to ensure all work items execute
-  // (some simulators don't support SIMD dispatch within a work group)
-  uint32_t group_size_x = 1;
-  ZE_CHECK(zeKernelSetGroupSize(kernel_add_one, group_size_x, 1, 1));
-  ZE_CHECK(zeKernelSetGroupSize(kernel_multiply_two, group_size_x, 1, 1));
-  ZE_CHECK(zeKernelSetGroupSize(kernel_add_one_fork, group_size_x, 1, 1));
-  uint32_t group_count_x = DATA_SIZE / group_size_x;
-  std::cout << "Kernel group size: " << group_size_x << ", group count: " << group_count_x << std::endl;
-
-  if (!CaptureGraphWithForks(kernel_add_one, kernel_multiply_two, kernel_add_one_fork,
-                              context, primary_cmdlist, fork1_cmdlist, fork2_cmdlist,
-                              dev_buf, host_input, staging_buf, host_output, buf_size,
-                              fork_event1, join_event1, fork_event2, join_event2,
-                              group_count_x, graph, exec_graph)) {
-    std::cerr << "ERROR: Failed to capture graph with forks" << std::endl;
-    return false;
-  }
-
-  std::cout << "Graph captured successfully with sequential forks: Fork1->Primary->Fork2->Primary" << std::endl;
-
-  // Execute the graph multiple times
-  for (int i = 0; i < graph_exec_count; ++i) {
-    ZE_CHECK(AppendGraph(primary_cmdlist, exec_graph));
-  }
-
-  // Synchronize
-  ZE_CHECK(zeCommandListHostSynchronize(primary_cmdlist, UINT64_MAX));
-
-  // Verify results for single iteration
-  int* output = static_cast<int*>(host_output);
-  if (graph_exec_count == 1) {
-    bool correct = true;
-    // Debug: print first 8 values
-    std::cout << "Output[0..7]: ";
-    for (int i = 0; i < 8 && i < DATA_SIZE; ++i) {
-      std::cout << output[i] << " ";
-    }
-    std::cout << std::endl;
-
-    // Expected: (i + 2) * 2 = 2i + 4
-    // Steps: add_one(i)=i+1, fork1 D2D round-trip (no-op), fork2 add_one=(i+1)+1=i+2,
-    //        multiply_two=(i+2)*2=2i+4
-    for (int i = 0; i < DATA_SIZE; ++i) {
-      int expected = (i + 2) * 2;
-      if (output[i] != expected) {
-        std::cerr << "MISMATCH at [" << i << "]: expected=" << expected
-                  << " got=" << output[i] << std::endl;
-        correct = false;
-        break;
-      }
-    }
-    std::cout << "Result verification: " << (correct ? "PASSED" : "FAILED") << std::endl;
-  } else {
-    std::cout << "Result verification: skipped (multi-iteration)" << std::endl;
-  }
-
-  // Cleanup
-  ExecutableGraphDestroy(exec_graph);
-  GraphDestroy(graph);
-
-  for (uint32_t i = 0; i < EVENT_POOL_SIZE; ++i) {
-    zeEventDestroy(events[i]);
-  }
-  zeEventPoolDestroy(event_pool);
-
-  zeCommandListDestroy(fork2_cmdlist);
-  zeCommandListDestroy(fork1_cmdlist);
-  zeCommandListDestroy(primary_cmdlist);
-
-  zeMemFree(context, staging_buf);
-  zeMemFree(context, dev_buf);
-  zeMemFree(context, host_output);
-  zeMemFree(context, host_input);
-
-  return true;
-}
-
-
-/// Initializes Level Zero resources, loads kernels, and runs the graph pipeline.
-static bool RunGraphTest(ze_device_handle_t device, ze_driver_handle_t driver,
-                          int graph_exec_count) {
-  const std::string kernel_module = "graph_kernels.spv";
-  std::string kernel_path = utils::GetExecutablePath();
-  if (!kernel_path.empty() && kernel_path.back() != '/') {
-    kernel_path += '/';
-  }
-  kernel_path += kernel_module;
-
-  std::vector<uint8_t> binary = utils::LoadBinaryFile(kernel_path);
-  if (binary.empty()) {
-    std::cerr << "ERROR: Unable to load kernel module: " << kernel_path << std::endl;
-    return false;
-  }
-
-  ze_context_handle_t context = utils::ze::GetContext(driver);
-  if (context == nullptr) {
-    std::cerr << "ERROR: Failed to get Level Zero context" << std::endl;
-    return false;
-  }
-
-  // Create module from SPIR-V binary
-  ze_module_desc_t module_desc = {ZE_STRUCTURE_TYPE_MODULE_DESC,
-                                  nullptr,
-                                  ZE_MODULE_FORMAT_IL_SPIRV,
-                                  static_cast<uint32_t>(binary.size()),
-                                  binary.data(),
-                                  nullptr,
-                                  nullptr};
-  ze_module_handle_t module = nullptr;
-  ZE_CHECK(zeModuleCreate(context, device, &module_desc, &module, nullptr));
-
-  // Create add_one kernel (used on primary cmdlist)
-  ze_kernel_desc_t kernel_desc_add = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, "add_one"};
-  ze_kernel_handle_t kernel_add_one = nullptr;
-  ZE_CHECK(zeKernelCreate(module, &kernel_desc_add, &kernel_add_one));
-
-  // Create multiply_two kernel (used on primary cmdlist)
-  ze_kernel_desc_t kernel_desc_mul = {ZE_STRUCTURE_TYPE_KERNEL_DESC, nullptr, 0, "multiply_two"};
-  ze_kernel_handle_t kernel_multiply_two = nullptr;
-  ZE_CHECK(zeKernelCreate(module, &kernel_desc_mul, &kernel_multiply_two));
-
-  // Create separate add_one kernel instance for fork2 cmdlist
-  // (separate handle avoids any kernel state sharing across cmdlists)
-  ze_kernel_handle_t kernel_add_one_fork = nullptr;
-  ZE_CHECK(zeKernelCreate(module, &kernel_desc_add, &kernel_add_one_fork));
-
-  // Enable data collection
-  utils::SetEnv("PTI_ENABLE_COLLECTION", "1");
-
-  if (!RunGraphPipeline(kernel_add_one, kernel_multiply_two, kernel_add_one_fork,
-                        context, device, graph_exec_count)) {
-    std::cerr << "ERROR: Graph pipeline failed" << std::endl;
-    return false;
-  }
-
-  // Disable data collection
-  utils::SetEnv("PTI_ENABLE_COLLECTION", "");
-
-  // Cleanup
-  zeKernelDestroy(kernel_add_one_fork);
-  zeKernelDestroy(kernel_multiply_two);
-  zeKernelDestroy(kernel_add_one);
-  zeModuleDestroy(module);
-  zeContextDestroy(context);
-
-  return true;
-}
-
-int main(int argc, char* argv[]) {
-  if (zeInit(ZE_INIT_FLAG_GPU_ONLY) != ZE_RESULT_SUCCESS) {
-    std::cerr << "ERROR: Failed to initialize Level Zero" << std::endl;
-    return 1;
-  }
-
-  ze_device_handle_t device = utils::ze::GetGpuDevice();
-  ze_driver_handle_t driver = utils::ze::GetGpuDriver();
-  if (device == nullptr || driver == nullptr) {
-    std::cerr << "ERROR: Unable to find GPU device" << std::endl;
-    return 1;
-  }
-
-  if (!LoadGraphExtension(driver)) {
-    std::cerr << "ERROR: Graph extension not available" << std::endl;
-    return 1;
-  }
-
-  int graph_exec_count = GRAPH_EXECUTION_COUNT;
-  if (argc >= MIN_CLI_ARGS) {
-    try {
-      graph_exec_count = std::stoi(argv[1]);
-      if (graph_exec_count <= 0) {
-        std::cerr << "ERROR: Count must be positive" << std::endl;
-        return 1;
-      }
-    } catch (const std::exception& e) {
-      std::cerr << "ERROR: Invalid count: " << argv[1] << std::endl;
-      return 1;
-    }
-  }
-
-  std::cout << "Level Zero Graph API Test (Sequential Fork/Join Pattern)" << std::endl;
-  std::cout << "Target device: " << utils::ze::GetDeviceName(device) << std::endl;
-  std::cout << "Graph executions: " << graph_exec_count << std::endl;
-  std::cout << "Data size: " << DATA_SIZE << " elements" << std::endl;
-  std::cout << "Pattern: Primary -> Fork1 -> Primary -> Fork2 -> Primary (sequential, both join to primary)" << std::endl;
-
-  auto start = std::chrono::steady_clock::now();
-  bool success = RunGraphTest(device, driver, graph_exec_count);
-  auto end = std::chrono::steady_clock::now();
-  if (!success) {
-    std::cerr << "ERROR: Graph test failed" << std::endl;
-    return 1;
-  }
-  std::chrono::duration<float> elapsed = end - start;
-  std::cout << "\nTotal execution time: " << elapsed.count() << " seconds" << std::endl;
-
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/.gitignore b/tools/unitrace/test/fuzz/.gitignore
deleted file mode 100644
index 1ec8ca9e..00000000
--- a/tools/unitrace/test/fuzz/.gitignore
+++ /dev/null
@@ -1,9 +0,0 @@
-build/
-build_fixed/
-results/
-crash-*
-oom-*
-timeout-*
-# SDL505 evidence and findings register: uploaded to SDL, not committed
-evidence/
-findings.json
diff --git a/tools/unitrace/test/fuzz/README.md b/tools/unitrace/test/fuzz/README.md
deleted file mode 100644
index fbdc6497..00000000
--- a/tools/unitrace/test/fuzz/README.md
+++ /dev/null
@@ -1,114 +0,0 @@
-# Fuzz Testing for Unitrace (SDL505)
-
-Fuzz harnesses and campaign scripts for SDL task SDL505 - Perform Fuzz Testing
-(UNITRACEI-135). The evidence report and the findings register are not committed:
-`make_evidence.py` writes them to `evidence/`, and `tar -czf SDL505_evidence.tar.gz
-evidence` packs them for the SDL upload.
-
-## What is fuzzed
-
-Every harness calls the code unitrace ships, not a copy. The parsers of files
-unitrace reads back from disk, and the helpers that write names into JSON or
-check numbers from the environment and the driver, are functions of their own
-in the file that uses them (`ze_metrics.h`, `ze_collector.h`, `utils_ze.h`,
-`utils_host.h`, `chromelogger.h`, `unitrace.cc`), free of Level Zero calls. The
-harnesses include those files; `UNITRACE_FUZZ` leaves out `unitrace.cc`'s
-`main()`. The one exception: `fuzz_metric_samples` repeats the two `ze_metrics.h`
-loops that read the values once `CalculatedSamplesFit` accepted the counts, since
-they call Level Zero.
-
-| Target | Untrusted input | Code |
-|--------|-----------------|------|
-| `fuzz_elf64` | Module native binary from the GPU driver (ELF64/ZeBin, DWARF `.debug_line`) | `elf64_reader.h`, `kernel_extractor.h`, `source_resolver.h` |
-| `fuzz_metric_query` | `.metrics.<pid>.q` in `UNITRACE_DataDir` | `ze_metrics.h` `ReadMetricQueryRecord` |
-| `fuzz_stall_sampling` | `.t` sampling segments in `UNITRACE_DataDir` | `ze_metrics.h` `ReadMetricSegment` |
-| `fuzz_kernel_props` | `.kprops` / `.ktime` in `UNITRACE_DataDir` | `ze_metrics.h` `ReadKernelPropsRecord`, `ReadKernelTimeRecord` |
-| `fuzz_cli_args` | Command line | `cli_options.h` `ParseArgs`, `JsonEscape` |
-| `fuzz_kernel_filter` | `--include/--exclude-kernels[-file]` | `ze_collector.h` `ParseFilterList` |
-| `fuzz_sample_lists` | `--devices/--ranks-to-sample`, `PMI_SIZE`, `PMI_RANK`, ... | `utils_ze.h` `ParseDeviceList`, `ParseRankList` |
-| `fuzz_kmd_trace` | bpftrace output for `--chrome-kmd-logging` | `unitrace.cc` `ReadKmdEvent`, `KmdEventToJson` |
-| `fuzz_analyzeperfmetrics` | Metric CSV | `analyzeperfmetrics.py` (also the `perfdashboard.py` read path) |
-| `fuzz_mergetrace` | Chrome JSON / Perfetto traces | `mergetrace.py` |
-| `fuzz_summary` | Tar archive of summaries | `summary.py` `read_summary_tar` |
-| `fuzz_categorize` | Category schema INI | `categorize.py` `build_tree_from_ini` |
-| `fuzz_roofline_csv` | Device config and metric CSV | `roofline_libs.py` |
-| `fuzz_trace_json` | Kernel, ITT and device names and the command line written to the trace and config log | `utils_host.h` `JsonString`, `chromelogger.h` `JsonNameField`, `unitrace.cc` `StringifyJsonArray` |
-| `fuzz_env_numbers` | `UNITRACE_DeviceId`, `PTI_DEVICE_ID`, `--chrome-event-buffer-size`, ... | `utils_ze.h` `ParseDeviceIndex`, `DevicesStringToSet`, `utils_host.h` `ParseChromeEventBufferSize` |
-| `fuzz_metric_samples` | Counts the driver returns with calculated metric values (in place of a Level Zero mock) | `ze_metrics.h` `CalculatedSamplesFit`, `UnwrapTimestamp` |
-| `fuzz_metrics_server` | Requests to the localhost metrics server, `-f` options file | `analyzeperfmetrics.py` `ParseMetricsRequest`, `ReadOptionsFromFile` |
-| `fuzz_perfdashboard_upload` | CSV uploaded to the counter dashboard | `perfdashboard.py` `upload_csv_input1` |
-
-Besides crashes, hangs and memory exhaustion, some harnesses check output:
-`fuzz_kmd_trace`, `fuzz_cli_args` and `fuzz_trace_json` require valid JSON (`cpp/json_check.h`),
-`fuzz_env_numbers` requires an accepted number to be the one written,
-`fuzz_mergetrace` requires a successful merge to be valid JSON. A Python harness
-lists the exceptions that are a clean rejection of malformed input; any other
-exception is a finding.
-
-## Build
-
-C++: the targets build with unitrace (clang with libFuzzer; the Level Zero headers
-unitrace fetches, no GPU needed). Any clang that links libFuzzer works, including
-the one oneAPI ships (`$CMPLR_ROOT/bin/compiler/clang++`); test_unitrace.py picks it
-by itself when there is no clang on PATH. The binaries land in `build-fuzz/test/fuzz/cpp`:
-
-```sh
-cmake -S tools/unitrace -B build-fuzz -DUNITRACE_BUILD_FUZZ=ON \
-      -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang \
-      -DBUILD_WITH_OMP=0 -DBUILD_WITH_PERFETTO=OFF
-cmake --build build-fuzz --target unitrace_fuzz
-```
-
-`BUILD_WITH_OMP=0` and `BUILD_WITH_PERFETTO=OFF`, as test_unitrace.py and
-`coverage_report.sh` use: no fuzzed parser is in either, CMake's OpenMP lookup fails
-for oneAPI's bare clang, and Perfetto would download and build protobuf.
-
-Python: `pip install atheris` (plus the scripts' own requirements, `requirements.txt`).
-
-## Run
-
-```sh
-cd tools/unitrace/test/fuzz
-./run_fuzz.sh -t 3600 -s 1 -b ../../../../build-fuzz/test/fuzz/cpp          # all targets in parallel, 1 h each
-./run_fuzz.sh -t 600 -b ../../../../build-fuzz/test/fuzz/cpp elf64 kmd_trace  # selected targets
-```
-
-Each target gets `results/campaign/<target>/` with the evolving `corpus/`,
-reproducers in `artifacts/` (`crash-*`, `oom-*`, `timeout-*`), the full `fuzz.log`
-and `run.json` (command, seed, duration, start/end, exit status). A target directory
-that already exists (an earlier or concurrent run) is refused, so use a new `-o`
-for each campaign; the script exits non-zero if any campaign failed or its
-`run.json` could not be written. Limits: 10 s per
-input, 1 GB per allocation, and an RSS limit of 2 GB (`-m`). Atheris' instrumentation
-grows a Python fuzzing process by ~1.7 KB per input, so give hour-long Python runs
-`-m 4096`.
-
-The default `-b` is `../../build/test/fuzz/cpp` (a build in `tools/unitrace/build`);
-for the `build-fuzz` build above, pass `-b` as shown.
-
-Replay one input: `build-fuzz/test/fuzz/cpp/fuzz_<target> <file>` or `python3 python/fuzz_<target>.py <file>`.
-
-## Coverage, regression, evidence
-
-```sh
-./coverage_report.sh results/campaign results/coverage   # llvm-cov and coverage.py, text/JSON/HTML
-(cd .. && python3 test_unitrace.py --test-name 'fuzz_*') > results/regression.txt
-python3 make_evidence.py --campaign main=results/campaign
-```
-
-`coverage_report.sh` needs `clang`, `llvm-profdata` and `llvm-cov` (or their `-18`
-variants) and `coverage.py` (`pip install coverage`). It rebuilds unitrace with
-coverage flags; extra CMake options for that build (e.g. `-DBUILD_WITH_XPTI=0`) go
-in the `UNITRACE_CMAKE_ARGS` environment variable.
-
-Each target is also a test in `test/tests.txt` (`[fuzz_<target>]`, running
-`replay.py <target>`): `python test_unitrace.py` (in `test/`) builds the targets and
-runs them with the other cpp tests, as CI does; `--test-name 'fuzz_*'` runs only
-the fuzz tests, `--test-name fuzz_elf64` one target. A new target runs in CI once it
-has its `[fuzz_<target>]` block there; a C++ target also needs its
-`add_fuzz_target()` entry in `cpp/CMakeLists.txt`, or it is not built.
-
-`regression/<target>/` holds every input that crashed a target; the fuzz tests
-replay them with the seed corpus. Add a new crash input there when a finding is
-fixed. `make_evidence.py` reads the register of findings and their disposition
-from `findings.json` (not committed).
diff --git a/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_stall.csv b/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_stall.csv
deleted file mode 100644
index 03f940e7..00000000
--- a/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_stall.csv
+++ /dev/null
@@ -1,6 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel,Pid,KernelId
-"test_kernel",12345,1
-Source,Offset,Instruction,Dependency,Active[Events],ControlStall[Events],SbidStall[Events]
-"test.cl:10",0x00000080,"(W) and (1|M0) r0:ud","NA",5,2,0
diff --git a/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_timed.csv b/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_timed.csv
deleted file mode 100644
index 7d8f86c6..00000000
--- a/tools/unitrace/test/fuzz/corpus/analyzeperfmetrics/valid_timed.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 1
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-100000, 200000, 1800
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 2
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-110000, 210000, 1795
diff --git a/tools/unitrace/test/fuzz/corpus/categorize/valid.ini b/tools/unitrace/test/fuzz/corpus/categorize/valid.ini
deleted file mode 100644
index 0a989858..00000000
--- a/tools/unitrace/test/fuzz/corpus/categorize/valid.ini
+++ /dev/null
@@ -1,9 +0,0 @@
-[matmul if equals to]
-gemm_kernel
-
-[allreduce if ends with]
-ALLREDUCE_SMALL
-ALLREDUCE_LARGE
-
-[conv if starts with]
-conv2d_forward
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/accepted_values.bin b/tools/unitrace/test/fuzz/corpus/cli_args/accepted_values.bin
deleted file mode 100644
index e772b803..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/accepted_values.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/action.bin b/tools/unitrace/test/fuzz/corpus/cli_args/action.bin
deleted file mode 100644
index e8c830b9..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/action.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/basic_flags.bin b/tools/unitrace/test/fuzz/corpus/cli_args/basic_flags.bin
deleted file mode 100644
index 235b09c3..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/basic_flags.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/chrome_opts.bin b/tools/unitrace/test/fuzz/corpus/cli_args/chrome_opts.bin
deleted file mode 100644
index 6b2dd995..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/chrome_opts.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/missing_value.bin b/tools/unitrace/test/fuzz/corpus/cli_args/missing_value.bin
deleted file mode 100644
index 6c284422..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/missing_value.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/cli_args/rejected_values.bin b/tools/unitrace/test/fuzz/corpus/cli_args/rejected_values.bin
deleted file mode 100644
index 36d84014..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/cli_args/rejected_values.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/elf64/dwarf4_line_table.elf b/tools/unitrace/test/fuzz/corpus/elf64/dwarf4_line_table.elf
deleted file mode 100644
index 0e47dbfb..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/elf64/dwarf4_line_table.elf and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/elf64/dwarf5_line_table.elf b/tools/unitrace/test/fuzz/corpus/elf64/dwarf5_line_table.elf
deleted file mode 100644
index 865df36d..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/elf64/dwarf5_line_table.elf and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/elf64/empty.bin b/tools/unitrace/test/fuzz/corpus/elf64/empty.bin
deleted file mode 100644
index e69de29b..00000000
diff --git a/tools/unitrace/test/fuzz/corpus/elf64/minimal_elf.bin b/tools/unitrace/test/fuzz/corpus/elf64/minimal_elf.bin
deleted file mode 100644
index fc050713..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/elf64/minimal_elf.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/elf64/not_elf.bin b/tools/unitrace/test/fuzz/corpus/elf64/not_elf.bin
deleted file mode 100644
index e0d84f45..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/elf64/not_elf.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/env_numbers/defaults.bin b/tools/unitrace/test/fuzz/corpus/env_numbers/defaults.bin
deleted file mode 100644
index 7f6c9bec..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/env_numbers/defaults.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/env_numbers/valid.bin b/tools/unitrace/test/fuzz/corpus/env_numbers/valid.bin
deleted file mode 100644
index 68cbac6b..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/env_numbers/valid.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/env_numbers/zero_padded_index b/tools/unitrace/test/fuzz/corpus/env_numbers/zero_padded_index
deleted file mode 100644
index abe05d87..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/env_numbers/zero_padded_index and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/kernel_filter/quoted.txt b/tools/unitrace/test/fuzz/corpus/kernel_filter/quoted.txt
deleted file mode 100644
index 3bc89517..00000000
--- a/tools/unitrace/test/fuzz/corpus/kernel_filter/quoted.txt
+++ /dev/null
@@ -1 +0,0 @@
-"foo,bar",baz,"qux,with,commas"
diff --git a/tools/unitrace/test/fuzz/corpus/kernel_filter/simple.txt b/tools/unitrace/test/fuzz/corpus/kernel_filter/simple.txt
deleted file mode 100644
index dc3b5f2e..00000000
--- a/tools/unitrace/test/fuzz/corpus/kernel_filter/simple.txt
+++ /dev/null
@@ -1 +0,0 @@
-matmul,conv2d,gemm
diff --git a/tools/unitrace/test/fuzz/corpus/kernel_filter/whitespace.txt b/tools/unitrace/test/fuzz/corpus/kernel_filter/whitespace.txt
deleted file mode 100644
index 424ef363..00000000
--- a/tools/unitrace/test/fuzz/corpus/kernel_filter/whitespace.txt
+++ /dev/null
@@ -1 +0,0 @@
-  spaces , around , values  
diff --git a/tools/unitrace/test/fuzz/corpus/kernel_props/kprops_valid.txt b/tools/unitrace/test/fuzz/corpus/kernel_props/kprops_valid.txt
deleted file mode 100644
index b7fce6bc..00000000
--- a/tools/unitrace/test/fuzz/corpus/kernel_props/kprops_valid.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-"_ZTS7kernel1"
-0x800000001000
-12
-3
-"_ZTS7kernel2"
-0x800000002000
-13
-3
diff --git a/tools/unitrace/test/fuzz/corpus/kernel_props/ktime_valid.txt b/tools/unitrace/test/fuzz/corpus/kernel_props/ktime_valid.txt
deleted file mode 100644
index f191275c..00000000
--- a/tools/unitrace/test/fuzz/corpus/kernel_props/ktime_valid.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-0
-1
-123456789
-123459999
-"gemm_kernel"
-1
-2
-223456789
-223459999
-"vec_add"
diff --git a/tools/unitrace/test/fuzz/corpus/kmd_trace/empty_fields.txt b/tools/unitrace/test/fuzz/corpus/kmd_trace/empty_fields.txt
deleted file mode 100644
index eb92cf62..00000000
--- a/tools/unitrace/test/fuzz/corpus/kmd_trace/empty_fields.txt
+++ /dev/null
@@ -1 +0,0 @@
-,,,,
diff --git a/tools/unitrace/test/fuzz/corpus/kmd_trace/invalid_numbers.txt b/tools/unitrace/test/fuzz/corpus/kmd_trace/invalid_numbers.txt
deleted file mode 100644
index 8538cc81..00000000
--- a/tools/unitrace/test/fuzz/corpus/kmd_trace/invalid_numbers.txt
+++ /dev/null
@@ -1 +0,0 @@
-not_a_number,func,not_a_number,not_a_number
diff --git a/tools/unitrace/test/fuzz/corpus/kmd_trace/valid.txt b/tools/unitrace/test/fuzz/corpus/kmd_trace/valid.txt
deleted file mode 100644
index 1e1ed91c..00000000
--- a/tools/unitrace/test/fuzz/corpus/kmd_trace/valid.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-1234,kmd_func,1000000,500
-5678,another_func,2000000,1000,extra_data
diff --git a/tools/unitrace/test/fuzz/corpus/mergetrace/truncated.json b/tools/unitrace/test/fuzz/corpus/mergetrace/truncated.json
deleted file mode 100644
index db076b4c..00000000
--- a/tools/unitrace/test/fuzz/corpus/mergetrace/truncated.json
+++ /dev/null
@@ -1,2 +0,0 @@
-{ "traceEvents": [
-{"ph": "X", "name": "kernel1", "cat": "gpu", "pid": 1, "tid": 1, "ts": 1000, "dur": 500}
diff --git a/tools/unitrace/test/fuzz/corpus/mergetrace/valid_trace.json b/tools/unitrace/test/fuzz/corpus/mergetrace/valid_trace.json
deleted file mode 100644
index 1b9eed81..00000000
--- a/tools/unitrace/test/fuzz/corpus/mergetrace/valid_trace.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{ "traceEvents": [
-{"ph": "X", "name": "kernel1", "cat": "gpu", "pid": 1, "tid": 1, "ts": 1000, "dur": 500},
-{"ph": "X", "name": "kernel2", "cat": "gpu", "pid": 1, "tid": 1, "ts": 2000, "dur": 300}
-]}
diff --git a/tools/unitrace/test/fuzz/corpus/metric_query/huge_kname.bin b/tools/unitrace/test/fuzz/corpus/metric_query/huge_kname.bin
deleted file mode 100644
index cb03cf6c..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/metric_query/huge_kname.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/metric_query/valid_record.bin b/tools/unitrace/test/fuzz/corpus/metric_query/valid_record.bin
deleted file mode 100644
index b3b02cfa..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/metric_query/valid_record.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/metric_samples/valid.bin b/tools/unitrace/test/fuzz/corpus/metric_samples/valid.bin
deleted file mode 100644
index cc0270a5..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/metric_samples/valid.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/metric_samples/wrapped_ts.bin b/tools/unitrace/test/fuzz/corpus/metric_samples/wrapped_ts.bin
deleted file mode 100644
index 8314ab36..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/metric_samples/wrapped_ts.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/metrics_server/config.bin b/tools/unitrace/test/fuzz/corpus/metrics_server/config.bin
deleted file mode 100644
index 4dd61627..00000000
--- a/tools/unitrace/test/fuzz/corpus/metrics_server/config.bin
+++ /dev/null
@@ -1 +0,0 @@
-
-d 1 -k kernel_a -i 2
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/corpus/metrics_server/request.bin b/tools/unitrace/test/fuzz/corpus/metrics_server/request.bin
deleted file mode 100644
index 5ac93870..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/metrics_server/request.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/metrics_server/request_result_dir.bin b/tools/unitrace/test/fuzz/corpus/metrics_server/request_result_dir.bin
deleted file mode 100644
index 33c527be..00000000
--- a/tools/unitrace/test/fuzz/corpus/metrics_server/request_result_dir.bin
+++ /dev/null
@@ -1 +0,0 @@
-/"kernel_a[SIMD32]"/3/0
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_stall.csv b/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_stall.csv
deleted file mode 100644
index 03f940e7..00000000
--- a/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_stall.csv
+++ /dev/null
@@ -1,6 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel,Pid,KernelId
-"test_kernel",12345,1
-Source,Offset,Instruction,Dependency,Active[Events],ControlStall[Events],SbidStall[Events]
-"test.cl:10",0x00000080,"(W) and (1|M0) r0:ud","NA",5,2,0
diff --git a/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_timed.csv b/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_timed.csv
deleted file mode 100644
index 7d8f86c6..00000000
--- a/tools/unitrace/test/fuzz/corpus/perfdashboard_upload/valid_timed.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 1
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-100000, 200000, 1800
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 2
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-110000, 210000, 1795
diff --git a/tools/unitrace/test/fuzz/corpus/roofline_csv/valid_timed.csv b/tools/unitrace/test/fuzz/corpus/roofline_csv/valid_timed.csv
deleted file mode 100644
index 7d8f86c6..00000000
--- a/tools/unitrace/test/fuzz/corpus/roofline_csv/valid_timed.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 1
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-100000, 200000, 1800
-
-Kernel, GlobalInstanceId
-"test_kernel[SIMD32 {64; 1; 1} {16; 1; 1}]", 2
-GpuTime[ns], GpuCoreClocks[cycles], AvgGpuCoreFrequencyMHz[MHz]
-110000, 210000, 1795
diff --git a/tools/unitrace/test/fuzz/corpus/sample_lists/rank1.bin b/tools/unitrace/test/fuzz/corpus/sample_lists/rank1.bin
deleted file mode 100644
index 071316ad..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/sample_lists/rank1.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/sample_lists/valid.bin b/tools/unitrace/test/fuzz/corpus/sample_lists/valid.bin
deleted file mode 100644
index a53a32dc..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/sample_lists/valid.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/stall_sampling/huge_data.bin b/tools/unitrace/test/fuzz/corpus/stall_sampling/huge_data.bin
deleted file mode 100644
index acc903de..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/stall_sampling/huge_data.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/stall_sampling/valid_segment.bin b/tools/unitrace/test/fuzz/corpus/stall_sampling/valid_segment.bin
deleted file mode 100644
index 7ad7019b..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/stall_sampling/valid_segment.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/summary/realistic_timing.tgz b/tools/unitrace/test/fuzz/corpus/summary/realistic_timing.tgz
deleted file mode 100644
index 4ff60860..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/summary/realistic_timing.tgz and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/summary/valid.tgz b/tools/unitrace/test/fuzz/corpus/summary/valid.tgz
deleted file mode 100644
index 0076089b..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/summary/valid.tgz and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/trace_json/plain_name.bin b/tools/unitrace/test/fuzz/corpus/trace_json/plain_name.bin
deleted file mode 100644
index f8f904fe..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/trace_json/plain_name.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/corpus/trace_json/quoted_kernel.bin b/tools/unitrace/test/fuzz/corpus/trace_json/quoted_kernel.bin
deleted file mode 100644
index 95b5d7b5..00000000
Binary files a/tools/unitrace/test/fuzz/corpus/trace_json/quoted_kernel.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/coverage_report.sh b/tools/unitrace/test/fuzz/coverage_report.sh
deleted file mode 100755
index d4b2ebab..00000000
--- a/tools/unitrace/test/fuzz/coverage_report.sh
+++ /dev/null
@@ -1,206 +0,0 @@
-#!/bin/bash
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Measures the code coverage a campaign's corpora reach in the fuzzed product code.
-#
-# Usage: ./coverage_report.sh [campaign_dir] [out_dir]
-#   campaign_dir  output of run_fuzz.sh: <dir>/<target>/corpus (default results/campaign);
-#                 a target the campaign did not run is measured on corpus/<target>
-#   out_dir       default results/coverage
-#
-# C++: each harness is rebuilt with clang source-based coverage and its corpus and
-#      regression inputs replayed (-runs=0); llvm-cov reports the product sources
-#      (src/), not the harnesses. Each binary carries an empty stub for every header
-#      function it does not call, which a profile or report merged across binaries
-#      mixes with the real records ("functions have mismatched data"), so each target
-#      is measured on its own and a line, branch or function counts as covered if any
-#      target covers it.
-# Python: coverage.py (lines and branches) over coverage_replay.py, restricted to the
-#      fuzzed scripts; lines and branches are reported separately, their mix as
-#      total_percent.
-# Writes cpp_report.txt, cpp_coverage.json, lcov/, html_cpp/<target>/,
-# python_report.txt, python_coverage.json, html_python/ and coverage_summary.json.
-
-set -eu
-FUZZ_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$FUZZ_DIR/../.." && pwd)"
-SRC="$ROOT/src"
-SCRIPTS="$ROOT/scripts"
-CAMPAIGN="$(cd "${1:-$FUZZ_DIR/results/campaign}" && pwd)"
-OUT="${2:-$FUZZ_DIR/results/coverage}"
-mkdir -p "$OUT"
-OUT="$(cd "$OUT" && pwd)"
-BIN="$OUT/bin"
-PROF="$OUT/profraw"
-rm -rf "$BIN" "$PROF" "$OUT/lcov" "$OUT/html_cpp" "$OUT/html_python" "$OUT"/.coverage*
-mkdir -p "$BIN" "$PROF" "$OUT/lcov" "$OUT/html_cpp"
-
-LLVM_PROFDATA=$(command -v llvm-profdata || command -v llvm-profdata-18)
-LLVM_COV=$(command -v llvm-cov || command -v llvm-cov-18)
-
-# The targets are the harnesses in cpp/ and python/.
-CPP_TARGETS=()
-for f in "$FUZZ_DIR"/cpp/fuzz_*.cc; do t="${f##*/fuzz_}"; CPP_TARGETS+=("${t%.cc}"); done
-PY_TARGETS=()
-for f in "$FUZZ_DIR"/python/fuzz_*.py; do
-  t="${f##*/fuzz_}"; t="${t%.py}"; [[ $t == common ]] || PY_TARGETS+=("$t")
-done
-# Files that are parsers throughout: measured whole.
-CPP_SOURCES=("$SRC/utils/elf64_reader.h" "$SRC/utils/kernel_extractor.h"
-             "$SRC/utils/source_resolver.h" "$SRC/utils/cli_options.h")
-# Files that hold parsers next to Level Zero code: only the parser functions are
-# measured (the rest needs a GPU and is out of scope).
-CPP_MIXED_SOURCES=("$SRC/levelzero/ze_metrics.h" "$SRC/levelzero/ze_collector.h" "$SRC/utils/utils_ze.h"
-                   "$SRC/utils/utils_host.h" "$SRC/chromelogger.h" "$SRC/unitrace.cc")
-CPP_PARSER_FUNCTIONS="SplitFilterLine|ParseFilterList|ReadMetricQueryRecord|ReadMetricSegment|\
-ReadKernelPropsRecord|ReadKernelTimeRecord|CalculatedSamplesFit|UnwrapTimestamp|ParseDeviceList|\
-ParseRankList|ParseDeviceIndex|DevicesStringToSet|JsonEscape|JsonString|Utf8SequenceLength|IsDigits|\
-ToInt|ToUint32|ParseChromeEventBufferSize|UnquoteName|JsonNameField|IsDecimal|ParseKmdLine|ReadKmdEvent|\
-KmdEventToJson|StringifyJsonArray"
-
-# The input directories of target $1, one per line: its campaign corpus, or the
-# checked-in corpus/<target> when the campaign did not run it (a campaign on selected
-# targets), and regression/<target> if there is one. Only existing directories.
-inputs() {
-  local dirs=()
-  if [[ -d "$CAMPAIGN/$1/corpus" ]]; then
-    dirs+=("$CAMPAIGN/$1/corpus")
-  elif [[ -d "$FUZZ_DIR/corpus/$1" ]]; then
-    dirs+=("$FUZZ_DIR/corpus/$1")
-  fi
-  [[ -d "$FUZZ_DIR/regression/$1" ]] && dirs+=("$FUZZ_DIR/regression/$1")
-  printf '%s\n' "${dirs[@]}"
-}
-
-# The harnesses include the unitrace sources, so they build with unitrace.
-cmake -S "$ROOT" -B "$BIN/build" -DUNITRACE_BUILD_FUZZ=ON -DCMAKE_BUILD_TYPE=Debug \
-  -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DUNITRACE_FUZZ_SANITIZERS=fuzzer \
-  -DUNITRACE_FUZZ_EXTRA_FLAGS="-O0 -fprofile-instr-generate -fcoverage-mapping" -DBUILD_WITH_OMP=0 -DBUILD_WITH_PERFETTO=OFF ${UNITRACE_CMAKE_ARGS:-} \
-  > "$OUT/build.log" 2>&1
-cmake --build "$BIN/build" --target unitrace_fuzz >> "$OUT/build.log" 2>&1
-
-for t in "${CPP_TARGETS[@]}"; do
-  cp "$BIN/build/test/fuzz/cpp/fuzz_$t" "$BIN/fuzz_$t"
-  mapfile -t dirs < <(inputs "$t")
-  LLVM_PROFILE_FILE="$PROF/$t.profraw" "$BIN/fuzz_$t" -runs=0 -close_fd_mask=3 \
-    -rss_limit_mb=2048 -malloc_limit_mb=1024 "${dirs[@]}" > "$OUT/replay_$t.log" 2>&1
-  "$LLVM_PROFDATA" merge -sparse "$PROF/$t.profraw" -o "$OUT/lcov/$t.profdata"
-  "$LLVM_COV" export -format=lcov "$BIN/fuzz_$t" -instr-profile="$OUT/lcov/$t.profdata" \
-    "${CPP_SOURCES[@]}" "${CPP_MIXED_SOURCES[@]}" > "$OUT/lcov/$t.info"
-  # Per-function line ranges, to keep only the parser functions of the mixed files.
-  "$LLVM_COV" export -format=text -skip-expansions "$BIN/fuzz_$t" -instr-profile="$OUT/lcov/$t.profdata" \
-    "${CPP_MIXED_SOURCES[@]}" > "$OUT/lcov/$t.json"
-  "$LLVM_COV" show "$BIN/fuzz_$t" -instr-profile="$OUT/lcov/$t.profdata" -format=html \
-    -output-dir="$OUT/html_cpp/$t" "${CPP_SOURCES[@]}" "${CPP_MIXED_SOURCES[@]}"
-done
-
-PARSER_FUNCTIONS="$CPP_PARSER_FUNCTIONS" MIXED_SOURCES="${CPP_MIXED_SOURCES[*]}" \
-python3 - "$OUT" "$ROOT" "$("$LLVM_COV" --version | grep -o 'version [0-9.]*')" "${CPP_TARGETS[@]}" <<'PY'
-import collections, json, os, re, sys
-out, root, version, targets = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4:]
-parser_re = re.compile(os.environ["PARSER_FUNCTIONS"])
-mixed = {os.path.relpath(p, root) for p in os.environ["MIXED_SOURCES"].split()}
-# In the mixed files only the lines inside a parser function count.
-allowed = collections.defaultdict(set)     # file -> lines of parser functions
-for t in targets:
-    for fn in json.load(open(os.path.join(out, "lcov", t + ".json")))["data"][0]["functions"]:
-        if not parser_re.search(fn["name"]):
-            continue
-        for r in fn["regions"]:
-            f = os.path.relpath(fn["filenames"][r[5]], root)
-            if f in mixed:
-                allowed[f].update(range(r[0], r[2] + 1))
-def keep(f, ln):
-    return f not in mixed or ln in allowed[f]
-lines = collections.defaultdict(dict)      # file -> line -> max count over targets
-branches = collections.defaultdict(dict)   # file -> (line, block, branch) -> max taken
-functions = collections.defaultdict(dict)  # file -> mangled name -> max count
-for t in targets:
-    f = None
-    for rec in open(os.path.join(out, "lcov", t + ".info")):
-        key, _, val = rec.strip().partition(":")
-        if key == "SF":
-            f = os.path.relpath(val, root)
-        elif key == "DA":
-            ln, cnt = val.split(",")[:2]
-            if not keep(f, int(ln)):
-                continue
-            lines[f][int(ln)] = max(lines[f].get(int(ln), 0), int(cnt))
-        elif key == "BRDA":
-            ln, blk, br, taken = val.split(",")
-            if not keep(f, int(ln)):
-                continue
-            k = (int(ln), blk, br)
-            branches[f][k] = max(branches[f].get(k, 0), 0 if taken == "-" else int(taken))
-        elif key == "FNDA":
-            cnt, name = val.split(",", 1)
-            if f in mixed and not parser_re.search(name):
-                continue
-            functions[f][name] = max(functions[f].get(name, 0), int(cnt))
-pct = lambda h, n: round(100.0 * h / n, 2) if n else 100.0
-hit = lambda d: [sum(1 for c in d.values() if c > 0), len(d)]
-files = {f: {"lines": hit(lines[f]), "branches": hit(branches[f]), "functions": hit(functions[f])}
-         for f in sorted(lines)}
-tot = {k: [sum(v[k][0] for v in files.values()), sum(v[k][1] for v in files.values())]
-       for k in ("lines", "branches", "functions")}
-json.dump({"tool": f"llvm-cov {version}", "method": "union over targets of per-target llvm-cov LCOV exports",
-           "files": files, "totals": tot}, open(os.path.join(out, "cpp_coverage.json"), "w"), indent=2)
-with open(os.path.join(out, "cpp_report.txt"), "w") as o:
-    o.write(f"C++ product code coverage (llvm-cov {version}): union over the {len(targets)} targets of each\n"
-            "target's own profile, covered hits / instrumented total.\n\n")
-    o.write(f"{'File':34} {'Lines':>20} {'Branches':>20} {'Functions':>20}\n")
-    for f, v in list(files.items()) + [("TOTAL", tot)]:
-        cell = lambda k: f"{v[k][0]}/{v[k][1]} {pct(*v[k]):6.2f}%"
-        o.write(f"{f:34} {cell('lines'):>20} {cell('branches'):>20} {cell('functions'):>20}\n")
-PY
-
-PY_SOURCES="$SCRIPTS/metrics/analyzeperfmetrics.py,$SCRIPTS/metrics/perfdashboard.py,$SCRIPTS/tracemerge/mergetrace.py,$SCRIPTS/summary/summary.py,$SCRIPTS/summary/categorize.py,$SCRIPTS/roofline/roofline_libs.py"
-for t in "${PY_TARGETS[@]}"; do
-  mapfile -t dirs < <(inputs "$t")
-  (cd "$OUT" && UNITRACE_FUZZ_REPLAY=1 COVERAGE_FILE="$OUT/.coverage.$t" \
-     python3 -m coverage run --branch --include="$PY_SOURCES" \
-     "$FUZZ_DIR/python/coverage_replay.py" "$t" "${dirs[@]}" > "$OUT/replay_$t.log" 2>&1)
-done
-(cd "$OUT" && python3 -m coverage combine --keep .coverage.* > /dev/null &&
- python3 -m coverage report > python_report.txt &&
- python3 -m coverage json -o python_coverage.json > /dev/null &&
- python3 -m coverage html -d html_python > /dev/null)
-
-python3 - "$OUT" "$ROOT" <<'PY'
-import json, os, sys
-out, root = sys.argv[1], sys.argv[2]
-cpp = json.load(open(os.path.join(out, "cpp_coverage.json")))
-py = json.load(open(os.path.join(out, "python_coverage.json")))
-pct = lambda h, n: round(100.0 * h / n, 2) if n else 100.0
-summary = {
-    "cpp": {
-        "tool": cpp["tool"],
-        "method": cpp["method"],
-        "files": {f: {"lines_percent": pct(*v["lines"]), "branches_percent": pct(*v["branches"]),
-                      "functions_percent": pct(*v["functions"])} for f, v in cpp["files"].items()},
-        "total_lines_percent": pct(*cpp["totals"]["lines"]),
-        "total_branches_percent": pct(*cpp["totals"]["branches"]),
-        "total_functions_percent": pct(*cpp["totals"]["functions"]),
-    },
-    "python": {
-        "tool": "coverage.py " + py["meta"]["version"] + " (lines and branches)",
-        # percent_covered mixes statements and branches; lines and branches are
-        # reported on their own, the mix as total_percent. A relative filename is
-        # relative to out, where coverage json ran; join keeps an absolute one.
-        "files": {os.path.relpath(os.path.join(out, k), root): {
-                      "lines_percent": pct(v["summary"]["covered_lines"], v["summary"]["num_statements"]),
-                      "branches_percent": pct(v["summary"].get("covered_branches", 0), v["summary"].get("num_branches", 0))}
-                  for k, v in py["files"].items()},
-        "total_lines_percent": pct(py["totals"]["covered_lines"], py["totals"]["num_statements"]),
-        "total_branches_percent": pct(py["totals"].get("covered_branches", 0), py["totals"].get("num_branches", 0)),
-        "total_percent": round(py["totals"]["percent_covered"], 2),
-    },
-}
-json.dump(summary, open(os.path.join(out, "coverage_summary.json"), "w"), indent=2)
-print(json.dumps(summary, indent=2))
-PY
-rm -rf "$BIN" "$PROF"
diff --git a/tools/unitrace/test/fuzz/cpp/CMakeLists.txt b/tools/unitrace/test/fuzz/cpp/CMakeLists.txt
deleted file mode 100644
index bb3139fc..00000000
--- a/tools/unitrace/test/fuzz/cpp/CMakeLists.txt
+++ /dev/null
@@ -1,159 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzz targets for unitrace (SDL505 — Perform Fuzz Testing)
-#
-# The targets include the unitrace sources the parsers live in (ze_collector.h,
-# ze_metrics.h, utils_ze.h, utils_host.h, chromelogger.h, unitrace.cc), so they build as part of
-# unitrace, with its include paths and generated headers. No GPU is needed:
-#   cmake -S tools/unitrace -B build-fuzz -DUNITRACE_BUILD_FUZZ=ON \
-#         -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang \
-#         -DBUILD_WITH_OMP=0 -DBUILD_WITH_PERFETTO=OFF
-#   cmake --build build-fuzz --target unitrace_fuzz
-#
-# Each target is a standalone libFuzzer binary.
-
-# Clang, or oneAPI's clang-based icpx (IntelLLVM).
-if(NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang|IntelLLVM")
-  message(FATAL_ERROR "The fuzz targets need clang (libFuzzer); set CMAKE_CXX_COMPILER=clang++")
-endif()
-
-set(UNITRACE_SRC "${PROJECT_SOURCE_DIR}/src")
-
-# Common compiler flags for all fuzz targets. coverage_report.sh builds with
-# UNITRACE_FUZZ_SANITIZERS=fuzzer and coverage flags in UNITRACE_FUZZ_EXTRA_FLAGS.
-set(UNITRACE_FUZZ_SANITIZERS "fuzzer,address,undefined" CACHE STRING "-fsanitize= for the fuzz targets")
-set(UNITRACE_FUZZ_EXTRA_FLAGS "" CACHE STRING "Extra compile and link flags for the fuzz targets")
-set(FUZZ_COMPILE_FLAGS "-fsanitize=${UNITRACE_FUZZ_SANITIZERS} -fno-sanitize-recover=undefined -fno-omit-frame-pointer -g -O1 ${UNITRACE_FUZZ_EXTRA_FLAGS}")
-set(FUZZ_LINK_FLAGS    "-fsanitize=${UNITRACE_FUZZ_SANITIZERS} ${UNITRACE_FUZZ_EXTRA_FLAGS}")
-
-# The include paths and definitions unitrace and the collector library build with,
-# plus the generated headers in the build directory.
-set(FUZZ_INCLUDE_DIRS
-  "${CMAKE_BINARY_DIR}"
-  "${UNITRACE_SRC}"
-  "${UNITRACE_SRC}/levelzero"
-  "${UNITRACE_SRC}/opencl"
-  "${UNITRACE_SRC}/itt"
-  "$<TARGET_PROPERTY:unitrace,INCLUDE_DIRECTORIES>"
-  "$<TARGET_PROPERTY:unitrace_tool,INCLUDE_DIRECTORIES>"
-)
-set(FUZZ_DEFINITIONS
-  UNITRACE_FUZZ
-  "$<TARGET_PROPERTY:unitrace,COMPILE_DEFINITIONS>"
-)
-
-add_custom_target(unitrace_fuzz)
-
-# ---------------------------------------------------------------------------
-# Helper: declare a fuzz target
-# ---------------------------------------------------------------------------
-function(add_fuzz_target name)
-  cmake_parse_arguments(FT "" "" "SOURCES;INCLUDES;LIBS" ${ARGN})
-  add_executable(${name} ${FT_SOURCES} "${UNITRACE_SRC}/utils/logger_factory.cc")
-  target_include_directories(${name} PRIVATE ${FUZZ_INCLUDE_DIRS} ${FT_INCLUDES})
-  target_compile_definitions(${name} PRIVATE ${FUZZ_DEFINITIONS})
-  set_target_properties(${name} PROPERTIES
-    COMPILE_FLAGS "${FUZZ_COMPILE_FLAGS}"
-    LINK_FLAGS    "${FUZZ_LINK_FLAGS}"
-  )
-  target_compile_features(${name} PRIVATE cxx_std_17)
-  target_link_libraries(${name} ${CMAKE_DL_LIBS} pthread ${FT_LIBS})
-  # logger_factory.cc uses <filesystem>: link the library unitrace links for it, if
-  # the toolchain needs one (the parent CMakeLists.txt checks).
-  if (FILESYSTEM_NEEDS_LIBSTDCXXFS)
-    target_link_libraries(${name} stdc++fs)
-  elseif (FILESYSTEM_NEEDS_LIBCXXFS)
-    target_link_libraries(${name} c++fs)
-  endif()
-  # Where the collector's libraries are (e.g. Xptifw_LIBRARY_DIR for -lxptifw), for
-  # the targets that link them.
-  target_link_directories(${name} PRIVATE "$<TARGET_PROPERTY:unitrace_tool,LINK_DIRECTORIES>")
-  # The generated headers (.gen, commit hash, IGA) come from the unitrace build.
-  add_dependencies(${name} unitrace unitrace_tool)
-  add_dependencies(unitrace_fuzz ${name})
-endfunction()
-
-# ---------------------------------------------------------------------------
-# 1. ELF64 / ZeBin parser chain (elf64_reader.h, kernel_extractor.h,
-#    source_resolver.h) — highest-value binary format target
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_elf64
-  SOURCES fuzz_elf64.cc
-)
-
-# ---------------------------------------------------------------------------
-# 2. Binary metric query file parser (.q files) — ze_metrics.h
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_metric_query
-  SOURCES fuzz_metric_query.cc
-)
-
-# ---------------------------------------------------------------------------
-# 3. Binary stall sampling file parser (.t files) — ze_metrics.h
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_stall_sampling
-  SOURCES fuzz_stall_sampling.cc
-)
-
-# ---------------------------------------------------------------------------
-# 4. CLI argument parser — cli_options.h
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_cli_args
-  SOURCES fuzz_cli_args.cc
-)
-
-# ---------------------------------------------------------------------------
-# 5. Kernel filter file parser — ze_collector.h ParseFilterList()
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_kernel_filter
-  SOURCES fuzz_kernel_filter.cc
-)
-
-# ---------------------------------------------------------------------------
-# 6. KMD trace data parser — unitrace.cc ReadKmdEvent(), ParseKmdLine(), KmdEventToJson()
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_kmd_trace
-  SOURCES fuzz_kmd_trace.cc
-)
-
-# ---------------------------------------------------------------------------
-# 7. Kernel properties (.kprops) and kernel times (.ktime) readers
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_kernel_props
-  SOURCES fuzz_kernel_props.cc
-)
-
-# ---------------------------------------------------------------------------
-# 8. --devices-to-sample / --ranks-to-sample and the MPI launcher environment
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_sample_lists
-  SOURCES fuzz_sample_lists.cc
-)
-
-# ---------------------------------------------------------------------------
-# 9. Names and arguments written into the Chrome trace and the config log
-# ---------------------------------------------------------------------------
-# tracer.h brings the collectors chromelogger.h relies on, so link what the
-# collector library links (OpenCL, ...).
-add_fuzz_target(fuzz_trace_json
-  SOURCES fuzz_trace_json.cc
-  LIBS "$<TARGET_PROPERTY:unitrace_tool,LINK_LIBRARIES>"
-)
-
-# ---------------------------------------------------------------------------
-# 10. Device indexes and the Chrome event buffer size from the environment
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_env_numbers
-  SOURCES fuzz_env_numbers.cc
-)
-
-# ---------------------------------------------------------------------------
-# 11. Metric value counts returned by the driver and the sampling timestamps
-# ---------------------------------------------------------------------------
-add_fuzz_target(fuzz_metric_samples
-  SOURCES fuzz_metric_samples.cc
-)
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_cli_args.cc b/tools/unitrace/test/fuzz/cpp/fuzz_cli_args.cc
deleted file mode 100644
index 7d1b1c3d..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_cli_args.cc
+++ /dev/null
@@ -1,147 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzz harness for the generic CLI argument parser (cli_options.h). It parses
-// with its own option table, not unitrace's kCliOptions: the values unitrace's
-// handlers and FinalizeParse() convert (device and MPI rank lists, device index,
-// Chrome event buffer size) are fuzzed by fuzz_sample_lists and fuzz_env_numbers.
-//
-// Defines a minimal option table that exercises every CliOption variant
-// (Bool, BoolH, Value with validator, ValueH, Action) and feeds fuzz-derived
-// argv arrays through cli::ParseArgs(). The Value options have no environment
-// variable: glibc keeps every string set with setenv(), so fuzz-derived values
-// there would grow memory over a campaign. --flag-a still sets one, to "1".
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include <sstream>
-
-#include "cli_options.h"
-#include "json_check.h"
-
-// Minimal context struct exercising all handler paths.
-struct FuzzCtx {
-  bool flag_a = false;
-  bool flag_b = false;
-  std::string value_c;
-  std::string value_d;
-  bool action_fired = false;
-};
-
-// Validator: accepts only alphanumeric strings.
-static bool ValidateAlnum(const std::string &s) {
-  for (char c : s) {
-    if (!std::isalnum(static_cast<unsigned char>(c))) return false;
-  }
-  return !s.empty();
-}
-
-// Validator: accepts only numeric strings.
-static bool ValidateNumeric(const std::string &s) {
-  for (char c : s) {
-    if (!std::isdigit(static_cast<unsigned char>(c))) return false;
-  }
-  return !s.empty();
-}
-
-// Handler for BoolH: sets a flag on the context.
-static cli::Status HandleBoolH(FuzzCtx &ctx,
-                                const cli::CliOption<FuzzCtx> &,
-                                const char *) {
-  ctx.flag_b = !ctx.flag_b;
-  return cli::Status::Ok;
-}
-
-// Handler for ValueH: stores a string on the context.
-static cli::Status HandleValueH(FuzzCtx &ctx,
-                                 const cli::CliOption<FuzzCtx> &,
-                                 const char *value) {
-  ctx.value_d = value ? value : "";
-  return cli::Status::Ok;
-}
-
-// Handler for Action: simulates --help / --version.
-static cli::Status HandleAction(FuzzCtx &ctx,
-                                 const cli::CliOption<FuzzCtx> &,
-                                 const char *) {
-  ctx.action_fired = true;
-  return cli::Status::ExitOk;
-}
-
-using Opt = cli::Factory<FuzzCtx>;
-
-static constexpr cli::CliOption<FuzzCtx> kFuzzOptions[] = {
-    Opt::Bool("--flag-a", "-a", "core", "A boolean flag", "FUZZ_FLAG_A"),
-    Opt::BoolH("--flag-b", "-b", "core", "A handled boolean flag", HandleBoolH),
-    Opt::Value("--value-c", "-c", "string", "core", "name",
-               "A validated string value", nullptr, ValidateAlnum),
-    Opt::Value("--value-num", "-n", "int", "core", "number",
-               "A numeric value", nullptr, ValidateNumeric, "0"),
-    Opt::ValueH("--value-d", "-d", "string", "core", "data",
-                "A handled value", HandleValueH),
-    Opt::Action("--action", "core", "A print-and-exit action", HandleAction),
-};
-
-static constexpr size_t kNumOptions =
-    sizeof(kFuzzOptions) / sizeof(kFuzzOptions[0]);
-
-// libFuzzer entry point: one input is one command line.
-//   data, size  the argv strings, separated by NUL bytes (at most 64 are used);
-//               argv[0] is "fuzz_unitrace"
-// Parses them with cli::ParseArgs() against kFuzzOptions, then checks that
-// cli::JsonEscape() of every argument is a valid JSON string. Returns 0; a crash,
-// a sanitizer report or the trap is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  // Build argv by splitting fuzz input on null bytes.
-  std::vector<std::string> tokens;
-  tokens.push_back("fuzz_unitrace");
-
-  const char *begin = reinterpret_cast<const char *>(data);
-  const char *end = begin + size;
-  const char *p = begin;
-
-  while (p < end) {
-    const char *nul = static_cast<const char *>(
-        std::memchr(p, '\0', static_cast<size_t>(end - p)));
-    if (nul == nullptr) {
-      tokens.emplace_back(p, end);
-      break;
-    }
-    tokens.emplace_back(p, nul);
-    p = nul + 1;
-  }
-
-  // Limit to avoid combinatorial explosion.
-  if (tokens.size() > 64) {
-    tokens.resize(64);
-  }
-
-  // Build the char* argv.
-  std::vector<char *> argv;
-  argv.reserve(tokens.size());
-  for (auto &t : tokens) {
-    argv.push_back(t.data());
-  }
-
-  FuzzCtx ctx;
-  int argc = static_cast<int>(argv.size());
-  (void)cli::ParseArgs<FuzzCtx>(argc, argv.data(), kFuzzOptions, kNumOptions,
-                                 ctx);
-
-  // Oracle: JsonEscape (used for --print-options-schema) must produce a valid JSON string.
-  for (const auto &t : tokens) {
-    std::ostringstream os;
-    cli::JsonEscape(os, t.c_str());
-    if (!json_check::IsValid(os.str())) __builtin_trap();
-  }
-
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_elf64.cc b/tools/unitrace/test/fuzz/cpp/fuzz_elf64.cc
deleted file mode 100644
index 9e05636d..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_elf64.cc
+++ /dev/null
@@ -1,109 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzz harness for the ELF64/ZeBin parser chain:
-//   elf64_reader.h  -> ReadElf64Sections, FindElf64Section
-//   kernel_extractor.h -> ReadGenArchitectureNotes, GetKernelBinary
-//   source_resolver.h  -> CollectRelocations, ParseLineUnit, KernelLineTable
-//
-// Feeds arbitrary bytes as a module binary and exercises every parsing layer.
-
-#include <cstddef>
-#include <cstdint>
-#include <cstdlib>
-#include <string>
-#include <vector>
-
-#include "elf64_reader.h"
-#include "kernel_extractor.h"
-#include "source_resolver.h"
-
-// libFuzzer entry point: one input is one module native binary from the driver.
-//   data, size  the binary (ELF64/ZeBin), any bytes
-// Runs it through every layer unitrace parses a module with: the section table, the
-// architecture notes, the kernel binary lookup, the relocations and DWARF line units
-// of .debug_line, and KernelLineTable::Build() for the first .text.<kernel>.
-// Returns 0; parse errors are expected, a crash or sanitizer report is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  // Layer 1: section table
-  std::vector<Elf64Section> sections;
-  Elf64Status status = ReadElf64Sections(data, size, sections);
-
-  if (status != Elf64Status::kOk) {
-    return 0;
-  }
-
-  // Layer 2: architecture notes
-  GenArchitecture arch;
-  (void)ReadGenArchitectureNotes(data, size, sections, arch, false);
-
-  // Layer 2b: look up common section names
-  (void)FindElf64Section(sections, ".text");
-  (void)FindElf64Section(sections, ".debug_line");
-  (void)FindElf64Section(sections, ".debug_str");
-  (void)FindElf64Section(sections, ".debug_line_str");
-  (void)FindElf64Section(sections, ".note.intelgt.compat");
-
-  // Layer 3: try to extract a kernel binary for a dummy kernel name
-  KernelBinaryView kernel_view;
-  (void)GetKernelBinary(data, size, "fuzz_kernel", kernel_view);
-
-  // Layer 4: if .debug_line exists, exercise the DWARF line-table decoder
-  int64_t debug_line_idx = FindElf64Section(sections, ".debug_line");
-  if (debug_line_idx >= 0 && sections[debug_line_idx].data_ != nullptr) {
-    const Elf64Section &debug_line = sections[debug_line_idx];
-
-    StringTableView debug_str{};
-    int64_t ds = FindElf64Section(sections, ".debug_str");
-    if (ds >= 0) {
-      debug_str.data_ = sections[ds].data_;
-      debug_str.size_ = sections[ds].size_;
-    }
-
-    StringTableView debug_line_str{};
-    int64_t dls = FindElf64Section(sections, ".debug_line_str");
-    if (dls >= 0) {
-      debug_line_str.data_ = sections[dls].data_;
-      debug_line_str.size_ = sections[dls].size_;
-    }
-
-    // Collect relocations for all .text.* sections
-    for (size_t i = 0; i < sections.size(); ++i) {
-      if (sections[i].name_.substr(0, 6) == ".text.") {
-        std::string text_name(sections[i].name_);
-        Relocations relocations;
-        CollectRelocations(sections, static_cast<uint32_t>(debug_line_idx),
-                           static_cast<uint32_t>(i), text_name, debug_line,
-                           relocations);
-      }
-    }
-
-    // Parse every line unit
-    ByteCursor cursor(debug_line.data_, debug_line.size_);
-    while (!cursor.Done()) {
-      LineUnit unit;
-      bool fatal = false;
-      (void)ParseLineUnit(cursor, debug_str, debug_line_str, nullptr, unit, fatal);
-      if (fatal) {
-        break;
-      }
-    }
-  }
-
-  // Layer 5: full KernelLineTable::Build (exercises the whole chain end-to-end)
-  // Try with a few plausible kernel names from sections we found.
-  for (const auto &section : sections) {
-    if (section.name_.size() > 6 &&
-        section.name_.substr(0, 6) == ".text.") {
-      std::string kernel_name(section.name_.substr(6));
-      KernelLineTable table;
-      (void)table.Build(data, size, kernel_name);
-      break;
-    }
-  }
-
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_env_numbers.cc b/tools/unitrace/test/fuzz/cpp/fuzz_env_numbers.cc
deleted file mode 100644
index ea8b4def..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_env_numbers.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the numbers unitrace and the collector read from the environment and the
-// command line: UNITRACE_DeviceId, PTI_DEVICE_ID and PTI_SUB_DEVICE_ID
-// (utils_ze.h ParseDeviceIndex(), unitrace.cc, utils_ze.h),
-// UNITRACE_ChromeEventBufferSize from --chrome-event-buffer-size
-// (utils_host.h ParseChromeEventBufferSize(), unitrace.cc, chromelogger.h TraceBuffer) and the
-// devices to sample as the metric profiler reads them (DevicesStringToSet(),
-// ze_metrics.h). The collector runs inside the application, so an exception here
-// terminates it. Input: device index \0 buffer size \0 device list.
-
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <set>
-#include <string>
-
-#include "utils_ze.h"
-
-// libFuzzer entry point: one input is three environment values.
-//   data, size  device index \0 Chrome event buffer size \0 device list
-// Checks that an accepted device index is exactly the decimal number given (not a
-// prefix or a truncation of it) and an accepted buffer size is not below -1, and
-// runs the profiler's device list through DevicesStringToSet(). Returns 0; an
-// uncaught exception (it would terminate the application) or the trap is the
-// finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string input(reinterpret_cast<const char*>(data), size);
-  std::string part[3];
-  size_t pos = 0;
-  for (int k = 0; k < 3 && pos <= input.size(); ++k) {
-    size_t nul = input.find('\0', pos);
-    part[k] = input.substr(pos, nul == std::string::npos ? std::string::npos : nul - pos);
-    if (nul == std::string::npos) break;
-    pos = nul + 1;
-  }
-
-  // An accepted index must be the number written, not a prefix or a truncation of it.
-  uint32_t device = 0;
-  if (ParseDeviceIndex(part[0], device) && !part[0].empty() &&
-      (!IsDigits(part[0]) || std::strtoull(part[0].c_str(), nullptr, 10) != device)) {
-    fprintf(stderr, "[FUZZ] device index %s accepted as %u\n", part[0].c_str(), device);
-    __builtin_trap();
-  }
-
-  int capacity = 0;
-  if (ParseChromeEventBufferSize(part[1], capacity) && capacity < -1) {
-    fprintf(stderr, "[FUZZ] chrome event buffer size %s accepted as %d\n", part[1].c_str(), capacity);
-    __builtin_trap();
-  }
-
-  std::set<int> devices;
-  DevicesStringToSet(part[2], devices);
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_kernel_filter.cc b/tools/unitrace/test/fuzz/cpp/fuzz_kernel_filter.cc
deleted file mode 100644
index 4477dd9e..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_kernel_filter.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the kernel filter parser (--include-kernels[-file], --exclude-kernels[-file]),
-// ze_collector.h ParseFilterList(), as ze_collector.h calls it. The first input
-// line is the --*-kernels string, the rest is the --*-kernels-file contents.
-
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-
-#include "levelzero/ze_collector.h"
-
-// libFuzzer entry point: one input is one kernel filter.
-//   data, size  first line: the --include-kernels string; the rest: the contents of
-//               the --include-kernels-file
-// Checks that every item ParseFilterList() returns is non-empty and has no leading
-// or trailing whitespace. Returns 0; the trap is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string input(reinterpret_cast<const char*>(data), size);
-  size_t nl = input.find('\n');
-  std::string filter = input.substr(0, nl);
-  std::istringstream file(nl == std::string::npos ? std::string() : input.substr(nl + 1));
-  auto items = ::ParseFilterList(&file, filter);
-  for (const auto& item : items) {
-    // An item is never empty and never starts or ends with whitespace.
-    if (item.empty() || isspace(static_cast<unsigned char>(item.front())) ||
-        isspace(static_cast<unsigned char>(item.back()))) {
-      __builtin_trap();
-    }
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_kernel_props.cc b/tools/unitrace/test/fuzz/cpp/fuzz_kernel_props.cc
deleted file mode 100644
index 9a139e2e..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_kernel_props.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the kernel properties (.kprops) and kernel times (.ktime) readers,
-// ze_metrics.h ReadKernelPropsRecord() and ReadKernelTimeRecord(), as
-// ze_metrics.h ReadModuleAndKernelProps() and ComputeTimedMetrics() call them.
-
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-
-#include "levelzero/ze_metrics.h"
-
-// libFuzzer entry point: one input is read both as a .kprops and as a .ktime file.
-//   data, size  the file contents
-// Reads every record until the reader stops. Returns 0; a crash, hang or sanitizer
-// report is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string input(reinterpret_cast<const char*>(data), size);
-  {
-    std::istringstream in(input);
-    KernelPropsRecord record;
-    while (ReadKernelPropsRecord(in, record)) {
-    }
-  }
-  {
-    std::istringstream in(input);
-    KernelTimeRecord record;
-    std::string kernel_name;
-    // A .ktime record is the four fields, then the kernel name on its own line,
-    // which ComputeTimedMetrics() reads after each record.
-    while (ReadKernelTimeRecord(in, record) && std::getline(in, kernel_name)) {
-    }
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_kmd_trace.cc b/tools/unitrace/test/fuzz/cpp/fuzz_kmd_trace.cc
deleted file mode 100644
index 34006088..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_kmd_trace.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the raw KMD trace reader (--chrome-kmd-logging), unitrace.cc
-// ReadKmdEvent() and KmdEventToJson(), as unitrace.cc DumpKmdTraceData() calls
-// them. Oracle: every event written to oskmd.json must be valid JSON.
-
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-
-#include "unitrace.cc"  // UNITRACE_FUZZ leaves out its main()
-#include "json_check.h"
-
-// libFuzzer entry point: one input is one raw KMD trace (bpftrace output).
-//   data, size  the trace
-// Reads every event and checks that the Chrome trace event written for it is valid
-// JSON. Returns 0; the trap is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::istringstream in(std::string(reinterpret_cast<const char*>(data), size));
-  KmdEvent event;
-  while (ReadKmdEvent(in, event)) {
-    std::string json = KmdEventToJson(event, event.timestamp_, event.duration_);
-    if (!json_check::IsValid(json)) {
-      fprintf(stderr, "[FUZZ] invalid JSON emitted: %s\n", json.c_str());
-      __builtin_trap();
-    }
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_metric_query.cc b/tools/unitrace/test/fuzz/cpp/fuzz_metric_query.cc
deleted file mode 100644
index 565142c9..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_metric_query.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the intermediate metric query file (.q) reader, ze_metrics.h
-// ReadMetricQueryRecord(), as ze_metrics.h ComputeMetricsQueried() calls it.
-
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-
-#include "levelzero/ze_metrics.h"
-
-// libFuzzer entry point: one input is one .q metric query file.
-//   data, size  the file contents
-// Reads every record until the reader stops. Returns 0; a crash, an allocation
-// beyond -malloc_limit_mb or a sanitizer report is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::istringstream in(std::string(reinterpret_cast<const char*>(data), size),
-                        std::ios::binary);
-  MetricQueryRecord record;
-  while (ReadMetricQueryRecord(in, record)) {
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_metric_samples.cc b/tools/unitrace/test/fuzz/cpp/fuzz_metric_samples.cc
deleted file mode 100644
index 31231ef4..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_metric_samples.cc
+++ /dev/null
@@ -1,93 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the checks on what the driver returns for the sampled metrics, in place of
-// a Level Zero mock: ze_metrics.h CalculatedSamplesFit(), which ze_metrics.h
-// ComputeStallMetrics() and ComputeTimedMetrics() call on the counts of
-// zetMetricGroupCalculateMultipleMetricValuesExp before reading the values, and
-// UnwrapTimestamp() on the sampling timestamps. When the counts are accepted, the
-// values are read row by row as both loops in ze_metrics.h read them, so ASan
-// reports a read past the buffer. The loops are copies (the real ones call Level
-// Zero); the stall array they fill is bounded by ComputeStallMetrics() itself,
-// which rejects more than max_num_of_stall_types stall metrics up front.
-// Input: the timestamps (uint64 previous, ts, span), then num_samples, num_values
-// (uint16 each), row_size (uint8), then the samples[] entries (uint32 each).
-
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-#include <vector>
-
-#include "levelzero/ze_metrics.h"
-
-// Takes the next sizeof(T) bytes of the input as out (unaligned, host byte order)
-// and advances data and size past them. Returns false, leaving everything as it
-// is, when fewer bytes are left.
-template <typename T>
-static bool Take(const uint8_t*& data, size_t& size, T& out) {
-  if (size < sizeof(T)) return false;
-  memcpy(&out, data, sizeof(T));
-  data += sizeof(T);
-  size -= sizeof(T);
-  return true;
-}
-
-// libFuzzer entry point: one input is one set of driver results.
-//   data, size  previous, ts, span (uint64 each), then num_samples, num_values
-//               (uint16 each), row_size (uint8), then the samples[] entries
-//               (uint32 each)
-// Checks UnwrapTimestamp() against the loop it replaced, then, if
-// CalculatedSamplesFit() accepts the counts, reads the values as both ze_metrics.h
-// loops do. Returns 0; the trap or an ASan read past the values is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  uint64_t previous = 0, ts = 0, span = 0;
-  if (Take(data, size, previous) && Take(data, size, ts) && Take(data, size, span)) {
-    const uint64_t unwrapped = UnwrapTimestamp(ts, previous, span);
-    // The result is the first whole number of spans on that is not before previous,
-    // as the loop it replaced (while (previous > ts) ts += span) computed; where that
-    // does not fit a uint64_t, previous.
-    if (span != 0 && ts < previous) {
-      const unsigned __int128 expected =
-          ts + (static_cast<unsigned __int128>((previous - ts - 1) / span) + 1) * span;
-      if (unwrapped != (expected <= UINT64_MAX ? static_cast<uint64_t>(expected) : previous)) {
-        fprintf(stderr, "[FUZZ] UnwrapTimestamp(%lu, %lu, %lu) = %lu\n", ts, previous, span, unwrapped);
-        __builtin_trap();
-      }
-    }
-  }
-
-  uint16_t num_samples = 0, num_values = 0;
-  uint8_t row_size = 0;
-  if (!Take(data, size, num_samples) || !Take(data, size, num_values) || !Take(data, size, row_size)) {
-    return 0;
-  }
-  // The buffers ze_metrics.h allocates from the first call's counts; the driver's
-  // second call returns the counts under test.
-  std::vector<uint32_t> samples(size / sizeof(uint32_t));
-  if (!samples.empty()) memcpy(samples.data(), data, samples.size() * sizeof(uint32_t));
-  const size_t values_capacity = samples.size() * 4;
-  std::vector<uint64_t> values(values_capacity);
-
-  if (!CalculatedSamplesFit(samples.data(), num_samples, samples.size(), num_values,
-                                           values.size(), row_size)) {
-    return 0;
-  }
-  volatile uint64_t sink = 0;
-  const uint64_t* value = values.data();
-  for (uint32_t i = 0; i < num_samples; ++i) {
-    // ComputeStallMetrics: rows of row_size values from j.
-    for (uint32_t j = 0; j + row_size <= samples[i]; j += row_size) {
-      for (uint32_t k = 0; k < row_size; ++k) sink += value[j + k];
-    }
-    // ComputeTimedMetrics: samples[i] / row_size rows.
-    for (uint32_t j = 0; j < samples[i] / row_size; ++j) {
-      for (uint32_t k = 0; k < row_size; ++k) sink += value[j * row_size + k];
-    }
-    value += samples[i];
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_sample_lists.cc b/tools/unitrace/test/fuzz/cpp/fuzz_sample_lists.cc
deleted file mode 100644
index 5e1467c8..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_sample_lists.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the --devices-to-sample and --ranks-to-sample parsers and the MPI
-// launcher environment they read (PMI_SIZE, PMI_RANK, ...), utils_ze.h
-// ParseDeviceList() and ParseRankList(), as utils_ze.h GetZeDevicesToSample()
-// and GetZeRanksToSample() call them. Input: list \0 size \0 rank.
-
-#include <cstddef>
-#include <cstdint>
-#include <set>
-#include <string>
-
-#include "utils_ze.h"
-
-// libFuzzer entry point: one input is one sample list and MPI environment.
-//   data, size  list \0 MPI size \0 MPI rank
-// Parses list as --devices-to-sample and as --ranks-to-sample. Returns 0; an
-// uncaught exception or a crash is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string input(reinterpret_cast<const char*>(data), size);
-  std::string part[3];
-  size_t pos = 0;
-  for (int k = 0; k < 3 && pos <= input.size(); ++k) {
-    size_t nul = input.find('\0', pos);
-    part[k] = input.substr(pos, nul == std::string::npos ? std::string::npos : nul - pos);
-    if (nul == std::string::npos) break;
-    pos = nul + 1;
-  }
-  std::set<int> devices;
-  (void)ParseDeviceList(part[0], devices);
-  std::set<int> ranks;
-  (void)ParseRankList(part[0], part[1], part[2], ranks);
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_stall_sampling.cc b/tools/unitrace/test/fuzz/cpp/fuzz_stall_sampling.cc
deleted file mode 100644
index 8b559664..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_stall_sampling.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the intermediate metric sampling file (.t) reader, ze_metrics.h
-// ReadMetricSegment(), as ze_metrics.h ComputeStallMetrics() and
-// ComputeTimedMetrics() call it. The buffer is MAX_METRIC_BUFFER as in the tool.
-
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "levelzero/ze_metrics.h"
-
-static constexpr uint64_t kMaxMetricBuffer = 8ULL * 1024ULL * 1024ULL;
-
-// libFuzzer entry point: one input is one .t metric sampling file.
-//   data, size  the file contents
-// Reads every segment into a MAX_METRIC_BUFFER buffer and checks that none is
-// reported larger than the buffer. Returns 0; the trap or an ASan write past the
-// buffer is the finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  static std::vector<uint8_t> buffer(kMaxMetricBuffer);
-  std::istringstream in(std::string(reinterpret_cast<const char*>(data), size),
-                        std::ios::binary);
-  size_t raw_size = 0;
-  while (ReadMetricSegment(in, buffer.data(), kMaxMetricBuffer, raw_size) ==
-         SegmentStatus::kOk) {
-    if (raw_size > kMaxMetricBuffer) __builtin_trap();
-  }
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/fuzz_trace_json.cc b/tools/unitrace/test/fuzz/cpp/fuzz_trace_json.cc
deleted file mode 100644
index 5d812400..00000000
--- a/tools/unitrace/test/fuzz/cpp/fuzz_trace_json.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Fuzzes the strings unitrace writes into JSON: kernel, ITT and device names
-// (chromelogger.h JsonNameField(), utils_host.h JsonString()) and the
-// command line written to the --result-dir config log (unitrace.cc
-// CreateConfigLog() and StringifyJsonArray()). Names come from the
-// module binary (GetZeKernelCommandName quotes them), the application (ITT) and
-// the driver. Input: kernel name \0 device or ITT name \0 argv[0] \0 argv[1] ...
-// Oracle: every record must be valid JSON.
-
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <string>
-#include <vector>
-
-#include "unitrace.cc"  // UNITRACE_FUZZ leaves out its main()
-#include "tracer.h"  // chromelogger.h, after the headers it relies on
-#include "json_check.h"
-
-// Traps, after printing it, if json is not valid JSON: the harness's oracle.
-static void Check(const std::string& json) {
-  if (!json_check::IsValid(json)) {
-    fprintf(stderr, "[FUZZ] invalid JSON emitted: %s\n", json.c_str());
-    __builtin_trap();
-  }
-}
-
-// libFuzzer entry point: one input is one set of names and arguments.
-//   data, size  kernel name \0 device or ITT name \0 argv[0] \0 argv[1] ...
-// Builds the trace and config-log records unitrace writes for them (kernel events
-// with and without a tile prefix, process/thread metadata, ITT arguments, the
-// app_args line) and checks each with Check(). Returns 0; the trap is the
-// finding.
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  std::string input(reinterpret_cast<const char*>(data), size);
-  std::vector<std::string> part;
-  size_t pos = 0;
-  while (true) {
-    size_t nul = input.find('\0', pos);
-    part.push_back(input.substr(pos, nul == std::string::npos ? std::string::npos : nul - pos));
-    if (nul == std::string::npos) break;
-    pos = nul + 1;
-  }
-  const std::string& kernel = part[0];
-  const std::string other = part.size() > 1 ? part[1] : "";
-
-  // Kernel event, with and without implicit scaling (chromelogger.h FlushDeviceBuffer).
-  Check("{\"ph\": \"X\"" + JsonNameField(kernel) + "}");
-  Check("{\"ph\": \"X\"" + JsonNameField(kernel, "Tile #0: ") + "}");
-  // Device process/thread metadata, ITT argument key and string value.
-  Check("{\"args\": {\"name\": " + JsonString(other) + "}}");
-  Check("{\"args\": {" + JsonString(other) + ":[" + JsonString(other) + "]}}");
-
-  // Config log: app and unitrace arguments (C strings, so no embedded NUL).
-  std::vector<char*> argv;
-  for (size_t k = 2; k < part.size(); ++k) {
-    argv.push_back(&part[k][0]);
-  }
-  argv.push_back(nullptr);
-  Check("{" + StringifyJsonArray("app_args", argv.data()) + "\"pid\": 0}");
-  return 0;
-}
diff --git a/tools/unitrace/test/fuzz/cpp/json_check.h b/tools/unitrace/test/fuzz/cpp/json_check.h
deleted file mode 100644
index 8bee3257..00000000
--- a/tools/unitrace/test/fuzz/cpp/json_check.h
+++ /dev/null
@@ -1,182 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-//
-// Minimal strict JSON (RFC 8259) validator, used by the fuzz harnesses as an
-// oracle: output unitrace writes to a trace file must parse.
-
-#ifndef PTI_TOOLS_UNITRACE_FUZZ_JSON_CHECK_H_
-#define PTI_TOOLS_UNITRACE_FUZZ_JSON_CHECK_H_
-
-#include <cctype>
-#include <string>
-
-namespace json_check {
-
-// A recursive-descent parser over one string that only checks it: it builds no
-// value. i_ is the read position; every method returns false at the first byte
-// that cannot continue a valid document. Nesting is limited to 64 levels, so a
-// harness input cannot overflow the stack.
-class Parser {
- public:
-  explicit Parser(const std::string& s) : s_(s) {}
-
-  // true if the whole string is one JSON value, with optional whitespace around
-  // it and nothing after it.
-  bool Document() {
-    Ws();
-    if (!Value(0)) return false;
-    Ws();
-    return i_ == s_.size();
-  }
-
- private:
-  // Skips the four whitespace characters JSON allows.
-  void Ws() {
-    while (i_ < s_.size() && (s_[i_] == ' ' || s_[i_] == '\t' || s_[i_] == '\n' || s_[i_] == '\r')) ++i_;
-  }
-  // Consumes the literal w (true, false or null) if the input continues with it.
-  bool Lit(const char* w) {
-    size_t n = std::char_traits<char>::length(w);
-    if (s_.compare(i_, n, w) != 0) return false;
-    i_ += n;
-    return true;
-  }
-  // One value of any kind, chosen by its first character; depth is the nesting
-  // level of the enclosing objects and arrays.
-  bool Value(int depth) {
-    if (depth > 64 || i_ >= s_.size()) return false;
-    char c = s_[i_];
-    if (c == '{') return Object(depth);
-    if (c == '[') return Array(depth);
-    if (c == '"') return String();
-    if (c == 't') return Lit("true");
-    if (c == 'f') return Lit("false");
-    if (c == 'n') return Lit("null");
-    return Number();
-  }
-  // An object, from its '{': "key": value pairs separated by commas.
-  bool Object(int depth) {
-    ++i_;
-    Ws();
-    if (i_ < s_.size() && s_[i_] == '}') { ++i_; return true; }
-    for (;;) {
-      Ws();
-      if (i_ >= s_.size() || s_[i_] != '"' || !String()) return false;
-      Ws();
-      if (i_ >= s_.size() || s_[i_] != ':') return false;
-      ++i_;
-      Ws();
-      if (!Value(depth + 1)) return false;
-      Ws();
-      if (i_ >= s_.size()) return false;
-      if (s_[i_] == ',') { ++i_; continue; }
-      if (s_[i_] == '}') { ++i_; return true; }
-      return false;
-    }
-  }
-  // An array, from its '[': values separated by commas.
-  bool Array(int depth) {
-    ++i_;
-    Ws();
-    if (i_ < s_.size() && s_[i_] == ']') { ++i_; return true; }
-    for (;;) {
-      Ws();
-      if (!Value(depth + 1)) return false;
-      Ws();
-      if (i_ >= s_.size()) return false;
-      if (s_[i_] == ',') { ++i_; continue; }
-      if (s_[i_] == ']') { ++i_; return true; }
-      return false;
-    }
-  }
-  // A string, from its opening quote: no raw control characters, only valid UTF-8
-  // (Utf8()), and only the escapes JSON defines (\uXXXX with four hex digits).
-  bool String() {
-    ++i_;
-    while (i_ < s_.size()) {
-      unsigned char c = static_cast<unsigned char>(s_[i_]);
-      if (c == '"') { ++i_; return true; }
-      if (c < 0x20) return false;
-      if (c >= 0x80) {
-        if (!Utf8()) return false;
-        continue;
-      }
-      if (c == '\\') {
-        ++i_;
-        if (i_ >= s_.size()) return false;
-        char e = s_[i_];
-        if (e == 'u') {
-          for (int k = 0; k < 4; ++k) {
-            ++i_;
-            if (i_ >= s_.size() || !std::isxdigit(static_cast<unsigned char>(s_[i_]))) return false;
-          }
-        } else if (std::string("\"\\/bfnrt").find(e) == std::string::npos) {
-          return false;
-        }
-      }
-      ++i_;
-    }
-    return false;
-  }
-  // One UTF-8 encoded character, from its lead byte (RFC 3629): JSON text is UTF-8,
-  // so raw bytes that are not (a lone 0xff, a cut sequence, an overlong form, a
-  // surrogate, a code point above U+10FFFF) make the document invalid. Checked here
-  // on its own, not with the escaping code under test.
-  bool Utf8() {
-    const unsigned char lead = static_cast<unsigned char>(s_[i_]);
-    int more = 0;
-    unsigned char lo = 0x80, hi = 0xbf;  // valid range of the second byte
-    if (lead >= 0xc2 && lead <= 0xdf) { more = 1; }
-    else if (lead == 0xe0) { more = 2; lo = 0xa0; }
-    else if (lead == 0xed) { more = 2; hi = 0x9f; }
-    else if (lead >= 0xe1 && lead <= 0xef) { more = 2; }
-    else if (lead == 0xf0) { more = 3; lo = 0x90; }
-    else if (lead == 0xf4) { more = 3; hi = 0x8f; }
-    else if (lead >= 0xf1 && lead <= 0xf3) { more = 3; }
-    else return false;
-    for (int k = 1; k <= more; ++k) {
-      if (i_ + k >= s_.size()) return false;
-      const unsigned char b = static_cast<unsigned char>(s_[i_ + k]);
-      if (k == 1 ? (b < lo || b > hi) : (b < 0x80 || b > 0xbf)) return false;
-    }
-    i_ += more + 1;
-    return true;
-  }
-  // A number: optional minus, an integer part without leading zeros, then an
-  // optional fraction and exponent.
-  bool Number() {
-    size_t start = i_;
-    if (i_ < s_.size() && s_[i_] == '-') ++i_;
-    if (i_ >= s_.size() || !std::isdigit(static_cast<unsigned char>(s_[i_]))) return false;
-    if (s_[i_] == '0') {
-      ++i_;
-    } else {
-      while (i_ < s_.size() && std::isdigit(static_cast<unsigned char>(s_[i_]))) ++i_;
-    }
-    if (i_ < s_.size() && s_[i_] == '.') {
-      ++i_;
-      if (i_ >= s_.size() || !std::isdigit(static_cast<unsigned char>(s_[i_]))) return false;
-      while (i_ < s_.size() && std::isdigit(static_cast<unsigned char>(s_[i_]))) ++i_;
-    }
-    if (i_ < s_.size() && (s_[i_] == 'e' || s_[i_] == 'E')) {
-      ++i_;
-      if (i_ < s_.size() && (s_[i_] == '+' || s_[i_] == '-')) ++i_;
-      if (i_ >= s_.size() || !std::isdigit(static_cast<unsigned char>(s_[i_]))) return false;
-      while (i_ < s_.size() && std::isdigit(static_cast<unsigned char>(s_[i_]))) ++i_;
-    }
-    return i_ > start;
-  }
-
-  const std::string& s_;
-  size_t i_ = 0;
-};
-
-// true if s is one complete, valid JSON document.
-inline bool IsValid(const std::string& s) { return Parser(s).Document(); }
-
-}  // namespace json_check
-
-#endif  // PTI_TOOLS_UNITRACE_FUZZ_JSON_CHECK_H_
diff --git a/tools/unitrace/test/fuzz/make_evidence.py b/tools/unitrace/test/fuzz/make_evidence.py
deleted file mode 100644
index 31e2e132..00000000
--- a/tools/unitrace/test/fuzz/make_evidence.py
+++ /dev/null
@@ -1,526 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Builds the SDL505 evidence report from the outputs of run_fuzz.sh,
-# coverage_report.sh and the fuzz tests of test_unitrace.py, and from
-# findings.json.
-#
-# Usage: python3 make_evidence.py [--campaign NAME=DIR]... [--coverage DIR]
-#                                 [--regression FILE] [--out DIR] [--notes JSON]
-# Writes <out>/SDL505_fuzzing_report.json, .txt and .html (text only, no images).
-
-import argparse
-import datetime
-import glob
-import html
-import json
-import os
-import platform
-import re
-import subprocess
-import sys
-
-FUZZ_DIR = os.path.dirname(os.path.abspath(__file__))
-
-INTERFACES = {
-    "elf64": ("Module native binary (ELF64/ZeBin) returned by the GPU driver (zeModuleGetNativeBinary): "
-              "section table, IntelGT compatibility notes, kernel ISA, DWARF .debug_line and relocations",
-              "src/utils/elf64_reader.h, kernel_extractor.h, source_resolver.h", "C++", "libFuzzer"),
-    "metric_query": ("Intermediate metric query file .metrics.<pid>.q read back from UNITRACE_DataDir",
-                     "src/levelzero/ze_metrics.h ReadMetricQueryRecord", "C++", "libFuzzer"),
-    "stall_sampling": ("Intermediate metric sampling file (.t) read back from UNITRACE_DataDir",
-                       "src/levelzero/ze_metrics.h ReadMetricSegment", "C++", "libFuzzer"),
-    "kernel_props": ("Kernel properties (.kprops) and kernel times (.ktime) files read back from UNITRACE_DataDir",
-                     "src/levelzero/ze_metrics.h ReadKernelPropsRecord, ReadKernelTimeRecord",
-                     "C++", "libFuzzer"),
-    "cli_args": ("Command line: the table-driven option parser and its JSON schema escaping",
-                 "src/utils/cli_options.h ParseArgs, Lookup, JsonEscape", "C++", "libFuzzer"),
-    "kernel_filter": ("--include-kernels / --exclude-kernels strings and their -file contents",
-                      "src/levelzero/ze_collector.h ParseFilterList", "C++", "libFuzzer"),
-    "sample_lists": ("--devices-to-sample, --ranks-to-sample and the MPI launcher environment "
-                     "(PMI_SIZE, PMIX_SIZE, OMPI_*_SIZE, PMI_RANK, PMIX_RANK)",
-                     "src/utils/utils_ze.h ParseDeviceList, ParseRankList; utils_host.h ToInt",
-                     "C++", "libFuzzer"),
-    "kmd_trace": ("Raw OS/KMD trace produced by the user's bpftrace script (--chrome-kmd-logging, runs as root)",
-                  "src/unitrace.cc ReadKmdEvent, KmdEventToJson", "C++", "libFuzzer"),
-    "analyzeperfmetrics": ("Metric CSV files (query, time-based, stall) given to analyzeperfmetrics.py, "
-                           "uniview.py and perfdashboard.py",
-                           "scripts/metrics/analyzeperfmetrics.py", "Python", "Atheris"),
-    "mergetrace": ("Chrome JSON and Perfetto traces given to mergetrace.py / uniview.py",
-                   "scripts/tracemerge/mergetrace.py", "Python", "Atheris"),
-    "summary": ("Tar archive of unitrace summaries given to summary.py",
-                "scripts/summary/summary.py read_summary_tar", "Python", "Atheris"),
-    "categorize": ("Category schema INI given to categorize.py, and lookups in the resulting tree",
-                   "scripts/summary/categorize.py build_tree_from_ini, summary.categorize", "Python", "Atheris"),
-    "roofline_csv": ("Device config CSV and metric query CSV given to roofline.py",
-                     "scripts/roofline/roofline_libs.py Platform, file_to_json", "Python", "Atheris"),
-    "trace_json": ("Names written into the Chrome trace and the --result-dir config log: kernel names (module "
-                   "binary), ITT task names, argument keys and strings (application), device names (driver), "
-                   "the command line",
-                   "src/utils/utils_host.h JsonString, src/chromelogger.h JsonNameField, "
-                   "src/unitrace.cc StringifyJsonArray", "C++", "libFuzzer"),
-    "env_numbers": ("UNITRACE_DeviceId, PTI_DEVICE_ID, PTI_SUB_DEVICE_ID, --chrome-event-buffer-size, and the "
-                    "devices to sample as the metric profiler reads them",
-                    "src/utils/utils_ze.h ParseDeviceIndex, DevicesStringToSet; src/utils/utils_host.h "
-                    "ToUint32, ParseChromeEventBufferSize", "C++", "libFuzzer"),
-    "metric_samples": ("Counts returned by zetMetricGroupCalculateMultipleMetricValuesExp and the sampling "
-                       "timestamps, in place of a Level Zero mock",
-                       "src/levelzero/ze_metrics.h CalculatedSamplesFit, UnwrapTimestamp",
-                       "C++", "libFuzzer"),
-    "metrics_server": ("Requests to the localhost metrics server and the -f options file of analyzeperfmetrics.py",
-                       "scripts/metrics/analyzeperfmetrics.py ParseMetricsRequest, ReadOptionsFromFile",
-                       "Python", "Atheris"),
-    "perfdashboard_upload": ("CSV uploaded to the counter dashboard",
-                             "scripts/metrics/perfdashboard.py upload_csv_input1, index_kernels", "Python",
-                             "Atheris"),
-}
-
-OUT_OF_SCOPE = [
-    "Level Zero / OpenCL / XPTI / OMPT / ITT tracing callbacks: the values they receive (handles, timestamps, "
-    "sizes) come from the vendor runtime in the same process and are not parsed; the one complex structure a "
-    "runtime returns, the module native binary, is fuzzed (elf64), and so are the names written to the trace "
-    "(trace_json). The ITT name copies and zeKernelGetName were reviewed and fixed (FUZZ-024, FUZZ-025).",
-    "zetMetricGroupCalculateMultipleMetricValuesExp: the raw metric blobs are decoded by the Level Zero driver, "
-    "not by unitrace; unitrace's framing of them (.q/.t) is fuzzed, and so are its checks on the counts the "
-    "driver returns (metric_samples).",
-    "PDF plotting (matplotlib) and the HTTP plumbing of the analyzeperfmetrics.py and uniview.py servers "
-    "(http.server; they bind to 127.0.0.1): the request parsing unitrace adds is fuzzed (metrics_server). "
-    "uniview.py serves the trace file's directory to ui.perfetto.dev for a single request.",
-    "The bpftrace script given to --chrome-kmd-logging: executed by bpftrace as root by design; its output is fuzzed. "
-    "The application's arguments are passed to bpftrace -c joined by spaces (reviewed): bpftrace splits the "
-    "string again, so an argument containing whitespace does not reach the application unchanged. The command "
-    "runs with the privileges the user gave unitrace; no change made.",
-    "The removal of the temporary data directory: created by mkdtemp, not taken from input; reviewed (FUZZ-026).",
-]
-
-
-LIMITATIONS = [
-    "No Intel GPU with a Level Zero runtime was available on the fuzzing host, so unitrace was not run "
-    "end-to-end on a GPU workload after the changes. The changed parsers are exercised by the harnesses and "
-    "the regression suite, the product (unitrace, libunitrace_tool.so) was built from the changed sources, "
-    "the existing Python tests (test_dashboard_*, test_uniview_routing: 38 tests) pass, and FUZZ-005, "
-    "FUZZ-018 and FUZZ-019 were verified on the built binaries (product_binary_verification.txt).",
-    "FUZZ-024 (ITT names), FUZZ-025 (zeKernelGetName) and FUZZ-026 (data directory clean-up) are in code "
-    "that runs only with a GPU or an instrumented application; their fixes are built and reviewed, not "
-    "fuzzed or run. FUZZ-023's checks are fuzzed (metric_samples), its call sites only built.",
-    "The .q metric query reader's call site (ze_metrics.h ComputeMetricsQueried, FUZZ-001/FUZZ-002) is "
-    "compiled only for Windows, which was not built here: the parser it calls (ReadMetricQueryRecord) is built and "
-    "fuzzed, but the call site and the FUZZ-002 bounds check are covered by review only. A Windows build is "
-    "needed before release.",
-    "Campaigns ran 1 hour per target and round. Edge coverage stopped growing well before the end of each "
-    "run (see 'edges @exec') except for elf64 in gaps and gaps_seed8, where the DWARF-4/5 seeds opened new "
-    "code: two more 1 h runs from their merged corpus (elf64_ext, elf64_ext_seed9) reached no new edge after "
-    "their first 65,536 executions; and analyzeperfmetrics, which still gains an edge now and then (267, 268 and 270 "
-    "edges in main, seed8 and round4). Longer runs, e.g. nightly in CI, remain recommended.",
-]
-
-
-def run(cmd):
-    """Run a command and return its standard output.
-
-    cmd: the argument list for subprocess.run (no shell), with a 30 s timeout.
-    Returns stdout stripped of surrounding whitespace, or "" if the command cannot
-    be started, times out or raises any other exception. Exit status is ignored.
-    """
-    try:
-        return subprocess.run(cmd, capture_output=True, text=True, timeout=30).stdout.strip()
-    except Exception:
-        return ""
-
-
-def environment():
-    """Describe the fuzzing host and tools for the report.
-
-    Returns a dict: host OS, CPU model and count, the first line of
-    clang++ --version, the sanitizers used, Python and Atheris versions, and the
-    git commit and branch of FUZZ_DIR. A value that cannot be found is "" (see run).
-    """
-    atheris_version = run([sys.executable, "-c",
-                           "import importlib.metadata as m; print(m.version('atheris'))"])
-    return {
-        "host_os": platform.platform(),
-        "cpu": run(["sh", "-c", "grep -m1 'model name' /proc/cpuinfo | cut -d: -f2"]),
-        "cpu_count": os.cpu_count(),
-        "clang": run(["clang++", "--version"]).splitlines()[0] if run(["clang++", "--version"]) else "",
-        "libfuzzer_sanitizers": "AddressSanitizer + UndefinedBehaviorSanitizer (-fno-sanitize-recover=undefined)",
-        "python": platform.python_version(),
-        "atheris": atheris_version,
-        "git_commit": run(["git", "-C", FUZZ_DIR, "rev-parse", "HEAD"]),
-        "git_branch": run(["git", "-C", FUZZ_DIR, "rev-parse", "--abbrev-ref", "HEAD"]),
-    }
-
-
-STAT = re.compile(r"^stat::(\w+):\s+(\d+)", re.M)
-PROGRESS = re.compile(r"^#(\d+)\s+(NEW|REDUCE|pulse|INITED|DONE|RELOAD)\s+cov: (\d+) ft: (\d+) corp: (\d+)/", re.M)
-CRASH = re.compile(r"(ERROR: libFuzzer: [^\n]+|=== Uncaught Python exception: ===\n[^\n]*\n?[^\n]*)")
-
-
-def campaign(dir_):
-    """Summarize one run_fuzz.sh output directory.
-
-    dir_: the campaign directory; each subdirectory with a run.json is one target.
-    Returns {target: dict} with seed, duration, timing, command, executions,
-    exec/s, peak RSS, coverage edges and features, corpus size, the executions at
-    which coverage last grew, artifact names and up to three crash reports, parsed
-    from run.json, fuzz.log and artifacts/. Subdirectories without run.json are
-    skipped; a missing fuzz.log or a malformed run.json raises (OSError, KeyError,
-    json.JSONDecodeError).
-    """
-    out = {}
-    for tdir in sorted(glob.glob(os.path.join(dir_, "*"))):
-        meta_path = os.path.join(tdir, "run.json")
-        if not os.path.isfile(meta_path):
-            continue
-        meta = json.load(open(meta_path))
-        log = open(os.path.join(tdir, "fuzz.log"), errors="replace").read()
-        stats = {k: int(v) for k, v in STAT.findall(log)}
-        progress = PROGRESS.findall(log)
-        new = [p for p in progress if p[1] == "NEW"]
-        edges_grew, max_edges = None, -1
-        for p in progress:
-            if int(p[2]) > max_edges:
-                edges_grew, max_edges = int(p[0]), int(p[2])
-        last = progress[-1] if progress else None
-        artifacts = sorted(os.path.basename(a) for a in glob.glob(os.path.join(tdir, "artifacts", "*")))
-        out[meta["target"]] = {
-            "seed": meta["seed"],
-            "duration_s": meta["duration_s"],
-            "elapsed_s": int((datetime.datetime.fromisoformat(meta["end"]) -
-                              datetime.datetime.fromisoformat(meta["start"])).total_seconds()),
-            "start": meta["start"],
-            "end": meta["end"],
-            "exit_status": meta["exit_status"],
-            "command": " ".join(meta["command"]),
-            "executions": stats.get("number_of_executed_units", int(last[0]) if last else 0),
-            "average_exec_per_sec": stats.get("average_exec_per_sec"),
-            "peak_rss_mb": stats.get("peak_rss_mb"),
-            "coverage_edges": int(last[2]) if last else None,
-            "coverage_features": int(last[3]) if last else None,
-            "corpus_size": len(os.listdir(os.path.join(tdir, "corpus")))
-                           if os.path.isdir(os.path.join(tdir, "corpus")) else None,
-            "last_new_coverage_at_execution": int(new[-1][0]) if new else None,
-            "edges_last_grew_at_execution": edges_grew,
-            "crashes": artifacts,
-            "crash_reports": CRASH.findall(log)[:3],
-        }
-    return out
-
-
-# Campaigns run on the fixed code; the others ran before a fix and found the FUZZ-* issues.
-FINAL_CAMPAIGNS = ["main", "seed8", "round4", "gaps", "gaps_seed8", "elf64_ext", "elf64_ext_seed9", "rebased"]
-# libFuzzer artifact prefix -> what it counts as in the summary; a timeout is a hang.
-ARTIFACT_KINDS = {"crash": "crashes", "oom": "out-of-memory", "timeout": "hangs"}
-
-
-def artifact_summary(campaigns):
-    """Count the libFuzzer artifacts of every run by kind.
-
-    campaigns: {campaign name: campaign() result}.
-    Returns a dict: the FINAL_CAMPAIGNS present, their run count and artifact
-    counts, each out-of-memory artifact of them as (campaign, target, artifact),
-    and the run count and artifact counts over all campaigns. Kinds come
-    from the artifact name prefix via ARTIFACT_KINDS (crash, out-of-memory, hangs
-    for timeouts); an unknown prefix counts as a crash.
-    """
-    def count(names):
-        n = {k: 0 for k in ARTIFACT_KINDS.values()}
-        for name in names:
-            for c in campaigns.get(name, {}).values():
-                for a in c["crashes"]:
-                    n[ARTIFACT_KINDS.get(a.split("-", 1)[0], "crashes")] += 1
-        return n
-    final = [c for c in FINAL_CAMPAIGNS if c in campaigns]
-    oom = [(name, target, a) for name in final for target, c in campaigns[name].items()
-           for a in c["crashes"] if a.startswith("oom-")]
-    return {
-        "final_campaigns": final,
-        "final_oom": oom,
-        "runs_final": sum(len(campaigns[c]) for c in final),
-        "final": count(final),
-        "all": count(campaigns),
-        "runs_all": sum(len(r) for r in campaigns.values()),
-    }
-
-
-CRASH_START = re.compile(r"ERROR: libFuzzer|ERROR: AddressSanitizer|runtime error:|Uncaught Python exception|ALARM:|\[FUZZ\]")
-KEEP_HEAD = KEEP_TAIL = 150
-LOG_LIMIT = 1 << 20
-
-
-def copy_log(src, dst):
-    """Copy a fuzzer log into the evidence package.
-
-    src: the log path. dst: the destination path.
-    A log of at most LOG_LIMIT bytes is copied byte for byte. A larger one is
-    written trimmed: the first KEEP_HEAD lines, a note with the original size, the
-    60 lines from each crash report start (CRASH_START), and the last KEEP_TAIL
-    lines. Undecodable bytes are replaced. Returns None.
-    """
-    if os.path.getsize(src) <= LOG_LIMIT:
-        with open(src, "rb") as i, open(dst, "wb") as o:
-            o.write(i.read())
-        return
-    head, tail, crash, total, after = [], [], [], 0, 0
-    with open(src, errors="replace") as f:
-        for line in f:
-            total += 1
-            if total <= KEEP_HEAD:
-                head.append(line)
-                continue
-            if CRASH_START.search(line):
-                after = 60
-            if after > 0:
-                crash.append(line)
-                after -= 1
-            tail.append(line)
-            if len(tail) > KEEP_TAIL:
-                tail.pop(0)
-    with open(dst, "w") as o:
-        o.writelines(head)
-        o.write(f"\n[... log trimmed for the evidence package: {total} lines, {os.path.getsize(src)} bytes "
-                f"in the original; the first {KEEP_HEAD}, every crash report and the last {KEEP_TAIL} are kept ...]\n\n")
-        if crash:
-            o.write("[crash reports]\n")
-            o.writelines(crash)
-            o.write("\n[last lines]\n")
-        o.writelines(tail)
-
-
-def package_logs(campaigns, out):
-    """Copy every campaign's run metadata and logs into the evidence directory.
-
-    campaigns: a list of [name, dir] pairs. out: the evidence directory.
-    For each target with a run.json writes out/campaigns/<name>/<target>/ with
-    run.json, the fuzz*.log files (via copy_log) and artifacts.txt listing the
-    artifact names, or "none". Returns None.
-    """
-    for name, d in campaigns:
-        for meta in sorted(glob.glob(os.path.join(d, "*", "run.json"))):
-            tdir = os.path.dirname(meta)
-            dst = os.path.join(out, "campaigns", name, os.path.basename(tdir))
-            os.makedirs(dst, exist_ok=True)
-            with open(meta) as i, open(os.path.join(dst, "run.json"), "w") as o:
-                o.write(i.read())
-            for log in glob.glob(os.path.join(tdir, "fuzz*.log")):
-                copy_log(log, os.path.join(dst, os.path.basename(log)))
-            arts = sorted(os.listdir(os.path.join(tdir, "artifacts"))) if os.path.isdir(
-                os.path.join(tdir, "artifacts")) else []
-            with open(os.path.join(dst, "artifacts.txt"), "w") as o:
-                o.write("".join(a + "\n" for a in arts) or "none\n")
-
-
-def text_report(r):
-    """Render the evidence report as plain text.
-
-    r: the report dict built by main.
-    Returns the text: interfaces fuzzed, tools and environment, campaign tables,
-    hangs and crashes, coverage, findings, regression suite, product binary
-    verification, limitations and reproduction steps.
-    Raises KeyError if r lacks a field it prints.
-    """
-    L = []
-    w = L.append
-    w("SDL505 - Perform Fuzz Testing: Evidence Report")
-    w("=" * 78)
-    w(f"Project:   {r['project']}")
-    w(f"Task:      {r['task']}")
-    w(f"Generated: {r['generated']}")
-    w(f"Branch:    {r['environment']['git_branch']} @ {r['environment']['git_commit']}")
-    w("")
-    w("1. INTERFACES FUZZED")
-    w("-" * 78)
-    for t, i in r["interfaces"].items():
-        w(f"  {t} [{i['language']}, {i['fuzzer']}]")
-        w(f"      input: {i['interface']}")
-        w(f"      code:  {i['code']}")
-    w("  Out of scope:")
-    for o in r["out_of_scope"]:
-        w(f"    - {o}")
-    w("")
-    w("2. TOOLS AND ENVIRONMENT")
-    w("-" * 78)
-    for k, v in r["environment"].items():
-        w(f"  {k:22} {v}")
-    w("")
-    w("3. CAMPAIGNS")
-    w("-" * 78)
-    w("  Limits: 10 s per input, 1 GB per allocation, 2 GB RSS (4 GB for round4, see FUZZ-016).")
-    w("  'edges @exec' is the execution at which the run last reached a new edge, 'last new @exec'")
-    w("  the one at which it last kept an input for new coverage (edges or finer-grained features):")
-    w("  well below 'executions' means coverage plateaued; 0 means the run started from an earlier")
-    w("  run's corpus and found no new coverage at all. 'corpus' '-': the run used the seed directory.")
-    w("")
-    for name, runs in r["campaigns"].items():
-        w(f"  3.{list(r['campaigns']).index(name) + 1} {name}")
-        if r["campaign_notes"].get(name):
-            w(f"      {r['campaign_notes'][name]}")
-        w(f"  {'target':20} {'seed':>4} {'ran(s)':>7} {'executions':>13} {'exec/s':>7} {'edges':>6} "
-          f"{'corpus':>6} {'edges @exec':>13} {'last new @exec':>14} crashes")
-        for t, c in runs.items():
-            w(f"  {t:20} {c['seed']:>4} {c['elapsed_s']:>7} {c['executions']:>13,} "
-              f"{c['average_exec_per_sec'] or 0:>7} {c['coverage_edges'] or 0:>6} {c['corpus_size'] if c['corpus_size'] is not None else '-':>6} "
-              f"{c.get('edges_last_grew_at_execution') or 0:>13,} "
-              f"{c['last_new_coverage_at_execution'] or 0:>14,} {len(c['crashes'])}")
-            for a in c["crashes"]:
-                w(f"      crash artifact: {a}")
-        w("")
-    h = r["hangs_and_crashes"]
-    fmt = lambda n: ", ".join(f"{k} {v}" for k, v in n.items())
-    w(f"  HANGS AND CRASHES (libFuzzer artifacts; a timeout counts as a hang)")
-    w(f"    Final code, {h['runs_final']} runs ({', '.join(h['final_campaigns'])}): {fmt(h['final'])}")
-    for campaign_name, target, artifact in h.get("final_oom", []):
-        # Only the artifact FUZZ-016 investigated is explained as its false positive;
-        # any other out-of-memory is reported as a finding to triage.
-        if (campaign_name, target) == ("seed8", "analyzeperfmetrics") and "round4" in h["final_campaigns"]:
-            w(f"      out-of-memory: {target} in {campaign_name} ({artifact}), a false positive (FUZZ-016):")
-            w("      the Atheris process grew past the 2 GB RSS limit; round4 reran it at 4 GB for the full")
-            w("      hour with none.")
-        else:
-            w(f"      out-of-memory: {target} in {campaign_name} ({artifact}): not triaged - add it to the")
-            w("      findings register with its disposition.")
-    w(f"    All campaigns, {h['runs_all']} runs, including those that found FUZZ-*: {fmt(h['all'])}")
-    w("")
-    cov = r["coverage"]
-    w("4. CODE COVERAGE (corpora replayed on coverage-instrumented builds)")
-    w("-" * 78)
-    if cov:
-        w(f"  C++ product code (llvm-cov):  lines {cov['cpp']['total_lines_percent']}%  "
-          f"functions {cov['cpp']['total_functions_percent']}%  branches {cov['cpp']['total_branches_percent']}%")
-        w(f"  {r['coverage_scope']}")
-        for f, v in cov["cpp"]["files"].items():
-            w(f"    {f:48} lines {v['lines_percent']:6}%  functions {v['functions_percent']:6}%  "
-              f"branches {v['branches_percent']:6}%")
-        py = cov["python"]
-        if "total_lines_percent" in py:
-            w(f"  Python scripts (coverage.py): lines {py['total_lines_percent']}%  "
-              f"branches {py['total_branches_percent']}%")
-        else:  # a coverage report from before lines and branches were split
-            w(f"  Python scripts (coverage.py): {py['total_percent']}% of lines and branches")
-        for f, v in py["files"].items():
-            branches = f"  branches {v['branches_percent']:6}%" if "branches_percent" in v else ""
-            w(f"    {f:48} lines {v['lines_percent']:6}%{branches}")
-        w(f"  Target: {r['coverage_target']}")
-    w("")
-    w("5. FINDINGS AND DISPOSITION")
-    w("-" * 78)
-    for f in r["findings"]:
-        w(f"  {f['id']}  [{f['severity']}] [{f['disposition']}]  {f['title']}")
-        w(f"      found by:   {f['found_by']}")
-        w(f"      location:   {f['location']}")
-        w(f"      root cause: {f['root_cause']}")
-        w(f"      impact:     {f['impact']}")
-        w(f"      fix:        {f['fix']}")
-        if f["regression_tests"]:
-            w(f"      regression: {', '.join(f['regression_tests'])}")
-        if f.get("note"):
-            w(f"      note:       {f['note']}")
-    s = r["findings_summary"]
-    w(f"  Total {s['total']}: " + ", ".join(f"{k} {v}" for k, v in s["by_disposition"].items()))
-    w("")
-    w("6. REGRESSION SUITE")
-    w("-" * 78)
-    w("  " + r["regression"].replace("\n", "\n  "))
-    w("")
-    w("7. PRODUCT BINARY VERIFICATION")
-    w("-" * 78)
-    w("  " + r["product_binary_verification"].strip().replace("\n", "\n  "))
-    w("")
-    w("8. LIMITATIONS")
-    w("-" * 78)
-    for l in r["limitations"]:
-        w(f"  - {l}")
-    w("")
-    w("9. REPRODUCTION")
-    w("-" * 78)
-    for line in r["reproduction"]:
-        w("  " + line)
-    return "\n".join(L) + "\n"
-
-
-def html_report(r, text):
-    """Wrap the text report in a minimal HTML page.
-
-    r: the report dict (unused). text: the text from text_report.
-    Returns an HTML document with the HTML-escaped text in a <pre> block.
-    """
-    return ("<!DOCTYPE html>\n<html><head><meta charset=\"utf-8\"><title>SDL505 Fuzzing Evidence - unitrace"
-            "</title></head><body><pre>\n" + html.escape(text) + "</pre></body></html>\n")
-
-
-def main():
-    """Build the SDL505 fuzzing evidence report.
-
-    Options: --campaign NAME=DIR (repeatable; default main=results/campaign),
-    --coverage, --regression, --out, --notes (JSON of campaign descriptions).
-    Reads findings.json, the campaigns, coverage_summary.json, the regression
-    output and product_binary_verification.txt (missing optional files become
-    None or "not run"), copies the logs (package_logs) and writes
-    SDL505_fuzzing_report.json, .txt and .html to --out, printing the text.
-    """
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--campaign", action="append", default=None,
-                    help="NAME=DIR of a run_fuzz.sh output; repeatable")
-    ap.add_argument("--coverage", default=os.path.join(FUZZ_DIR, "results", "coverage"))
-    ap.add_argument("--regression", default=os.path.join(FUZZ_DIR, "results", "regression.txt"))
-    ap.add_argument("--out", default=os.path.join(FUZZ_DIR, "evidence"))
-    ap.add_argument("--notes", help="JSON object: campaign name -> description")
-    args = ap.parse_args()
-    campaigns = args.campaign or [f"main=" + os.path.join(FUZZ_DIR, "results", "campaign")]
-    notes = {}
-    if args.notes and os.path.isfile(args.notes):
-        notes = json.load(open(args.notes))
-    verification = os.path.join(args.out, "product_binary_verification.txt")
-
-    findings = json.load(open(os.path.join(FUZZ_DIR, "findings.json")))
-    by_disp = {}
-    for f in findings["findings"]:
-        by_disp[f["disposition"]] = by_disp.get(f["disposition"], 0) + 1
-    cov_path = os.path.join(args.coverage, "coverage_summary.json")
-    runs = {name: campaign(d) for name, d in (c.split("=", 1) for c in campaigns)}
-    report = {
-        "project": findings["project"],
-        "task": findings["task"],
-        "generated": datetime.datetime.now().astimezone().isoformat(timespec="seconds"),
-        "environment": environment(),
-        "interfaces": {t: {"interface": i[0], "code": i[1], "language": i[2], "fuzzer": i[3]}
-                       for t, i in INTERFACES.items()},
-        "out_of_scope": OUT_OF_SCOPE,
-        "campaign_notes": notes,
-        "limitations": LIMITATIONS,
-        "product_binary_verification": open(verification).read() if os.path.isfile(verification)
-                                       else "not run",
-        "campaigns": runs,
-        "hangs_and_crashes": artifact_summary(runs),
-        "coverage": json.load(open(cov_path)) if os.path.isfile(cov_path) else None,
-        "coverage_target": "SDL505 aspirational target 30% code coverage",
-        "coverage_scope": ("Scope: the files the harnesses reach (listed below), not the whole of unitrace; the collectors and tracing callbacks that only pass runtime values through are out of scope (section 1)."),
-        "severity_scale": findings["severity_scale"],
-        "findings": findings["findings"],
-        "findings_summary": {"total": len(findings["findings"]), "by_disposition": by_disp},
-        "regression": open(args.regression).read().strip() if os.path.isfile(args.regression) else "not run",
-        "reproduction": [
-            "cmake -S tools/unitrace -B build-fuzz -DUNITRACE_BUILD_FUZZ=ON -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang && cmake --build build-fuzz --target unitrace_fuzz",
-            "pip install atheris   # plus tools/unitrace/requirements.txt",
-            "cd tools/unitrace/test/fuzz",
-            "./run_fuzz.sh -t 3600 -s <seed> -b ../../../../build-fuzz/test/fuzz/cpp [-m 4096] [target...]   # seeds: section 3",
-            "./coverage_report.sh results/campaign results/coverage",
-            "(cd .. && python3 test_unitrace.py --test-name 'fuzz_*') > results/regression.txt",
-            "python3 make_evidence.py --campaign main=results/campaign",
-            "Replay one input: ../../../../build-fuzz/test/fuzz/cpp/fuzz_<target> <file>  |  python3 python/fuzz_<target>.py <file>",
-        ],
-    }
-    os.makedirs(args.out, exist_ok=True)
-    package_logs([c.split("=", 1) for c in campaigns], args.out)
-    base = os.path.join(args.out, "SDL505_fuzzing_report")
-    json.dump(report, open(base + ".json", "w"), indent=2)
-    text = text_report(report)
-    open(base + ".txt", "w").write(text)
-    open(base + ".html", "w").write(html_report(report, text))
-    print(text)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/unitrace/test/fuzz/python/coverage_replay.py b/tools/unitrace/test/fuzz/python/coverage_replay.py
deleted file mode 100644
index 7e0e7a52..00000000
--- a/tools/unitrace/test/fuzz/python/coverage_replay.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Replays a corpus through one harness's TestOneInput, for coverage.py:
-#   UNITRACE_FUZZ_REPLAY=1 python3 -m coverage run coverage_replay.py <target> <dir>...
-# An input that raises is reported and counted, not fatal.
-
-import importlib
-import os
-import sys
-
-os.environ["UNITRACE_FUZZ_REPLAY"] = "1"
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-
-def main():
-    """Replays inputs through one harness for coverage.py.
-
-    Arguments: the target name (fuzz_<target>.py is imported) and the directories
-    whose files are the inputs. Each input is passed to TestOneInput once; one that
-    raises is reported and counted, not fatal, so the whole corpus is measured.
-    """
-    target, dirs = sys.argv[1], sys.argv[2:]
-    harness = importlib.import_module("fuzz_" + target)
-    runs = failures = 0
-    for d in dirs:
-        for name in sorted(os.listdir(d)):
-            path = os.path.join(d, name)
-            if not os.path.isfile(path):
-                continue
-            with open(path, "rb") as f:
-                data = f.read()
-            runs += 1
-            try:
-                harness.TestOneInput(data)
-            except Exception as ex:
-                failures += 1
-                print(f"[REPLAY] {path}: {type(ex).__name__}: {ex}", file=sys.stderr)
-    print(f"[REPLAY] {target}: {runs} inputs, {failures} raised")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_analyzeperfmetrics.py b/tools/unitrace/test/fuzz/python/fuzz_analyzeperfmetrics.py
deleted file mode 100644
index 31021803..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_analyzeperfmetrics.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes scripts/metrics/analyzeperfmetrics.py on an untrusted metrics CSV, along
-# the two paths that read one:
-#   - perfdashboard.py read_metrics(): ScanDeviceSections + ReadMetricFrame, unguarded
-#   - analyzeperfmetrics.py main(): MetricsInfo, -l listing (print_data), and for a
-#     stall table the stall report (StallColumns, NonZeroStallRows,
-#     KernelRanges, BuildStallReport)
-# Plotting to PDF and the HTTP server are out of scope.
-
-import argparse
-import csv
-import io
-import sys
-import atheris
-import fuzz_common
-
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot  # noqa: F401  (pre-imported so only unitrace code is instrumented)
-import pandas  # noqa: F401
-from matplotlib.backends.backend_pdf import PdfPages  # noqa: F401
-
-fuzz_common.add_script_dir("metrics")
-with fuzz_common.instrument():
-    import analyzeperfmetrics as apm
-
-# csv.Error: a field above csv.field_size_limit(); analyzeperfmetrics.main and
-# perfdashboard.upload_csv_input1 both catch it.
-EXPECTED = (UnicodeDecodeError, csv.Error)
-REPORT_ARGS = argparse.Namespace(numtopstalls=3)
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is one metrics CSV.
-
-    Reads it as perfdashboard.py does (ScanDeviceSections, ReadMetricFrame), then as
-    analyzeperfmetrics.py main() does (MetricsInfo, the -l listing and, for stall
-    tables, the stall report). Only the errors in EXPECTED, and those main() itself
-    turns into an error message, are a clean rejection; any other exception is a
-    finding.
-    """
-    with fuzz_common.TempFile(data, ".csv") as path:
-        try:
-            apm.ScanFirstHeader(path)
-            for device, header, last, kind in apm.ScanDeviceSections(path):
-                apm.ReadMetricFrame(path, header, last, kind)
-        except EXPECTED:
-            return
-
-        try:
-            info = apm.MetricsInfo(input_path=path, is_result_directory=False)
-        except Exception:
-            return  # main() reports these as "Error: ..." and exits
-        info.print_data(path + ".out")
-        for device in info.devices.values():
-            df = device.get_device_data()
-            if df is None or df.shape[0] == 0 or device.kind != "stall":
-                continue
-            stalls = apm.StallColumns(df)
-            if len(stalls) == 0:
-                continue
-            for kernel, pid, kernelid, start, stop in apm.KernelRanges(df):
-                df2 = apm.NonZeroStallRows(df.iloc[start:stop], stalls)
-                if df2.shape[0] == 0:
-                    continue
-                apm.BuildStallReport(apm.StallKernelLabel(kernel, pid, kernelid), REPORT_ARGS,
-                                     df2, stalls)
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_categorize.py b/tools/unitrace/test/fuzz/python/fuzz_categorize.py
deleted file mode 100644
index 33c037c3..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_categorize.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes scripts/summary/categorize.py build_tree_from_ini() (ConfigParser and
-# the search-tree builder), then looks names up in the tree with
-# summary.categorize() as summary.py does. Input: name \0 INI, or a plain INI
-# (the seed corpus).
-
-import configparser
-import sys
-import atheris
-import fuzz_common
-
-fuzz_common.add_script_dir("summary")
-with fuzz_common.instrument():
-    import categorize
-    import summary
-
-EXPECTED = (configparser.Error, UnicodeDecodeError)
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is a category schema INI, optionally preceded by a
-    name to look up and a NUL (name \\0 INI); without a NUL it is all INI, so plain
-    INI files serve as seeds.
-
-    Builds the search tree with categorize.build_tree_from_ini(), with and without
-    remove_tag_spaces, and looks the name up in each with summary.categorize().
-    configparser errors and undecodable bytes are a clean rejection; any other
-    exception is a finding.
-    """
-    head, sep, ini = data.partition(b"\0")
-    if not sep:
-        head, ini = b"", data
-    name = head.decode("utf-8", "replace")
-    with fuzz_common.TempFile(ini, ".ini") as path:
-        for remove_spaces in (False, True):
-            try:
-                tree = categorize.build_tree_from_ini(path, remove_spaces)
-            except EXPECTED:
-                return
-            summary.categorize(tree, name)
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_common.py b/tools/unitrace/test/fuzz/python/fuzz_common.py
deleted file mode 100644
index 73d5599e..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_common.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Shared helpers for the Atheris harnesses. A harness lists the exceptions that
-# are a clean rejection of malformed input; any other exception propagates and
-# Atheris records it as a crash with its reproducer.
-
-import atexit
-import os
-import shutil
-import sys
-import tempfile
-
-SCRIPTS = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "scripts"))
-
-
-def add_script_dir(*parts):
-    """Makes the scripts in tools/unitrace/scripts/<parts> importable.
-
-    parts: the path below scripts/, e.g. "metrics". The directory is put first on
-    sys.path, once, so a harness imports the script unitrace ships.
-    """
-    path = os.path.join(SCRIPTS, *parts)
-    if path not in sys.path:
-        sys.path.insert(0, path)
-
-
-_private_dir = None
-
-
-def _private_tmp():
-    """A directory only this user can enter (mkdtemp: mode 0700, unpredictable name),
-    created once per process and removed at exit. Keeps TempFile's fixed names out
-    of the shared temporary directory, where another user could plant a symlink."""
-    global _private_dir
-    if _private_dir is None:
-        _private_dir = tempfile.mkdtemp(prefix="unitrace_fuzz_")
-        atexit.register(shutil.rmtree, _private_dir, True)
-    return _private_dir
-
-
-class TempFile:
-    """A file holding data, at one path per process and suffix.
-
-    Used as `with TempFile(data, ".csv") as path:`; the file and path + ".out" (where
-    a harness lets a script write its output) are removed on exit. They live in a
-    private directory (_private_tmp()), not the shared temporary one. The path is
-    reused because the scripts resolve it with pathlib, which interns every distinct
-    path for the life of the process: a fresh temporary name per input grows memory
-    without bound over millions of inputs.
-    """
-
-    def __init__(self, data, suffix=""):
-        self.data = data
-        self.path = os.path.join(_private_tmp(), f"input{suffix}")
-
-    def __enter__(self):
-        with open(self.path, "wb") as f:
-            f.write(self.data)
-        return self.path
-
-    def __exit__(self, *exc):
-        for p in (self.path, self.path + ".out"):
-            try:
-                os.unlink(p)
-            except OSError:
-                pass
-        return False
-
-
-def instrument():
-    """The context to import the fuzzed scripts in.
-
-    Returns atheris.instrument_imports(), so Atheris gets coverage feedback from the
-    scripts, or a no-op context when UNITRACE_FUZZ_REPLAY is set (coverage_replay.py
-    under coverage.py, where Atheris' instrumentation would get in the way).
-    """
-    if os.environ.get("UNITRACE_FUZZ_REPLAY"):
-        import contextlib
-        return contextlib.nullcontext()
-    import atheris
-    return atheris.instrument_imports()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_mergetrace.py b/tools/unitrace/test/fuzz/python/fuzz_mergetrace.py
deleted file mode 100644
index 5d4ee205..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_mergetrace.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes scripts/tracemerge/mergetrace.py: merge_trace_files (Chrome JSON,
-# including its repair-and-retry of a truncated file) and MergePerfettoTraces.
-# Oracle: a successful JSON merge must itself be valid JSON.
-
-import json
-import sys
-import atheris
-import fuzz_common
-
-fuzz_common.add_script_dir("tracemerge")
-with fuzz_common.instrument():
-    import mergetrace
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is one trace file.
-
-    Merges it as a Chrome JSON trace (merge_trace_files, with its repair of a
-    truncated file) and checks that a merge it reports as successful is valid JSON
-    (not NaN or Infinity, which json.load would accept, nor a number that overflows
-    a float), then merges it as Perfetto traces (MergePerfettoTraces). Any exception
-    is a finding.
-    """
-    with fuzz_common.TempFile(data, ".json") as path:
-        out = path + ".out"
-        if mergetrace.merge_trace_files([path], out):
-            with open(out) as f:
-                json.load(f, parse_constant=mergetrace.RejectJsonConstant,
-                          parse_float=mergetrace.ParseFiniteFloat)
-        mergetrace.MergePerfettoTraces([path], out)
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_metrics_server.py b/tools/unitrace/test/fuzz/python/fuzz_metrics_server.py
deleted file mode 100644
index 9a01e0f5..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_metrics_server.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes the two non-CSV inputs of scripts/metrics/analyzeperfmetrics.py:
-#   - a request to the localhost metrics server (PerfMetricsHTTPServer do_GET),
-#     ParseMetricsRequest(); a returned instance must convert with float() and a
-#     device with int(), as do_GET converts them
-#   - the -f/--config options file, ReadOptionsFromFile via ParseArguments()
-# Input: one flag byte (bit 0: config file, bit 1: --result-dir, bit 2: stall
-# sampling), then the request path or the file contents.
-
-import sys
-import atheris
-import fuzz_common
-
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot  # noqa: F401  (pre-imported so only unitrace code is instrumented)
-import pandas  # noqa: F401
-from matplotlib.backends.backend_pdf import PdfPages  # noqa: F401
-
-fuzz_common.add_script_dir("metrics")
-with fuzz_common.instrument():
-    import analyzeperfmetrics as apm
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is one flag byte, then a request path or an options file.
-
-    Flag bit 0 set: the rest is a -f/--config options file, parsed by ParseArguments
-    (argparse exiting or reporting the file unreadable is a clean rejection).
-    Otherwise the rest is a metrics server request path (decoded as latin-1, as
-    http.server does), parsed by ParseMetricsRequest with bit 1 as --result-dir and
-    bit 2 as stall sampling; an accepted request's instance must convert with
-    float() and its device with int(), as do_GET converts them. Any other
-    exception is a finding.
-    """
-    if not data:
-        return
-    flags, body = data[0], data[1:]
-    if flags & 1:
-        with fuzz_common.TempFile(body, ".txt") as path:
-            try:
-                apm.ParseArguments(["-f", path, "input.csv"])
-            except SystemExit:
-                pass  # argparse rejected the options and printed why
-            except UnicodeDecodeError:
-                pass  # argparse reports the file as unreadable
-        return
-
-    # The server gets the path as http.server decodes the request line: latin-1.
-    path = body.decode("latin-1")
-    status, kname, instance, device_id = apm.ParseMetricsRequest(path, bool(flags & 2), bool(flags & 4))
-    if status == "ok":
-        float(instance)
-        if device_id is not None:
-            int(device_id)
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_perfdashboard_upload.py b/tools/unitrace/test/fuzz/python/fuzz_perfdashboard_upload.py
deleted file mode 100644
index 23fa0253..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_perfdashboard_upload.py
+++ /dev/null
@@ -1,41 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes the CSV upload of the counter dashboard, scripts/metrics/perfdashboard.py
-# upload_csv_input1(): the browser sends the file base64-encoded and the Bokeh
-# callback reads it (read_metrics), maps its counter columns and indexes its kernel
-# instances. An exception escaping the callback leaves the dashboard half-updated.
-# The Bokeh models are built in memory; no server runs.
-
-import base64
-import sys
-import atheris
-import fuzz_common
-
-import matplotlib
-matplotlib.use("Agg")
-import pandas  # noqa: F401
-import bokeh.plotting  # noqa: F401  (pre-imported so only unitrace code is instrumented)
-import bokeh.models  # noqa: F401
-import bokeh.layouts  # noqa: F401
-
-fuzz_common.add_script_dir("metrics")
-with fuzz_common.instrument():
-    import perfdashboard as pd_app
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is one CSV file uploaded to the counter dashboard.
-
-    Calls the Bokeh upload callback with the file base64-encoded, as the browser
-    sends it. Any exception escaping the callback is a finding.
-    """
-    pd_app.upload_csv_input1("value", None, base64.b64encode(data).decode("ascii"))
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_roofline_csv.py b/tools/unitrace/test/fuzz/python/fuzz_roofline_csv.py
deleted file mode 100644
index 92aa83cd..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_roofline_csv.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes scripts/roofline/roofline_libs.py: Platform (the device config CSV
-# from device_configs/) and file_to_json (a unitrace metric query CSV).
-
-import sys
-import atheris
-import fuzz_common
-
-fuzz_common.add_script_dir("roofline")
-import pandas  # noqa: F401  (pre-imported so only unitrace code is instrumented)
-with fuzz_common.instrument():
-    import roofline_libs
-
-# Platform rejects a malformed config with ValueError (pandas errors for unparsable CSV).
-EXPECTED_CONFIG = (pandas.errors.EmptyDataError, pandas.errors.ParserError, ValueError,
-                   UnicodeDecodeError)
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is one CSV read both as a device config and as a metric
-    query output.
-
-    Loads it with roofline_libs.Platform (the errors in EXPECTED_CONFIG are its clean
-    rejection of a malformed config) and converts it with file_to_json. Any other
-    exception is a finding.
-    """
-    with fuzz_common.TempFile(data, ".csv") as path:
-        try:
-            roofline_libs.Platform(path)
-        except EXPECTED_CONFIG:
-            pass
-        roofline_libs.file_to_json(path)
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/python/fuzz_summary.py b/tools/unitrace/test/fuzz/python/fuzz_summary.py
deleted file mode 100644
index 24f10f30..00000000
--- a/tools/unitrace/test/fuzz/python/fuzz_summary.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Fuzzes scripts/summary/summary.py read_summary_tar(): tarfile.open on an
-# untrusted archive, and the timing-summary parser run over every member. Half
-# of the inputs are used as the archive itself; the other half become the
-# contents of the members of a well-formed archive, so the summary parser is
-# reached without the fuzzer having to forge a valid tar and gzip stream.
-
-import io
-import sys
-import tarfile
-import zlib
-import gzip
-import lzma
-import atheris
-import fuzz_common
-
-fuzz_common.add_script_dir("summary")
-with fuzz_common.instrument():
-    import summary
-
-EXPECTED = (tarfile.TarError, EOFError, zlib.error, gzip.BadGzipFile, OSError, lzma.LZMAError,
-            UnicodeDecodeError)
-
-
-def BuildArchive(fdp):
-    """A well-formed gzip tar archive of 1 to 3 members whose contents come from fdp.
-
-    Lets the summary parser be reached with fuzzed member contents without the
-    fuzzer having to forge a valid tar and gzip stream.
-    """
-    buf = io.BytesIO()
-    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
-        for i in range(fdp.ConsumeIntInRange(1, 3)):
-            content = fdp.ConsumeBytes(fdp.ConsumeIntInRange(0, 4096))
-            info = tarfile.TarInfo(name=f"output.{i}")
-            info.size = len(content)
-            tar.addfile(info, io.BytesIO(content))
-    return buf.getvalue()
-
-
-def TestOneInput(data):
-    """Atheris entry point: data is a selector byte, then either a whole archive (even
-    selector) or the contents of the members of one (odd selector, BuildArchive).
-
-    Reads it with summary.read_summary_tar(). The archive errors in EXPECTED are a
-    clean rejection; any other exception is a finding.
-    """
-    if not data:
-        return
-    # The selector is read explicitly, not with ConsumeBool(): which end of the data a
-    # FuzzedDataProvider call takes from is not part of its contract.
-    rest = data[1:]
-    archive = BuildArchive(atheris.FuzzedDataProvider(rest)) if data[0] & 1 else rest
-    with fuzz_common.TempFile(archive, ".tgz") as path:
-        try:
-            summary.read_summary_tar(path)
-        except EXPECTED:
-            pass
-
-
-if __name__ == "__main__":
-    atheris.Setup(sys.argv, TestOneInput)
-    atheris.Fuzz()
diff --git a/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_missing_instruction_column.csv b/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_missing_instruction_column.csv
deleted file mode 100644
index 3ff85beb..00000000
--- a/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_missing_instruction_column.csv
+++ /dev/null
@@ -1,6 +0,0 @@
-=== Device #0 Meurics ===
-
-Kernel,Pid,KernelId
-"test_kernel",05019,1
-Source,Offset,Inson,Dependency,Active[Events],ControlStall[vsen],EtSbidSts]
-"test.cl:10",0x00000,"(W) and (1|M0) &0:ud","NA",5,2,0
diff --git a/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_repeated_columns.csv b/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_repeated_columns.csv
deleted file mode 100644
index 8311d844..00000000
--- a/tools/unitrace/test/fuzz/regression/analyzeperfmetrics/stall_repeated_columns.csv
+++ /dev/null
@@ -1,5 +0,0 @@
-=== Device #0 Metrics ===
-
-Kernel,Pid,KernelId
-"test_kernel",12345,1
-Source,Offset,Instruction,Dependency,Active[Events],ControlStall[Events],SbidStall[Ev000080,"(W) and (1|M0) r0:ud","NA",5,2 (1|M0) r0:ud","NA",5,2,0
diff --git a/tools/unitrace/test/fuzz/regression/categorize/configparser_continuation_after_novalue.bin b/tools/unitrace/test/fuzz/regression/categorize/configparser_continuation_after_novalue.bin
deleted file mode 100644
index 5a533c89..00000000
Binary files a/tools/unitrace/test/fuzz/regression/categorize/configparser_continuation_after_novalue.bin and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/categorize/empty_name_lookup b/tools/unitrace/test/fuzz/regression/categorize/empty_name_lookup
deleted file mode 100644
index 0906b8bf..00000000
Binary files a/tools/unitrace/test/fuzz/regression/categorize/empty_name_lookup and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/categorize/no_endswith_section.bin b/tools/unitrace/test/fuzz/regression/categorize/no_endswith_section.bin
deleted file mode 100644
index e69de29b..00000000
diff --git a/tools/unitrace/test/fuzz/regression/cli_args/arg_invalid_utf8 b/tools/unitrace/test/fuzz/regression/cli_args/arg_invalid_utf8
deleted file mode 100644
index fc51fc2c..00000000
Binary files a/tools/unitrace/test/fuzz/regression/cli_args/arg_invalid_utf8 and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/elf64/dwarf_advance_line_overflow b/tools/unitrace/test/fuzz/regression/elf64/dwarf_advance_line_overflow
deleted file mode 100644
index 713423d0..00000000
Binary files a/tools/unitrace/test/fuzz/regression/elf64/dwarf_advance_line_overflow and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/elf64/dwarf_extended_opcode_length_wrap b/tools/unitrace/test/fuzz/regression/elf64/dwarf_extended_opcode_length_wrap
deleted file mode 100644
index 15f5b61f..00000000
Binary files a/tools/unitrace/test/fuzz/regression/elf64/dwarf_extended_opcode_length_wrap and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/elf64/relocation_section_size_outside_file b/tools/unitrace/test/fuzz/regression/elf64/relocation_section_size_outside_file
deleted file mode 100644
index c5013ea9..00000000
Binary files a/tools/unitrace/test/fuzz/regression/elf64/relocation_section_size_outside_file and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_negative b/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_negative
deleted file mode 100644
index a8079cff..00000000
Binary files a/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_negative and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_not_a_number b/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_not_a_number
deleted file mode 100644
index ac402aff..00000000
Binary files a/tools/unitrace/test/fuzz/regression/env_numbers/chrome_buffer_size_not_a_number and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_not_a_number b/tools/unitrace/test/fuzz/regression/env_numbers/device_index_not_a_number
deleted file mode 100644
index f2ba8f84..00000000
--- a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_not_a_number
+++ /dev/null
@@ -1 +0,0 @@
-abc
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_trailing_garbage b/tools/unitrace/test/fuzz/regression/env_numbers/device_index_trailing_garbage
deleted file mode 100644
index fa9d7802..00000000
--- a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_trailing_garbage
+++ /dev/null
@@ -1 +0,0 @@
-7x
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_wraps_uint32 b/tools/unitrace/test/fuzz/regression/env_numbers/device_index_wraps_uint32
deleted file mode 100644
index bd1a2a86..00000000
--- a/tools/unitrace/test/fuzz/regression/env_numbers/device_index_wraps_uint32
+++ /dev/null
@@ -1 +0,0 @@
-4294967297
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_invalid_byte b/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_invalid_byte
deleted file mode 100644
index 300da52a..00000000
Binary files a/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_invalid_byte and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_not_a_number b/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_not_a_number
deleted file mode 100644
index 6acaaac9..00000000
Binary files a/tools/unitrace/test/fuzz/regression/env_numbers/devices_list_not_a_number and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_invalid_utf8 b/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_invalid_utf8
deleted file mode 100644
index 8e07b342..00000000
--- a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_invalid_utf8
+++ /dev/null
@@ -1,2 +0,0 @@
-12,func�,1000,20
-13,ok,1001,2,data�
diff --git a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_nonnumeric_tid b/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_nonnumeric_tid
deleted file mode 100644
index 52203e4c..00000000
--- a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_nonnumeric_tid
+++ /dev/null
@@ -1,2 +0,0 @@
-not_a_1234,kmd_func,100000,0,500
-5678,another_func,20nu0m*
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_quote_in_name b/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_quote_in_name
deleted file mode 100644
index 1e6b3ff3..00000000
--- a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_quote_in_name
+++ /dev/null
@@ -1 +0,0 @@
-123,name"with\quote,100,5,data "x"
diff --git a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_tid_leading_zeros b/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_tid_leading_zeros
deleted file mode 100644
index 3fd65819..00000000
Binary files a/tools/unitrace/test/fuzz/regression/kmd_trace/kmd_tid_leading_zeros and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/kmd_trace/mixed_output_no_final_newline.txt b/tools/unitrace/test/fuzz/regression/kmd_trace/mixed_output_no_final_newline.txt
deleted file mode 100644
index 9acb61d0..00000000
--- a/tools/unitrace/test/fuzz/regression/kmd_trace/mixed_output_no_final_newline.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-@count[xe_exec]: 3
-1234,xe_exec_ioctl,1000,20
-5678,xe_exec_ioctl,2000,30,end,99
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/mergetrace/float_overflow_timestamp.json b/tools/unitrace/test/fuzz/regression/mergetrace/float_overflow_timestamp.json
deleted file mode 100644
index 15d4cef4..00000000
--- a/tools/unitrace/test/fuzz/regression/mergetrace/float_overflow_timestamp.json
+++ /dev/null
@@ -1 +0,0 @@
-{"traceEvents": [{"name": "k", "ph": "X", "pid": 1, "tid": 1, "ts": 1e400, "dur": 1}]}
diff --git a/tools/unitrace/test/fuzz/regression/mergetrace/nan_timestamp.json b/tools/unitrace/test/fuzz/regression/mergetrace/nan_timestamp.json
deleted file mode 100644
index 2f72b807..00000000
--- a/tools/unitrace/test/fuzz/regression/mergetrace/nan_timestamp.json
+++ /dev/null
@@ -1 +0,0 @@
-{"traceEvents": [{"name": "k", "ph": "X", "pid": 1, "tid": 1, "ts": NaN, "dur": 1}]}
diff --git a/tools/unitrace/test/fuzz/regression/metric_query/q_huge_data_size b/tools/unitrace/test/fuzz/regression/metric_query/q_huge_data_size
deleted file mode 100644
index 59b9dc39..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_query/q_huge_data_size and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metric_query/q_huge_kname_size b/tools/unitrace/test/fuzz/regression/metric_query/q_huge_kname_size
deleted file mode 100644
index cb03cf6c..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_query/q_huge_kname_size and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metric_samples/clock_span_zero b/tools/unitrace/test/fuzz/regression/metric_samples/clock_span_zero
deleted file mode 100644
index 8c6e6a1d..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_samples/clock_span_zero and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metric_samples/driver_counts_exceed_values b/tools/unitrace/test/fuzz/regression/metric_samples/driver_counts_exceed_values
deleted file mode 100644
index 1b54d66a..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_samples/driver_counts_exceed_values and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metric_samples/row_size_zero b/tools/unitrace/test/fuzz/regression/metric_samples/row_size_zero
deleted file mode 100644
index 452d589b..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_samples/row_size_zero and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metric_samples/unwrap_overflow b/tools/unitrace/test/fuzz/regression/metric_samples/unwrap_overflow
deleted file mode 100644
index a0709037..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metric_samples/unwrap_overflow and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/config_nested_missing_file b/tools/unitrace/test/fuzz/regression/metrics_server/config_nested_missing_file
deleted file mode 100644
index 33fc4121..00000000
--- a/tools/unitrace/test/fuzz/regression/metrics_server/config_nested_missing_file
+++ /dev/null
@@ -1 +0,0 @@
-
-favicon.ico
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/config_unbalanced_quote b/tools/unitrace/test/fuzz/regression/metrics_server/config_unbalanced_quote
deleted file mode 100644
index 345b9e10..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metrics_server/config_unbalanced_quote and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/request_huge_device b/tools/unitrace/test/fuzz/regression/metrics_server/request_huge_device
deleted file mode 100644
index 75fea9ce..00000000
--- a/tools/unitrace/test/fuzz/regression/metrics_server/request_huge_device
+++ /dev/null
@@ -1 +0,0 @@
-/k/1/11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_device b/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_device
deleted file mode 100644
index 3e14863b..00000000
--- a/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_device
+++ /dev/null
@@ -1 +0,0 @@
-/k/1/�
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_instance b/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_instance
deleted file mode 100644
index 107450fb..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metrics_server/request_superscript_instance and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/metrics_server/request_without_slash b/tools/unitrace/test/fuzz/regression/metrics_server/request_without_slash
deleted file mode 100644
index 880c423e..00000000
Binary files a/tools/unitrace/test/fuzz/regression/metrics_server/request_without_slash and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/roofline_csv/one_row_config.csv b/tools/unitrace/test/fuzz/regression/roofline_csv/one_row_config.csv
deleted file mode 100644
index 25572212..00000000
Binary files a/tools/unitrace/test/fuzz/regression/roofline_csv/one_row_config.csv and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/sample_lists/device_id_out_of_int_range b/tools/unitrace/test/fuzz/regression/sample_lists/device_id_out_of_int_range
deleted file mode 100644
index b0611c93..00000000
Binary files a/tools/unitrace/test/fuzz/regression/sample_lists/device_id_out_of_int_range and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/sample_lists/mpi_size_not_a_number b/tools/unitrace/test/fuzz/regression/sample_lists/mpi_size_not_a_number
deleted file mode 100644
index fd113dac..00000000
Binary files a/tools/unitrace/test/fuzz/regression/sample_lists/mpi_size_not_a_number and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/sample_lists/pmi_size_invalid b/tools/unitrace/test/fuzz/regression/sample_lists/pmi_size_invalid
deleted file mode 100644
index 4f631dab..00000000
Binary files a/tools/unitrace/test/fuzz/regression/sample_lists/pmi_size_invalid and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/summary/dangling_link_member b/tools/unitrace/test/fuzz/regression/summary/dangling_link_member
deleted file mode 100644
index 02bd9ff2..00000000
Binary files a/tools/unitrace/test/fuzz/regression/summary/dangling_link_member and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/summary/mixed_malformed_member_archive b/tools/unitrace/test/fuzz/regression/summary/mixed_malformed_member_archive
deleted file mode 100644
index b4bf131c..00000000
Binary files a/tools/unitrace/test/fuzz/regression/summary/mixed_malformed_member_archive and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/summary/oversized_field_member b/tools/unitrace/test/fuzz/regression/summary/oversized_field_member
deleted file mode 100644
index 99042613..00000000
Binary files a/tools/unitrace/test/fuzz/regression/summary/oversized_field_member and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/summary/table_header_at_eof b/tools/unitrace/test/fuzz/regression/summary/table_header_at_eof
deleted file mode 100644
index 34e42841..00000000
--- a/tools/unitrace/test/fuzz/regression/summary/table_header_at_eof
+++ /dev/null
@@ -1 +0,0 @@
-



*****************************











*****************************
















\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/app_arg_with_quote b/tools/unitrace/test/fuzz/regression/trace_json/app_arg_with_quote
deleted file mode 100644
index 71c16ac4..00000000
Binary files a/tools/unitrace/test/fuzz/regression/trace_json/app_arg_with_quote and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/itt_arg_key_with_quote b/tools/unitrace/test/fuzz/regression/trace_json/itt_arg_key_with_quote
deleted file mode 100644
index bd566a44..00000000
Binary files a/tools/unitrace/test/fuzz/regression/trace_json/itt_arg_key_with_quote and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_control_char b/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_control_char
deleted file mode 100644
index 23bd33e0..00000000
Binary files a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_control_char and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_invalid_utf8 b/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_invalid_utf8
deleted file mode 100644
index be5984c5..00000000
Binary files a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_invalid_utf8 and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_trailing_backslash b/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_trailing_backslash
deleted file mode 100644
index 5a85ebd1..00000000
--- a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_trailing_backslash
+++ /dev/null
@@ -1 +0,0 @@
-kernel\
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_with_quote b/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_with_quote
deleted file mode 100644
index 8c8277b9..00000000
--- a/tools/unitrace/test/fuzz/regression/trace_json/kernel_name_with_quote
+++ /dev/null
@@ -1 +0,0 @@
-"kernel"quote"
\ No newline at end of file
diff --git a/tools/unitrace/test/fuzz/regression/trace_json/name_truncated_utf8 b/tools/unitrace/test/fuzz/regression/trace_json/name_truncated_utf8
deleted file mode 100644
index c322b5b0..00000000
Binary files a/tools/unitrace/test/fuzz/regression/trace_json/name_truncated_utf8 and /dev/null differ
diff --git a/tools/unitrace/test/fuzz/replay.py b/tools/unitrace/test/fuzz/replay.py
deleted file mode 100644
index 9360fbab..00000000
--- a/tools/unitrace/test/fuzz/replay.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Replays one fuzz target's seed corpus (corpus/<target>/) and crash inputs
-# (regression/<target>/), as tests.txt runs it:
-#   replay.py <target> <dir holding the C++ fuzz_* binaries>
-# C++ targets are the libFuzzer binaries of the fuzz build; Python targets the
-# harnesses in python/. Exit status: 0 passed, 1 failed, 77 skipped (the target
-# cannot run here: off Linux, no clang with libFuzzer, or no atheris; the last
-# line printed says why).
-
-import os
-import subprocess
-import sys
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-SKIPPED = 77
-
-
-def run(cmd):
-    """Runs cmd and forwards its output, decoded with replacement: a harness echoes
-    parts of its input (e.g. a rejected device list holding 0xff), and the test
-    runner reads this script's output as UTF-8 text."""
-    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    sys.stdout.write(result.stdout.decode("utf-8", "replace"))
-    sys.stdout.flush()
-    return result
-
-
-def inputs(target):
-    """The input directories of target that exist: corpus/<target> and
-    regression/<target>.
-    """
-    dirs = [os.path.join(HERE, d, target) for d in ("corpus", "regression")]
-    return [d for d in dirs if os.path.isdir(d)]
-
-
-def replay_cpp(target, bin_dir):
-    """Replays the inputs of a C++ target through its libFuzzer binary (-runs=0).
-
-    target: the name, e.g. "elf64"; bin_dir: the directory holding fuzz_<target>.
-    Returns 0 if every input runs cleanly, 1 if one fails or the binary is missing
-    although it could be built, SKIPPED if it is missing because the fuzz build
-    cannot run here (fuzz_tests.skip_reason()).
-    """
-    exe = os.path.join(bin_dir, "fuzz_" + target)
-    if not os.path.isfile(exe):
-        sys.path.insert(0, os.path.dirname(HERE))
-        import fuzz_tests
-        reason = fuzz_tests.skip_reason()
-        if reason:
-            print(reason)
-            return SKIPPED
-        print(f"[ERROR] fuzz_{target} is not built at {exe}")
-        return 1
-    cmd = [exe, "-runs=0", "-timeout=10", "-rss_limit_mb=2048", "-malloc_limit_mb=1024"] + inputs(target)
-    print("Command: " + " ".join(cmd))
-    result = run(cmd)
-    if result.returncode != 0:
-        print(f"[ERROR] fuzz_{target} failed on an input (exit status {result.returncode})")
-        return 1
-    return 0
-
-
-def replay_python(target, harness):
-    """Replays the inputs of a Python target through its Atheris harness.
-
-    target: the name, e.g. "summary"; harness: the path of fuzz_<target>.py. Each
-    input file is run once. Returns 0 if all run cleanly, 1 if one fails or there are
-    no inputs, SKIPPED if atheris (which the harnesses import) is not installed.
-    """
-    try:
-        import atheris  # noqa: F401  (the harnesses import it)
-    except ImportError:
-        print("atheris not installed")
-        return SKIPPED
-    files = [os.path.join(d, f) for d in inputs(target) for f in sorted(os.listdir(d))
-             if os.path.isfile(os.path.join(d, f))]
-    if not files:
-        print(f"[ERROR] fuzz_{target} has no inputs")
-        return 1
-    # A harness given files runs each once (atheris/libFuzzer -runs semantics).
-    cmd = [sys.executable, harness] + files
-    print("Command: " + " ".join(cmd[:2]) + f" <{len(files)} inputs>")
-    result = run(cmd)
-    if result.returncode != 0:
-        print(f"[ERROR] fuzz_{target} failed on an input (exit status {result.returncode})")
-        return 1
-    return 0
-
-
-def main():
-    """replay.py <target> <fuzz binaries dir>: replays one target; returns its exit
-    status (0 passed, 1 failed, SKIPPED). Off Linux every target is SKIPPED.
-    """
-    if len(sys.argv) != 3:
-        print("usage: replay.py <target> <fuzz binaries dir>")
-        return 1
-    target, bin_dir = sys.argv[1], sys.argv[2]
-    if sys.platform != "linux":
-        print(f"not supported on {sys.platform}")
-        return SKIPPED
-    harness = os.path.join(HERE, "python", f"fuzz_{target}.py")
-    if os.path.isfile(harness):
-        return replay_python(target, harness)
-    if os.path.isfile(os.path.join(HERE, "cpp", f"fuzz_{target}.cc")):
-        return replay_cpp(target, bin_dir)
-    print(f"[ERROR] no fuzz target '{target}'")
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/test/fuzz/run_fuzz.sh b/tools/unitrace/test/fuzz/run_fuzz.sh
deleted file mode 100755
index ac74af13..00000000
--- a/tools/unitrace/test/fuzz/run_fuzz.sh
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/bin/bash
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-#
-# Runs fuzzing campaigns for unitrace (SDL505).
-#
-# Usage:
-#   ./run_fuzz.sh [-t seconds] [-s seed] [-o out_dir] [-b build_dir] [-m mb]
-#              [target...]
-#
-#   -t  duration per target in seconds (default 3600)
-#   -s  libFuzzer/Atheris random seed (default 1), recorded for reproduction
-#   -o  output directory (default results/campaign); a target directory that already
-#       exists (an earlier or concurrent run) is refused, so a run's artifacts, log
-#       and run.json stay together
-#   -b  directory holding the C++ fuzz_* binaries (default ../../build/test/fuzz/cpp)
-#   -m  RSS limit in MB (default 2048). Atheris' instrumentation grows the Python
-#       process by ~1.7 KB per input, so hour-long Python runs may need 4096.
-#   target  a target name, as in fuzz_<name> under cpp/ and python/ (e.g. elf64,
-#           kmd_trace); default: all, run in parallel
-#
-# Exits non-zero if any campaign failed (a crash, a missing binary, or its run.json
-# could not be written).
-#
-# Each target gets <out>/<target>/ with:
-#   corpus/     the evolving corpus (starts from corpus/<target>/ and regression/<target>/)
-#   artifacts/  crash-*, oom-*, timeout-* reproducers
-#   fuzz.log    full fuzzer output, including coverage and final statistics
-#   run.json    command line, seed, duration, start/end time, exit status
-
-set -u
-FUZZ_DIR="$(cd "$(dirname "$0")" && pwd)"
-DURATION=3600
-SEED=1
-OUT="$FUZZ_DIR/results/campaign"
-BUILD_DIR="$FUZZ_DIR/../../build/test/fuzz/cpp"
-RSS_MB=2048
-
-while getopts "t:s:o:b:m:" opt; do
-  case $opt in
-    t) DURATION=$OPTARG ;;
-    s) SEED=$OPTARG ;;
-    o) OUT=$OPTARG ;;
-    b) BUILD_DIR=$OPTARG ;;
-    m) RSS_MB=$OPTARG ;;
-    *) sed -n '10,23p' "$0" >&2; exit 2 ;;
-  esac
-done
-shift $((OPTIND - 1))
-
-# The targets are the harnesses in cpp/ and python/.
-CPP_TARGETS=()
-for f in "$FUZZ_DIR"/cpp/fuzz_*.cc; do t="${f##*/fuzz_}"; CPP_TARGETS+=("${t%.cc}"); done
-PY_TARGETS=()
-for f in "$FUZZ_DIR"/python/fuzz_*.py; do
-  t="${f##*/fuzz_}"; t="${t%.py}"; [[ $t == common ]] || PY_TARGETS+=("$t")
-done
-TARGETS=("$@")
-[[ ${#TARGETS[@]} -eq 0 ]] && TARGETS=("${CPP_TARGETS[@]}" "${PY_TARGETS[@]}")
-
-# Succeeds if target $1 is a C++ (libFuzzer) target, fails for a Python (Atheris)
-# one.
-is_cpp() { [[ " ${CPP_TARGETS[*]} " == *" $1 "* ]]; }
-
-# Runs one campaign and returns its fuzzer's exit status: fuzzes target $1 for
-# $DURATION seconds with seed $SEED, from a corpus seeded with corpus/<target> and
-# regression/<target>. Writes
-# $OUT/<target>/: the evolved corpus/, reproducers in artifacts/ (crash-*, oom-*,
-# timeout-*), the fuzzer output in fuzz.log and run.json (command, seed, duration,
-# start and end time, exit status).
-run_target() {
-  local t=$1 dir="$OUT/$1" cmd
-  # A directory holds one run: its artifacts, log and run.json describe the same run
-  # (make_evidence.py reads them together). mkdir reserves it atomically, so an
-  # earlier run, a target given twice, or another campaign writing to the same -o
-  # directory is refused instead of overwriting it.
-  mkdir -p "$OUT"
-  if ! mkdir "$dir" 2>/dev/null; then
-    echo "[ERROR] $dir already exists (an earlier or concurrent run); use another -o directory"
-    return 1
-  fi
-  mkdir -p "$dir/corpus" "$dir/artifacts"
-  for seeds in "$FUZZ_DIR/corpus/$t" "$FUZZ_DIR/regression/$t"; do
-    [[ -d "$seeds" ]] && cp -n "$seeds"/* "$dir/corpus/" 2>/dev/null
-  done
-  local flags=(-max_total_time="$DURATION" -seed="$SEED" -timeout=10 -rss_limit_mb="$RSS_MB"
-               -malloc_limit_mb=1024 -print_final_stats=1 -close_fd_mask=3
-               -artifact_prefix="$dir/artifacts/")
-  if is_cpp "$t"; then
-    cmd=("$BUILD_DIR/fuzz_$t" "${flags[@]}" "$dir/corpus")
-  else
-    cmd=(python3 "$FUZZ_DIR/python/fuzz_$t.py" "${flags[@]}" "$dir/corpus")
-  fi
-  local start; start=$(date -Iseconds)
-  "${cmd[@]}" > "$dir/fuzz.log" 2>&1
-  local status=$?
-  python3 - "$dir/run.json" "$t" "$SEED" "$DURATION" "$start" "$(date -Iseconds)" "$status" "${cmd[@]}" <<'PY'
-import json, sys
-path, target, seed, duration, start, end, status, *cmd = sys.argv[1:]
-json.dump({"target": target, "seed": int(seed), "duration_s": int(duration), "start": start,
-           "end": end, "exit_status": int(status), "command": cmd}, open(path, "w"), indent=2)
-PY
-  # Without its run.json the run is no evidence, whatever the fuzzer returned.
-  if [[ $? -ne 0 ]]; then
-    echo "[ERROR] $t: cannot write $dir/run.json"
-    return 1
-  fi
-  echo "[DONE] $t exit=$status"
-  return $status
-}
-
-mkdir -p "$OUT"
-pids=()
-for t in "${TARGETS[@]}"; do
-  run_target "$t" &
-  pids+=($!)
-done
-# A campaign that crashed, or whose binary is missing, makes the script fail.
-failed=0
-for pid in "${pids[@]}"; do
-  wait "$pid" || failed=1
-done
-exit $failed
diff --git a/tools/unitrace/test/fuzz_tests.py b/tools/unitrace/test/fuzz_tests.py
deleted file mode 100644
index 6c305aba..00000000
--- a/tools/unitrace/test/fuzz_tests.py
+++ /dev/null
@@ -1,178 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# The fuzz build step of test_unitrace.py's cpp-test group. The fuzz tests are
-# the [fuzz_*] blocks of tests.txt; each runs test/fuzz/replay.py, which
-# replays one target's seed corpus and regression inputs.
-#
-# The C++ targets include the unitrace sources, so they build with unitrace
-# itself, configured with clang and -DUNITRACE_BUILD_FUZZ=ON in
-# <unitrace build>/test/fuzz_build, with the same BUILD_WITH_* switches as the
-# unitrace under test, except BUILD_WITH_OMP and BUILD_WITH_PERFETTO, which are
-# always off, and with local clones of the repositories the main build fetched
-# (headers, ittapi), so it does not download them again. The clang is the one on
-# PATH or, in the oneAPI CI images, the one oneAPI ships. The fuzz tests need no
-# GPU. Their C++ targets are skipped off Linux or without a clang with libFuzzer,
-# the Python targets without atheris.
-
-import os
-import platform
-import re
-import shutil
-import subprocess
-import tempfile
-
-import test_layout
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-UNITRACE_SOURCE_DIR = os.path.normpath(os.path.join(_HERE, ".."))
-
-YELLOW = "\033[33m"
-RESET = "\033[0m"
-
-
-# The sanitizers the fuzz targets build with (test/fuzz/cpp/CMakeLists.txt).
-SANITIZERS = "-fsanitize=fuzzer,address,undefined"
-
-
-def _candidate_compilers():
-    """(C compiler, C++ compiler) pairs to try, in order.
-
-    clang on PATH first. Then the clang that oneAPI ships, which the CI images load
-    (setvars.sh sets CMPLR_ROOT) without putting clang on PATH: bin/compiler/ from
-    oneAPI 2024 on, linux/bin-llvm/ before. Then oneAPI's own icx/icpx drivers, which
-    are clang-based too.
-    """
-    pairs = [("clang", "clang++")]
-    root = os.environ.get("CMPLR_ROOT", "")
-    if root:
-        for sub in ("bin/compiler", "linux/bin-llvm"):
-            pairs.append((os.path.join(root, sub, "clang"), os.path.join(root, sub, "clang++")))
-    pairs.append(("icx", "icpx"))
-    return pairs
-
-
-def _links_fuzz_target(cxx):
-    """true if cxx builds and links a trivial fuzz target with SANITIZERS: some
-    distributions ship clang without libFuzzer or the sanitizer runtimes."""
-    with tempfile.TemporaryDirectory() as tmp:
-        src = os.path.join(tmp, "probe.cc")
-        with open(src, "w") as f:
-            f.write('#include <cstddef>\n#include <cstdint>\n'
-                    'extern "C" int LLVMFuzzerTestOneInput(const uint8_t*, size_t) { return 0; }\n')
-        probe = subprocess.run([cxx, SANITIZERS, src, "-o", os.path.join(tmp, "probe")],
-                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    return probe.returncode == 0
-
-
-def find_compilers():
-    """The (C, C++) compilers to build the fuzz targets with: the first pair of
-    _candidate_compilers() that exists and links a fuzz target. Returns
-    (None, reason) if there is none."""
-    found = False
-    for cc, cxx in _candidate_compilers():
-        if shutil.which(cc) is None or shutil.which(cxx) is None:
-            continue
-        found = True
-        if _links_fuzz_target(cxx):
-            return shutil.which(cc), shutil.which(cxx)
-    if not found:
-        return None, "no clang (PATH or oneAPI) found"
-    return None, f"no clang links libFuzzer and the sanitizers ({SANITIZERS})"
-
-
-def skip_reason():
-    """Why the C++ fuzz targets cannot run here, or None if they can: they
-    need Linux and a clang with libFuzzer (find_compilers()).
-    """
-    if platform.system() != "Linux":
-        return f"not supported on {platform.system()}"
-    cc, reason = find_compilers()
-    return None if cc else reason
-
-
-def _build_switches(unitrace_build_dir):
-    """The -DBUILD_WITH_*=<value> options of the unitrace build under test, and the
-    dependency paths it found (-D<Name>_LIBRARY, -D<Name>_INCLUDE_DIR).
-
-    unitrace_build_dir: the build directory (None: the default one); its
-    CMakeCache.txt is read. The fuzz build gets the same switches, so it compiles the
-    same features and does not look for libraries the main build was configured
-    without. Returns [] if there is no cache.
-    """
-    cache = os.path.join(test_layout.unitrace_build_dir(unitrace_build_dir), "CMakeCache.txt")
-    switches = []
-    if os.path.isfile(cache):
-        with open(cache) as f:
-            for line in f:
-                m = re.match(r"(BUILD_WITH_[A-Z0-9_]+):[A-Z]+=(.*)$", line.strip())
-                if m:
-                    switches.append(f"-D{m.group(1)}={m.group(2)}")
-                    continue
-                # Where the main build found a dependency (e.g. Xptifw_LIBRARY and
-                # Xptifw_INCLUDE_DIR given on its command line): the same, not looked up again.
-                m = re.match(r"([A-Za-z0-9]+_(?:LIBRARY|INCLUDE_DIR)):(FILEPATH|PATH|STRING)=(.+)$", line.strip())
-                if m and not m.group(3).endswith("-NOTFOUND"):
-                    switches.append(f"-D{m.group(1)}:{m.group(2)}={m.group(3)}")
-    return switches
-
-
-def _reuse_header_clones(unitrace_build_dir, build_dir):
-    """Clones, from the build under test, the repositories its configure and build
-    fetched from GitHub (headers, ittapi) into the fuzz build, so the fetch scripts
-    find them (build_utils.clone() skips a clone at the pinned commit) and do not go
-    to the network again. A local clone shares the objects and checks out the same
-    commit, but has its own work tree, which get_itt.py builds in. A repository the
-    main build does not have (system headers used instead) is fetched as usual.
-    """
-    parent = test_layout.unitrace_build_dir(unitrace_build_dir)
-    for name in ("level-zero", "intel-graphics-compiler", "compute-runtime", "OpenCL-Headers",
-                 "ittapi"):
-        src = os.path.join(parent, name)
-        dst = os.path.join(build_dir, name)
-        if os.path.isdir(os.path.join(src, ".git")) and not os.path.lexists(dst):
-            os.makedirs(build_dir, exist_ok=True)
-            subprocess.run(["git", "clone", "--quiet", src, dst], check=True)
-
-
-def build(unitrace_build_dir=None):
-    """Configures and builds the fuzz targets, part of the cpp-test build step.
-
-    unitrace_build_dir: the unitrace build under test (None: the default one). The
-    targets build with unitrace itself, with find_compilers()' clang and
-    -DUNITRACE_BUILD_FUZZ=ON (and -DBUILD_WITH_OMP=0 -DBUILD_WITH_PERFETTO=OFF), into
-    <unitrace build>/test/fuzz_build; the build is incremental. Returns 0 on success
-    or when the targets cannot be built here (a Skipped notice is printed), 1 if the build
-    fails.
-    """
-    reason = skip_reason()
-    if reason:
-        print(f"{YELLOW}fuzz build: Skipped ({reason}){RESET}")
-        return 0
-    cc, cxx = find_compilers()
-    print(f"Fuzz build compiler: {cxx}")
-    build_dir = test_layout.fuzz_build_dir(unitrace_build_dir)
-    configure = ["cmake", "-S", UNITRACE_SOURCE_DIR, "-B", build_dir, "-G", "Ninja",
-                 "-DUNITRACE_BUILD_FUZZ=ON",
-                 f"-DCMAKE_C_COMPILER={cc}", f"-DCMAKE_CXX_COMPILER={cxx}"]
-    configure += _build_switches(unitrace_build_dir)
-    # Without the OpenMP collector, whatever the build under test has: CMake's
-    # FindOpenMP depends on the compiler (it fails for oneAPI's bare clang), and no
-    # fuzzed parser is in it. Given last, so it overrides the forwarded switch.
-    configure.append("-DBUILD_WITH_OMP=0")
-    # Without Perfetto output either: no fuzzed parser is in it, and its setup
-    # downloads the trace proto and builds protobuf a second time.
-    configure.append("-DBUILD_WITH_PERFETTO=OFF")
-    _reuse_header_clones(unitrace_build_dir, build_dir)
-    try:
-        print("Fuzz build started ... ")
-        subprocess.run(configure, check=True)
-        subprocess.run(["cmake", "--build", build_dir, "--target", "unitrace_fuzz"], check=True)
-        print("Fuzz build completed ...")
-        return 0
-    except subprocess.CalledProcessError as e:
-        print(f"[ERROR] during fuzz build: {e}")
-        return 1
diff --git a/tools/unitrace/test/python_test/CMakeLists.txt b/tools/unitrace/test/python_test/CMakeLists.txt
deleted file mode 100644
index d9093635..00000000
--- a/tools/unitrace/test/python_test/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-
-cmake_minimum_required(VERSION 3.22) 
-
-project(UnitracePythonTest)
-
-find_package(PythonInterp 3.9 REQUIRED)
-
-
-
diff --git a/tools/unitrace/test/python_test/mat_mul/gold/linux/d.txt b/tools/unitrace/test/python_test/mat_mul/gold/linux/d.txt
deleted file mode 100644
index b110654e..00000000
--- a/tools/unitrace/test/python_test/mat_mul/gold/linux/d.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           6475366100
-    Total Device Time for L0 backend (ns):               141976
-
-== L0 Backend ==
-
-                                                                                                                                                 Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",            2,               104061,    73.294785,                52030,                50416,                53645
-                                                                                                                   "zeCommandListAppendMemoryCopy(D2M)",            3,                27395,    19.295515,                 9131,                 4166,                12604
-                                                                                                                                          "gemm_kernel",            1,                10520,     7.409703,                10520,                10520,                10520
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                 Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",      AOT,   32,                   5,                  0,                         0,                       0,                           128
-                                                                                                                                          "gemm_kernel",      AOT,    8,                  15,               4096,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/python_test/mat_mul/gold/linux/t.txt b/tools/unitrace/test/python_test/mat_mul/gold/linux/t.txt
deleted file mode 100644
index 1e64d50e..00000000
--- a/tools/unitrace/test/python_test/mat_mul/gold/linux/t.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-Thread 32936 Device 1863164014248 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 365787111234400 (append) 365787112001800 (submit) 365787112939404 (start) 365787112977008 (end)
-Thread 32936 Device 1863164014248 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 365787112713500 (append) 365787443913700 (submit) 365787444558595 (start) 365787444601199 (end)
-Thread 32936 Device 1863164014248 : "gemm_kernel[SIMD8 {1; 1; 1} {16; 8; 1}]" [ns] 365787438022000 (append) 365787443913700 (submit) 365787444601720 (start) 365787444611511 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787439619200 (append) 365787443913700 (submit) 365787444612241 (start) 365787444615886 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787454279800 (append) 365787455109300 (submit) 365787455517216 (start) 365787455524716 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787456442400 (append) 365787456726300 (submit) 365787456951508 (start) 365787456959008 (end)
-
diff --git a/tools/unitrace/test/python_test/mat_mul/gold/windows/d.txt b/tools/unitrace/test/python_test/mat_mul/gold/windows/d.txt
deleted file mode 100644
index b110654e..00000000
--- a/tools/unitrace/test/python_test/mat_mul/gold/windows/d.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           6475366100
-    Total Device Time for L0 backend (ns):               141976
-
-== L0 Backend ==
-
-                                                                                                                                                 Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-"_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",            2,               104061,    73.294785,                52030,                50416,                53645
-                                                                                                                   "zeCommandListAppendMemoryCopy(D2M)",            3,                27395,    19.295515,                 9131,                 4166,                12604
-                                                                                                                                          "gemm_kernel",            1,                10520,     7.409703,                10520,                10520,                10520
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                 Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-"_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",      AOT,   32,                   5,                  0,                         0,                       0,                           128
-                                                                                                                                          "gemm_kernel",      AOT,    8,                  15,               4096,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/python_test/mat_mul/gold/windows/t.txt b/tools/unitrace/test/python_test/mat_mul/gold/windows/t.txt
deleted file mode 100644
index 1e64d50e..00000000
--- a/tools/unitrace/test/python_test/mat_mul/gold/windows/t.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-Thread 32936 Device 1863164014248 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 365787111234400 (append) 365787112001800 (submit) 365787112939404 (start) 365787112977008 (end)
-Thread 32936 Device 1863164014248 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 365787112713500 (append) 365787443913700 (submit) 365787444558595 (start) 365787444601199 (end)
-Thread 32936 Device 1863164014248 : "gemm_kernel[SIMD8 {1; 1; 1} {16; 8; 1}]" [ns] 365787438022000 (append) 365787443913700 (submit) 365787444601720 (start) 365787444611511 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787439619200 (append) 365787443913700 (submit) 365787444612241 (start) 365787444615886 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787454279800 (append) 365787455109300 (submit) 365787455517216 (start) 365787455524716 (end)
-Thread 32936 Device 1863164014248 : "zeCommandListAppendMemoryCopy(D2M)[64]" [ns] 365787456442400 (append) 365787456726300 (submit) 365787456951508 (start) 365787456959008 (end)
-
diff --git a/tools/unitrace/test/python_test/mat_mul/matMul.py b/tools/unitrace/test/python_test/mat_mul/matMul.py
deleted file mode 100644
index fda8e5f3..00000000
--- a/tools/unitrace/test/python_test/mat_mul/matMul.py
+++ /dev/null
@@ -1,23 +0,0 @@
-import torch
-
-# check if XPU is present
-if not torch.xpu.is_available():
-    print("[ERROR] XPU device is not present.")
-else:
-    # generate two random 4x4 matrices with single precision on XPU
-    xpu_a = torch.rand((4, 4), dtype=torch.float32, device="xpu")
-    xpu_b = torch.rand((4, 4), dtype=torch.float32, device="xpu")
-
-    # matrix multiplication on XPU
-    xpu_c = torch.matmul(xpu_a, xpu_b)
-
-    # copy the data back to CPU for validation
-    cpu_a = xpu_a.to("cpu")
-    cpu_b = xpu_b.to("cpu")
-    cpu_c = xpu_c.to("cpu")
-
-    # validation
-    if torch.allclose(cpu_c, torch.matmul(cpu_a, cpu_b)):
-        print("[INFO] Matrix multiplication is correct!")
-    else:
-        print("[ERROR] Matrix multiplication validation failed.")
\ No newline at end of file
diff --git a/tools/unitrace/test/python_test/vec_add/gold/linux/d.txt b/tools/unitrace/test/python_test/vec_add/gold/linux/d.txt
deleted file mode 100644
index 5fdcc80c..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/linux/d.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           3527922600
-    Total Device Time for L0 backend (ns):               117494
-
-== L0 Backend ==
-
-                                                                                                                                                         Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-        "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",            2,                68332,    58.157864,                34166,                25937,                42395
-"_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE",           10,                34163,    29.076378,                 3416,                 1979,                 7083
-                                                                                                                           "zeCommandListAppendMemoryCopy(D2M)",            3,                14999,    12.765759,                 4999,                 3541,                 5729
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                         Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-        "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",      AOT,   32,                   5,                  0,                         0,                       0,                           128
-"_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE",      AOT,   32,                   3,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/python_test/vec_add/gold/linux/h.txt b/tools/unitrace/test/python_test/vec_add/gold/linux/h.txt
deleted file mode 100644
index 44819732..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/linux/h.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           5985108100
-    Total API Time for L0 backend (ns):            111228000
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                        zeModuleCreate,            2,            101628300,     91.369354,             50814150,              2622500,             99005800
-         zeCommandListAppendMemoryCopy,            3,              1679700,      1.510141,               559900,                99500,              1401600
-                    zeCommandListReset,            6,              1131700,      1.017460,               188616,                 1700,               473600
-                zeEventHostSynchronize,            3,              1102700,      0.991387,               367566,               153500,               777700
-                   zeCommandListCreate,            3,               998200,      0.897436,               332733,               283400,               424700
-           zeContextMakeMemoryResident,            2,               920000,      0.827130,               460000,               270000,               650000
-                 zeDeviceGetProperties,            4,               919700,      0.826860,               229925,               125100,               385900
-     zeCommandQueueExecuteCommandLists,            6,               493400,      0.443593,                82233,                31400,               182600
-                      zeMemAllocDevice,            2,               489900,      0.440447,               244950,               175800,               314100
-          zeCommandListCreateImmediate,            1,               313000,      0.281404,               313000,               313000,               313000
-                             zeMemFree,            4,               252200,      0.226741,                63050,                24500,                95900
-       zeCommandListAppendLaunchKernel,           12,               196900,      0.177024,                16408,                 4800,                49400
-                      zeMemAllocShared,            2,               178700,      0.160661,                89350,                65600,               113100
-                  zeCommandQueueCreate,            1,               160200,      0.144028,               160200,               160200,               160200
-                        zeKernelCreate,            2,               139300,      0.125238,                69650,                59100,                80200
-                        zeMemAllocHost,            1,               100900,      0.090715,               100900,               100900,               100900
-                         zeEventCreate,           13,                96000,      0.086309,                 7384,                 1600,                52400
-                     zeEventPoolCreate,            1,                92900,      0.083522,                92900,                92900,                92900
-        zeDriverGetExtensionProperties,            2,                44600,      0.040098,                22300,                17900,                26700
-              zeKernelSetArgumentValue,           40,                30200,      0.027151,                  755,                  200,                 5500
-                           zeDriverGet,            5,                22000,      0.019779,                 4400,                  500,                12600
-                 zeDeviceGetRootDevice,           11,                21300,      0.019150,                 1936,                  100,                12000
-                    zeFenceQueryStatus,            9,                20800,      0.018700,                 2311,                  300,                10200
-                       zeContextCreate,            1,                17800,      0.016003,                17800,                17800,                17800
-   zeDriverGetExtensionFunctionAddress,            8,                17600,      0.015823,                 2200,                  900,                 5900
-                    zeCommandListClose,            6,                14700,      0.013216,                 2450,                  900,                 5400
-                           zeDeviceGet,            6,                13600,      0.012227,                 2266,                  300,                10600
-            zeKernelSetGlobalOffsetExp,           12,                13400,      0.012047,                 1116,                  300,                 8000
-                      zeEventHostReset,            2,                13400,      0.012047,                 6700,                 5600,                 7800
-                         zeFenceCreate,            3,                12100,      0.010879,                 4033,                 1100,                 9100
-zeDeviceGetCommandQueueGroupProperties,            2,                10700,      0.009620,                 5350,                 1800,                 8900
-           zeDeviceGetModuleProperties,            1,                10700,      0.009620,                10700,                10700,                10700
-                  zeKernelSetGroupSize,           12,                 9700,      0.008721,                  808,                  200,                 3000
-                 zeDriverGetProperties,            1,                 7400,      0.006653,                 7400,                 7400,                 7400
-                 zeCommandQueueDestroy,            1,                 6900,      0.006203,                 6900,                 6900,                 6900
-           zeDeviceGetMemoryProperties,            2,                 6500,      0.005844,                 3250,                 1200,                 5300
-                 zeDeviceGetSubDevices,            7,                 5700,      0.005125,                  814,                  200,                 1400
-                 zeModuleGetProperties,            2,                 5200,      0.004675,                 2600,                 1300,                 3900
-                        zeFenceDestroy,            3,                 4700,      0.004226,                 1566,                  300,                 4100
-             zeKernelSetIndirectAccess,            2,                 4400,      0.003956,                 2200,                  800,                 3600
-     zeDeviceGetMemoryAccessProperties,            1,                 4400,      0.003956,                 4400,                 4400,                 4400
-                 zeDriverGetApiVersion,            1,                 4300,      0.003866,                 4300,                 4300,                 4300
-               zeMemGetAllocProperties,            4,                 3300,      0.002967,                  825,                  500,                 1300
-                 zeKernelGetProperties,            2,                 3300,      0.002967,                 1650,                 1500,                 1800
-                          zeFenceReset,            6,                 1800,      0.001618,                  300,                  100,                  500
-          zeDeviceGetComputeProperties,            1,                 1700,      0.001528,                 1700,                 1700,                 1700
-            zeDeviceGetCacheProperties,            2,                 1600,      0.001438,                  800,                  800,                  800
-            zeDeviceGetImageProperties,            1,                  500,      0.000450,                  500,                  500,                  500
-
-
diff --git a/tools/unitrace/test/python_test/vec_add/gold/linux/t.txt b/tools/unitrace/test/python_test/vec_add/gold/linux/t.txt
deleted file mode 100644
index fa5180b0..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/linux/t.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683712981961600 (append) 683712982387300 (submit) 683712983417195 (start) 683712983448445 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683712982837600 (append) 683713047948100 (submit) 683713048662214 (start) 683713048687630 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713046960100 (append) 683713047948100 (submit) 683713048688047 (start) 683713048694192 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713047227000 (append) 683713047948100 (submit) 683713048694714 (start) 683713048696901 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713047399100 (append) 683713047948100 (submit) 683713048697422 (start) 683713048699505 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048295300 (append) 683713056298000 (submit) 683713056635500 (start) 683713056643729 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048472200 (append) 683713056298000 (submit) 683713056644354 (start) 683713056646437 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048654000 (append) 683713056298000 (submit) 683713056646958 (start) 683713056649353 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048721100 (append) 683713056298000 (submit) 683713056649770 (start) 683713056651853 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713057432100 (append) 683713058221200 (submit) 683713058488387 (start) 683713058491824 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713056631200 (append) 683713058221200 (submit) 683713058474845 (start) 683713058482345 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713056908000 (append) 683713058221200 (submit) 683713058482866 (start) 683713058484949 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713057038100 (append) 683713058221200 (submit) 683713058485470 (start) 683713058487657 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713059333300 (append) 683713059522200 (submit) 683713059750377 (start) 683713059756835 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713060397200 (append) 683713060611100 (submit) 683713060884277 (start) 683713060891360 (end)
-
diff --git a/tools/unitrace/test/python_test/vec_add/gold/windows/d.txt b/tools/unitrace/test/python_test/vec_add/gold/windows/d.txt
deleted file mode 100644
index 5fdcc80c..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/windows/d.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-=== Device Timing Summary ===
-
-                Total Execution Time (ns):           3527922600
-    Total Device Time for L0 backend (ns):               117494
-
-== L0 Backend ==
-
-                                                                                                                                                         Kernel,        Calls,            Time (ns),     Time (%),         Average (ns),             Min (ns),             Max (ns)
-        "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",            2,                68332,    58.157864,                34166,                25937,                42395
-"_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE",           10,                34163,    29.076378,                 3416,                 1979,                 7083
-                                                                                                                           "zeCommandListAppendMemoryCopy(D2M)",            3,                14999,    12.765759,                 4999,                 3541,                 5729
-
-
-=== Kernel Properties ===
-
-                                                                                                                                                         Kernel, Compiled, SIMD, Number of Arguments, SLM Per Work Group, Private Memory Per Thread, Spill Memory Per Thread, Register File Size Per Thread
-        "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE",      AOT,   32,                   5,                  0,                         0,                       0,                           128
-"_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE",      AOT,   32,                   3,                  0,                         0,                       0,                           128
-
-
diff --git a/tools/unitrace/test/python_test/vec_add/gold/windows/h.txt b/tools/unitrace/test/python_test/vec_add/gold/windows/h.txt
deleted file mode 100644
index 44819732..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/windows/h.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-
-=== API Timing Summary ===
-
-             Total Execution Time (ns):           5985108100
-    Total API Time for L0 backend (ns):            111228000
-
-== L0 Backend ==
-
-                              Function,        Calls,            Time (ns),      Time (%),         Average (ns),             Min (ns),             Max (ns)
-                        zeModuleCreate,            2,            101628300,     91.369354,             50814150,              2622500,             99005800
-         zeCommandListAppendMemoryCopy,            3,              1679700,      1.510141,               559900,                99500,              1401600
-                    zeCommandListReset,            6,              1131700,      1.017460,               188616,                 1700,               473600
-                zeEventHostSynchronize,            3,              1102700,      0.991387,               367566,               153500,               777700
-                   zeCommandListCreate,            3,               998200,      0.897436,               332733,               283400,               424700
-           zeContextMakeMemoryResident,            2,               920000,      0.827130,               460000,               270000,               650000
-                 zeDeviceGetProperties,            4,               919700,      0.826860,               229925,               125100,               385900
-     zeCommandQueueExecuteCommandLists,            6,               493400,      0.443593,                82233,                31400,               182600
-                      zeMemAllocDevice,            2,               489900,      0.440447,               244950,               175800,               314100
-          zeCommandListCreateImmediate,            1,               313000,      0.281404,               313000,               313000,               313000
-                             zeMemFree,            4,               252200,      0.226741,                63050,                24500,                95900
-       zeCommandListAppendLaunchKernel,           12,               196900,      0.177024,                16408,                 4800,                49400
-                      zeMemAllocShared,            2,               178700,      0.160661,                89350,                65600,               113100
-                  zeCommandQueueCreate,            1,               160200,      0.144028,               160200,               160200,               160200
-                        zeKernelCreate,            2,               139300,      0.125238,                69650,                59100,                80200
-                        zeMemAllocHost,            1,               100900,      0.090715,               100900,               100900,               100900
-                         zeEventCreate,           13,                96000,      0.086309,                 7384,                 1600,                52400
-                     zeEventPoolCreate,            1,                92900,      0.083522,                92900,                92900,                92900
-        zeDriverGetExtensionProperties,            2,                44600,      0.040098,                22300,                17900,                26700
-              zeKernelSetArgumentValue,           40,                30200,      0.027151,                  755,                  200,                 5500
-                           zeDriverGet,            5,                22000,      0.019779,                 4400,                  500,                12600
-                 zeDeviceGetRootDevice,           11,                21300,      0.019150,                 1936,                  100,                12000
-                    zeFenceQueryStatus,            9,                20800,      0.018700,                 2311,                  300,                10200
-                       zeContextCreate,            1,                17800,      0.016003,                17800,                17800,                17800
-   zeDriverGetExtensionFunctionAddress,            8,                17600,      0.015823,                 2200,                  900,                 5900
-                    zeCommandListClose,            6,                14700,      0.013216,                 2450,                  900,                 5400
-                           zeDeviceGet,            6,                13600,      0.012227,                 2266,                  300,                10600
-            zeKernelSetGlobalOffsetExp,           12,                13400,      0.012047,                 1116,                  300,                 8000
-                      zeEventHostReset,            2,                13400,      0.012047,                 6700,                 5600,                 7800
-                         zeFenceCreate,            3,                12100,      0.010879,                 4033,                 1100,                 9100
-zeDeviceGetCommandQueueGroupProperties,            2,                10700,      0.009620,                 5350,                 1800,                 8900
-           zeDeviceGetModuleProperties,            1,                10700,      0.009620,                10700,                10700,                10700
-                  zeKernelSetGroupSize,           12,                 9700,      0.008721,                  808,                  200,                 3000
-                 zeDriverGetProperties,            1,                 7400,      0.006653,                 7400,                 7400,                 7400
-                 zeCommandQueueDestroy,            1,                 6900,      0.006203,                 6900,                 6900,                 6900
-           zeDeviceGetMemoryProperties,            2,                 6500,      0.005844,                 3250,                 1200,                 5300
-                 zeDeviceGetSubDevices,            7,                 5700,      0.005125,                  814,                  200,                 1400
-                 zeModuleGetProperties,            2,                 5200,      0.004675,                 2600,                 1300,                 3900
-                        zeFenceDestroy,            3,                 4700,      0.004226,                 1566,                  300,                 4100
-             zeKernelSetIndirectAccess,            2,                 4400,      0.003956,                 2200,                  800,                 3600
-     zeDeviceGetMemoryAccessProperties,            1,                 4400,      0.003956,                 4400,                 4400,                 4400
-                 zeDriverGetApiVersion,            1,                 4300,      0.003866,                 4300,                 4300,                 4300
-               zeMemGetAllocProperties,            4,                 3300,      0.002967,                  825,                  500,                 1300
-                 zeKernelGetProperties,            2,                 3300,      0.002967,                 1650,                 1500,                 1800
-                          zeFenceReset,            6,                 1800,      0.001618,                  300,                  100,                  500
-          zeDeviceGetComputeProperties,            1,                 1700,      0.001528,                 1700,                 1700,                 1700
-            zeDeviceGetCacheProperties,            2,                 1600,      0.001438,                  800,                  800,                  800
-            zeDeviceGetImageProperties,            1,                  500,      0.000450,                  500,                  500,                  500
-
-
diff --git a/tools/unitrace/test/python_test/vec_add/gold/windows/t.txt b/tools/unitrace/test/python_test/vec_add/gold/windows/t.txt
deleted file mode 100644
index fa5180b0..00000000
--- a/tools/unitrace/test/python_test/vec_add/gold/windows/t.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683712981961600 (append) 683712982387300 (submit) 683712983417195 (start) 683712983448445 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu36DistributionElementwiseKernelFunctorIffLi4ENS0_9templates3xpu27Uniform4DistributionFunctorENS4_23UniformTransformFunctorIffEEiEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683712982837600 (append) 683713047948100 (submit) 683713048662214 (start) 683713048687630 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713046960100 (append) 683713047948100 (submit) 683713048688047 (start) 683713048694192 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713047227000 (append) 683713047948100 (submit) 683713048694714 (start) 683713048696901 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713047399100 (append) 683713047948100 (submit) 683713048697422 (start) 683713048699505 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048295300 (append) 683713056298000 (submit) 683713056635500 (start) 683713056643729 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048472200 (append) 683713056298000 (submit) 683713056644354 (start) 683713056646437 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048654000 (append) 683713056298000 (submit) 683713056646958 (start) 683713056649353 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713048721100 (append) 683713056298000 (submit) 683713056649770 (start) 683713056651853 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713057432100 (append) 683713058221200 (submit) 683713058488387 (start) 683713058491824 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713056631200 (append) 683713058221200 (submit) 683713058474845 (start) 683713058482345 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713056908000 (append) 683713058221200 (submit) 683713058482866 (start) 683713058484949 (end)
-Thread 2516 Device 3140521589432 : "_ZTSN2at6native3xpu27VectorizedElementwiseKernelILi4ENS1_13BinaryFunctorIfffNS1_10AddFunctorIfEEEENS_6detail5ArrayIPcLi3EEE23TrivialOffsetCalculatorILi2EjEEE[SIMD32 {1; 1; 1} {256; 1; 1}]" [ns] 683713057038100 (append) 683713058221200 (submit) 683713058485470 (start) 683713058487657 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713059333300 (append) 683713059522200 (submit) 683713059750377 (start) 683713059756835 (end)
-Thread 2516 Device 3140521589432 : "zeCommandListAppendMemoryCopy(D2M)[128]" [ns] 683713060397200 (append) 683713060611100 (submit) 683713060884277 (start) 683713060891360 (end)
-
diff --git a/tools/unitrace/test/python_test/vec_add/vecAdd.py b/tools/unitrace/test/python_test/vec_add/vecAdd.py
deleted file mode 100644
index 3f8de113..00000000
--- a/tools/unitrace/test/python_test/vec_add/vecAdd.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import torch
-
-# check if XPU is present
-if not torch.xpu.is_available():
-  print("[ERROR] XPU device is not present.")
-
-# generate random tensor data with single precision data on xpu device
-xpu_a = torch.rand(32, dtype=torch.float32, device="xpu")
-xpu_b = torch.rand(32, dtype=torch.float32, device="xpu")
-
-# execute element wise add on XPU
-for i in range(10):
-  xpu_c = xpu_a + xpu_b
-
-# copy the result and other data back to CPU for validation
-cpu_a = xpu_a.to("cpu")
-cpu_b = xpu_b.to("cpu")
-cpu_c = xpu_c.to("cpu")
-
-# validation
-if torch.allclose(cpu_c, cpu_a + cpu_b):
-  print("[INFO] vector addition is correct!")
-else:
-  print("[ERROR] validation failed!")
diff --git a/tools/unitrace/test/requirements.txt b/tools/unitrace/test/requirements.txt
deleted file mode 100644
index 11ccc906..00000000
--- a/tools/unitrace/test/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-protobuf >= 3.20, < 8
diff --git a/tools/unitrace/test/run_test.py b/tools/unitrace/test/run_test.py
deleted file mode 100644
index f387c9bd..00000000
--- a/tools/unitrace/test/run_test.py
+++ /dev/null
@@ -1,645 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import sys
-import subprocess
-import os
-import platform
-import unidiff
-import argparse
-import shutil
-import glob
-import signal
-import tempfile
-from pathlib import Path
-from datetime import datetime
-
-import test_layout
-
-def extract_test_case_output(cmake_root_path, test_case_name, scenario):
-    # Construct the path to the expected output file within the "gold" folder
-    scenario = scenario.lstrip('-')
-    if platform.system() == "Windows":
-        expected_output_file = os.path.join(cmake_root_path, test_case_name, "gold", "windows", f"{scenario}.txt").replace("\\", "/")
-    else:
-        expected_output_file = os.path.join(cmake_root_path, test_case_name, "gold", "linux", f"{scenario}.txt").replace("\\", "/")
-
-    print(f"[INFO] Extracting expected output from file: {expected_output_file}")
-
-    # Check if the file exists
-    if not os.path.isfile(expected_output_file):
-        raise FileNotFoundError(f"[ERROR] Expected output file {expected_output_file} not found")
-
-    # Return the path to the expected output file
-    return expected_output_file
-
-def call_unidiff(scenario, output_dir, output_file_with_pid, expected_output_file):
-    cur_path = os.path.join(output_dir, output_file_with_pid)
-    ref_path = expected_output_file
-
-    if scenario in ["--device-timeline", "-t"]:
-        print(f"[INFO] Running device timeline comparison for {cur_path} vs {ref_path}")
-        device_timeline_cur = unidiff.DeviceTimeline(cur_path)
-        device_timeline_ref = unidiff.DeviceTimeline(ref_path)
-        print(f"[INFO] Running device timeline comparison for {cur_path} vs {ref_path}")
-        result = device_timeline_cur.compare(device_timeline_ref)
-        print(f"[INFO] return code : {result}")
-        output_filename = os.path.join(output_dir, "device-timeline_results.csv")
-        device_timeline_cur.save_to_csv(device_timeline_ref, filename = output_filename)
-        print(f"[INFO] Device timeline comparison complete. Result: {'Passed' if result == 0 else 'Failed'}")
-        return result
-
-    elif scenario in ["--device-timing", "-d"]:
-        print(f"[INFO] Running device timing comparison for {cur_path} vs {ref_path}")
-        device_timing_cur = unidiff.DeviceTiming(cur_path)
-        device_timing_ref = unidiff.DeviceTiming(ref_path)
-        print(f"[INFO] Running device timing comparison for {cur_path} vs {ref_path}")
-        result = device_timing_cur.compare(device_timing_ref)
-        print(f"[INFO] return code : {result}")
-        output_filename = os.path.join(output_dir, "device_timing_results.csv")
-        device_timing_cur.save_to_csv(device_timing_ref, filename = output_filename)
-        print(f"[INFO] Device timing comparison complete. Result: {'Passed' if result == 0 else 'Failed'}")
-        return result
-
-    else:
-        print(f"[ERROR] Unknown scenario: {scenario}")
-        return 1
-
-# Seconds a signaled run may take to exit: stopping -k sampling and computing the
-# metrics happens in the signal handler.
-SIGNAL_EXIT_TIMEOUT = 120
-
-def run_and_signal(command, signal_name, signal_after):
-    """Run command and send it signal_name after signal_after seconds.
-
-    SIGINT goes to the whole process group, as Ctrl-C does; any other signal
-    only to the launched process, as `kill <pid>` does. Whatever is left of the
-    group is killed afterwards (e.g. the application after SIGTERM to unitrace).
-    Returns (completed process, error message or None). Output goes to files,
-    not pipes: a surviving application would hold pipes open."""
-    sig = signal.Signals[signal_name]
-    with tempfile.TemporaryFile("w+") as out, tempfile.TemporaryFile("w+") as err:
-        proc = subprocess.Popen(command, text=True, stdout=out, stderr=err,
-                                start_new_session=True)
-        error = None
-        try:
-            try:
-                proc.wait(timeout=signal_after)
-                error = f"exited ({proc.returncode}) before {signal_name} was sent"
-            except subprocess.TimeoutExpired:
-                if sig == signal.SIGINT:
-                    os.killpg(proc.pid, sig)
-                else:
-                    os.kill(proc.pid, sig)
-                try:
-                    proc.wait(timeout=SIGNAL_EXIT_TIMEOUT)
-                    if proc.returncode < 0:
-                        error = (f"was killed by {signal.Signals(-proc.returncode).name} "
-                                 f"instead of handling {signal_name}")
-                except subprocess.TimeoutExpired:
-                    error = f"did not exit within {SIGNAL_EXIT_TIMEOUT}s after {signal_name}"
-        finally:
-            try:
-                os.killpg(proc.pid, signal.SIGKILL)
-            except ProcessLookupError:
-                pass
-            proc.wait()
-        out.seek(0)
-        err.seek(0)
-        return subprocess.CompletedProcess(command, proc.returncode, out.read(), err.read()), error
-
-def contains_non_whitespace(path):
-    with open(path, "r", encoding="utf-8", errors="ignore") as f:
-        return any(not ch.isspace() for ch in f.read())
-
-def run_unitrace(cmake_root_path, scenarios, test_case_name, args, extra_test_prog, test_bin_dir, test_output_dir, use_mpiexec=False, num_ranks=1, specific_test_case=None, unitrace_exe_override=None, skip_golden_compare=False, results_subdir=None, signal_name=None, signal_after=None):
-    is_python_test = test_case_name.find("python") != -1
-    unitrace_exe = cmake_root_path + "/../../build/" + test_layout.exe("unitrace")
-    test_case = test_layout.workload_exe(test_bin_dir, test_case_name).replace("\\", "/")
-
-    if is_python_test:
-        test_case = test_case_name
-
-    # Explicit launcher location, for a unitrace built or delivered outside
-    # the standalone tools/unitrace layout.
-    if unitrace_exe_override:
-        unitrace_exe = unitrace_exe_override
-    
-    # Check if test case executable exists
-    if not os.path.exists(test_case):
-        print(f"[ERROR] Test case executable not found at {test_case}", file=sys.stderr)
-        return 1
-
-    # "native" scenario: run the application by itself, without unitrace. This is
-    # a sanity check for the driver/environment. If the app cannot even run on
-    # its own, the problem is not unitrace, so the caller can skip the remaining
-    # unitrace scenarios for this test. This runs before the unitrace executable
-    # check on purpose, so a missing/bad unitrace build cannot mask a driver issue.
-    if scenarios.strip() == "native":
-        native_command = []
-        if use_mpiexec:
-            native_command.extend(["mpiexec", "-n", str(num_ranks)])
-        native_command += [test_case] + args
-        print(f"[INFO] Native run (app only, no unitrace): {' '.join(native_command)}")
-        if signal_name:
-            # The application runs far longer than --signal-after: it passes if it
-            # is still running (has not failed) when the signal would be sent.
-            try:
-                native_proc = subprocess.Popen(native_command, stdout=subprocess.DEVNULL,
-                                               stderr=subprocess.DEVNULL, start_new_session=True)
-            except Exception as e:
-                print(f"[ERROR] DRIVER/ENVIRONMENT ISSUE (NOT a unitrace problem): could not "
-                      f"launch the application '{' '.join(native_command)}': {e}", file = sys.stderr)
-                return 1
-            try:
-                native_proc.wait(timeout=signal_after)
-            except subprocess.TimeoutExpired:
-                os.killpg(native_proc.pid, signal.SIGKILL)
-                native_proc.wait()
-                print(f"[INFO] Native run still running after {signal_after}s, as expected.", file = sys.stderr)
-                return 0
-            if native_proc.returncode != 0:
-                print(f"[ERROR] DRIVER/ENVIRONMENT ISSUE (NOT a unitrace problem): the "
-                      f"application failed to run on its own with return code "
-                      f"{native_proc.returncode}, before unitrace was involved.", file = sys.stderr)
-                return 1
-            print(f"[INFO] Native run succeeded.", file = sys.stderr)
-            return 0
-        try:
-            native_result = subprocess.run(native_command, text=True, capture_output=True)
-        except Exception as e:
-            print(f"[ERROR] DRIVER/ENVIRONMENT ISSUE (NOT a unitrace problem): could not "
-                  f"launch the application '{' '.join(native_command)}': {e}", file = sys.stderr)
-            return 1
-        if native_result.returncode != 0:
-            print(f"[ERROR] DRIVER/ENVIRONMENT ISSUE (NOT a unitrace problem): the "
-                  f"application failed to run on its own with return code "
-                  f"{native_result.returncode}, before unitrace was involved.", file = sys.stderr)
-            print(f"[ERROR] Native command '{' '.join(native_command)}' failed.", file = sys.stderr)
-            print(f"[ERROR] Native stderr output: {native_result.stderr}", file = sys.stderr)
-            print(f"[ERROR] Native stdout output: {native_result.stdout}", file = sys.stderr)
-            return 1
-        print(f"[INFO] Native run succeeded.", file = sys.stderr)
-        return 0
-
-    # Check if Unitrace executable exists (unitrace scenarios only)
-    if not os.path.exists(unitrace_exe):
-        print(f"[ERROR] Unitrace executable not found at {unitrace_exe}", file=sys.stderr)
-        return 1
-
-    scenario_set = set(scenarios.split(" "))
-    is_result_dir = "--result-dir" in scenario_set
-    # Prepare command here
-    command = []
-    
-    # Add mpiexec if requested
-    if use_mpiexec:
-        command.extend(["mpiexec", "-n", str(num_ranks)])
-    
-    command.append(unitrace_exe)
-    
-    for scenario in scenarios.split(" "):
-        if scenario != "--result-dir":
-            command.append(scenario)
-
-    test_output_name = specific_test_case if specific_test_case else os.path.basename(test_case) #graph
-    output_dir = test_layout.results_dir(test_output_dir, results_subdir).replace("\\", "/")
-    
-    # Ensure the output directory exists
-    os.makedirs(output_dir, exist_ok = True)
-
-    if is_result_dir:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
-        if platform.system() == "Windows":
-            # Windows has limit to MAX_PATH (260 characters)
-            output_result_dir = timestamp
-        else:
-            output_result_dir = f"output{scenarios}_{test_output_name}_{timestamp}".replace("--", "_").replace("-", "_").replace(" ","")
-        output_result_dir_path = os.path.join(output_dir, output_result_dir).replace("\\", "/")
-        os.makedirs(output_result_dir_path, exist_ok = True)
-    else:
-        output_file = f"output{scenarios}_{test_output_name}.txt".replace("--", "_").replace("-", "_").replace(" ","") #output_k_result_dir_graph.txt
-        output_file_path = os.path.join(output_dir, output_file).replace("\\", "/")
-        
-    metric_dir = os.path.join(test_layout.metric_scratch_dir(test_output_dir, results_subdir),
-                              specific_test_case if is_python_test and specific_test_case is not None
-                              else test_case_name)
-
-    # Dispatch on the scenario's token set, not on any single token's position.
-    is_chrome_logging_present = any(token.startswith("--chrome") for token in scenario_set)
-    is_metrics_scenario = not scenario_set.isdisjoint({"-k", "-q"})
-    if is_result_dir:
-        command += ["--result-dir", output_result_dir_path]
-    else:
-        if is_chrome_logging_present:
-            command += ["--output-dir-path", output_dir]
-        elif is_metrics_scenario:
-            # Metric files are written next to the -o base name; anchor it at
-            # a per-test scratch directory (where the collection glob below
-            # looks) so the run does not depend on the working directory.
-            os.makedirs(metric_dir, exist_ok = True)
-            command += ["-o", os.path.join(metric_dir, "metric")]
-        else:
-            command += ["-o", output_file_path]
-
-    command += [test_case] + args
-
-    # unitrace reports an over-long Windows path only as a failure to open the
-    # file, so name the real cause up front. Estimate the longest path it
-    # writes: <result dir>/<app>.<pid>/<longest report name>, or <-o file>
-    # with .<pid> inserted.
-    if is_result_dir:
-        app_name = os.path.splitext(os.path.basename(test_case))[0]
-        longest_path = f"{output_result_dir_path}/{app_name}.000000/ccl_summary_report.txt"
-    elif not is_chrome_logging_present and not is_metrics_scenario:
-        longest_path = output_file_path[:-len(".txt")] + ".000000.txt"
-    else:
-        longest_path = ""
-    if test_layout.windows_path_too_long(longest_path):
-        print(f"[WARNING] unitrace output paths may reach {len(longest_path)} characters, "
-              f"over the Windows MAX_PATH limit ({test_layout.WINDOWS_MAX_PATH}): {longest_path}. "
-              f"Pass a shorter --output-dir to test_unitrace.py.", file = sys.stderr)
-
-    print(f"[INFO] Executing command: {' '.join(command)}")
-
-    try:
-        before_list_of_files = set(os.listdir(output_dir))
-        if signal_name:
-            result, signal_error = run_and_signal(command, signal_name, signal_after)
-            if signal_error:
-                print(f"[ERROR] Unitrace {signal_error}.", file = sys.stderr)
-                print(f"[ERROR] Unitrace command {' '.join(command)} failed.", file = sys.stderr)
-                print(f"[ERROR] Unitrace stderr output: {result.stderr}", file = sys.stderr)
-                print(f"[ERROR] Unitrace stdout output: {result.stdout}", file = sys.stderr)
-                return 1
-            # unitrace exits non-zero after handling the signal; the output
-            # checks below decide the result.
-            print(f"[INFO] Unitrace handled {signal_name} and exited with {result.returncode}.", file = sys.stderr)
-        else:
-            result = subprocess.run(command, text=True, capture_output=True) # executing Unitrace command
-        if result.returncode != 0 and not signal_name:
-            print(f"[ERROR] Unitrace execution failed with return code {result.returncode}.", file = sys.stderr)
-            print(f"[ERROR] Unitrace command {' '.join(command)} failed.", file = sys.stderr)
-            print(f"[ERROR] Unitrace stderr output: {result.stderr}", file = sys.stderr)
-            print(f"[ERROR] Unitrace stdout output: {result.stdout}", file = sys.stderr)
-            return 1  # Indicate failure due to Unitrace ERROR
-
-        print(f"[ERROR] Unitrace stderr output: {result.stderr}", file = sys.stderr)
-        print(f"[ERROR] Unitrace stdout output: {result.stdout}", file = sys.stderr)
-        
-        if not is_result_dir:
-            # Metric logs need to be moved to result folder
-            if is_metrics_scenario:
-                # Find all files starting with "metric" in the scratch directory
-                pattern = os.path.join(metric_dir, "metric*")
-                metric_files = glob.glob(pattern)
-                print(f"[INFO] Found metric files: {metric_files}", file = sys.stderr)
-                # Move each file to destination
-                for file_path in metric_files:
-                    filename = os.path.basename(file_path)
-                    destination_path = os.path.join(output_dir, filename)
-                    shutil.move(file_path, destination_path)
-                    os.rename(destination_path, output_dir + "/" + filename + "_" + output_file)
-                    print(f"[INFO] Moved metric file {file_path} to {destination_path}", file = sys.stderr)
-
-            after_list_of_files = set(os.listdir(output_dir))
-            new_files = list(after_list_of_files - before_list_of_files)
-            # check if scenario is "chrome" logging
-            # then test needs to modify the file name to reflect right test case.
-            if is_chrome_logging_present:
-                min_no_of_lines = 4 # Metric files has initial few lines for headers etc..
-                print(f"[INFO] Chrome logging scenario detected, renaming output files to reflect test case name.", file = sys.stderr)
-                for idx, new_file in enumerate(new_files):
-                    new_file = os.path.join(output_dir, new_file)
-                    new_file_name = ""
-                    if new_file.find("python") != -1 and new_file.find(".json") != -1:
-                        new_file_name = "_" + specific_test_case + ".json"
-                    else:
-                        new_file_name += "_" +os.path.basename(new_file)
-                    new_name = os.path.join(output_dir, "output") + scenarios.replace(" ","").replace("--", "_").replace("-", "_").replace(" ","") + new_file_name
-                    try:
-                        os.rename(new_file, new_name)
-                    except Exception as e:
-                        print(f"[ERROR] Occurred while renaming the output file: {e}", file = sys.stderr)
-                        return 1
-                    new_files[idx] = os.path.basename(new_name)
-                    print(f"[INFO] Renamed chrome logging output file to {new_name}", file = sys.stderr)
-
-        # Check if the output file is generated
-        output_files = []
-        if is_result_dir:
-            result_dir = Path(output_result_dir_path)
-            all_files = [str(f.relative_to(result_dir)) for f in result_dir.rglob("*") if f.is_file()]
-            for file in all_files:
-                print(f"[INFO] Found file: {file}")
-            
-            if is_chrome_logging_present:
-                output_files = [str(f.relative_to(result_dir)) for f in result_dir.rglob("chrome_trace.json")]
-                print(f"[INFO] Found chrome_trace.json files: {output_files}")
-            elif "-k" in scenario_set or "-q" in scenario_set:
-                # The metric data is the primary artifact of -k/-q. The file is
-                # metrics_<device>.csv when written by the in-process collector
-                # and metrics.csv when the parent computes it from raw data
-                # (Windows metric query).
-                output_files = [str(f.relative_to(result_dir))
-                                for pattern in ("metrics_*", "metrics.csv")
-                                for f in result_dir.rglob(pattern) if f.is_file()]
-                print(f"[INFO] Found metrics files: {output_files}")
-                # -k/-q also imply device timing when no chrome logging is
-                # requested, so require the timing report too: a missing report
-                # (e.g. lost during process teardown) must fail the test.
-                timing_files = [str(f.relative_to(result_dir))
-                                for f in result_dir.rglob("device_timing.txt") if f.is_file()]
-                print(f"[INFO] Found timing files: {timing_files}")
-                if not timing_files:
-                    print(f"[ERROR] device_timing.txt not found.", file = sys.stderr)
-                    output_files = []
-            else:
-                file_patterns = [
-                    "host_timing.txt",
-                    "device_timing.txt", 
-                    "device_submission.txt",
-                    "trace.txt",
-                    "call_logging.txt",
-                    "device_timeline.txt",
-                    "ccl_summary_report.txt"
-                ]
-                output_files = [str(f.relative_to(result_dir)) 
-                                for pattern in file_patterns 
-                                for f in result_dir.rglob(pattern)]
-                print(f"[INFO] Found timing/trace files: {output_files}")
-        else:
-            for f in new_files:
-                result_file_pattern = f.split(".")
-                if (is_chrome_logging_present and "chrome" in result_file_pattern[0]
-                    and (test_case_name.replace("/","_").split(".")[0] in result_file_pattern[0] or (specific_test_case is not None and specific_test_case in result_file_pattern[0]))
-                ):
-                    output_files.append(f)
-                elif is_metrics_scenario and f.endswith(output_file) and "metrics" in f:
-                    output_files.append(f)
-                elif output_file.startswith(result_file_pattern[0]):
-                    output_files.append(f)
-                if len(output_files) > 0 and not use_mpiexec:
-                    break
-
-        if output_files:
-            if use_mpiexec:
-                print(f"[INFO] MPI Output files generated: {output_files}")
-            else:
-                print(f"[INFO] Output file '{output_files[0]}' generated successfully.")
-        else:
-            if not use_mpiexec:
-                if is_result_dir:
-                    print(f"[ERROR] Output file not found.", file = sys.stderr)
-                else:
-                    print(f"[ERROR] Output file matching pattern '{output_file}' not found.", file = sys.stderr)
-                return 1  # Returning non-zero indicates failure
-            return 0
-
-        # Validating the test output
-        # Check if the output file contains '[ERROR]'
-        # TODO: we will keep output in the buffer
-        if is_result_dir:
-            output_file_full_path = os.path.join(output_result_dir_path, output_files[0])
-        else:
-            output_file_full_path = os.path.join(output_dir, output_files[0])
-        with open(output_file_full_path, "r") as outfile:
-            output_content = outfile.read()
-            if "[ERROR]" in output_content:
-                print(f"[ERROR] found in output file '{output_file_full_path}'.", file = sys.stderr)
-                return 1  # Indicate failure due to ERROR in output
-
-        if extra_test_prog != None:
-            print("[INFO] Test has custom checker, going to use it for validation.", file = sys.stderr)
-            # obtain list of generated files from unitrace stderr output
-            full_path_output_files = []
-            if is_result_dir:
-                full_path_output_files = [str(f) for f in result_dir.rglob("*") if f.is_file()]
-            else:
-                err_lines = result.stderr.splitlines()
-                for line in err_lines:
-                    i = line.find("is stored in")
-                    if i > 0:
-                        full_path_output_files.append(line[i+13:].strip()) 
-            
-            # execute provided test with list of files as arguments
-            if extra_test_prog.endswith(".py"):
-                cmd = [sys.executable, extra_test_prog]
-            else:
-                cmd = [extra_test_prog]
-            cmd += full_path_output_files
-            if len(command) > 1:
-                cmd += ['--cmd'] + command[1:]
-            
-            rc = subprocess.run(cmd, text=True)
-            if rc.returncode != 0:
-                return 1  # extra test prog failed
-            else:
-                return 0
-        elif not scenario_set.isdisjoint(set(["-k", "-q"])) and signal_name:
-            # Interrupted run: the metric files exist, so the profiler was
-            # stopped on the signal. They may hold no counter rows: those are
-            # matched to kernel times that the application writes only when it
-            # exits normally.
-            print(f"[INFO] Metric files written after {signal_name}: {output_files}", file = sys.stderr)
-            return 0
-        elif not scenario_set.isdisjoint(set(["-k", "-q"])):
-            min_no_of_lines = 4 # Metric files has initial few lines for headers etc..
-            for output_file in output_files:
-                root_dir = result_dir if is_result_dir else output_dir
-                with open(os.path.join(root_dir, output_file), 'r') as outfile:
-                    # Check to make sure file has counter values generated.
-                    if len(outfile.readlines()) <= min_no_of_lines:
-                        print(f"[ERROR] Metric file '{output_file}' is not having counters present.")
-                        return 1 # Metric file should have more than 4 line present.
-        elif scenario_set.isdisjoint(set(["--device-timing", "-d", "--device-timeline", "-t"])):
-            min_no_of_lines = 4 # Metric files has initial few lines for headers etc..
-            print(f"[INFO] Nothing to compare for {scenario_set} hence exiting early.", file = sys.stderr)
-            # check if unidiff support validation for current scenario else return early as success
-            return 0
-        else:
-            print("[INFO] Going to run unidiff for comparison.")
-            # Extract the relevant section from the expected output file
-            # TODO: we need not create a buffer instead of file will work
-            scenario_d_or_t = ""
-            if not set(["-d","--device-timing"]).isdisjoint(scenario_set):
-                scenario_d_or_t = "-d"
-            elif not set(["-t","--device-timeline"]).isdisjoint(scenario_set):
-                scenario_d_or_t = "-t"
-
-            if use_mpiexec:
-                # For MPI tests, the output file may have rank information
-                # We will pick the latest modified file for comparison
-                print(f"[INFO] MPI test detected, selecting latest output file for comparison.")
-                # Parse ranks from scenarios string if --ranks-to-sample is present
-                scenario_args = scenarios.split()
-                device_sampled = True
-                ranks_sampled = []
-                if "--ranks-to-sample" in scenario_args:
-                    ranks_arg_index = scenario_args.index("--ranks-to-sample")
-                    if ranks_arg_index + 1 < len(scenario_args):
-                        ranks_str = scenario_args[ranks_arg_index + 1]
-                        ranks_sampled = [int(rank.strip()) for rank in ranks_str.split(',') if int(rank.strip()) < num_ranks]
-                        print(f"[INFO] Sampled ranks detected: {ranks_sampled}")
-                elif "--devices-to-sample" in scenario_args:
-                    devices_arg_index = scenario_args.index("--devices-to-sample")
-                    if devices_arg_index + 1 < len(scenario_args):
-                        devices_str = scenario_args[devices_arg_index + 1]
-                        sampled_devices = [int(device.strip()) for device in devices_str.split(',')]
-                        print(f"[INFO] Sampled devices detected: {sampled_devices}")
-                        if len(sampled_devices) > 1:
-                            print(f"[ERROR] test don't support more then 1 device sampling for MPI tests.", file = sys.stderr)
-                            return 1
-                        if sampled_devices[0] != 0:
-                            device_sampled = False
-                        else:
-                            ranks_sampled = [0]
-                # Create ranks list from number of ranks
-                ranks_list = []
-                for rank in range(num_ranks):
-                    ranks_list.append(rank)
-                
-                # Without validated goldens only the content comparison is
-                # skipped; the per-rank structural checks below still apply.
-                expected_output_file = None if skip_golden_compare else \
-                    extract_test_case_output(cmake_root_path, test_case_name, scenario_d_or_t)
-                # Compare each sampled rank output
-                all_passed = True
-                for rank in ranks_list:
-                    rank_output_file = None
-                    for of in output_files:
-                        if is_result_dir:
-                            substr = f"rank_{rank}"
-                            if substr in of:
-                                rank_output_file = of
-                                break
-                        else:
-                            # Extract rank from filename before .txt extension
-                            if of.endswith('.txt'):
-                                # Get the part before .txt
-                                filename_without_ext = of[:-4]
-                                # Split by '.' and get the last part which should be the rank
-                                parts = filename_without_ext.split('.')
-                                if parts and parts[-1].isdigit() and int(parts[-1]) == rank:
-                                    rank_output_file = of
-                                    break
-                    if rank_output_file is None:
-                        if rank in ranks_sampled and device_sampled:
-                            print(f"[ERROR] Output file for rank {rank} not found among generated files.", file = sys.stderr)
-                            all_passed = False
-                        continue
-                    root_dir = result_dir if is_result_dir else output_dir  
-                    if rank in ranks_sampled and device_sampled:
-                        if skip_golden_compare:
-                            print(f"[INFO] SILENCED: golden-output comparison "
-                                  f"skipped for rank {rank} (--skip-golden-compare).")
-                        else:
-                            # Call unidiff comparison
-                            comparison_result = call_unidiff(scenario_d_or_t, root_dir, rank_output_file, expected_output_file)
-                            if comparison_result != 0:
-                                print(f"[ERROR] Unidiff comparison failed for rank {rank}.", file = sys.stderr)
-                                all_passed = False
-                                break
-                    else:
-                        # check if rank_output_file is empty file or not
-                        output_file_with_path = os.path.join(root_dir, rank_output_file)
-                         # check if file has any character in it (not space)
-                        if contains_non_whitespace(output_file_with_path) == False:
-                            print(f"[INFO] Output file for rank {rank} is empty as expected since it is not sampled.")
-                        else:
-                            print(f"[ERROR] Output file for rank {rank} is not empty but it was not sampled.", file = sys.stderr)
-                            print("====Begin File Contents====")
-                            with open(output_file_with_path, 'r') as fp:
-                                contents = fp.read()
-                                print(contents)
-                            print("====End File Contents====")
-                            all_passed = False
-                            break
-                if all_passed:
-                    return 0
-                else:
-                    return 1
-            else:
-                if skip_golden_compare:
-                    print("[INFO] SILENCED: golden-output comparison skipped "
-                          "(--skip-golden-compare); execution and output checks passed.")
-                    return 0
-                gold_file_to_compare = specific_test_case if specific_test_case is not None else test_case_name
-                expected_output_file = extract_test_case_output(cmake_root_path, gold_file_to_compare, scenario_d_or_t)
-                root_dir = result_dir if is_result_dir else output_dir  
-                output_file_with_pid = max(output_files, key = lambda f: os.path.getmtime(os.path.join(root_dir, f)))
-
-                # Call unidiff comparison
-                comparison_result = call_unidiff(scenario_d_or_t, root_dir, output_file_with_pid, expected_output_file)
-                if comparison_result != 0:
-                    print(f"[ERROR] Unidiff comparison failed.", file = sys.stderr)
-                    return 1
-                else:
-                    return 0
-    except Exception as e:
-          print(f"[ERROR] Occurred while running unitrace: {e}", file = sys.stderr)
-          return 1
-
-def main():
-    parser = argparse.ArgumentParser(prog="run_test.py", description="Run unitrace test")
-    parser.add_argument('-e', '--extra_test_prog', type=str)
-    parser.add_argument('-c', '--cmake_root_path', type=str, default=None,
-                        help='Test source root holding the gold files. '
-                             'Defaults to cpp_test next to this script, or python_test for python tests.')
-    parser.add_argument('--test-bin-dir', type=str, default=None,
-                        help='Directory holding the installed test binaries '
-                             '(default: tools/unitrace/build/test/bin)')
-    parser.add_argument('--output-dir', type=str, default=None,
-                        help='Directory for results and metric scratch files '
-                             '(default: tools/unitrace/build/test/output/<cpp_test|python_test>)')
-    parser.add_argument('--results-subdir', type=str, default=None,
-                        help='Write results under <output-dir>/results/<NAME> (test_unitrace.py '
-                             'passes the tests.txt test name) instead of directly in results/')
-    parser.add_argument('--mpiexec', action='store_true', help='Run unitrace with mpiexec')
-    parser.add_argument('-n', '--num_ranks', type=int, default=1, help='Number of MPI ranks (default: 1)')
-    parser.add_argument('-t','--test_case', type=str, default=None, help='Specific test case name (not the test executable name)')
-    parser.add_argument('--unitrace-exe', type=str, default=None,
-                        help='Path to the unitrace binary when it is not at <cmake_root>/../../build/unitrace')
-    parser.add_argument('--skip-golden-compare', action='store_true',
-                        help='Skip golden-output content comparisons (for environments without '
-                             'validated golden files); execution and output checks still apply')
-    parser.add_argument('--signal', type=str, default=None, choices=['SIGINT', 'SIGTERM'],
-                        help='Interrupt the unitrace run with this signal after --signal-after '
-                             'seconds (SIGINT to the whole process group like Ctrl-C, SIGTERM to '
-                             'unitrace only like kill); the run must still write its output. '
-                             'Linux only.')
-    parser.add_argument('--signal-after', type=float, default=5,
-                        help='Seconds before --signal is sent (default: 5)')
-    parser.add_argument('-s', '--scenario', type=str, required=True,
-                        help='Unitrace scenario options to run, or "native" to run the application without unitrace')
-    parser.add_argument('args', nargs=argparse.REMAINDER, help='Application and its arguments (parsing stops here)')
-    args = parser.parse_args()
-
-    if not args.args:
-        parser.error("[ERROR] Application command is required")
-        return 1
-    elif args.args[0] == "--":
-        args.args = args.args[1:]
-
-    scenario = args.scenario
-
-    is_python = "python" in os.path.basename(args.args[0])
-    if args.cmake_root_path is None:
-        base = os.path.dirname(os.path.abspath(__file__))
-        args.cmake_root_path = os.path.join(base, "python_test" if is_python else "cpp_test")
-    if args.test_bin_dir is None:
-        args.test_bin_dir = test_layout.bin_dir()
-    if args.output_dir is None:
-        args.output_dir = test_layout.output_dir(group="python_test" if is_python else "cpp_test")
-
-    return run_unitrace(args.cmake_root_path, scenario, args.args[0], args.args[1:], 
-                       args.extra_test_prog, args.test_bin_dir, args.output_dir,
-                       args.mpiexec, args.num_ranks, args.test_case,
-                       args.unitrace_exe, args.skip_golden_compare, args.results_subdir,
-                       args.signal, args.signal_after)
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/test/test_dashboard_bridge.py b/tools/unitrace/test/test_dashboard_bridge.py
deleted file mode 100644
index 82c4271b..00000000
--- a/tools/unitrace/test/test_dashboard_bridge.py
+++ /dev/null
@@ -1,148 +0,0 @@
-import contextlib
-import http.client
-import io
-import socket
-import sys
-import tempfile
-import threading
-import unittest
-import warnings
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
-
-from bokeh.client import pull_session
-from bokeh.models import Div
-from bokeh.util.warnings import BokehUserWarning
-from tornado.ioloop import IOLoop
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts" / "metrics"))
-import perfdashboard
-from perfdashboard import (check_port_available, create_server, prewarm_session,
-                           start_server_process, stop_owned_process)
-
-
-class BridgeTest(unittest.TestCase):
-    def test_duplicate_reference_warning_filter(self):
-        args = SimpleNamespace(input="metrics.csv", trace=None, eustall=True)
-        with warnings.catch_warnings(record=True) as caught:
-            warnings.simplefilter("always")
-            with patch("perfdashboard.Server"), patch("perfdashboard.ScriptHandler"):
-                create_server(args)
-            for reference in ("p1358", "p1540", "p1722"):
-                warnings.warn(f"reference already known '{reference}'", BokehUserWarning)
-            warnings.warn("Other Bokeh warning", BokehUserWarning)
-            warnings.warn("reference already known 'p1358'", UserWarning)
-        self.assertEqual([str(item.message) for item in caught], [
-            "Other Bokeh warning", "reference already known 'p1358'",
-        ])
-
-    def test_occupied_port_is_not_killed(self):
-        with patch("perfdashboard.socket.create_connection") as connection, patch(
-            "perfdashboard.subprocess.Popen"
-        ) as spawn:
-            with self.assertRaisesRegex(OSError, "Port 8000 is in use"):
-                check_port_available(8000)
-            connection.return_value.close.assert_called_once()
-            spawn.assert_not_called()
-
-    def test_owned_process_cleanup(self):
-        proc = MagicMock()
-        proc.poll.return_value = None
-        stop_owned_process(proc)
-        proc.terminate.assert_called_once()
-        proc.wait.assert_called_once_with(timeout=5)
-        proc.poll.return_value = 0
-        stop_owned_process(proc)
-        proc.terminate.assert_called_once()
-
-    def test_prewarm_is_quiet(self):
-        output = io.StringIO()
-        with patch("urllib.request.urlopen", return_value=MagicMock()), contextlib.redirect_stdout(output):
-            prewarm_session()
-        self.assertEqual(output.getvalue(), "")
-
-    def test_server_process_command(self):
-        proc = MagicMock(**{"poll.return_value": None})
-        output = io.StringIO()
-        with patch("perfdashboard.check_port_available") as check, patch(
-            "perfdashboard.subprocess.Popen", return_value=proc
-        ) as spawn, patch("perfdashboard.socket.create_connection"), patch(
-            "perfdashboard.time.sleep"
-        ), patch("perfdashboard.prewarm_session") as prewarm, contextlib.redirect_stdout(output):
-            started = start_server_process("metrics.csv", trace="trace.json", eustall=True)
-        self.assertIs(started, proc)
-        check.assert_called_once_with(8000)
-        prewarm.assert_called_once_with(8000)
-        command = spawn.call_args[0][0]
-        self.assertEqual(command[1], str(Path(perfdashboard.__file__).resolve()))
-        self.assertEqual(command[2:], [str(Path("metrics.csv").resolve()),
-                                       "--trace", str(Path("trace.json").resolve()), "--eustall"])
-        self.assertIn("http://localhost:8000/perfdashboard", output.getvalue())
-
-    def test_idle_connection_does_not_block_kernel_redirect(self):
-        with tempfile.TemporaryDirectory() as directory:
-            metrics = Path(directory) / "metrics.csv"
-            metrics.write_text(
-                'Kernel, GlobalInstanceId\n"kernel", 9\nSubDeviceId, QueryBeginTime[ns], Counter[%]\n0, 100, 42\n'
-                'Kernel, GlobalInstanceId\n"other", 4\nSubDeviceId, QueryBeginTime[ns], Counter[%]\n0, 200, 12\n'
-            )
-            args = SimpleNamespace(input=str(metrics), trace=None, eustall=False)
-            loop = IOLoop()
-            server = create_server(args, loop, port=0)
-            server.start()
-            worker = threading.Thread(target=loop.start)
-            worker.start()
-            idle = socket.create_connection(("localhost", server.port), timeout=2)
-            try:
-                for path, expected in (("/%22kernel%22/9", 302),
-                                       ("/%22kernel%2Fwith%25slash%22/9", 302),
-                                       ("/perfdashboard?gid=9", 200),
-                                       ("/kernel/invalid", 400),
-                                       ("/favicon.ico", 200)):
-                    with self.subTest(path=path):
-                        client = http.client.HTTPConnection("localhost", server.port, timeout=10)
-                        try:
-                            client.request("GET", path)
-                            response = client.getresponse()
-                            self.assertEqual(response.status, expected)
-                            if expected == 302:
-                                self.assertEqual(
-                                    response.getheader("Location"),
-                                    "/perfdashboard?gid=9&kernel="
-                                    + ("kernel%2Fwith%25slash" if "with" in path else "kernel"),
-                                )
-                            response.read()
-                        finally:
-                            client.close()
-                session = pull_session(url=f"http://localhost:{server.port}/perfdashboard",
-                                       arguments={"gid": "9"})
-                try:
-                    messages = [model.text for model in session.document.select({"type": Div})]
-                    self.assertFalse(any("samples selected" in text for text in messages), messages)
-                    self.assertFalse(any("Kernel 9:" in text for text in messages), messages)
-                finally:
-                    session.close()
-                session = pull_session(url=f"http://localhost:{server.port}/perfdashboard",
-                                       arguments={"gid": "2"})
-                try:
-                    messages = [model.text for model in session.document.select({"type": Div})]
-                    self.assertIn("No metric data collected or no metrics specified", messages)
-                    root = session.document.roots[0]
-                    self.assertEqual(len(root.children), 1)
-                    self.assertIsInstance(root.children[0], Div)
-                    self.assertEqual(root.children[0].text,
-                                     "No metric data collected or no metrics specified")
-                finally:
-                    session.close()
-            finally:
-                idle.close()
-                loop.add_callback(server.stop)
-                loop.add_callback(loop.stop)
-                worker.join(timeout=5)
-                loop.close(all_fds=True)
-            self.assertFalse(worker.is_alive())
-
-
-if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
diff --git a/tools/unitrace/test/test_dashboard_data.py b/tools/unitrace/test/test_dashboard_data.py
deleted file mode 100644
index 857f7dd6..00000000
--- a/tools/unitrace/test/test_dashboard_data.py
+++ /dev/null
@@ -1,131 +0,0 @@
-import json
-import sys
-import tempfile
-import unittest
-from unittest.mock import mock_open, patch
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts" / "metrics"))
-import perfdashboard as app
-
-
-class DataTest(unittest.TestCase):
-    def test_counter_columns_require_units(self):
-        frame = app.pd.DataFrame({
-            "ContextID": [1], "SourceID": [2], "ReportReason": [3],
-            "Counter[]": [4], "Counter[ ]": [5], "Counter[%]extra": [6],
-            " QueryBeginTime[ns] ": [100], "CoreFrequencyMHz[MHz]": [900],
-            "Active[%]": [42], "Reads[events]": [12],
-            "Bandwidth[GB/s]": [1.5], "Duration[ns] ": [100],
-            "Label[%]": ["invalid"],
-        })
-        self.assertEqual(set(app.counter_cols_from_df(frame)), {
-            "Active[%]", "Reads[events]", "Bandwidth[GB/s]", "Duration[ns] ",
-        })
-
-    def test_counters_come_from_csv_headers(self):
-        frame = app.pd.DataFrame({"Kernel": ["first"], "GlobalInstanceId": [1], "XVE_ACTIVE[%]": [42.], "ContextID": [123]})
-        app.df_input1 = frame
-        app.df_kernel = frame
-        app.df_kernel2 = None
-        app.csv1_col_map = app.build_counter_column_map(frame)
-        app.df_col_map_dict[id(frame)] = app.csv1_col_map
-        app.index_kernels(frame)
-        app.counter_multi_choice.options = app.counter_cols_from_df(frame)
-        self.assertEqual(app.counter_multi_choice.options, ["XVE_ACTIVE[%]"])
-        app.select_kernel_by_gid(1)
-        app.counter_multi_choice.value = ["XVE_ACTIVE[%]"]
-        app.plot_custom_counters_callback()
-        self.assertEqual(len(app.metric_plot_layout.children), 1)
-        self.assertEqual(app.metric_plot_layout.children[0].children[0].renderers[0].data_source.data["y"], [42.])
-
-    def read(self, source):
-        with tempfile.TemporaryDirectory() as directory:
-            path = Path(directory) / "metrics.csv"
-            path.write_text(source)
-            return app.read_metrics(str(path))
-
-    def test_stalls_select_trace_kernel_not_gid_order(self):
-        frame = app.pd.DataFrame({"Kernel": ["first", "second"], "Offset": ["0x00000100", "0x00000200"]})
-        trace = {"traceEvents": [{"name": "second[SIMD32 {1} {2}]",
-                                 "args": {"id": "19", "metrics": "http://localhost:8000/second/19"}}]}
-        with patch("builtins.open", mock_open(read_data=json.dumps(trace))):
-            selected = app.select_eustall_kernel(frame, "19", trace_path="trace.json")
-        self.assertEqual(selected["Kernel"].tolist(), ["second"])
-        self.assertEqual(app.select_eustall_kernel(frame, kernel_name="first")["Kernel"].tolist(), ["first"])
-        with self.assertRaises(ValueError):
-            app.select_eustall_kernel(frame, "99")
-
-    def test_hex_offsets(self):
-        for value, expected in (("100", "0x0100"), (" 1a0", "0x01a0"),
-                                ("0x100", "0x0100"), ("0x000001a8", "0x01a8"), (256, "0x0100")):
-            self.assertEqual(app.fmt_ip(value), expected)
-
-    def test_stall_sections(self):
-        source = (
-            '\nKernel,Pid,KernelId\n"GEMM",7,1\n'
-            'Source,Offset,Instruction,Dependency,Active[Events],SbidStall[Events]\n'
-            '"gemm.cl:12",0x00000080,"mov (1|M0) r1.0<1>:ud r0.0<0;1,0>:ud","NA",1,2\n'
-            '\nKernel,Pid,KernelId\n"GEMM",7,2\n'
-            'Source,Offset,Instruction,Dependency,Active[Events],SbidStall[Events]\n'
-            '"NA",0x000001a8,"unknown","NA",0,5\n'
-        )
-        frame = self.read(source)
-        self.assertEqual(frame["KernelId"].tolist(), [1, 2])
-        self.assertEqual(frame["Instruction"].tolist(), ["mov (1|M0) r1.0<1>:ud r0.0<0;1,0>:ud", "unknown"])
-        self.assertEqual(app.fmt_ip(frame.loc[1, "Offset"]), "0x01a8")
-        self.assertEqual(frame["SbidStall[Events]"].tolist(), [2, 5])
-        chart = app.build_eu_stall_chart(frame)
-        self.assertEqual(len(chart.children), 2)
-
-    def test_stall_sections_with_spaces(self):
-        source = (
-            '\nKernel, Pid, KernelId\n"GEMM", 7, 1\n'
-            'Source, Offset, Instruction, Dependency, Active[Events], SbidStall[Events]\n'
-            '"gemm.cl:12", 0x00000080, "mov (1|M0) r1.0<1>:ud r0.0<0;1,0>:ud", "NA", 1, 2\n'
-        )
-        frame = self.read(source)
-        self.assertEqual(frame["Pid"].tolist(), [7])
-        self.assertEqual(frame["KernelId"].tolist(), [1])
-        self.assertEqual(frame["Instruction"].tolist(), ["mov (1|M0) r1.0<1>:ud r0.0<0;1,0>:ud"])
-        self.assertEqual(frame["SbidStall[Events]"].tolist(), [2])
-
-    def test_classify_header_row(self):
-        for row in ("Kernel,Pid,KernelId\n", "Kernel, Pid, KernelId\n", " Kernel , Pid , KernelId \n"):
-            self.assertEqual(app.apm.ClassifyHeaderRow(row), "stall", row)
-        for row in ("Kernel, GlobalInstanceId\n", "Kernel ,GlobalInstanceId\n"):
-            self.assertEqual(app.apm.ClassifyHeaderRow(row), "time", row)
-        for row in ("Kernel\n", "Source,Offset\n", "\n", "kernel,pid,kernelid\n"):
-            self.assertIsNone(app.apm.ClassifyHeaderRow(row), row)
-
-    def test_query_sections_of_two_devices(self):
-        source = (
-            "\n=== Device #0 Metrics ===\n\n"
-            'Kernel, GlobalInstanceId\n"kernel,one", 1\nSubDeviceId, GpuTime[ns], CounterA[%]\n'
-            "0, 10, 1.5\n1, 11, 2.5\n"
-            "\n=== Device #1 Metrics ===\n\n"
-            'Kernel, GlobalInstanceId\n"second", 2\nSubDeviceId, GpuTime[ns], CounterB[%]\n0, 20, 99\n'
-        )
-        frame = self.read(source)
-        self.assertEqual(frame["Kernel"].tolist(), ["kernel,one", "kernel,one", "second"])
-        self.assertEqual(frame["GlobalInstanceId"].tolist(), [1, 1, 2])
-        self.assertEqual(frame["SubDeviceId"].tolist(), [0, 1, 0])
-        self.assertEqual(frame["CounterA[%]"].tolist()[:2], [1.5, 2.5])
-        self.assertEqual(frame.loc[2, "CounterB[%]"], 99)
-        self.assertTrue(app.pd.isna(frame.loc[2, "CounterA[%]"]))
-
-    def test_time_sections_drop_instance_separators(self):
-        source = (
-            'Kernel, GlobalInstanceId\n"GEMM", 1\nGpuTime[ns], XVE_ACTIVE[%]\n1, 90\n2, 80\n'
-            'Kernel, GlobalInstanceId\n"GEMM", 2\nGpuTime[ns], XVE_ACTIVE[%]\n3, 70\n'
-        )
-        frame = self.read(source)
-        self.assertEqual(frame["GlobalInstanceId"].tolist(), [1, 1, 2])
-        self.assertEqual(frame["XVE_ACTIVE[%]"].tolist(), [90, 80, 70])
-
-    def test_no_sections(self):
-        with self.assertRaises(ValueError):
-            self.read("nothing here\n")
-
-if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
diff --git a/tools/unitrace/test/test_dashboard_timeseries.py b/tools/unitrace/test/test_dashboard_timeseries.py
deleted file mode 100644
index 003d5979..00000000
--- a/tools/unitrace/test/test_dashboard_timeseries.py
+++ /dev/null
@@ -1,251 +0,0 @@
-import base64
-import sys
-import unittest
-from pathlib import Path
-
-import pandas as pd
-from bokeh.models import Button, Div, FileInput, Line, TextInput, VBar
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts" / "metrics"))
-import perfdashboard as app
-
-
-class TimeseriesTest(unittest.TestCase):
-    def setUp(self):
-        app.metric_plot_layout.children = []
-        app.counter_multi_choice.value = []
-        app.graph_mode_group.active = 0
-        app.df_kernel2 = None
-        app.df_input1 = pd.DataFrame({
-            "Kernel": ["first"] * 3 + ["second"] * 3,
-            "GlobalInstanceId": [4] * 3 + [9] * 3,
-            "QueryBeginTime[ns]": [100, 110, 140, 900, 920, 980],
-            "Active[%]": [0.123456, 20, 0, 30, 40, 50],
-            "Stall[%]": [80, 60, 0, 70, 60, 50],
-        })
-        app.csv1_col_map = app.build_counter_column_map(app.df_input1)
-        app.df_col_map_dict.clear()
-        app.df_col_map_dict[id(app.df_input1)] = app.csv1_col_map
-        app.index_kernels(app.df_input1)
-        app.counter_multi_choice.options = ["Active[%]", "Stall[%]"]
-        app.select_kernel_by_gid(4)
-        app.counter_multi_choice.value = ["Active[%]"]
-
-    def test_samples_and_numeric_axis(self):
-        app.plot_custom_counters_callback()
-        plot = app.metric_plot_layout.children[0].children[0]
-        renderer = plot.renderers[0]
-        self.assertEqual(plot.title.text, "first")
-        self.assertIsInstance(renderer.glyph, Line)
-        self.assertEqual(renderer.data_source.data["x"], [100, 110, 140])
-        self.assertEqual(renderer.data_source.data["y"], [0.123456, 20, 0])
-        self.assertEqual(plot.xaxis[0].ticker.desired_num_ticks, 8)
-        self.assertEqual(plot.xaxis[0].axis_label, "Time (ns)")
-
-    def test_comparison_and_counter_callbacks(self):
-        app.compare_kernel_input.value = "9"
-        plots = [panel.children[0] for panel in app.metric_plot_layout.children[0].children]
-        self.assertEqual(len(plots), 2)
-        self.assertEqual(plots[0].renderers[0].data_source.data["x"], [100, 110, 140])
-        self.assertEqual(plots[1].renderers[0].data_source.data["x"], [900, 920, 980])
-        app.counter_multi_choice.value = ["Active[%]", "Stall[%]"]
-        self.assertTrue(all(len(panel.children[0].renderers) == 2 for panel in app.metric_plot_layout.children[0].children))
-        app.counter_multi_choice.value = ["Stall[%]"]
-        self.assertTrue(all(len(panel.children[0].renderers) == 1 for panel in app.metric_plot_layout.children[0].children))
-        app.counter_multi_choice.value = []
-        self.assertEqual(app.metric_plot_layout.children, [])
-
-    def test_simplified_controls(self):
-        self.assertFalse(list(app.controls.select({"type": Button})))
-        self.assertEqual(list(app.controls.select({"type": FileInput})), [app.file_csv_input1])
-        self.assertEqual(list(app.controls.select({"type": TextInput})), [app.compare_kernel_input])
-        self.assertIs(app.controls.children[0], app.counter_multi_choice)
-        self.assertIs(app.controls.children[1], app.compare_kernel_input)
-        self.assertNotIn(app.kernel_name, app.controls.children)
-        self.assertIn(app.compare_kernel_name, app.controls.children)
-        for widget in app.controls.select({"type": Div}):
-            self.assertNotIn("Step ", widget.text)
-            self.assertNotIn("Plot Custom Counters", widget.text)
-            self.assertNotIn("UniTrace Counter Viewer", widget.text)
-
-    def test_csv_upload_populates_counters(self):
-        text = "".join(
-            f'Kernel, GlobalInstanceId\n"{kernel}", {gid}\n'
-            + group.drop(columns=["Kernel", "GlobalInstanceId"]).to_csv(index=False)
-            for (kernel, gid), group in app.df_input1.groupby(["Kernel", "GlobalInstanceId"]))
-        encoded = base64.b64encode(text.encode()).decode()
-        app.upload_csv_input1("value", "", encoded)
-        self.assertIn("Active[%]", app.counter_multi_choice.options)
-        self.assertEqual(app.counter_multi_choice.value, [])
-        app.counter_multi_choice.value = ["Active[%]"]
-        self.assertEqual(app.metric_plot_layout.children, [])
-        app.select_kernel_by_gid(4)
-        plot = app.metric_plot_layout.children[0].children[0]
-        self.assertEqual(plot.renderers[0].data_source.data["x"], [100, 110, 140])
-
-    def test_clearing_comparison_redraws(self):
-        app.compare_kernel_input.value = "9"
-        self.assertEqual(app.primary_kernel_id, "4")
-        self.assertEqual(app.df_kernel["GlobalInstanceId"].tolist(), [4, 4, 4])
-        app.compare_kernel_input.value = ""
-        plot = app.metric_plot_layout.children[0].children[0]
-        self.assertEqual(plot.renderers[0].data_source.data["x"], [100, 110, 140])
-        self.assertIsNone(app.df_kernel2)
-        self.assertEqual(app.primary_kernel_id, "4")
-
-    def test_invalid_ids_clear_stale_plots(self):
-        for value in ("999", "-1", "1.5", "abc", "4e0", ""):
-            with self.subTest(value=value):
-                app.select_kernel_by_gid(value)
-                self.assertFalse(app.selection_valid)
-                self.assertEqual(app.metric_plot_layout.children, [])
-                self.assertTrue(app.kernel_name.text)
-                app.select_kernel_by_gid(4)
-                self.assertTrue(app.selection_valid)
-
-    def test_missing_perfetto_id_displays_message(self):
-        app.select_kernel_by_gid(2)
-        self.assertEqual(app.status_div.text, "No metric data collected or no metrics specified")
-        self.assertIn(app.status_div, app.controls.children)
-        self.assertEqual(app.layout.children, [app.status_div])
-        self.assertFalse(list(app.layout.select({"type": TextInput})))
-        self.assertNotIn(app.counter_multi_choice, list(app.layout.references()))
-        self.assertFalse(app.selection_valid)
-        self.assertIsNone(app.df_kernel)
-        self.assertEqual(app.metric_plot_layout.children, [])
-        app.select_kernel_by_gid(4)
-        self.assertTrue(app.selection_valid)
-        self.assertNotIn("No metric data", app.status_div.text)
-        self.assertEqual(app.layout.children, [app.controls, app.metric_plot_layout])
-        self.assertTrue(app.metric_plot_layout.children)
-
-    def test_duplicate_and_missing_comparison(self):
-        for value, message in (("004", "must differ"), ("999", "not found")):
-            app.compare_kernel_input.value = value
-            self.assertFalse(app.selection_valid)
-            self.assertIn(message, app.compare_kernel_name.text)
-            self.assertEqual(app.metric_plot_layout.children, [])
-        app.compare_kernel_input.value = "9"
-        self.assertTrue(app.selection_valid)
-
-    def test_perfetto_selection_and_names(self):
-        app.compare_kernel_input.value = "9"
-        app.select_kernel_by_gid(9)
-        self.assertEqual(app.primary_kernel_id, "9")
-        self.assertEqual(app.compare_kernel_input.value, "")
-        self.assertIn("second", app.kernel_name.text)
-        self.assertEqual(app.df_kernel["GlobalInstanceId"].tolist(), [9, 9, 9])
-
-    def test_kernel_selection_has_no_sample_status(self):
-        app.counter_multi_choice.value = []
-        app.select_kernel_by_gid(4)
-        self.assertTrue(app.selection_valid)
-        self.assertEqual(app.df_kernel["GlobalInstanceId"].tolist(), [4, 4, 4])
-        self.assertEqual(app.status_div.text, "")
-        app.compare_kernel_input.value = "9"
-        self.assertEqual(app.df_kernel2["GlobalInstanceId"].tolist(), [9, 9, 9])
-        self.assertEqual(app.status_div.text, "")
-        app.compare_kernel_input.value = ""
-        self.assertIsNone(app.df_kernel2)
-        self.assertEqual(app.status_div.text, "")
-
-    def test_comparison_name_matches_plot_truncation(self):
-        for name, expected in (
-            ("second", "second"),
-            ("x" * 50, "x" * 50),
-            ("x" * 51, "x" * 50 + "..."),
-            ("<kernel>" + "x" * 60, "&lt;kernel&gt;" + "x" * 42 + "..."),
-        ):
-            with self.subTest(name=name):
-                app.compare_kernel_input.value = ""
-                app.df_input1.loc[app.df_input1["GlobalInstanceId"] == 9, "Kernel"] = name
-                app.compare_kernel_input.value = "9"
-                self.assertEqual(app.compare_kernel_name.text, f"Kernel 9: {expected}")
-                plot = app.metric_plot_layout.children[0].children[1].children[0]
-                short_name = name[:50] + ("..." if len(name) > 50 else "")
-                self.assertEqual(plot.title.text, short_name)
-
-    def test_missing_id_column_preserves_sample_plotting(self):
-        app.df_input1 = app.df_input1.drop(columns="GlobalInstanceId")
-        app.index_kernels(app.df_input1)
-        app.plot_custom_counters_callback()
-        self.assertTrue(app.compare_kernel_input.disabled)
-        self.assertEqual(len(app.metric_plot_layout.children[0].children[0].renderers[0].data_source.data["x"]), 6)
-
-    def test_kernel_execution_timestamps(self):
-        timestamps = [
-            51982842880, 51984583680, 51986324480,
-            51991649280, 51993395200, 51995141120,
-        ]
-        app.df_input1["QueryBeginTime[ns]"] = timestamps
-        app.select_kernel_by_gid(4)
-        app.compare_kernel_input.value = "9"
-        plots = [panel.children[0] for panel in app.metric_plot_layout.children[0].children]
-        for plot, expected in zip(plots, (timestamps[:3], timestamps[3:])):
-            self.assertEqual(plot.renderers[0].data_source.data["x"], expected)
-            self.assertEqual(plot.xaxis[0].axis_label, "Time (ns)")
-        self.assertLess(
-            plots[0].renderers[0].data_source.data["x"][-1],
-            plots[1].renderers[0].data_source.data["x"][0],
-        )
-
-    def test_sample_number_fallback(self):
-        app.df_input1 = app.df_input1.drop(columns="QueryBeginTime[ns]")
-        app.select_kernel_by_gid(4)
-        app.plot_custom_counters_callback()
-        plot = app.metric_plot_layout.children[0].children[0]
-        self.assertEqual(plot.renderers[0].data_source.data["x"], [1, 2, 3])
-        self.assertEqual(plot.xaxis[0].axis_label, "Sample number")
-
-    def test_external_legend(self):
-        panel = app.counter_plot_with_legend(app.show_counters_overlaid(
-            "single", [("Active[%]", [(100, 42)])],
-        ))
-        plot, legend = panel.children
-        self.assertFalse(plot.legend[0].visible)
-        self.assertEqual(legend.labels, ["Active[%]"])
-        self.assertEqual(legend.active, [0])
-        self.assertTrue(legend.inline)
-        self.assertEqual(legend.max_height, 140)
-        self.assertEqual(plot.margin, 0)
-        self.assertEqual(legend.margin, (0, 0, 0, plot.min_border_left))
-        callback = legend.js_property_callbacks["change:active"][0]
-        self.assertEqual(callback.args["groups"][0], plot.renderers)
-
-    def test_sampling_mode_uses_metadata_not_sample_count(self):
-        self.assertFalse(app.is_query_sampling(app.df_input1.iloc[:1]))
-        self.assertFalse(app.is_query_sampling(app.df_input1.assign(ReportId=1)))
-        query = app.df_input1.assign(QuerySplitOccurred=0, ReportId=1, ReportsCount=1)
-        query.columns = [f" {column.upper()} " for column in query.columns]
-        self.assertTrue(app.is_query_sampling(query))
-
-    def test_query_sampling_grouped_bars_and_comparison(self):
-        app.df_input1 = app.df_input1.iloc[[0, 3]].copy().assign(
-            QuerySplitOccurred=0, ReportId=1, ReportsCount=1,
-        )
-        app.index_kernels(app.df_input1)
-        app.select_kernel_by_gid(4)
-        app.counter_multi_choice.value = ["Active[%]", "Stall[%]"]
-        app.compare_kernel_input.value = "9"
-        panels = app.metric_plot_layout.children[0].children
-        for panel, expected in zip(panels, ([0.123456, 80], [30, 70])):
-            plot, legend = panel.children
-            self.assertEqual(plot.x_range.factors, ["1"])
-            self.assertEqual(plot.xaxis[0].axis_label, "Query report")
-            self.assertEqual(len(plot.renderers), 2)
-            for renderer, value in zip(plot.renderers, expected):
-                self.assertIsInstance(renderer.glyph, VBar)
-                self.assertEqual(renderer.data_source.data["top"], [value])
-            self.assertEqual(legend.labels, ["Active[%]", "Stall[%]"])
-            self.assertNotEqual(plot.renderers[0].glyph.x.transform.value,
-                                plot.renderers[1].glyph.x.transform.value)
-
-    def test_more_than_ten_counters(self):
-        plot = app.show_counters_overlaid("many", [
-            (f"counter{index}", [(0, 1), (10, 2)]) for index in range(12)
-        ])
-        self.assertEqual(len(plot.renderers), 12)
-
-
-if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
diff --git a/tools/unitrace/test/test_layout.py b/tools/unitrace/test/test_layout.py
deleted file mode 100644
index 5ce0e891..00000000
--- a/tools/unitrace/test/test_layout.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Where the test harness finds test binaries and writes its output.
-#
-# The workloads are built incrementally in the source tree
-# (test/cpp_test/build) and installed into the unitrace build directory, so a
-# clean unitrace build does not force a rebuild of the tests:
-#
-#   <unitrace build>/test/bin/<workload>/       one directory per workload: its
-#                                               binary and data files (.spv kernels)
-#   <unitrace build>/test/output/<group>/logs/     per-scenario logs
-#   <unitrace build>/test/output/<group>/results/<test>/  unitrace output files,
-#                                               one directory per tests.txt test
-#
-#   <unitrace build>/test/fuzz_build/           the clang build of unitrace with
-#                                               the fuzz targets (the [fuzz_*] tests)
-#
-# <group> is cpp_test or python_test. test_unitrace.py --output-dir replaces
-# <unitrace build>/test/output with a directory of the caller's choice, e.g. a
-# short one on Windows where unitrace output paths must stay under MAX_PATH.
-
-import os
-import platform
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-DEFAULT_UNITRACE_BUILD_DIR = os.path.normpath(os.path.join(_HERE, "..", "build"))
-
-
-def exe(name):
-    """Executable file name for the current platform."""
-    return name + ".exe" if platform.system() == "Windows" else name
-
-
-def unitrace_build_dir(build_dir=None):
-    return os.path.abspath(build_dir) if build_dir else DEFAULT_UNITRACE_BUILD_DIR
-
-
-def default_build_dir_error(build_dir=None):
-    """Error message when no build directory was given and the default
-    tools/unitrace/build holds no unitrace (e.g. unitrace was built from the
-    repository top level). Installing there would create a stray build/ that
-    contains only test/; None when the build directory is usable."""
-    if build_dir or os.path.exists(os.path.join(DEFAULT_UNITRACE_BUILD_DIR, exe("unitrace"))):
-        return None
-    return (f"[ERROR] No unitrace found in the default build directory "
-            f"{DEFAULT_UNITRACE_BUILD_DIR}. If unitrace was built elsewhere (e.g. "
-            f"the repository top-level build), pass --unitrace-build-dir <that "
-            f"build directory>; otherwise build tools/unitrace first.")
-
-
-def test_root(build_dir=None):
-    """Install prefix of the test workloads."""
-    return os.path.join(unitrace_build_dir(build_dir), "test")
-
-
-def fuzz_build_dir(build_dir=None):
-    """The clang build of unitrace with the fuzz targets: <unitrace build>/test/fuzz_build.
-
-    build_dir: the unitrace build directory (None: the default one).
-    """
-    return os.path.join(test_root(build_dir), "fuzz_build")
-
-
-def fuzz_bin_dir(build_dir=None):
-    """The directory of the C++ fuzz_* binaries of the fuzz build, {fuzz_bin} in
-    tests.txt.
-
-    build_dir: the unitrace build directory (None: the default one).
-    """
-    return os.path.join(fuzz_build_dir(build_dir), "test", "fuzz", "cpp")
-
-
-def bin_dir(build_dir=None):
-    return os.path.join(test_root(build_dir), "bin")
-
-
-def workload_exe(test_bin_dir, name):
-    """Installed executable of workload <name>. Each workload installs into its
-    own bin/<name>/ so data files with the same name (e.g. two tests shipping a
-    gemm.spv) cannot overwrite each other."""
-    return os.path.join(test_bin_dir, name, exe(name))
-
-
-def remove_flat_bin_files(build_dir=None):
-    """Delete files left directly in bin/ by the old flat layout. bin/<name>
-    used to be a binary and is now a directory, so a stale file there makes
-    cmake --install fail; the new layout keeps only directories in bin/."""
-    root = bin_dir(build_dir)
-    if not os.path.isdir(root):
-        return
-    for entry in os.listdir(root):
-        path = os.path.join(root, entry)
-        if os.path.isfile(path) or os.path.islink(path):
-            os.remove(path)
-
-
-def output_dir(build_dir=None, group="cpp_test", root=None):
-    """Output directory of a test group, under root when given."""
-    base = os.path.abspath(root) if root else os.path.join(test_root(build_dir), "output")
-    return os.path.join(base, group)
-
-
-# Windows paths longer than this fail in unitrace, which is not long-path aware
-# (MAX_PATH is 260 including the terminating NUL; directories get 248).
-WINDOWS_MAX_PATH = 259
-
-
-def windows_path_too_long(path):
-    """True when path cannot be created on Windows without long-path support."""
-    return platform.system() == "Windows" and len(path) > WINDOWS_MAX_PATH
-
-
-def logs_dir(group_output_dir):
-    return os.path.join(group_output_dir, "logs")
-
-
-def results_dir(group_output_dir, test=None):
-    """Results root, or the results directory of one tests.txt test."""
-    root = os.path.join(group_output_dir, "results")
-    return os.path.join(root, test) if test else root
-
-
-def metric_scratch_dir(group_output_dir, test=None):
-    """Where metric scenarios write before run_test.py moves the files to results."""
-    root = os.path.join(group_output_dir, "metric_scratch")
-    return os.path.join(root, test) if test else root
diff --git a/tools/unitrace/test/test_unitrace.py b/tools/unitrace/test/test_unitrace.py
deleted file mode 100644
index 97c45627..00000000
--- a/tools/unitrace/test/test_unitrace.py
+++ /dev/null
@@ -1,689 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-import os
-import subprocess
-import shutil
-import argparse
-import sys
-import platform
-import fnmatch
-import json
-
-import fuzz_tests
-import test_layout
-
-def clean_up_testing_folder(output_dir, test_names=None):
-    """Remove previous logs and results under output_dir: everything, or only
-    those of test_names (tests.txt names, already expanded from a glob).
-    The workload build tree is left alone so rebuilds stay incremental."""
-    logs_folder = test_layout.logs_dir(output_dir)
-    result_folder = test_layout.results_dir(output_dir)
-    scratch_folder = test_layout.metric_scratch_dir(output_dir)
-    
-    cleanup_status = True
-    
-    if test_names is not None:
-        for test_name in test_names:
-            # Remove this test's per-scenario <name>.<scenario>.log files
-            if os.path.exists(logs_folder):
-                for item in os.listdir(logs_folder):
-                    if item.startswith(f"{test_name}."):
-                        item_path = os.path.join(logs_folder, item)
-                        if os.path.isfile(item_path):
-                            os.remove(item_path)
-                            print(f"Removed file: {item_path}")
-                        elif os.path.isdir(item_path):
-                            shutil.rmtree(item_path, ignore_errors=False)
-                            print(f"Removed folder: {item_path}")
-
-            # Remove the test's results/<name> and metric_scratch/<name> folders
-            for folder in (test_layout.results_dir(output_dir, test_name),
-                           test_layout.metric_scratch_dir(output_dir, test_name)):
-                if not os.path.exists(folder):
-                    continue
-                print(f"Removing folder {folder}")
-                shutil.rmtree(folder, ignore_errors=False)
-                if not os.path.exists(folder):
-                    print(f"[INFO] Successfully removed folder: {folder}")
-                else:
-                    print(f"[ERROR] Unable to delete the folder '{folder}'.")
-                    cleanup_status = False
-
-            print(f"[INFO] Cleaned up folders for test: {test_name}")
-    else:
-        # Clean up all logs, results and metric scratch folders
-        for folder in (logs_folder, result_folder, scratch_folder):
-            if os.path.exists(folder):
-                print("Removing folder " + folder)
-                shutil.rmtree(folder, ignore_errors=False)
-
-            # Verify if the folder was successfully removed
-            if not os.path.exists(folder):
-                print(f"[INFO] Successfully removed folder : {folder}")
-            else:
-                print(f"[ERROR] Unable to delete the folder '{folder}'.")
-                cleanup_status = False
-
-    if cleanup_status == False:
-        return 1
-    else:
-        return 0
-
-
-def build(test_dir, test_name=None, unitrace_build_dir=None):
-    """Build the test project in <test_dir>/build and install the binaries
-    into <unitrace build>/test/bin. If test_name is provided, build and
-    install only that test. Both steps are incremental: unchanged workloads
-    are not recompiled and up-to-date binaries are not copied again."""
-    if not os.path.exists(test_dir):
-        raise FileNotFoundError(f"[ERROR] Test directory does not exist: {test_dir}")
-
-    # Set up paths
-    build_dir = os.path.join(test_dir, "build")
-    os.makedirs(build_dir, exist_ok = True)
-
-    # Change to the build directory
-    os.chdir(build_dir)
-    try:
-        print("Build started ... ")
-        configure = ['cmake', '..', '-G', 'Ninja']
-        if unitrace_build_dir:
-            configure.append(f"-DUNITRACE_BUILD_ROOT={unitrace_build_dir}")
-        subprocess.run(configure, check = True)
-        
-        # Build only the specific test if test_name is provided, otherwise build all
-        if test_name:
-            print(f"Building test: {test_name}")
-            subprocess.run(['ninja', test_name], check = True)
-        else:
-            subprocess.run(['ninja'], check = True)
-
-        test_layout.remove_flat_bin_files(unitrace_build_dir)
-        install = ['cmake', '--install', '.', '--prefix', test_layout.test_root(unitrace_build_dir)]
-        if test_name:
-            # each workload is its own install component
-            install += ['--component', test_name]
-        subprocess.run(install, check = True)
-
-        print("Build completed ...")
-        return 0
-    except subprocess.CalledProcessError as e:
-        print(f"[ERROR] during build: {e}")
-        print(f"Return Code: {e.returncode}")
-        if e.output:
-            print(f"Output: {e.output.decode()}")
-        if e.stderr:
-            print(f"[ERROR] Output: {e.stderr.decode()}")
-        return 1
-    except Exception as ex:
-        print(f"Unexpected [ERROR]: {ex}")
-        return 1
-
-# The "build" keys of 'unitrace --print-options-schema' (src/unitrace.cc).
-KNOWN_BUILD_FEATURES = ("L0", "OPENCL", "ITT", "XPTI", "MPI", "OMP", "PERFETTO")
-
-def load_test_definitions():
-    """Parse tests.txt into ([defaults] block, list of test blocks)."""
-    manifest_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tests.txt")
-    blocks = []
-    current = None
-    with open(manifest_path, 'r') as manifest:
-        for line in manifest:
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-            if line.startswith('[') and line.endswith(']'):
-                current = {"name": line[1:-1], "command": None, "platform": None,
-                           "requires": None,
-                           "options": [], "scenarios": [], "skips": [],
-                           "defaults_scenario": []}
-                blocks.append(current)
-                continue
-            if current is None:
-                raise ValueError(f"line outside a [test] block in {manifest_path}: {line}")
-            key, _, value = line.partition('=')
-            key, value = key.strip(), value.strip()
-            base, _, os_qualifier = key.partition(':')
-            os_qualifier = os_qualifier.strip() or None
-            if base == "command":
-                current["command"] = value
-            elif base == "platform":
-                current["platform"] = value.split()
-            elif base == "requires":
-                features = value.split()
-                if not features:
-                    raise ValueError(f"[{current['name']}] empty 'requires'; "
-                                     f"use 'requires = none' for no requirements")
-                if any(f.lower() == "none" for f in features):
-                    if len(features) > 1:
-                        raise ValueError(f"[{current['name']}] 'none' cannot be combined "
-                                         f"with other features in 'requires'")
-                    features = []
-                unknown = [f for f in features if f not in KNOWN_BUILD_FEATURES]
-                if unknown:
-                    raise ValueError(f"[{current['name']}] unknown feature(s) in 'requires': "
-                                     f"{' '.join(unknown)}; known: {' '.join(KNOWN_BUILD_FEATURES)}")
-                current["requires"] = features
-            elif base == "options":
-                current["options"].append((os_qualifier, value))
-            elif base == "scenario":
-                current["scenarios"].append((os_qualifier, value))
-            elif base == "skip-scenario":
-                current["skips"].append((os_qualifier, value))
-            elif base == "defaults-scenario":
-                current["defaults_scenario"].append((os_qualifier, value))
-            else:
-                raise ValueError(f"unknown key '{key}' in {manifest_path}")
-    defaults = next((b for b in blocks if b["name"] == "defaults"), None)
-    if defaults is None:
-        raise ValueError(f"no [defaults] block in {manifest_path}")
-    return defaults, [b for b in blocks if b["name"] != "defaults"]
-
-def applicable(qualified_values, current_os):
-    return [value for (os_qualifier, value) in qualified_values
-            if os_qualifier in (None, current_os)]
-
-def resolve_test(test, defaults, current_os):
-    """Resolve one test block for one OS: platform gate, scenario list
-    (own lines, else defaults), skip-scenario subtraction, options merge.
-    Returns the resolved scenario list, or None if the test does not run."""
-    platforms = test["platform"] or defaults["platform"] or []
-    if current_os not in platforms:
-        return None
-    scenarios = applicable(test["scenarios"], current_os)
-    # defaults-scenario = True/False decides whether the [defaults] list is
-    # included; when the key is absent, a block with its own scenario lines
-    # replaces the defaults and a block without any inherits them.
-    include_defaults = applicable(test["defaults_scenario"], current_os)
-    if include_defaults:
-        value = include_defaults[-1].strip().lower()
-        if value == "true":
-            scenarios = applicable(defaults["scenarios"], current_os) + scenarios
-        elif value != "false":
-            raise ValueError(f"[{test['name']}] defaults-scenario must be "
-                             f"True or False, got '{include_defaults[-1]}'")
-        elif not scenarios:
-            # defaults-scenario = False with no scenario lines: an empty
-            # matrix - the test runs once (plus the native run).
-            scenarios = [""]
-    elif not scenarios:
-        scenarios = applicable(defaults["scenarios"], current_os)
-    skips = applicable(test["skips"], current_os)
-    # A skip matches every scenario containing all of its tokens.
-    scenarios = [s for s in scenarios
-                 if not any(set(skip.split()) <= set(s.split()) for skip in skips)]
-    options = " ".join(applicable(test["options"], current_os))
-    if options:
-        scenarios = [f"{s} {options}".strip() for s in scenarios]
-    return scenarios
-
-def requirements_of(test, defaults):
-    """Build features a test needs: its own 'requires', else [defaults]'s."""
-    if test["requires"] is not None:
-        return test["requires"]
-    return defaults["requires"] or []
-
-def query_build_features(unitrace_exe):
-    """Set of features the unitrace binary was built with, read from the
-    "build" object of --print-options-schema. None when it cannot be
-    determined; callers then run every test as before."""
-    try:
-        result = subprocess.run([unitrace_exe, "--print-options-schema"],
-                                capture_output=True, text=True, timeout=60)
-        build = json.loads(result.stdout)["build"]
-    except Exception as e:
-        print(f"[WARNING] Could not query build features of '{unitrace_exe}' ({e}); "
-              f"running all tests without capability checks.")
-        return None
-    if set(build) != set(KNOWN_BUILD_FEATURES):
-        print(f"[WARNING] Build features reported by '{unitrace_exe}' "
-              f"({' '.join(sorted(build))}) differ from KNOWN_BUILD_FEATURES "
-              f"({' '.join(sorted(KNOWN_BUILD_FEATURES))}); update test_unitrace.py.")
-    return {name for name, enabled in build.items() if enabled}
-
-def missing_features(test, defaults, features):
-    if features is None:
-        return []
-    return sorted(set(requirements_of(test, defaults)) - features)
-
-def test_name_matches(name, test_name):
-    """Exact match, or fnmatch glob when the selector contains wildcards."""
-    if any(ch in test_name for ch in "*?["):
-        return fnmatch.fnmatch(name, test_name)
-    return name == test_name
-
-def build_target_of(test):
-    """The ninja target of a test's workload, or None when there is no
-    dedicated target (check scripts, python tests) and the whole project
-    must be built. A test name is not necessarily a target: e.g.
-    selective_kernels builds 'graph' and the event_reset variants build
-    'event_reset'."""
-    tokens = test["command"].split()
-    # skip leading NAME=VALUE environment prefixes
-    while tokens and "=" in tokens[0] and not tokens[0].endswith(".py"):
-        tokens.pop(0)
-    if not tokens or not tokens[0].endswith("run_test.py"):
-        return None
-    skip_next = False
-    for token in tokens[1:]:
-        if skip_next:
-            skip_next = False
-            continue
-        if token in ("-e", "-t", "-n", "-c", "-s", "--scenario"):
-            skip_next = True
-            continue
-        if token.startswith("-"):
-            continue
-        if "{" in token or "/" in token:
-            return None
-        return token
-    return None
-
-def test_group_of(test):
-    """The group a tests.txt test belongs to, from its command: python-test for commands
-    under python_test/, cpp-test for the rest (the fuzz tests under fuzz/ included)."""
-    return "python-test" if "python_test/" in test["command"] else "cpp-test"
-
-def is_fuzz_test(test):
-    """true for a fuzz test: a [fuzz_*] block, running fuzz/replay.py."""
-    return "fuzz/replay.py" in test["command"]
-
-def resolve_unitrace_exe(test_dir, unitrace_exe=None):
-    if unitrace_exe:
-        return unitrace_exe
-    exe_name = "unitrace.exe" if platform.system() == "Windows" else "unitrace"
-    return os.path.join(test_dir, "..", "..", "build", exe_name)
-
-def build_test_command(test_entry, test_dir, scenario, bin_dir, output_dir, unitrace_exe=None, skip_golden_compare=False, unitrace_build_dir=None):
-    """Expands one tests.txt command line for one scenario.
-
-    test_entry: {"name", "cmd"}; scenario: the unitrace options, "native" or "check";
-    bin_dir, output_dir: where the workloads are and where logs and results go;
-    unitrace_exe: the unitrace under test (None: the default build's);
-    skip_golden_compare: forwarded to run_test.py; unitrace_build_dir: the unitrace
-    build, for {fuzz_bin}. Placeholders {python}, {unitrace}, {bin} and {fuzz_bin} are
-    replaced; a run_test.py command gets the scenario and the directories.
-
-    Returns the command and the extra environment set by leading NAME=VALUE tokens
-    (formerly per-test ctest ENVIRONMENT properties).
-    """
-    tokens = [token.format(python=sys.executable,
-                           unitrace=resolve_unitrace_exe(test_dir, unitrace_exe),
-                           bin=bin_dir,
-                           fuzz_bin=test_layout.fuzz_bin_dir(unitrace_build_dir))
-              for token in test_entry["cmd"].split()]
-    extra_env = {}
-    while "=" in tokens[0] and not tokens[0].endswith(".py"):
-        name, _, value = tokens.pop(0).partition("=")
-        extra_env[name] = value
-    if tokens[0].endswith("run_test.py"):
-        # --scenario=<value> form: scenario values start with '-'
-        tokens.insert(1, f"--scenario={scenario}")
-        tokens[2:2] = ["--test-bin-dir", bin_dir, "--output-dir", output_dir,
-                       "--results-subdir", test_entry["name"]]
-        if unitrace_exe:
-            tokens[2:2] = ["--unitrace-exe", unitrace_exe]
-        if skip_golden_compare:
-            tokens.insert(2, "--skip-golden-compare")
-    return [sys.executable] + tokens, extra_env
-
-# A scenario-independent check exits with this status when it cannot run here
-# (e.g. a fuzz target without clang); it is reported as Skipped.
-SKIPPED_RETURN_CODE = 77
-
-def launch_test_with_scenarios(test_entry, scenarios, test_dir, bin_dir, output_dir, total_tests, unitrace_exe=None, skip_golden_compare=False, unitrace_build_dir=None):
-    """Runs one test: a run_test.py command natively and then once per scenario, any
-    other command once ("check").
-
-    Each run's output goes to <logs>/<test>.<scenario>.log. A check exiting with
-    SKIPPED_RETURN_CODE is reported as Skipped with the last line it printed. If the
-    native run fails, the scenarios are not run (a driver or environment problem).
-
-    Returns (sub-tests run, failed (scenario, log path) pairs, skipped).
-    """
-    test = test_entry["name"]
-    failed_options = []
-    skipped = False
-    sub_tests = 0
-
-    # "native" runs the app without unitrace first, as a driver/environment
-    # sanity check; if it fails, skip the unitrace scenarios (not our problem).
-    # Commands not using run_test.py ignore the scenario, so they run once.
-    if any(token.endswith("run_test.py") for token in test_entry["cmd"].split()):
-        run_list = ["native"] + scenarios
-    else:
-        run_list = ["check"]
-    native_failed = False
-    for cmd in run_list:
-        sub_tests += 1
-        command, extra_env = build_test_command(test_entry, test_dir, cmd, bin_dir, output_dir, unitrace_exe, skip_golden_compare, unitrace_build_dir)
-        result = subprocess.run(command, capture_output=True, text=True,
-                                env={**os.environ, **extra_env},
-                                cwd=os.path.dirname(os.path.abspath(__file__)))
-
-        # One log per scenario: <logs>/<test>.<scenario>.log.
-        # '.' delimits the test name from the scenario so per-test cleanup
-        # cannot match tests whose names extend this one (ze_gemm vs
-        # ze_gemm_metric).
-        log_name = test+"."+cmd.replace('--', '_').replace('-', '_').replace(" ", "")+".log"
-        logs_folder = test_layout.logs_dir(output_dir)
-        os.makedirs(logs_folder, exist_ok=True)
-        log_file_path = os.path.join(logs_folder, log_name)
-        with open(log_file_path, 'w') as log_file:
-            env_prefix = "".join(f"{k}={v} " for k, v in extra_env.items())
-            log_file.write("Command: " + env_prefix + " ".join(command) + "\n")
-            log_file.write(result.stdout or "")
-            log_file.write(result.stderr or "")
-
-        if result.returncode == SKIPPED_RETURN_CODE and cmd == "check":
-            skipped = True
-            YELLOW = '\033[33m'
-            RESET = '\033[0m'
-            reason = (result.stdout or "").strip().splitlines()
-            reason = reason[-1] if reason else ""
-            print(f"{YELLOW}{test} : Skipped ({reason}){RESET}")
-        elif result.returncode == 0:
-            print(str(total_tests+sub_tests)+" : "+test+cmd+" : Passed")
-        else:
-            native_failed = cmd == "native"
-            failed_options.append((cmd, log_file_path))
-            error_message = str(total_tests+sub_tests)+" : "+test+cmd+" : Failed"
-            RED = '\033[31m'
-            RESET = '\033[0m' # Resets text formatting to default
-            print(f"{RED}{error_message}{RESET}")
-
-        if native_failed:
-            print(f"[ERROR] '{test}' failed to run natively (driver/environment issue, "
-                  f"not a unitrace problem); skipping its unitrace scenarios.")
-            break
-    return sub_tests, failed_options, skipped
-
-def run_tests(test_dir, test_group, bin_dir, output_dir, test_name=None, unitrace_exe=None, skip_golden_compare=False, unitrace_build_dir=None):
-    """Runs the tests of one group, as tests.txt defines them for this OS.
-
-    test_name: a name or glob to run only matching tests. Tests needing a build
-    feature the unitrace under test lacks, or whose check exits with
-    SKIPPED_RETURN_CODE, are counted as Skipped. Prints a summary and, for each
-    failure, the errors of its log. Returns 1 if any test failed, else 0.
-    """
-    failed_test_flag = 0
-    failed_options = []
-    skipped_tests = []
-    total_tests = 0
-    current_os = platform.system()
-
-    features = query_build_features(resolve_unitrace_exe(test_dir, unitrace_exe))
-    if features is not None:
-        print(f"Unitrace build features: {' '.join(sorted(features))}")
-
-    defaults, tests = load_test_definitions()
-    for test in tests:
-        if test_group_of(test) != test_group:
-            continue
-        if test_name is not None and not test_name_matches(test["name"], test_name):
-            continue
-        scenarios = resolve_test(test, defaults, current_os)
-        if scenarios is None:
-            continue
-        missing = missing_features(test, defaults, features)
-        if missing:
-            skipped_tests.append(test["name"])
-            YELLOW = '\033[33m'
-            RESET = '\033[0m'
-            print(f"{YELLOW}{test['name']} : Skipped (unitrace built without "
-                  f"{' '.join(missing)}){RESET}")
-            continue
-        test_entry = {"name": test["name"], "cmd": test["command"]}
-        total_sub_tests, tests_status, skipped = launch_test_with_scenarios(test_entry, scenarios, test_dir, bin_dir, output_dir, total_tests, unitrace_exe, skip_golden_compare, unitrace_build_dir)
-        if skipped:
-            skipped_tests.append(test["name"])
-            continue
-        total_tests += total_sub_tests
-        for test_status in tests_status:
-            failed_options.append(test_status)
-    print("\n\n------------------------------------------------------------")
-    print("Total test run "+str(total_tests)+ "  Failed tests : "+str(len(failed_options))
-          + "  Skipped tests : "+str(len(skipped_tests)))
-    print("------------------------------------------------------------")
-    if len(failed_options) > 0:
-        print("-" * 70)
-        print("\n Sub-Test Failure Report:")
-        print("{:<20} {:<50} {:<30}".format("[Unitrace Option]", "[Failed Test Log Path]", "[Error Messages]"))
-        print("-" * 70)
-
-        failed_test_flag = 1
-        for failed_option, log_file_path in failed_options:
-            error_messages = []
-
-            if os.path.exists(log_file_path):
-                try:
-                    with open(log_file_path, 'r') as log_file:
-                        error_block = []
-                        capture_error = False
-
-                        for line in log_file:
-                            line = line.strip()
-                            if '[ERROR]' in line:
-                                if capture_error and error_block:
-                                    # Save the previous block when a new [ERROR] is found before 'return code'
-                                    error_messages.append("\n".join(error_block))
-                                    error_block = []
-                                capture_error = True
-
-                            # Append lines to the current error block
-                            if capture_error:
-                                error_block.append(line)
-
-                            # Stop capturing at 'return code' and save the block
-                            if ('return code' in line or '<end of output>' in line) and capture_error:
-                                error_messages.append("\n".join(error_block))
-                                error_block = []
-                                capture_error = False
-
-                    # Handle any leftover error block
-                    if capture_error and error_block:
-                        error_messages.append("\n".join(error_block))
-
-                except Exception as read_error:
-                    print(f"[ERROR] reading log file {log_file_path}: {read_error}", file=sys.stderr)
-            else:
-                print(f"[ERROR] Log file does not exist or is empty at: {log_file_path}")
-
-            # Format the error messages
-            if error_messages:
-                errors_str = "\n\n".join(error_messages)
-            else:
-                errors_str = "No [ERROR] found"
-
-            # Print the error information
-            print("{:<20} {:<50} {:<30}".format(failed_option, log_file_path, "\n" + errors_str))
-    return failed_test_flag
-
-def list_tests(test_group, test_name=None):
-    """Print each test's command line and its resolved scenario matrix."""
-    current_os = platform.system()
-    defaults, tests = load_test_definitions()
-    for test in tests:
-        if test_group_of(test) != test_group:
-            continue
-        if test_name is not None and not test_name_matches(test["name"], test_name):
-            continue
-        scenarios = resolve_test(test, defaults, current_os)
-        if scenarios is None:
-            print(f"{test['name']}  [not enabled on {current_os}]")
-            print(f"  command: {test['command']}")
-            print()
-            continue
-        print(f"{test['name']}")
-        print(f"  command: {test['command']}")
-        print(f"  requires: {' '.join(requirements_of(test, defaults)) or 'none'}")
-        if not any(token.endswith("run_test.py") for token in test["command"].split()):
-            print("  scenarios: scenario-independent (single check)")
-        elif scenarios == [""]:
-            print("  scenarios: none (single run + native)")
-        else:
-            print(f"  scenarios ({len(scenarios)} + native):")
-            for scenario in scenarios:
-                print(f"    {scenario}")
-        print()
-    return 0
-
-TEST_GROUPS = ("cpp-test", "python-test")
-# The directory of each group's tests (and of its output under test/output).
-GROUP_DIRS = {"cpp-test": "cpp_test", "python-test": "python_test"}
-
-def parse_arguments():
-    """Parse command-line arguments."""
-    parser = argparse.ArgumentParser(description="Unitrace Test Script")
-
-    # Optional argument for the test directory
-    parser.add_argument(
-        "--test-dir",
-        type=str,
-        default=os.getcwd(),
-        help="Path to the test directory. Defaults to the current working directory."
-    )
-    parser.add_argument(
-        "--test-group",
-        type=str,
-        choices=TEST_GROUPS,
-        default="cpp-test",
-        help="cpp-test or python-test group to run. default is cpp-test, "
-             "which includes the fuzz tests."
-    )
-    # Flags for actions
-    parser.add_argument(
-        "--run",
-        action="store_true",
-        help="Run tests only."
-    )
-    parser.add_argument(
-        "--test-name",
-        type=str,
-        default=None,
-        help="Name of the test to run."
-    )
-    parser.add_argument(
-        "--list",
-        action="store_true",
-        help="List each test with its command and resolved scenarios, without running anything."
-    )
-    parser.add_argument(
-        "--unitrace-exe",
-        type=str,
-        default=None,
-        help="Path to the unitrace binary when it is not at the standalone "
-             "location <test-dir>/../build/unitrace (e.g. a top-level build "
-             "or a prebuilt package)."
-    )
-    parser.add_argument(
-        "--unitrace-build-dir",
-        type=str,
-        default=None,
-        help="Path to the unitrace build directory holding build-time "
-             "artifacts the test workloads reuse (ITT library, downloaded "
-             "Level Zero headers) when unitrace was built outside the "
-             "standalone tools/unitrace layout. Forwarded to the workload "
-             "configure step as -DUNITRACE_BUILD_ROOT. Test binaries are "
-             "installed into <dir>/test/bin and logs and results are written "
-             "to <dir>/test/output. Defaults to tools/unitrace/build."
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=str,
-        default=None,
-        help="Write logs and results to <dir>/<cpp_test|python_test> instead "
-             "of <unitrace build>/test/output. Use a short path on Windows, "
-             "where unitrace output paths must stay under MAX_PATH (260)."
-    )
-    parser.add_argument(
-        "--skip-golden-compare",
-        action="store_true",
-        help="Skip golden-output content comparisons (for environments "
-             "without validated golden files); execution and output checks "
-             "still apply. Forwarded to run_test.py."
-    )
-    return parser.parse_args()
-
-def run_group(args, test_group):
-    """Builds (unless --run) and runs one test group: cpp-test or python-test.
-
-    args: the parsed command line; test_group: the group. Cleans up the group's
-    output, builds its tests, then runs them. For cpp-test the build is the workloads
-    (CMake) and the fuzz targets (fuzz_tests.build()); a --test-name that selects
-    only fuzz tests builds only the fuzz targets, one that selects none builds no
-    fuzz targets. With --list, prints the group's tests instead. Returns 0 on
-    success, non-zero on a build error or a failed test.
-    """
-    build_target = None
-    matched_names = None
-    build_workloads = True
-    build_fuzz = test_group == "cpp-test"
-    if args.test_name is not None:
-        _, tests = load_test_definitions()
-        group_tests = [t for t in tests if test_group_of(t) == test_group]
-        matched = [t for t in group_tests
-                   if test_name_matches(t["name"], args.test_name)]
-        if not matched:
-            print(f"[ERROR] No test matches '{args.test_name}' in group "
-                  f"'{test_group}'. Available tests:")
-            for t in group_tests:
-                print(f"  {t['name']}")
-            return 1
-        # Clean up exactly the matched tests (the selector may be a glob).
-        matched_names = [t["name"] for t in matched]
-        # Build only what the matched tests need: the fuzz targets only for fuzz
-        # tests, and only the matched workload when it is unambiguous; a test
-        # name is not necessarily a ninja target (see build_target_of).
-        workload_tests = [t for t in matched if not is_fuzz_test(t)]
-        build_workloads = bool(workload_tests)
-        build_fuzz = build_fuzz and len(workload_tests) < len(matched)
-        targets = {build_target_of(t) for t in workload_tests}
-        if len(targets) == 1:
-            build_target = targets.pop()
-
-    if args.list:
-        return list_tests(test_group, args.test_name)
-
-    error = test_layout.default_build_dir_error(args.unitrace_build_dir)
-    if error:
-        print(error)
-        return 1
-
-    test_dir = os.path.join(args.test_dir, GROUP_DIRS[test_group])
-    bin_dir = test_layout.bin_dir(args.unitrace_build_dir)
-    output_dir = test_layout.output_dir(args.unitrace_build_dir, os.path.basename(test_dir),
-                                        args.output_dir)
-
-    if args.run == False:
-        print("Cleaning up test folder ...")
-        status = clean_up_testing_folder(output_dir, matched_names)
-        # Build the tests now; a failed cleanup would leave stale results behind
-        if status == 0 and build_workloads:
-            status = build(test_dir, build_target, args.unitrace_build_dir)
-        if status == 0 and build_fuzz:
-            status = fuzz_tests.build(args.unitrace_build_dir)
-        if status != 0: #cleanup/build error check and return
-            return status
-    print("Start testing...")
-    print(f"Test binaries: {bin_dir}")
-    print(f"Test output:   {output_dir}")
-    status = run_tests(test_dir, test_group, bin_dir, output_dir, args.test_name, args.unitrace_exe, args.skip_golden_compare, args.unitrace_build_dir)
-    return(status)
-
-def main():
-    """Builds (unless --run) and runs the --test-group group; returns the exit status."""
-    args = parse_arguments()
-    if args.unitrace_exe:
-        args.unitrace_exe = os.path.abspath(args.unitrace_exe)
-    if args.unitrace_build_dir:
-        args.unitrace_build_dir = os.path.abspath(args.unitrace_build_dir)
-    args.test_dir = os.path.abspath(args.test_dir)
-    return run_group(args, args.test_group)
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/tools/unitrace/test/test_uniview_routing.py b/tools/unitrace/test/test_uniview_routing.py
deleted file mode 100644
index 0d8b8252..00000000
--- a/tools/unitrace/test/test_uniview_routing.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import contextlib
-import io
-import json
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
-import uniview
-
-
-class RoutingTest(unittest.TestCase):
-    def test_trace_access_logging_keeps_errors(self):
-        handler = object.__new__(uniview.TraceLoadingHttpHandler)
-        with patch.object(uniview.http.server.SimpleHTTPRequestHandler, "log_request") as log:
-            handler.log_request(200, 100)
-            handler.log_request(304)
-            log.assert_not_called()
-            handler.log_request(404)
-            log.assert_called_once_with(404, '-')
-
-    def test_dashboard_is_opt_in(self):
-        base = ["uniview.py", "-t", "trace.json", "-m", "metrics.csv"]
-        with patch.object(sys, "argv", base):
-            self.assertFalse(uniview.ParseArguments().dashboard)
-        with patch.object(sys, "argv", base + ["--dashboard"]):
-            self.assertTrue(uniview.ParseArguments().dashboard)
-        with patch.object(sys, "argv", base + ["--pdf"]), contextlib.redirect_stderr(io.StringIO()):
-            with self.assertRaises(SystemExit):
-                uniview.ParseArguments()
-
-    def run_pdf_mode(self, directory, metrics_header, link, options):
-        """Run the default PDF mode and return the options it forwards."""
-        root = Path(directory)
-        trace = root / "trace.json"
-        trace.write_text(json.dumps({"traceEvents": [{"args": {"metrics": link}}]}))
-        metrics = root / "metrics.csv"
-        metrics.write_text(metrics_header + "\nkernel,100,1\n")
-        argv = ["uniview.py", "-t", str(trace), "-m", str(metrics)] + options
-        with patch.object(sys, "argv", argv), patch.object(uniview, "LoadTrace"), patch.object(
-            uniview.apm, "main"
-        ) as run, patch.object(uniview.apm, "ParseArguments") as parse:
-            self.assertIsNone(uniview.main())
-        run.assert_called_once_with(parse.return_value)
-        return parse.call_args[0][0], str(metrics)
-
-    def test_pdf_mode_forwards_stall_options(self):
-        with tempfile.TemporaryDirectory() as directory:
-            forwarded, metrics = self.run_pdf_mode(
-                directory,
-                '\nKernel,Pid,KernelId\n"kernel",1,2\nSource,Offset,Instruction,Dependency,Active[Events]',
-                "http://localhost:8000/kernel/9",
-                ["-n", "3"],
-            )
-        self.assertEqual(forwarded, ["-n", "3", "-q", metrics])
-
-    def test_pdf_mode_forwards_config_and_https_links(self):
-        with tempfile.TemporaryDirectory() as directory:
-            config = Path(directory) / "view.txt"
-            config.write_text("")
-            forwarded, metrics = self.run_pdf_mode(
-                directory, "Kernel,GlobalInstanceId,Active[%]",
-                "https://localhost:8000/kernel/9", ["-f", str(config)],
-            )
-        self.assertEqual(forwarded, ["-f", str(config), "-p", metrics])
-
-
-if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
diff --git a/tools/unitrace/test/tests.txt b/tools/unitrace/test/tests.txt
deleted file mode 100644
index 3b8f13ca..00000000
--- a/tools/unitrace/test/tests.txt
+++ /dev/null
@@ -1,438 +0,0 @@
-# ============================================================================
-# Unitrace test suite definition (consumed by test_unitrace.py).
-# Run 'python test_unitrace.py --list' to see the resolved matrix.
-#
-# Each [name] block defines one test. Keys:
-#
-#   command  = <command line>
-#       What to run (paths relative to this directory).
-#       - run_test.py commands are executed once per resolved scenario,
-#         with --scenario=<value> appended, after one "native" run of the
-#         bare application (driver/environment sanity check).
-#       - Any other command (e.g. a check script) is scenario-independent
-#         and runs as-is.
-#       - Leading NAME=VALUE tokens set environment variables for this
-#         test only, e.g.:  command = FOO=1 run_test.py kuku GPU
-#       - Placeholders: {python}   = the python interpreter
-#                       {unitrace} = the unitrace binary under test
-#                       {bin}      = the directory the test workloads are installed in
-#                       {fuzz_bin} = the C++ fuzz_* binaries (fuzz build)
-#       - A scenario-independent command that cannot run here exits with
-#         status 77; the test is reported as Skipped.
-#
-#   options  = <unitrace options>
-#       Unitrace options shared by ALL scenarios of this test, appended to
-#       every scenario before the run (keeps scenario lines down to what
-#       actually varies):
-#           options  = --opencl
-#           scenario = -c            -->  runs "unitrace -c --opencl ..."
-#           scenario = -h            -->  runs "unitrace -h --opencl ..."
-#
-#   platform = <OS> [<OS>...]
-#       On which OS this test exists at all (Windows, Linux). A test absent
-#       here never runs there, regardless of scenarios. Omitted: inherited
-#       from [defaults].
-#
-#   requires = <FEATURE> [<FEATURE>...]
-#       Unitrace build features the test needs (L0, OPENCL, ITT, XPTI, MPI,
-#       OMP, PERFETTO - the "build" keys of 'unitrace --print-options-schema').
-#       If the unitrace under test was built without any of them, the test is
-#       reported as Skipped instead of run. Omitted: inherited from
-#       [defaults]. 'requires = none' means no requirement (the test always
-#       runs); an empty value or an unknown feature name is an error.
-#
-#   scenario = <unitrace options>
-#       One scenario per line; the test runs once per line.
-#       - If a block has NO scenario lines, it inherits the full [defaults]
-#         scenario list.
-#       - If it has ANY applicable scenario lines, those REPLACE the
-#         defaults completely (they do not add to them).
-#
-#   defaults-scenario = True | False   (case-insensitive)
-#       Overrides that implicit choice explicitly:
-#       - True: include the [defaults] list in addition to the block's own
-#         scenario lines (common matrix + per-test extras):
-#             defaults-scenario = True
-#             scenario          = -k
-#       - False with no scenario lines: an empty matrix - the test runs
-#         exactly once, with only its 'options' (plus the native run).
-#
-#   skip-scenario = <unitrace options>
-#       Removes scenarios from the inherited/declared list. A skip line
-#       matches every scenario that CONTAINS ALL of its tokens, in any
-#       order, with or without extra tokens. Examples against defaults:
-#           skip-scenario = -q
-#               removes "-q" and "-q --result-dir"
-#           skip-scenario = --result-dir
-#               removes all eight "... --result-dir" variants
-#           skip-scenario = -q --result-dir
-#               removes only "-q --result-dir" (both tokens required)
-#
-# ----------------------------------------------------------------------------
-# Per-platform lines: scenario, skip-scenario and options accept an :OS
-# qualifier (OS = Windows or Linux). Unqualified lines apply to every OS;
-# ":OS" lines apply only there.
-#
-# Resolution, done independently per OS:
-#   1. platform gate: if the current OS is not in 'platform', the test
-#      does not run here. Done.
-#   2. Collect scenario lines that apply here (unqualified + :thisOS).
-#      Non-empty -> that is the scenario list. Empty -> take [defaults].
-#   3. Remove everything matched by applicable skip-scenario lines
-#      (unqualified + :thisOS).
-#   4. Append applicable 'options' to each remaining scenario.
-#
-# Examples:
-#
-#   Different matrix per OS (own lines on both sides):
-#       [kuku]
-#       command          = run_test.py kuku GPU
-#       scenario:Linux   = -c
-#       scenario:Linux   = -q
-#       scenario:Windows = -h
-#     Linux runs -c and -q; Windows runs -h. Defaults unused.
-#
-#   Shared lines plus per-OS extras:
-#       scenario         = -c        # both
-#       scenario:Linux   = -q        # Linux also runs -q
-#     Linux: -c, -q.  Windows: -c.
-#
-#   Own scenarios on one OS only:
-#       scenario:Windows = -h
-#     Windows runs just -h. Linux has no applicable lines -> full defaults.
-#
-#   Defaults everywhere, trimmed on one OS:
-#       skip-scenario:Windows = -q
-#     Linux: all 16 defaults. Windows: 14 (both -q variants removed).
-#
-#   Test exists on one OS only:
-#       platform = Linux
-#     Runs the resolved scenarios on Linux; never runs on Windows.
-# ============================================================================
-
-[defaults]
-platform = Windows Linux
-requires = L0
-scenario = -c
-scenario = -h
-scenario = -d
-scenario = -t
-scenario = -s
-scenario = --chrome-call-logging --chrome-kernel-logging
-scenario = --chrome-device-logging
-scenario = -q
-scenario = -c --result-dir
-scenario = -h --result-dir
-scenario = -d --result-dir
-scenario = -t --result-dir
-scenario = -s --result-dir
-scenario = --chrome-call-logging --chrome-kernel-logging --result-dir
-scenario = --chrome-device-logging --result-dir
-scenario = -q --result-dir
-
-[cl_gemm]
-command  = run_test.py cl_gemm GPU
-requires = OPENCL
-options  = --opencl
-scenario = -c
-scenario = -d -v
-scenario = --chrome-call-logging --chrome-kernel-logging
-scenario = -h
-scenario = -s
-
-[cl_gemm_metric]
-command  = run_test.py cl_gemm GPU 4096
-requires = OPENCL
-options  = --opencl
-scenario = -k
-scenario = --result-dir -k
-
-[conditional_trace]
-platform = Linux
-command  = run_test.py conditional_trace GPU
-requires = OPENCL
-options  = --opencl --start-paused
-scenario = -d
-
-[dpc_gemm]
-command  = run_test.py dpc_gemm GPU
-
-[mpi_test_4_ranks_filter_0_2]
-platform = Linux
-command  = run_test.py --mpiexec -n 4 -t mpi_test_4_ranks_filter_0_2 device_and_rank_to_sample
-requires = L0 MPI
-options  = --ranks-to-sample 0,2
-scenario = -d
-scenario = -d --result-dir
-
-[mpi_test_1_rank_sample_device_0]
-platform = Linux
-command  = run_test.py --mpiexec -n 1 -t mpi_test_1_rank_sample_device_0 device_and_rank_to_sample
-requires = L0 MPI
-options  = --devices-to-sample 0
-scenario = -d
-scenario = -d --result-dir
-
-[mpi_test_1_rank_sample_device_256]
-platform = Linux
-command  = run_test.py --mpiexec -n 1 -t mpi_test_1_rank_sample_device_256 device_and_rank_to_sample
-requires = L0 MPI
-options  = --devices-to-sample 256
-scenario = -d
-
-[print_options_schema]
-command           = cpp_test/print_options_schema/check_options_schema.py {unitrace}
-requires          = none
-defaults-scenario = False
-
-[metric_config_parser]
-command           = cpp_test/metric_config/check_config_node.py {bin}
-requires          = none
-defaults-scenario = False
-
-[event_reset_immediate_cl]
-command  = run_test.py event_reset -- -im
-scenario = -h
-
-[event_reset_cl_with_fence]
-command  = run_test.py event_reset -- -1nicl -f
-scenario = -h
-
-[event_reset_cl_with_barrier]
-command  = run_test.py event_reset -- -1nicl -b
-scenario = -h
-
-[event_reset_cl_with_queue_sync]
-command  = run_test.py event_reset -- -1nicl
-scenario = -h
-
-[gemm_stall_sampling_scenario1]
-platform = Linux
-command  = run_test.py -e cpp_test/gemm_stall_sampling/check_outfiles.py -t gemm_stall_sampling_scenario1 gemm_stall_sampling --scenario 1 --size 256 --iterations 2
-scenario = --stall-sampling
-
-[gemm_stall_sampling_scenario2]
-platform = Linux
-command  = run_test.py -e cpp_test/gemm_stall_sampling/check_outfiles.py -t gemm_stall_sampling_scenario2 gemm_stall_sampling --scenario 2 --size 256 --iterations 2
-scenario = --stall-sampling
-
-[gemm_stall_sampling_scenario3]
-platform = Linux
-command  = run_test.py -e cpp_test/gemm_stall_sampling/check_outfiles.py -t gemm_stall_sampling_scenario3 gemm_stall_sampling --scenario 3 --size 256 --iterations 2
-scenario = --stall-sampling
-
-[gemm_stall_sampling_scenario4]
-platform = Linux
-command  = run_test.py -e cpp_test/gemm_stall_sampling/check_outfiles.py -t gemm_stall_sampling_scenario4 gemm_stall_sampling --scenario 4 --size 256 --iterations 2
-scenario = --stall-sampling
-
-[graph]
-command       = run_test.py graph
-skip-scenario = -t
-
-[selective_kernels]
-command  = run_test.py -e cpp_test/graph/check_outfiles.py graph
-options  = -d
-scenario = --include-kernels not_exists
-scenario = --include-kernels sycl
-scenario = --exclude-kernels sycl
-scenario = --include-kernels sycl --exclude-kernels 2},EE1_
-
-[grf]
-platform      = Linux
-command       = run_test.py grf
-skip-scenario = --result-dir
-
-[internal_conditional_trace]
-command           = run_test.py internal_conditional_trace GPU
-requires          = L0 ITT
-options           = --start-paused
-defaults-scenario = True
-scenario          = -k
-skip-scenario     = --result-dir
-
-[omp_gemm]
-command  = run_test.py omp_gemm GPU
-requires = L0 OMP
-
-[omp_cpu_gemm]
-command  = run_test.py omp_cpu_gemm
-requires = L0 OMP
-scenario = --chrome-omp-logging
-
-[sycl_graph_with_v2_adaptor]
-command  = SYCL_UR_USE_LEVEL_ZERO_V2=1 run_test.py sycl_graph_with_v2_adaptor
-
-[temporal]
-command  = run_test.py temporal
-options  = --session test --start-paused
-scenario = -d
-scenario = --chrome-call-logging --chrome-kernel-logging
-scenario = -h
-scenario = -t
-
-[ze_gemm]
-command  = run_test.py ze_gemm
-
-[ze_gemm_metric]
-command  = run_test.py ze_gemm 4096
-scenario = -k
-scenario = -q
-
-# Reduced ze_gemm for pre-silicon simulation, where the default case
-# (1024x1024, 4 repeats, full scenario matrix) exceeds a 2 h task timeout.
-[ze_gemm_presi]
-platform = Linux
-command  = run_test.py ze_gemm 128 1
-scenario = -c
-scenario = -h
-scenario = --chrome-kernel-logging
-
-# Ctrl-C (SIGINT to the whole job) or `kill` (SIGTERM to unitrace) during a long
-# -k run: unitrace must handle it on the main thread, stop the metric profiler
-# and write the metric files, without hanging or aborting (UNITRACEI-103). The
-# workload runs far longer than --signal-after; the signal ends the run.
-[ze_gemm_metric_sigint]
-platform = Linux
-command  = run_test.py --signal=SIGINT --signal-after=5 ze_gemm 1024 1000000
-scenario = -k
-
-[ze_gemm_metric_sigterm]
-platform = Linux
-command  = run_test.py --signal=SIGTERM --signal-after=5 ze_gemm 1024 1000000
-scenario = -k
-
-[ze_grph_api]
-platform      = Windows
-command       = run_test.py ze_graph_api
-skip-scenario = -q
-
-[ze_counterbased_events]
-platform = Linux
-command  = run_test.py -e cpp_test/ze_counterbased_events/check_outfiles.py ze_counterbased_events
-scenario = --chrome-device-logging
-
-[vec_add]
-platform = Linux
-command  = run_test.py -t vec_add {python} python_test/vec_add/vecAdd.py
-
-[mat_mul]
-platform      = Linux
-command       = run_test.py -t mat_mul {python} python_test/mat_mul/matMul.py
-skip-scenario = -q
-
-# ----------------------------------------------------------------------------
-# Fuzz tests (part of cpp-test, test/fuzz/README.md): replay each target's seed
-# corpus and crash inputs. No GPU needed; test_unitrace.py builds the C++
-# targets with clang into <unitrace build>/test/fuzz_build ({fuzz_bin}). A
-# target that cannot run here (no clang with libFuzzer, no atheris) is
-# reported as Skipped.
-# ----------------------------------------------------------------------------
-
-[fuzz_cli_args]
-command           = fuzz/replay.py cli_args {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_elf64]
-command           = fuzz/replay.py elf64 {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_env_numbers]
-command           = fuzz/replay.py env_numbers {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_kernel_filter]
-command           = fuzz/replay.py kernel_filter {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_kernel_props]
-command           = fuzz/replay.py kernel_props {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_kmd_trace]
-command           = fuzz/replay.py kmd_trace {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_metric_query]
-command           = fuzz/replay.py metric_query {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_metric_samples]
-command           = fuzz/replay.py metric_samples {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_sample_lists]
-command           = fuzz/replay.py sample_lists {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_stall_sampling]
-command           = fuzz/replay.py stall_sampling {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_trace_json]
-command           = fuzz/replay.py trace_json {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_analyzeperfmetrics]
-command           = fuzz/replay.py analyzeperfmetrics {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_categorize]
-command           = fuzz/replay.py categorize {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_mergetrace]
-command           = fuzz/replay.py mergetrace {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_metrics_server]
-command           = fuzz/replay.py metrics_server {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_perfdashboard_upload]
-command           = fuzz/replay.py perfdashboard_upload {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_roofline_csv]
-command           = fuzz/replay.py roofline_csv {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
-
-[fuzz_summary]
-command           = fuzz/replay.py summary {fuzz_bin}
-platform          = Linux
-requires          = none
-defaults-scenario = False
diff --git a/tools/unitrace/test/trace_format_test.py b/tools/unitrace/test/trace_format_test.py
deleted file mode 100644
index c64531dc..00000000
--- a/tools/unitrace/test/trace_format_test.py
+++ /dev/null
@@ -1,262 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Timeline trace-format test entry point (CI: Unitrace-trace-format): verifies the
-# json and protobuf timeline outputs describe the same work. For each scenario
-# (apps x chrome flags, Level Zero + OpenCL, device- vs call-logging) it drives
-# unitrace TWICE on the same app (json and protobuf) and checks equivalence, flow
-# direction, smaller protobuf size, and a structural cross-check via Perfetto's
-# own traceconv (downloaded to the build tree if not cached).
-#
-# unitrace emits ONE format per run, so the two runs differ in kernel timing;
-# anything timing-dependent (timestamps, track names, device lane packing) is not
-# comparable, so equivalence is on the slice-NAME MULTISET. The protobuf is parsed
-# with protoc-generated bindings (see trace_compare.py). --app/--scenario run a
-# subset. Fails hard on any mismatch or if protobuf support is unavailable (CI
-# builds with BUILD_WITH_PERFETTO=ON).
-
-import argparse
-import glob
-import os
-import platform
-import subprocess
-import sys
-import tempfile
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(0, os.path.join(HERE, "trace_utils"))
-import trace_compare
-import perfetto_vs_json_e2e
-import test_layout
-
-# Built executables carry a .exe suffix on Windows
-_EXE = ".exe" if platform.system() == "Windows" else ""
-DEFAULT_UNITRACE = os.path.normpath(os.path.join(HERE, "..", "build", "unitrace" + _EXE))
-BUILD_DIR = os.path.join(HERE, "cpp_test", "build")
-
-
-# Build the cpp_test apps (cmake + ninja) and install them into
-# <unitrace build>/test/bin, the same way test_unitrace.py does.
-def build_test_apps(targets, unitrace_build_dir):
-  os.makedirs(BUILD_DIR, exist_ok=True)
-  print("[INFO] building cpp_test apps in {}".format(BUILD_DIR))
-  targets = sorted(set(targets))
-  steps = [["cmake", "..", "-G", "Ninja", "-DCMAKE_BUILD_TYPE=Release"],
-           ["ninja", "-k", "0"] + targets]
-  # One install per target: an app that failed to build must not stop the
-  # others from being installed.
-  steps += [["cmake", "--install", ".", "--prefix", test_layout.test_root(unitrace_build_dir),
-             "--component", t] for t in targets]
-  test_layout.remove_flat_bin_files(unitrace_build_dir)
-  for i, step in enumerate(steps):
-    try:
-      rc = subprocess.run(step, cwd=BUILD_DIR).returncode
-    except FileNotFoundError:
-      rc = "{!r} not found".format(step[0])
-    if rc != 0:
-      print("[WARN] cpp_test build step {} failed ({}); continuing with the apps "
-            "that did build. Ensure oneAPI (icx/IntelSYCL) and cmake/ninja are on "
-            "PATH to build every SYCL/OpenCL scenario.".format(step[0], rc))
-      # ninja -k 0 still builds the targets it can, and each install is
-      # independent, so only a failed configure stops here.
-      if i == 0:
-        return
-
-# The scenario matrix. Each entry drives both formats and compares them. Flags
-# are chosen to cover distinct emitter paths:
-#   - call+kernel logging exercises the host API slices + the H2D flow records
-#     (the flow-arrow path that differs most between formats);
-#   - device logging alone exercises only the device (gpu_op) slices, no host
-#     flows;
-#   - cl_gemm drives the OpenCL collector/emitter; ze_/dpc_ drive Level Zero.
-SCENARIOS = [
-    {"name": "ze_call_kernel",  "app": "ze_gemm",
-     "flags": ["--chrome-call-logging", "--chrome-kernel-logging"]},
-    {"name": "ze_device",       "app": "ze_gemm",
-     "flags": ["--chrome-device-logging"]},
-    {"name": "cl_call_kernel",  "app": "cl_gemm",
-     "flags": ["--chrome-call-logging", "--chrome-kernel-logging", "--opencl"]},
-    {"name": "dpc_call_kernel", "app": "dpc_gemm",
-     "flags": ["--chrome-call-logging", "--chrome-kernel-logging"]},
-    {"name": "cl_device",       "app": "cl_gemm",
-     "flags": ["--chrome-device-logging", "--opencl"]},
-]
-
-
-def run_unitrace(unitrace, fmt, chrome_flags, app, app_args, out_dir):
-  os.makedirs(out_dir, exist_ok=True)
-  cmd = [unitrace] + list(chrome_flags)
-  if fmt == "protobuf":
-    cmd += ["--output-format", "protobuf"]
-  cmd += ["--output-dir-path", out_dir, app] + app_args
-  r = subprocess.run(cmd, capture_output=True, text=True)
-  if r.returncode != 0:
-    print("[ERROR] unitrace ({}) failed rc={}\n{}".format(fmt, r.returncode, r.stderr))
-    sys.exit(1)
-  # With --output-dir-path the trace is named <app>.<pid>.<ext> (the
-  # chrome_trace.<ext> name is only used under --result-dir). Each format runs
-  # into its own dir, so there is exactly one matching file to discover.
-  ext = "pftrace" if fmt == "protobuf" else "json"
-  matches = glob.glob(os.path.join(out_dir, "*." + ext))
-  if not matches:
-    print("[ERROR] no *.{} trace produced in {} (stderr:\n{})".format(ext, out_dir, r.stderr))
-    sys.exit(1)
-  if len(matches) > 1:
-    print("[ERROR] expected one *.{} trace in {}, found {}".format(ext, out_dir, matches))
-    sys.exit(1)
-  return matches[0]
-
-
-# Smallest protobuf advantage we require on file size. Protobuf (varint ints, no
-# quoting/whitespace) is well under half the JSON size in practice; 25% smaller is
-# a conservative floor that still catches a regression to a bloated encoding.
-_MIN_SIZE_SAVING = 0.25
-
-
-def check_size(name, json_bytes, pb_bytes):
-  size_saving = 1.0 - (pb_bytes / json_bytes) if json_bytes else 0.0
-  if size_saving < _MIN_SIZE_SAVING:
-    return ["protobuf trace not enough smaller than json: {}B vs {}B "
-            "({:.0%} < required {:.0%})".format(
-                pb_bytes, json_bytes, size_saving, _MIN_SIZE_SAVING)]
-  return []
-
-
-# Run one scenario (one app + flag set) in both formats and compare. Returns a
-# list of error strings (empty == passed); does not exit, so the matrix driver
-# can run every scenario and report all failures together.
-def compare_scenario(unitrace, name, chrome_flags, app, app_args):
-  # Host<->device flow arrows exist only when host API calls are logged
-  # alongside kernels; device-only logging emits kernel flow_ids with no host
-  # endpoint to pair with, so flow validation is gated on call+kernel logging.
-  check_flows = ("--chrome-call-logging" in chrome_flags
-                 and "--chrome-kernel-logging" in chrome_flags)
-
-  errors = []
-  with tempfile.TemporaryDirectory() as tmp:
-    json_path = run_unitrace(unitrace, "json", chrome_flags, app, app_args, os.path.join(tmp, "json"))
-    pb_path = run_unitrace(unitrace, "protobuf", chrome_flags, app, app_args, os.path.join(tmp, "pb"))
-    json_bytes = os.path.getsize(json_path)
-    pb_bytes = os.path.getsize(pb_path)
-    j = trace_compare.fingerprint_json(json_path)
-    p = trace_compare.fingerprint_protobuf(pb_path)
-    n_flows, flow_errors = (trace_compare.validate_protobuf_flows(pb_path) if check_flows else (0, []))
-    # An empty json fingerprint means the timeline is truncated (trace_compare
-    # reports the details) or empty. There is nothing to compare against, and
-    # traceconv would parse the same unparsable file, so record the failure and
-    # skip the cross-check instead of letting it raise: this scenario fails and the
-    # matrix driver still runs the rest.
-    json_ok = j["num_tracks"] != 0 and sum(j["slice_names"].values()) != 0
-    if not json_ok:
-      errors.append("[{}] json trace has no tracks/slices (truncated or empty).".format(name))
-    # Second engine: the protobuf trace also round-trips through Perfetto's own
-    # traceconv and must match the json structure (must run before tempdir cleanup).
-    elif not perfetto_vs_json_e2e.compare_traces(pb_path, json_path):
-      errors.append("[{}] traceconv structural compare failed".format(name))
-
-  # The protobuf trace must independently be well-formed.
-  if p["num_tracks"] == 0 or sum(p["slice_names"].values()) == 0:
-    errors.append("[{}] protobuf trace has no tracks/slices (malformed or empty).".format(name))
-
-  # The compact binary format must be meaningfully smaller than the text JSON.
-  errors += check_size(name, json_bytes, pb_bytes)
-
-  # Equivalence = identical slice-name multiset (same operations, same counts),
-  # ignoring the event APIs (see trace_compare.EXCLUDED_SLICE_NAMES).
-  diff = [(n, j["slice_names"].get(n, 0), p["slice_names"].get(n, 0))
-          for n in (set(j["slice_names"]) | set(p["slice_names"]))
-          if n not in trace_compare.EXCLUDED_SLICE_NAMES
-          and j["slice_names"].get(n, 0) != p["slice_names"].get(n, 0)]
-  if diff:
-    msg = ["[{}] slice-name multiset differs between json and protobuf (name, json, proto):".format(name)]
-    for d in sorted(diff)[:30]:
-      msg.append("    {!r} {} {}".format(*d))
-    errors.append("\n".join(msg))
-
-  # Flow arrows must be well-formed (begin -> step -> terminate-while-active).
-  for fe in flow_errors:
-    errors.append("[{}] {}".format(name, fe))
-  if check_flows and n_flows == 0 and not flow_errors:
-    errors.append("[{}] no host<->device flows found (expected with "
-                  "call+kernel logging).".format(name))
-  return errors
-
-
-def main():
-  ap = argparse.ArgumentParser(description="Compare unitrace json vs protobuf timeline output (same app, two runs).")
-  ap.add_argument("--unitrace", default=DEFAULT_UNITRACE, help="path to built unitrace")
-  ap.add_argument("--unitrace-build-dir", default=None,
-                  help="unitrace build directory; the apps are installed into "
-                       "<dir>/test/bin (default: tools/unitrace/build)")
-  ap.add_argument("--app", default=None, help="single test app to trace (overrides the scenario matrix)")
-  ap.add_argument("--scenario", default=None, help="run only the matrix scenario with this name")
-  ap.add_argument("--app-args", nargs=argparse.REMAINDER, default=[], help="args for the app (after --)")
-  ap.add_argument("--no-build", action="store_true",
-                  help="do not build the cpp_test apps; use whatever is already built")
-  args = ap.parse_args()
-
-  if not os.path.exists(args.unitrace):
-    print("[ERROR] unitrace not found at {} (build it first).".format(args.unitrace))
-    sys.exit(1)
-  app_args = args.app_args[1:] if args.app_args and args.app_args[0] == "--" else args.app_args
-
-  # --app: single ad-hoc run with the default call+kernel flags. Otherwise run
-  # the scenario matrix (optionally filtered by --scenario).
-  if args.app:
-    scenarios = [{"name": "custom", "app": args.app,
-                  "flags": ["--chrome-call-logging", "--chrome-kernel-logging"], "abs_app": args.app}]
-  else:
-    error = test_layout.default_build_dir_error(args.unitrace_build_dir)
-    if error:
-      print(error)
-      sys.exit(1)
-    scenarios = []
-    for s in SCENARIOS:
-      if args.scenario and s["name"] != args.scenario:
-        continue
-      s = dict(s)
-      s["abs_app"] = test_layout.workload_exe(test_layout.bin_dir(args.unitrace_build_dir), s["app"])
-      scenarios.append(s)
-    if not scenarios:
-      print("[ERROR] no scenario matched --scenario {!r}".format(args.scenario))
-      sys.exit(1)
-
-  # Build the apps the selected scenarios need up front (like test_unitrace.py), so
-  # nothing is skipped just because it was not pre-built. The scenario's "app" is
-  # its ninja target and install component. Skip only for --app (an arbitrary
-  # path) or when explicitly disabled.
-  if not args.app and not args.no_build:
-    build_test_apps([s["app"] for s in scenarios], args.unitrace_build_dir)
-
-  RED = "\033[31m"
-  RESET = "\033[0m"
-  print("Start testing...")
-  ran = 0
-  failed = 0
-  for s in scenarios:
-    label = s["name"] + " " + " ".join(s["flags"])
-    if not os.path.exists(s["abs_app"]):
-      print("{} : {} : Skipped (app not built)".format(ran + 1, label))
-      continue
-    ran += 1
-    errors = compare_scenario(args.unitrace, s["name"], s["flags"], s["abs_app"], app_args)
-    if errors:
-      failed += 1
-      print("{}{} : {} : Failed{}".format(RED, ran, label, RESET))
-      for e in errors:
-        print("    " + e.replace("\n", "\n    "))
-    else:
-      print("{} : {} : Passed".format(ran, label))
-
-  if ran == 0:
-    print("[ERROR] no scenario apps were built; nothing compared.")
-    sys.exit(1)
-  print("{}/{} scenarios passed.".format(ran - failed, ran))
-  sys.exit(1 if failed else 0)
-
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/test/trace_utils/perfetto_vs_json_e2e.py b/tools/unitrace/test/trace_utils/perfetto_vs_json_e2e.py
deleted file mode 100644
index 46e2e49a..00000000
--- a/tools/unitrace/test/trace_utils/perfetto_vs_json_e2e.py
+++ /dev/null
@@ -1,194 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# Convert a Perfetto protobuf trace to JSON with Perfetto's own traceconv and
-# check it has the same timeline STRUCTURE (track + slice-name multiset) as the
-# legacy direct-JSON trace of the same workload -- a cross-check via the real
-# Perfetto toolchain. Structural only: traceconv emits us timestamps, and the two
-# traces come from separate runs, so exact timing is not comparable. traceconv is
-# fetched version-pinned (or UNITRACE_TRACECONV) and cached.
-
-import argparse
-import hashlib
-import json
-import os
-import platform
-import re
-import subprocess
-import sys
-import urllib.request
-
-# Same directory; on sys.path both when imported by trace_format_test.py (which adds
-# trace_utils/) and when this file is run as a script.
-import trace_compare
-
-# Fetch the launcher from the immutable ${PERFETTO_TAG} git path, not the rolling
-# get.perfetto.dev pointer (whose hash changes on every upstream roll). The launcher
-# self-verifies the native binary it downloads, so pinning its one hash suffices.
-_LAUNCHER_URL = "https://raw.githubusercontent.com/google/perfetto/{tag}/tools/traceconv"
-
-# tools/traceconv launcher sha256 per PERFETTO_TAG. To bump: change PERFETTO_TAG in
-# cmake/Perfetto.cmake, fetch that tag's launcher, verify it, add its hash here.
-LAUNCHER_SHA256 = {
-    "v56.1": "6592b882ca8c49b9511124431676df5a49a236b8cd1d0788e009e3bd89cb0922",
-}
-
-
-def fail(msg):
-  print("[ERROR] " + msg, file=sys.stderr)
-  sys.exit(1)
-
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-# Cache traceconv in the unitrace build tree (next to the protoc/proto the build
-# already produces), so it persists across runs and is co-located with the build.
-_BUILD_DIR = os.path.normpath(os.path.join(_HERE, "..", "..", "build"))
-_PERFETTO_CMAKE = os.path.normpath(os.path.join(_HERE, "..", "..", "cmake", "Perfetto.cmake"))
-
-
-# Read PERFETTO_TAG from cmake/Perfetto.cmake (single source of truth with the proto).
-def perfetto_tag():
-  try:
-    text = open(_PERFETTO_CMAKE).read()
-  except OSError as ex:
-    fail("could not read PERFETTO_TAG from {}: {}".format(_PERFETTO_CMAKE, ex))
-  m = re.search(r'set\(PERFETTO_TAG\s+"([^"]+)"', text)
-  if not m:
-    fail("PERFETTO_TAG not found in {}".format(_PERFETTO_CMAKE))
-  return m.group(1)
-
-
-def get_traceconv():
-  override = os.environ.get("UNITRACE_TRACECONV")
-  if override:
-    if os.path.exists(override):
-      return override
-    fail("UNITRACE_TRACECONV={} does not exist".format(override))
-  tag = perfetto_tag()
-  expected = LAUNCHER_SHA256.get(tag)
-  if not expected:
-    fail("no vetted traceconv launcher sha256 for PERFETTO_TAG={}; fetch {}, "
-         "verify it, and add its hash to LAUNCHER_SHA256 (or set "
-         "UNITRACE_TRACECONV).".format(tag, _LAUNCHER_URL.format(tag=tag)))
-  # Cache per tag so a bump fetches fresh instead of trusting the old launcher.
-  cache = os.path.join(_BUILD_DIR, "traceconv-{}".format(tag))
-  if os.path.exists(cache):
-    # Re-verify the cached copy so a stale/tampered file is not trusted.
-    if hashlib.sha256(open(cache, "rb").read()).hexdigest() != expected:
-      os.remove(cache)
-  if not os.path.exists(cache):
-    url = _LAUNCHER_URL.format(tag=tag)
-    # Defense in depth for the sha256-pinned download below: the URL comes from
-    # the https constant above, so any other scheme means tampering.
-    if not url.startswith("https://"):
-      fail("refusing non-https traceconv URL: {}".format(url))
-    try:
-      os.makedirs(_BUILD_DIR, exist_ok=True)
-      # nosec B310: https enforced above; the payload is sha256-verified below
-      # against the pinned launcher hash before it is written or used.
-      with urllib.request.urlopen(url, timeout=60) as resp:  # nosec B310
-        data = resp.read()
-    except Exception as ex:
-      fail("could not download traceconv ({}): {}".format(url, ex))
-    digest = hashlib.sha256(data).hexdigest()
-    if digest != expected:
-      fail("traceconv launcher sha256 mismatch for {}: got {}, expected {} "
-           "(immutable git blob changed unexpectedly; set UNITRACE_TRACECONV to a "
-           "vetted binary).".format(tag, digest, expected))
-    with open(cache, "wb") as f:
-      f.write(data)
-    # Owner-only: the launcher is always invoked via sys.executable (see
-    # traceconv_to_json), so no execute or group/other bits are needed.
-    os.chmod(cache, 0o700)
-  return cache
-
-
-def traceconv_to_json(traceconv, in_file, out_file):
-  # The launcher is a python3 script (self-downloads its native binary); invoke it explicitly.
-  cmd = [sys.executable, traceconv, "json", in_file, out_file]
-  try:
-    r = subprocess.run(cmd, capture_output=True, text=True)
-  except Exception as ex:
-    fail("traceconv invocation failed: {}".format(ex))
-  if r.returncode != 0:
-    fail("traceconv returned {}:\n{}".format(r.returncode, r.stderr))
-
-
-from collections import Counter
-
-
-# Structural fingerprint of a Chrome-JSON trace: the multiset of slice ("X")
-# event names. Event names are format-invariant; absolute timestamps and the
-# pid/tid track *labels* are not (traceconv re-derives them), and the number of
-# device tracks varies run to run with engine/lane packing. The busy-wait APIs in
-# trace_compare.EXCLUDED_SLICE_NAMES are dropped, so this engine compares exactly
-# the same set of names as the direct-bindings compare in trace_compare.py.
-def slice_names_from_chrome_json(path):
-  # strict=False: the OpenCL path can embed raw control characters (e.g. NUL in a
-  # device name) that the default decoder rejects; harmless for the structural
-  # comparison here.
-  with open(path) as f:
-    data = json.loads(f.read(), strict=False)
-  events = data.get("traceEvents", data) if isinstance(data, dict) else data
-  name_counts = Counter()
-  for e in events:
-    if e.get("ph") == "X":
-      name = e.get("name", "")
-      if name not in trace_compare.EXCLUDED_SLICE_NAMES:
-        name_counts[name] += 1
-  return name_counts
-
-
-# Convert |protobuf| via traceconv and structurally compare it to |json|
-# Returns True on match. Importable by trace_format_test.py.
-def compare_traces(protobuf, json_path):
-  if not os.path.exists(protobuf):
-    fail("protobuf trace not found: {}".format(protobuf))
-  if not os.path.exists(json_path):
-    fail("json trace not found: {}".format(json_path))
-
-  # traceconv.exe has a Windows bug:
-  # its EXPORT_JSON step can't open its own temp file, so it exits 0 but emits no events.
-  # Skip this cross-check here; trace_compare.py already validates the protobuf.
-  if platform.system() == "Windows":
-    print("[WARN] skipping traceconv cross-check on Windows (traceconv.exe "
-          "EXPORT_JSON temp-file bug); protobuf validated by trace_compare.py.",
-          file=sys.stderr)
-    return True
-
-  traceconv = get_traceconv()
-  converted = protobuf + ".converted.json"
-  traceconv_to_json(traceconv, protobuf, converted)
-
-  proto_names = slice_names_from_chrome_json(converted)
-  json_names = slice_names_from_chrome_json(json_path)
-
-  if not json_names:
-    fail("no slices in the legacy json trace (nothing to compare)")
-
-  ok = True
-  if proto_names != json_names:
-    ok = False
-    print("[ERROR] slice-name multiset differs between protobuf->json and legacy json", file=sys.stderr)
-    for name in sorted(set(proto_names) | set(json_names)):
-      jc, pc = json_names.get(name, 0), proto_names.get(name, 0)
-      if jc != pc:
-        print("  {!r}: legacy json={}  protobuf->json={}".format(name, jc, pc), file=sys.stderr)
-  return ok
-
-
-def main():
-  parser = argparse.ArgumentParser(description="Compare protobuf(->traceconv json) vs legacy json trace structure.")
-  parser.add_argument("--protobuf", required=True, help=".pftrace file")
-  parser.add_argument("--json", required=True, help="legacy .json trace of the same workload")
-  args = parser.parse_args()
-  ok = compare_traces(args.protobuf, args.json)
-  print("[OK] trace structure matches (traceconv)" if ok else "[FAIL] trace structure differs")
-  sys.exit(0 if ok else 1)
-
-
-if __name__ == "__main__":
-  main()
diff --git a/tools/unitrace/test/trace_utils/trace_compare.py b/tools/unitrace/test/trace_utils/trace_compare.py
deleted file mode 100644
index 2e1daa71..00000000
--- a/tools/unitrace/test/trace_utils/trace_compare.py
+++ /dev/null
@@ -1,335 +0,0 @@
-#==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# =============================================================
-
-# The single library for parsing unitrace timeline traces (legacy Chrome JSON and
-# Perfetto protobuf). Everything that reads a trace lives here so callers don't
-# duplicate parsing; consumers are the per-test overlap checker
-# (cpp_test/ze_counterbased_events/check_outfiles.py) and the trace-format-test
-# orchestrator (trace_format_test.py).
-#
-# Two kinds of readers:
-#   - timing stats for the overlap guard: parse_timeline_stats[_perfetto] -> calc_stats
-#   - format-equivalence fingerprints / flow validation: fingerprint_json,
-#     fingerprint_protobuf, validate_protobuf_flows
-# Protobuf parsing uses pure protobuf bindings (no perfetto trace_processor / no
-# traceconv -- those would lose the int64-ns precision the format exists to keep);
-# the bindings are generated on demand by protoc from the build's perfetto_trace.proto.
-
-import importlib
-import os
-import platform
-import subprocess
-import sys
-import json
-from collections import Counter
-
-# tools/unitrace, three levels up (test/trace_utils/ -> test/ -> tools/unitrace/).
-_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
-_UNITRACE_DIR = os.path.normpath(os.path.join(_THIS_DIR, "..", ".."))
-_BUILD_DIR = os.path.join(_UNITRACE_DIR, "build")
-
-
-class Range:
-  def __init__(self, start, dur):
-    self.start = start
-    self.end = start + dur
-
-
-def calc_stats(name, rangevec):
-  min_gap = 0
-  max_gap = 0
-  idle = 0
-  total = 0
-  busy = 0
-  if (len(rangevec) > 0):
-    v = sorted(rangevec, key=lambda r: r.start)
-    first_ts = v[0].start
-    last_ts = v[len(v) - 1].end
-    total = last_ts - first_ts
-    busy = v[0].end - v[0].start
-    for i in range(1, len(v)):
-      busy += v[i].end - v[i].start
-      gap = v[i].start - v[i-1].end
-      if (i == 1):
-        min_gap = gap
-        max_gap = gap
-      elif (gap < min_gap):
-        min_gap = gap
-      elif (gap > max_gap):
-        max_gap = gap
-      if (gap > 0):
-        idle += gap
-  return {"name": name,
-          "total": total,
-          "busy": busy,
-          "idle": idle,
-          "min_gap": min_gap,
-          "max_gap": max_gap,
-          "overlaps": busy - (total - idle)
-         }
-
-
-def parse_timeline_stats(filename):
-  thread_names = {}
-  threads = {}
-
-  with open(filename, 'r') as fp:
-    try:
-      # strict=False: tolerate raw control chars (e.g. NUL in OpenCL device names).
-      data = json.loads(fp.read(), strict=False)
-    except Exception as ex:
-      print("File parse errors")
-      exit(-1)
-    if 'traceEvents' in data:
-      for e in data['traceEvents']:
-        if (e["ph"] == "M"):
-          if (e["name"] == "thread_name"):
-            pid_k = "{}_{}".format(e["pid"], e["tid"])
-            thread_names[pid_k] = e["args"]["name"]
-          elif (e["name"] == "process_name"):
-            pid_k = "{}_{}".format(e["pid"], e["pid"])
-            thread_names[pid_k] = e["args"]["name"]
-        elif (e["ph"] == "X" and e["cat"] == "gpu_op" and "pid" in e and "tid" in e):
-          pid_k = "{}_{}".format(e["pid"], e["tid"])
-          if (pid_k not in threads):
-            threads[pid_k] = []
-          r = Range(e["ts"], e["dur"])
-          threads[pid_k].append(r)
-    stats = []
-    for k in threads:
-      if (len(threads[k]) > 0):
-        stats.append(calc_stats(thread_names.get(k, k), threads[k]))
-    return stats
-
-
-def _import_perfetto_trace_pb2():
-  # Generate Python bindings on demand from the perfetto_trace.proto and protoc
-  # that the unitrace build produced. Resolve both from the build tree (env
-  # overrides UNITRACE_PERFETTO_PROTO / UNITRACE_PROTOC take precedence). There
-  # is no PATH fallback: protobuf support is a build requirement, so a missing
-  # proto/protoc is a hard error rather than a silent skip.
-  proto = os.environ.get("UNITRACE_PERFETTO_PROTO") or \
-      os.path.join(_BUILD_DIR, "perfetto", "perfetto_trace.proto")
-  protoc_exe = "protoc.exe" if platform.system() == "Windows" else "protoc"
-  protoc = os.environ.get("UNITRACE_PROTOC") or \
-      os.path.join(_BUILD_DIR, "protobuf-install", "bin", protoc_exe)
-  gen_dir = os.path.join(_THIS_DIR, "_perfetto_pb2")
-  module = os.path.join(gen_dir, "perfetto_trace_pb2.py")
-
-  if not os.path.exists(module):
-    if not os.path.exists(proto):
-      print("[ERROR] perfetto_trace.proto not found at {} (build unitrace with "
-            "BUILD_WITH_PERFETTO=ON, or set UNITRACE_PERFETTO_PROTO).".format(proto))
-      exit(-1)
-    if not os.path.exists(protoc):
-      print("[ERROR] protoc not found at {} (build unitrace with "
-            "BUILD_WITH_PERFETTO=ON, or set UNITRACE_PROTOC).".format(protoc))
-      exit(-1)
-    os.makedirs(gen_dir, exist_ok=True)
-    try:
-      subprocess.run([protoc, "--python_out=" + gen_dir,
-                      "--proto_path=" + os.path.dirname(proto), proto], check=True)
-    except subprocess.CalledProcessError:
-      print("[ERROR] failed to run protoc to generate perfetto_trace_pb2.")
-      exit(-1)
-
-  if gen_dir not in sys.path:
-    sys.path.insert(0, gen_dir)
-  try:
-    return importlib.import_module("perfetto_trace_pb2")
-  except ImportError:
-    print("[ERROR] could not import perfetto_trace_pb2 (the 'protobuf' pip "
-          "package is required).")
-    exit(-1)
-
-
-def parse_timeline_stats_perfetto(filename):
-  # Parse a Perfetto protobuf trace directly (no trace_processor dependency).
-  # The file is a sequence of single-packet Trace messages concatenated; protobuf
-  # message concatenation is itself a valid Trace, so one parse yields all packets.
-  # We pair TYPE_SLICE_BEGIN/END per track with a stack (Perfetto's nesting model)
-  # and compute the same per-track stats as the JSON path, in int ns.
-  pb = _import_perfetto_trace_pb2()
-  TE = pb.TrackEvent
-  with open(filename, "rb") as fp:
-    trace = pb.Trace()
-    trace.ParseFromString(fp.read())
-
-  track_names = {}    # uuid -> name (from TrackDescriptor)
-  open_slices = {}    # uuid -> stack of open begin timestamps
-  tracks = {}         # uuid -> list[Range]
-  for packet in trace.packet:
-    if packet.HasField("track_descriptor"):
-      d = packet.track_descriptor
-      name = d.name
-      if not name and d.HasField("thread"):
-        name = d.thread.thread_name
-      if not name and d.HasField("process"):
-        name = d.process.process_name
-      track_names[d.uuid] = name or str(d.uuid)
-    elif packet.HasField("track_event"):
-      ev = packet.track_event
-      uuid = ev.track_uuid
-      if ev.type == TE.TYPE_SLICE_BEGIN:
-        open_slices.setdefault(uuid, []).append(packet.timestamp)
-      elif ev.type == TE.TYPE_SLICE_END:
-        stack = open_slices.get(uuid)
-        if stack:
-          start = stack.pop()
-          tracks.setdefault(uuid, []).append(Range(start, packet.timestamp - start))
-
-  stats = []
-  for uuid in tracks:
-    if len(tracks[uuid]) > 0:
-      stats.append(calc_stats(track_names.get(uuid, str(uuid)), tracks[uuid]))
-  return stats
-
-
-# ---- format-equivalence fingerprints --------------------------------------
-# A fingerprint is the run- and format-invariant signal used to assert json and
-# protobuf describe the same work: the slice-NAME MULTISET (count per operation
-# name). Track identity / lane packing / timestamps are NOT compared -- they
-# differ across the two separate runs and across the formats by design.
-
-# Slice names excluded from every equivalence compare. These are non-deterministic
-# APIs the runtime calls in a busy-wait loop until the work completes, so their call
-# count tracks how long each run happened to take rather than the work performed.
-# The traces being compared always come from two separate runs, which differ in
-# timing by design, so these counts are not comparable; every other slice name still
-# has to match exactly. Lives here so both compare engines (the direct
-# protobuf-bindings fingerprints below and the traceconv round-trip in
-# perfetto_vs_json_e2e.py) filter the same set.
-EXCLUDED_SLICE_NAMES = frozenset([
-    "zeEventHostSynchronize",
-    "zeEventQueryStatus",
-])
-
-
-def _summarize(tracks):
-  slice_names = Counter()
-  for slices in tracks.values():
-    for s in slices:
-      slice_names[s] += 1
-  return {"num_tracks": len(tracks), "slice_names": slice_names}
-
-
-def _check_json_complete(path, text):
-  # A complete unitrace JSON timeline ends with the "\n]\n}\n" tags that
-  # ChromeLogger writes when it closes the trace. Their absence means the traced
-  # process died without finalizing the logger, so the tail of the trace is still
-  # in the ofstream buffer and the file ends mid-record. Diagnose that here: the
-  # raw JSONDecodeError ("Expecting ',' delimiter") points at the end of the file
-  # and reads like malformed output rather than a truncated write. Report it and
-  # return False rather than exiting, so the caller can fail just this scenario and
-  # the matrix driver still runs the remaining ones; the tail is never repaired,
-  # since that would hide real data loss.
-  # Compare with whitespace stripped out of the tail so the check is independent of
-  # newline style (the writer emits CRLF on Windows) and of the trailing newline.
-  if "".join(text[-16:].split()).endswith("]}"):
-    return True
-  tail = text[-120:].replace("\n", "\\n")
-  print("[ERROR] truncated timeline {}: the JSON closing tags are missing, so the "
-        "traced process exited without finalizing the trace (unitrace's buffered "
-        "writes never reached disk). {} bytes, ends with:\n    ...{}".format(
-            path, len(text), tail))
-  return False
-
-
-def fingerprint_json(path):
-  # strict=False: the OpenCL path can embed raw control characters in kernel
-  # names/args, which the default (strict) decoder rejects; harmless here since we
-  # only look at slice names.
-  with open(path) as f:
-    text = f.read()
-
-  # A truncated trace cannot be parsed at all (json.loads would raise on the
-  # cut-off record and abort the whole run), so return an empty fingerprint: the
-  # error is already reported and the caller sees a mismatch for this scenario.
-  if not _check_json_complete(path, text):
-    return _summarize({})
-
-  data = json.loads(text, strict=False)
-  tracks = {}
-  for e in data.get("traceEvents", []):
-    if e.get("ph") == "X" and e.get("cat") in ("gpu_op", "cpu_op"):
-      k = "{}_{}".format(e.get("pid"), e.get("tid"))
-      tracks.setdefault(k, []).append(e.get("name", ""))
-  return _summarize(tracks)
-
-
-def fingerprint_protobuf(path):
-  pb = _import_perfetto_trace_pb2()
-  TE = pb.TrackEvent
-  trace = pb.Trace()
-  with open(path, "rb") as f:
-    trace.ParseFromString(f.read())
-  tracks = {}
-  for p in trace.packet:
-    if p.HasField("track_event"):
-      ev = p.track_event
-      if ev.type == TE.TYPE_SLICE_BEGIN:
-        tracks.setdefault(ev.track_uuid, []).append(ev.name)
-  return _summarize(tracks)
-
-
-# ---- protobuf flow-arrow validation ---------------------------------------
-# unitrace emits only H2D flows: the same flow_id on a host SUBMIT slice (cpu_op)
-# and the device kernel slice (gpu_op). Perfetto infers direction from slice
-# begin-timestamp (earlier = source), so a correct H2D flow has its EARLIEST slice
-# be the host submit (arrow host->device) and touches >= 2 slices (else no arrow).
-# D2H (kernel->wait) flows are intentionally not emitted (they would render
-# backwards; see UNITRACEI-107), so terminating_flow_ids must be absent.
-# Returns (n_flows, errors).
-def validate_protobuf_flows(path):
-  pb = _import_perfetto_trace_pb2()
-  TE = pb.TrackEvent
-  trace = pb.Trace()
-  with open(path, "rb") as f:
-    trace.ParseFromString(f.read())
-
-  host_tracks = set()
-  touches = {}          # fid -> list[(ts, is_host)]
-  begins = []           # (ts, track_uuid, [flow_ids]) to classify after tracks known
-  has_terminating = False
-  for p in trace.packet:
-    if not p.HasField("track_event"):
-      continue
-    ev = p.track_event
-    if ev.type != TE.TYPE_SLICE_BEGIN:
-      continue
-    if "cpu_op" in ev.categories:
-      host_tracks.add(ev.track_uuid)
-    if ev.flow_ids:
-      begins.append((p.timestamp, ev.track_uuid, list(ev.flow_ids)))
-    if ev.terminating_flow_ids:
-      has_terminating = True
-
-  for ts, tu, fids in begins:
-    is_host = tu in host_tracks
-    for fid in fids:
-      touches.setdefault(fid, []).append((ts, is_host))
-
-  errors = []
-  if has_terminating:
-    errors.append("unexpected terminating_flow_ids present (unitrace emits H2D flow_ids only)")
-
-  n_flows = 0
-  orphan = []
-  bad_dir = []
-  for fid, ts_list in touches.items():
-    if len(ts_list) < 2:
-      orphan.append(fid)        # a flow id on only one slice draws no arrow
-      continue
-    n_flows += 1
-    # The earliest slice carrying the id must be the host submit (host -> device).
-    if not min(ts_list, key=lambda x: x[0])[1]:
-      bad_dir.append(fid)
-  if orphan:
-    errors.append("flow ids on only one slice (no arrow drawn): {}".format(sorted(orphan)[:10]))
-  if bad_dir:
-    errors.append("H2D flow whose earliest slice is NOT the host submit "
-                  "(arrow would point device->host): {}".format(sorted(bad_dir)[:10]))
-  return n_flows, errors
diff --git a/tools/unitrace/test/unidiff.py b/tools/unitrace/test/unidiff.py
deleted file mode 100644
index 914b4aab..00000000
--- a/tools/unitrace/test/unidiff.py
+++ /dev/null
@@ -1,349 +0,0 @@
-# ==============================================================
-# Copyright (C) Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-# ==============================================================
-
-import argparse
-import sys
-import csv
-import re
-
-def get_parser():
-    parser = argparse.ArgumentParser(description = 'unitrace test diffing tool')
-
-    parser.add_argument('--test', required = True, type = str, help = 'test run result file')
-    parser.add_argument('--ref', required = True, type = str, help = 'reference run result file')
-    parser.add_argument('--scenario', required = True, type = str, help ='unitrace test scenario')
-
-    return parser.parse_args()
-
-class ApiTiming:
-    def __init__(self, file):
-        self.lines = {}
-        ignoring_functions = ["zeCommandList", "clEnqueue"]
-        process_function_data = False
-
-        with open(file, encoding='utf-8') as f:
-            for line in f:
-                line = line.strip()
-
-                # Skip irrelevant lines
-                if not line or any(skip in line for skip in [
-                    "API Timing Summary",
-                    "L0 Backend",
-                    "CL GPU Backend",
-                    "CL CPU Backend",
-                    "Total Execution Time (ns):",
-                    "Total API Time for L0 backend (ns):",
-                    "Total API Time for CL GPU backend (ns):",
-                    "Total API Time for CL CPU backend (ns):"
-                ]):
-                    process_function_data = False
-                    continue
-
-                # Detect header line
-                if re.match(r'^Function\s*,', line):
-                    process_function_data = True
-                    continue
-
-                if process_function_data:
-                    # Use regex to split by comma but respect quoted strings
-                    columns = [col.strip().strip('"') for col in re.split(r',(?=(?:[^"]*"[^"]*")*[^"]*$)', line)]
-
-                    if len(columns) == 7:
-                        function_name = columns[0]
-                        if any(f in function_name for f in ignoring_functions):
-                            continue
-                        self.lines[function_name] = columns
-
-    def compare(self, ref):
-        mismatched_functions = 0
-        total_functions = len(self.lines)
-
-        for function_name, cur_row in self.lines.items():
-            ref_row = ref.lines.get(function_name)
-
-            if not ref_row:
-                print(f"[WARNING] Function '{function_name}' not found in reference data.")
-                continue
-
-            cur_calls = int(cur_row[1].replace(",", "").strip())
-            ref_calls = int(ref_row[1].replace(",", "").strip())
-
-            if cur_calls != ref_calls:
-                mismatched_functions += 1
-                print(f"[WARNING] Calls mismatch for function '{function_name}':")
-                print(f"[WARNING] Current: {cur_calls}")
-                print(f"[WARNING] Reference: {ref_calls}")
-
-        if total_functions > 0:
-            mismatch_percentage = (mismatched_functions / total_functions) * 100
-        else:
-            print("[ERROR] Number of functions is zero.")
-            return 3
-
-        if mismatch_percentage >= 10:
-            print(f"[ERROR] Test failed: {mismatched_functions} out of {total_functions} functions mismatched ({mismatch_percentage:.2f}%).")
-            return 3
-        else:
-            print(f"[INFO] Test passed: {mismatched_functions} out of {total_functions} functions mismatched ({mismatch_percentage:.2f}%).")
-            return 0
-
-    def save_to_csv(self, ref, filename='output.csv'):
-        field_names = [
-            "No.",
-            "Function",
-            "Calls (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Time (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Time (%) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Average (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Min (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Max (ns) (Cur, Ref, Diff, Diff by Ref value(%)"
-        ]
-
-        with open(filename, mode='w', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow(field_names)
-
-            for i, (function, cur_row) in enumerate(self.lines.items(), start=1):
-                ref_row = ref.lines.get(function, ["0"] * 7)
-                row = [i, function]
-
-                for j in range(1, 7):
-                    try:
-                        cur_value = float(cur_row[j].replace(",", "").strip())
-                        ref_value = float(ref_row[j].replace(",", "").strip())
-                        diff = cur_value - ref_value
-                        diff_percent = (diff / ref_value) * 100 if ref_value != 0 else 'N/A'
-
-                        formatted = f"{cur_value}, {ref_value}, {diff}, {diff_percent:.2f}" if diff_percent != 'N/A' else f"{cur_value}, {ref_value}, {diff}, N/A"
-                        row.append(formatted)
-                    except (ValueError, IndexError):
-                        row.append(f"{cur_row[j] if j < len(cur_row) else 'N/A'}, {ref_row[j] if j < len(ref_row) else 'N/A'}, N/A, N/A")
-
-                writer.writerow(row)
-
-        print(f"[INFO] Data saved to {filename}")
-        
-class DeviceTiming:
-    def __init__(self, file):
-        self.lines = {}
-        ignoring_kernels = ["zeCommandList", "clEnqueue"]
-        process_kernel_data = False
-
-        with open(file, encoding='utf-8') as f:
-            for line in f:
-                line = line.strip()
-
-                # Skip irrelevant lines
-                if not line or any(skip in line for skip in [
-                    "Device Timing Summary",
-                    "L0 Backend",
-                    "CL GPU Backend",
-                    "CL CPU Backend",
-                    "Total Execution Time (ns):",
-                    "Total Device Time for CL GPU backend (ns):",
-                    "Total Device Time for CL CPU backend (ns):"
-                ]):
-                    process_kernel_data = False
-                    continue
-
-                # Detect header line
-                if re.match(r'^Kernel\s*,', line):
-                    process_kernel_data = True
-                    continue
-
-                if process_kernel_data:
-                    # Use regex to split by comma but respect quoted strings
-                    columns = [col.strip().strip('"') for col in re.split(r',(?=(?:[^"]*"[^"]*")*[^"]*$)', line)]
-
-                    if len(columns) == 7:
-                        kernel_name = columns[0]
-                        if any(k in kernel_name for k in ignoring_kernels):
-                            continue
-                        self.lines[kernel_name] = columns
-
-    def compare(self, ref):
-        mismatched_kernels = 0
-        total_kernels = len(self.lines)
-
-        for kernel_name, cur_row in self.lines.items():
-            ref_row = ref.lines.get(kernel_name)
-
-            if not ref_row:
-                print(f"[WARNING] Kernel '{kernel_name}' not found in reference data.")
-                continue
-
-            cur_calls = int(cur_row[1].replace(",", "").strip())
-            ref_calls = int(ref_row[1].replace(",", "").strip())
-
-            if cur_calls != ref_calls:
-                mismatched_kernels += 1
-                print(f"[WARNING] Calls mismatch for kernel '{kernel_name}':")
-                print(f"[WARNING] Current: {cur_calls}")
-                print(f"[WARNING] Reference: {ref_calls}")
-
-        if total_kernels > 0:
-            mismatch_percentage = (mismatched_kernels / total_kernels) * 100
-        else:
-            print("[ERROR] Number of kernels in the file is zero.")
-            return 3
-
-        if mismatch_percentage >= 10:
-            print(f"[ERROR] Test failed: {mismatched_kernels} out of {total_kernels} kernels mismatched ({mismatch_percentage:.2f}%).")
-            return 3
-        else:
-            print(f"[INFO] Test passed: {mismatched_kernels} out of {total_kernels} kernels mismatched ({mismatch_percentage:.2f}%).")
-            return 0
-
-    def save_to_csv(self, ref, filename='output.csv'):
-        field_names = [
-            "No.",
-            "Kernel",
-            "Calls (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Time (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Time (%) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Average (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Min (ns) (Cur, Ref, Diff, Diff by Ref value(%)",
-            "Max (ns) (Cur, Ref, Diff, Diff by Ref value(%)"
-        ]
-
-        with open(filename, mode='w', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow(field_names)
-
-            for i, (kernel, cur_row) in enumerate(self.lines.items(), start=1):
-                ref_row = ref.lines.get(kernel, ["0"] * 7)
-                row = [i, kernel]
-
-                for j in range(1, 7):
-                    try:
-                        cur_value = float(cur_row[j].replace(",", "").strip())
-                        ref_value = float(ref_row[j].replace(",", "").strip())
-                        diff = cur_value - ref_value
-                        diff_percent = (diff / ref_value) * 100 if ref_value != 0 else 'N/A'
-
-                        formatted = f"{cur_value}, {ref_value}, {diff}, {diff_percent:.2f}" if diff_percent != 'N/A' else f"{cur_value}, {ref_value}, {diff}, N/A"
-                        row.append(formatted)
-                    except (ValueError, IndexError):
-                        row.append(f"{cur_row[j] if j < len(cur_row) else 'N/A'}, {ref_row[j] if j < len(ref_row) else 'N/A'}, N/A, N/A")
-
-                writer.writerow(row)
-
-        print(f"[INFO] Data saved to {filename}")
-
-
-class DeviceTimeline:
-    def __init__(self, file):
-        device_pattern = re.compile(r"Thread (\d+) Device (\S+) : (.+) \[ns\] (\d+) \(append\) (\d+) \(submit\) (\d+) \(start\) (\d+) \(end\)")
-        ignore_patterns = ["zeCommandList", "clEnqueue"]
-        self.kernels = []  # Initialize kernels list
-
-        try:
-            with open(file, encoding='utf-8') as f:
-                lines = f.readlines()
-
-                for i, line in enumerate(lines):
-                    line = line.strip()
-
-                    if not line:  # Skip empty lines
-                        continue
-                    match = device_pattern.match(line)
-                    if match:
-                        try:
-                            keep = True
-                            kernel = match.group(3).strip()
-                            for k in ignore_patterns:
-                                if k in kernel:
-                                    keep = False
-                                    continue
-                            if keep:
-                                self.kernels.append(kernel)
-
-                        except ValueError as e:
-                            print(f"[ERROR] processing line {i + 1}: {line}. [ERROR] {e}")
-                    else:
-                        print(f"[WARNING] Line {i + 1} did not match the expected format: {line}")
-
-        except FileNotFoundError:
-            print(f"[ERROR] The file {file} was not found.")
-        except Exception as e:
-            print(f"[ERROR] An unexpected error occurred while parsing {file}: {e}")
-
-    def compare(self, ref):
-        count_self = len(self.kernels)
-        count_ref = len(ref.kernels)
-
-        print(f"[INFO] Valid Kernel Count in self: {count_self}")
-        print(f"[INFO] Valid Kernel Count in ref: {count_ref}")
-
-        if count_self == count_ref:
-            print("[INFO] Kernel counts are the same.")
-            return 0  # Test passed
-        else:
-            print("[ERROR] Kernel counts differ.")
-            return 3  # Test failed
-
-    def save_to_csv(self, ref, filename='kernel_comparison.csv'):
-        field_names = ["Kernel", "Kernel Count in Test File", "Kernel Count in Ref File"]
-
-        with open(filename, mode='w', newline='') as file:
-            writer = csv.writer(file)
-            writer.writerow(field_names)
-
-            all_kernels = list(set(self.kernels) | set(ref.kernels))
-
-            for k in all_kernels:
-                count_in_cur = sum(1 for entry in self.kernels if entry == k)
-                count_in_ref = sum(1 for entry in ref.kernels if entry == k)
-                row = [k, count_in_cur, count_in_ref]
-                writer.writerow(row)
-
-        print(f"[INFO] Data saved to {filename}")
-
-def main():
-    args = get_parser()
-    result = 0
-
-    if args.scenario in ("--device-timing", "-d"):
-        device_timing_cur = DeviceTiming(args.test)
-        device_timing_ref = DeviceTiming(args.ref)
-        result = device_timing_cur.compare(device_timing_ref)
-
-        if result == 0:
-            print("[INFO] Device Comparison Passed")
-        else:
-            print("[ERROR] Device Comparison Failed")
-
-        device_timing_cur.save_to_csv(device_timing_ref, filename = 'device_timing_results.csv')
-
-    # yet to be invoked
-    #if args.scenario in ("--host-timing", "-h"):
-    #    api_cur = ApiTimeing(args.test)
-    #    api_ref = ApiTimeing(args.ref)
-    #    result = api_cur.compare(api_ref, scenario = args.scenario)
-
-    #    if result == 0:
-    #        print("[INFO] API Comparison Passed")
-    #    else:
-    #        print("[ERROR] API Comparison Failed")
-    #
-    #    api_cur.save_to_csv(api_cur.lines, api_ref.lines, filename = 'api_results.csv', scenario = args.scenario)
-
-    if args.scenario in ("--device-timeline", "-t"):
-        device_timeline_cur = DeviceTimeline(args.test)
-        device_timeline_ref = DeviceTimeline(args.ref)
-        result = device_timeline_cur.compare(device_timeline_ref)
-
-        if result == 0:
-            print("[INFO] Device Timeline Comparison Passed")
-        else:
-            print("[ERROR] Device Timeline Comparison Failed")
-
-        device_timeline_cur.save_to_csv(device_timeline_ref, filename = 'device_timeline_results.csv')
-
-    return result
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/tools/unitrace/test/utils/shared_library.h b/tools/unitrace/test/utils/shared_library.h
deleted file mode 100644
index 0b6378ac..00000000
--- a/tools/unitrace/test/utils/shared_library.h
+++ /dev/null
@@ -1,80 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_TEST_UTILS_SHARED_LIBRARY_H_
-#define UNITRACE_TEST_UTILS_SHARED_LIBRARY_H_
-
-#if defined(_WIN32)
-#include <Windows.h>
-#else
-#include <cerrno>
-#include <dlfcn.h>
-#endif
-
-#include <string>
-#include <vector>
-
-#include "utils/unitrace_assert.h"
-
-class SharedLibrary {
- public:
-  static SharedLibrary* Create(const std::string& name) {
-#if defined(_WIN32)
-    HMODULE handle = nullptr;
-    handle = LoadLibraryA(name.c_str());
-#else
-    void* handle = nullptr;
-    handle = dlopen(name.c_str(), RTLD_NOW);
-#endif
-    if (handle != nullptr) {
-      return new SharedLibrary(handle);
-    }
-    return nullptr;
-  }
-
-  ~SharedLibrary() {
-#if defined(_WIN32)
-    BOOL completed = FreeLibrary(handle_);
-    UNITRACE_ASSERT(completed == TRUE);
-#else
-    int completed = dlclose(handle_);
-    UNITRACE_ASSERT(completed == 0);
-#endif
-  }
-
-  template<typename T> T GetSym(const char* name) {
-    void* sym = nullptr;
-#if defined(_WIN32)
-    sym = GetProcAddress(handle_, name);
-#else
-    sym = dlsym(handle_, name);
-#endif
-    return reinterpret_cast<T>(sym);
-  }
-
-#if defined(_WIN32)
-  HMODULE GetHandle() {
-#else
-  void* GetHandle() {
-#endif
-    return handle_;
-  }
-
- private:
-#if defined(_WIN32)
-  SharedLibrary(HMODULE handle) : handle_(handle) {}
-#else
-  SharedLibrary(void* handle) : handle_(handle) {}
-#endif
-
-#if defined(_WIN32)
-  HMODULE handle_ = nullptr;
-#else
-  void* handle_ = nullptr;
-#endif
-};
-
-#endif // UNITRACE_TEST_UTILS_SHARED_LIBRARY_H_
\ No newline at end of file
diff --git a/tools/unitrace/test/utils/ze_utils.h b/tools/unitrace/test/utils/ze_utils.h
deleted file mode 100644
index cdce4b54..00000000
--- a/tools/unitrace/test/utils/ze_utils.h
+++ /dev/null
@@ -1,403 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_TEST_UTILS_ZE_UTILS_H_
-#define UNITRACE_TEST_UTILS_ZE_UTILS_H_
-
-#include <string.h>
-
-#include <chrono>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include <level_zero/ze_api.h>
-#include <level_zero/zet_api.h>
-
-#include "utils/demangle.h"
-#include "utils/unitrace_assert.h"
-#include "utils/utils.h"
-
-namespace utils {
-namespace ze {
-
-inline std::vector<ze_driver_handle_t> GetDriverList() {
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t driver_count = 0;
-  status = zeDriverGet(&driver_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (driver_count == 0) {
-    return std::vector<ze_driver_handle_t>();
-  }
-
-  std::vector<ze_driver_handle_t> driver_list(driver_count);
-  status = zeDriverGet(&driver_count, driver_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return driver_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t device_count = 0;
-  status = zeDeviceGet(driver, &device_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> device_list(device_count);
-  status = zeDeviceGet(driver, &device_count, device_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetDeviceList() {
-  std::vector<ze_device_handle_t> device_list;
-  for (auto driver : utils::ze::GetDriverList()) {
-    for (auto device : utils::ze::GetDeviceList(driver)) {
-      device_list.push_back(device);
-    }
-  }
-  return device_list;
-}
-
-inline std::vector<ze_device_handle_t> GetSubDeviceList(
-    ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-
-  uint32_t sub_device_count = 0;
-  status = zeDeviceGetSubDevices(device, &sub_device_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (sub_device_count == 0) {
-    return std::vector<ze_device_handle_t>();
-  }
-
-  std::vector<ze_device_handle_t> sub_device_list(sub_device_count);
-  status = zeDeviceGetSubDevices(
-      device, &sub_device_count, sub_device_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return sub_device_list;
-}
-
-inline ze_driver_handle_t GetGpuDriver() {
-  std::vector<ze_driver_handle_t> driver_list;
-
-  for (auto driver : GetDriverList()) {
-    for (auto device : GetDeviceList(driver)) {
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-      ze_result_t status = zeDeviceGetProperties(device, &props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        driver_list.push_back(driver);
-      }
-    }
-  }
-
-  if (driver_list.empty()) {
-    return nullptr;
-  }
-
-  std::string value = utils::GetEnv("PTI_DEVICE_ID");
-  uint32_t device_id = value.empty() ? 0 : std::stoul(value);
-  UNITRACE_ASSERT(device_id < driver_list.size());
-  return driver_list[device_id];
-}
-
-inline ze_device_handle_t GetGpuDevice() {
-  std::vector<ze_device_handle_t> device_list;
-
-  for (auto driver : GetDriverList()) {
-    for (auto device : GetDeviceList(driver)) {
-      ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-      ze_result_t status = zeDeviceGetProperties(device, &props);
-      UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-      if (props.type == ZE_DEVICE_TYPE_GPU) {
-        device_list.push_back(device);
-      }
-    }
-  }
-
-  if (device_list.empty()) {
-    return nullptr;
-  }
-
-  std::string value = utils::GetEnv("PTI_DEVICE_ID");
-  uint32_t device_id = value.empty() ? 0 : std::stoul(value);
-  UNITRACE_ASSERT(device_id < device_list.size());
-
-  std::vector<ze_device_handle_t> sub_device_list =
-    GetSubDeviceList(device_list[device_id]);
-  if (sub_device_list.empty()) {
-    return device_list[device_id];
-  }
-
-  value = utils::GetEnv("PTI_SUB_DEVICE_ID");
-  if (value.empty()) {
-    return device_list[device_id];
-  }
-
-  uint32_t sub_device_id = value.empty() ? 0 : std::stoul(value);
-  UNITRACE_ASSERT(sub_device_id < sub_device_list.size());
-  return sub_device_list[sub_device_id];
-}
-
-inline ze_context_handle_t GetContext(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_context_handle_t context = nullptr;
-  ze_context_desc_t context_desc = {
-      ZE_STRUCTURE_TYPE_CONTEXT_DESC, nullptr, 0};
-
-  status = zeContextCreate(driver, &context_desc, &context);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return context;
-}
-
-inline std::string GetDeviceName(ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES, };
-  status = zeDeviceGetProperties(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.name;
-}
-
-inline int GetMetricId(zet_metric_group_handle_t group, std::string name) {
-  UNITRACE_ASSERT(group != nullptr);
-
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  uint32_t metric_count = 0;
-  status = zetMetricGet(group, &metric_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  if (metric_count == 0) {
-    return -1;
-  }
-
-  std::vector<zet_metric_handle_t> metric_list(metric_count, nullptr);
-  status = zetMetricGet(group, &metric_count, metric_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  int target = -1;
-  for (uint32_t i = 0; i < metric_count; ++i) {
-    zet_metric_properties_t metric_props{};
-    status = zetMetricGetProperties(metric_list[i], &metric_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    if (name == metric_props.name) {
-      target = i;
-      break;
-    }
-  }
-
-  return target;
-}
-
-inline zet_metric_group_handle_t FindMetricGroup(
-    ze_device_handle_t device, std::string name,
-    zet_metric_group_sampling_type_flag_t type) {
-  UNITRACE_ASSERT(device != nullptr);
-  
-  ze_result_t status = ZE_RESULT_SUCCESS;
-  uint32_t group_count = 0;
-  status = zetMetricGroupGet(device, &group_count, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  if (group_count == 0) {
-    return nullptr;
-  }
-
-  std::vector<zet_metric_group_handle_t> group_list(group_count, nullptr);
-  status = zetMetricGroupGet(device, &group_count, group_list.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  zet_metric_group_handle_t target = nullptr;
-  for (uint32_t i = 0; i < group_count; ++i) {
-    zet_metric_group_properties_t group_props{};
-    group_props.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
-    status = zetMetricGroupGetProperties(group_list[i], &group_props);
-    UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-    if (name == group_props.name && (group_props.samplingType & type)) {
-      target = group_list[i];
-      break;
-    }
-  }
-
-  return target;
-}
-
-inline std::string GetResultType(zet_value_type_t type) {
-  switch (type) {
-    case ZET_VALUE_TYPE_UINT32:
-      return "UINT32";
-    case ZET_VALUE_TYPE_UINT64:
-      return "UINT64";
-    case ZET_VALUE_TYPE_FLOAT32:
-      return "FLOAT32";
-    case ZET_VALUE_TYPE_FLOAT64:
-      return "FLOAT64";
-    case ZET_VALUE_TYPE_BOOL8:
-      return "BOOL8";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline std::string GetMetricType(zet_metric_type_t type) {
-  switch (type) {
-    case ZET_METRIC_TYPE_DURATION:
-      return "DURATION";
-    case ZET_METRIC_TYPE_EVENT:
-      return "EVENT";
-    case ZET_METRIC_TYPE_EVENT_WITH_RANGE:
-      return "EVENT_WITH_RANGE";
-    case ZET_METRIC_TYPE_THROUGHPUT:
-      return "THROUGHPUT";
-    case ZET_METRIC_TYPE_TIMESTAMP:
-      return "TIMESTAMP";
-    case ZET_METRIC_TYPE_FLAG:
-      return "FLAG";
-    case ZET_METRIC_TYPE_RATIO:
-      return "RATIO";
-    case ZET_METRIC_TYPE_RAW:
-      return "RAW";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-inline size_t GetKernelMaxSubgroupSize(ze_kernel_handle_t kernel) {
-  UNITRACE_ASSERT(kernel != nullptr);
-  ze_kernel_properties_t props{};
-  ze_result_t status = zeKernelGetProperties(kernel, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.maxSubgroupSize;
-}
-
-inline std::string GetKernelName(
-    ze_kernel_handle_t kernel, bool demangle = false) {
-  UNITRACE_ASSERT(kernel != nullptr);
-
-  size_t size = 0;
-  ze_result_t status = zeKernelGetName(kernel, &size, nullptr);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  UNITRACE_ASSERT(size > 0);
-
-  std::vector<char> name(size);
-  status = zeKernelGetName(kernel, &size, name.data());
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  UNITRACE_ASSERT(name[size - 1] == '\0');
-
-  if (demangle) {
-    return utils::Demangle(name.data());
-  }
-  return std::string(name.begin(), name.end() - 1);
-}
-
-inline void GetDeviceTimestamps(
-    ze_device_handle_t device,
-    uint64_t* host_timestamp,
-    uint64_t* device_timestamp) {
-  UNITRACE_ASSERT(device != nullptr);
-  UNITRACE_ASSERT(host_timestamp != nullptr);
-  UNITRACE_ASSERT(device_timestamp != nullptr);
-  ze_result_t status = zeDeviceGetGlobalTimestamps(
-      device, host_timestamp, device_timestamp);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-}
-
-// TODO: use zeMetricGetGlobalTimestamps
-inline void GetMetricTimestamps(
-    ze_device_handle_t device,
-    uint64_t* host_timestamp,
-    uint64_t* metric_timestamp) {
-  UNITRACE_ASSERT(device != nullptr);
-  UNITRACE_ASSERT(host_timestamp != nullptr);
-  UNITRACE_ASSERT(metric_timestamp != nullptr);
-  ze_result_t status = zeDeviceGetGlobalTimestamps(
-      device, host_timestamp, metric_timestamp);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-}
-
-inline uint64_t GetDeviceTimerFrequency(ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, };
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.timerResolution;
-}
-
-inline uint64_t GetMetricTimerFrequency(ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, };
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return props.timerResolution;
-}
-
-inline uint64_t GetDeviceTimestampMask(ze_device_handle_t device) {
-  UNITRACE_ASSERT(device != nullptr);
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, };
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  return ((props.kernelTimestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)()
-              : ((1ull << props.kernelTimestampValidBits) - 1ull));
-}
-
-inline uint64_t GetMetricTimestampMask(ze_device_handle_t device) {
-#ifdef PTI_OA_TIMESTAMP_VALID_BITS
-  return (1ull << PTI_OA_TIMESTAMP_VALID_BITS) - 1ull;
-#else
-  ze_device_properties_t props{ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, };
-  ze_result_t status = zeDeviceGetProperties(device, &props);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-  uint32_t devicemask = (props.deviceId & 0xFF00);
-  if ((devicemask == 0x5600) || (devicemask == 0x4F00) || (devicemask == 0x0B00) ||
-      (devicemask == 0x7D00) || (devicemask == 0xE200) || (devicemask == 0x6400) || (devicemask == 0x9A00)) {
-      return (1ull << (props.kernelTimestampValidBits - 1)) - 1ull;
-  }
-  else {
-      return ((props.kernelTimestampValidBits == 64) ? (std::numeric_limits<uint64_t>::max)()
-                  : ((1ull << props.kernelTimestampValidBits) - 1ull));
-  }
-#endif
-}
-
-inline ze_api_version_t GetDriverVersion(ze_driver_handle_t driver) {
-  UNITRACE_ASSERT(driver != nullptr);
-
-  ze_api_version_t version = ZE_API_VERSION_FORCE_UINT32;
-  ze_result_t status = zeDriverGetApiVersion(driver, &version);
-  UNITRACE_ASSERT(status == ZE_RESULT_SUCCESS);
-
-  return version;
-}
-
-inline ze_api_version_t GetVersion() {
-  auto driver_list = GetDriverList();
-  if (driver_list.empty()) {
-    return ZE_API_VERSION_FORCE_UINT32;
-  }
-  return GetDriverVersion(driver_list.front());
-}
-
-} // namespace ze
-} // namespace utils
-
-#endif // UNITRACE_TEST_UTILS_ZE_UTILS_H_
diff --git a/tools/unitrace/third-party-programs.txt b/tools/unitrace/third-party-programs.txt
deleted file mode 100644
index 00b98d40..00000000
--- a/tools/unitrace/third-party-programs.txt
+++ /dev/null
@@ -1,301 +0,0 @@
-This file contains the list of third-party software included in or with the
-Intel software and their required license, copyright statement, permission
-notice, disclaimers, or other terms. This third-party software is governed by
-the separate license terms listed in this file.
-===============================================================================
-1. PERFETTO
-   Copyright (C) The Android Open Source Project
-
-   OpenCL(TM) HEADERS (Khronos)
-   Copyright (c) 2008-2020 The Khronos Group Inc.
-
-   Apache License 2.0
-
-                                    Apache License
-                              Version 2.0, January 2004
-                           http://www.apache.org/licenses/
-
-      TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-      1. Definitions.
-
-         "License" shall mean the terms and conditions for use, reproduction,
-         and distribution as defined by Sections 1 through 9 of this document.
-
-         "Licensor" shall mean the copyright owner or entity authorized by
-         the copyright owner that is granting the License.
-
-         "Legal Entity" shall mean the union of the acting entity and all
-         other entities that control, are controlled by, or are under common
-         control with that entity. For the purposes of this definition,
-         "control" means (i) the power, direct or indirect, to cause the
-         direction or management of such entity, whether by contract or
-         otherwise, or (ii) ownership of fifty percent (50%) or more of the
-         outstanding shares, or (iii) beneficial ownership of such entity.
-
-         "You" (or "Your") shall mean an individual or Legal Entity
-         exercising permissions granted by this License.
-
-         "Source" form shall mean the preferred form for making modifications,
-         including but not limited to software source code, documentation
-         source, and configuration files.
-
-         "Object" form shall mean any form resulting from mechanical
-         transformation or translation of a Source form, including but
-         not limited to compiled object code, generated documentation,
-         and conversions to other media types.
-
-         "Work" shall mean the work of authorship, whether in Source or
-         Object form, made available under the License, as indicated by a
-         copyright notice that is included in or attached to the work
-         (an example is provided in the Appendix below).
-
-         "Derivative Works" shall mean any work, whether in Source or Object
-         form, that is based on (or derived from) the Work and for which the
-         editorial revisions, annotations, elaborations, or other modifications
-         represent, as a whole, an original work of authorship. For the purposes
-         of this License, Derivative Works shall not include works that remain
-         separable from, or merely link (or bind by name) to the interfaces of,
-         the Work and Derivative Works thereof.
-
-         "Contribution" shall mean any work of authorship, including
-         the original version of the Work and any modifications or additions
-         to that Work or Derivative Works thereof, that is intentionally
-         submitted to Licensor for inclusion in the Work by the copyright owner
-         or by an individual or Legal Entity authorized to submit on behalf of
-         the copyright owner. For the purposes of this definition, "submitted"
-         means any form of electronic, verbal, or written communication sent
-         to the Licensor or its representatives, including but not limited to
-         communication on electronic mailing lists, source code control systems,
-         and issue tracking systems that are managed by, or on behalf of, the
-         Licensor for the purpose of discussing and improving the Work, but
-         excluding communication that is conspicuously marked or otherwise
-         designated in writing by the copyright owner as "Not a Contribution."
-
-         "Contributor" shall mean Licensor and any individual or Legal Entity
-         on behalf of whom a Contribution has been received by Licensor and
-         subsequently incorporated within the Work.
-
-      2. Grant of Copyright License. Subject to the terms and conditions of
-         this License, each Contributor hereby grants to You a perpetual,
-         worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-         copyright license to reproduce, prepare Derivative Works of,
-         publicly display, publicly perform, sublicense, and distribute the
-         Work and such Derivative Works in Source or Object form.
-
-      3. Grant of Patent License. Subject to the terms and conditions of
-         this License, each Contributor hereby grants to You a perpetual,
-         worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-         (except as stated in this section) patent license to make, have made,
-         use, offer to sell, sell, import, and otherwise transfer the Work,
-         where such license applies only to those patent claims licensable
-         by such Contributor that are necessarily infringed by their
-         Contribution(s) alone or by combination of their Contribution(s)
-         with the Work to which such Contribution(s) was submitted. If You
-         institute patent litigation against any entity (including a
-         cross-claim or counterclaim in a lawsuit) alleging that the Work
-         or a Contribution incorporated within the Work constitutes direct
-         or contributory patent infringement, then any patent licenses
-         granted to You under this License for that Work shall terminate
-         as of the date such litigation is filed.
-
-      4. Redistribution. You may reproduce and distribute copies of the
-         Work or Derivative Works thereof in any medium, with or without
-         modifications, and in Source or Object form, provided that You
-         meet the following conditions:
-
-         (a) You must give any other recipients of the Work or
-             Derivative Works a copy of this License; and
-
-         (b) You must cause any modified files to carry prominent notices
-             stating that You changed the files; and
-
-         (c) You must retain, in the Source form of any Derivative Works
-             that You distribute, all copyright, patent, trademark, and
-             attribution notices from the Source form of the Work,
-             excluding those notices that do not pertain to any part of
-             the Derivative Works; and
-
-         (d) If the Work includes a "NOTICE" text file as part of its
-             distribution, then any Derivative Works that You distribute must
-             include a readable copy of the attribution notices contained
-             within such NOTICE file, excluding those notices that do not
-             pertain to any part of the Derivative Works, in at least one
-             of the following places: within a NOTICE text file distributed
-             as part of the Derivative Works; within the Source form or
-             documentation, if provided along with the Derivative Works; or,
-             within a display generated by the Derivative Works, if and
-             wherever such third-party notices normally appear. The contents
-             of the NOTICE file are for informational purposes only and
-             do not modify the License. You may add Your own attribution
-             notices within Derivative Works that You distribute, alongside
-             or as an addendum to the NOTICE text from the Work, provided
-             that such additional attribution notices cannot be construed
-             as modifying the License.
-
-         You may add Your own copyright statement to Your modifications and
-         may provide additional or different license terms and conditions
-         for use, reproduction, or distribution of Your modifications, or
-         for any such Derivative Works as a whole, provided Your use,
-         reproduction, and distribution of the Work otherwise complies with
-         the conditions stated in this License.
-
-      5. Submission of Contributions. Unless You explicitly state otherwise,
-         any Contribution intentionally submitted for inclusion in the Work
-         by You to the Licensor shall be under the terms and conditions of
-         this License, without any additional terms or conditions.
-         Notwithstanding the above, nothing herein shall supersede or modify
-         the terms of any separate license agreement you may have executed
-         with Licensor regarding such Contributions.
-
-      6. Trademarks. This License does not grant permission to use the trade
-         names, trademarks, service marks, or product names of the Licensor,
-         except as required for reasonable and customary use in describing the
-         origin of the Work and reproducing the content of the NOTICE file.
-
-      7. Disclaimer of Warranty. Unless required by applicable law or
-         agreed to in writing, Licensor provides the Work (and each
-         Contributor provides its Contributions) on an "AS IS" BASIS,
-         WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-         implied, including, without limitation, any warranties or conditions
-         of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-         PARTICULAR PURPOSE. You are solely responsible for determining the
-         appropriateness of using or redistributing the Work and assume any
-         risks associated with Your exercise of permissions under this License.
-
-      8. Limitation of Liability. In no event and under no legal theory,
-         whether in tort (including negligence), contract, or otherwise,
-         unless required by applicable law (such as deliberate and grossly
-         negligent acts) or agreed to in writing, shall any Contributor be
-         liable to You for damages, including any direct, indirect, special,
-         incidental, or consequential damages of any character arising as a
-         result of this License or out of the use or inability to use the
-         Work (including but not limited to damages for loss of goodwill,
-         work stoppage, computer failure or malfunction, or any and all
-         other commercial damages or losses), even if such Contributor
-         has been advised of the possibility of such damages.
-
-      9. Accepting Warranty or Additional Liability. While redistributing
-         the Work or Derivative Works thereof, You may choose to offer,
-         and charge a fee for, acceptance of support, warranty, indemnity,
-         or other liability obligations and/or rights consistent with this
-         License. However, in accepting such obligations, You may act only
-         on Your own behalf and on Your sole responsibility, not on behalf
-         of any other Contributor, and only if You agree to indemnify,
-         defend, and hold each Contributor harmless for any liability
-         incurred by, or claims asserted against, such Contributor by reason
-         of your accepting any such warranty or additional liability.
-
-      END OF TERMS AND CONDITIONS
-
-   The license texts and versions are recorded at third_party/perfetto/ and
-   third_party/opencl-headers/.
-===============================================================================
-2. PROTOBUF (Protocol Buffers)
-   Copyright 2008 Google Inc.  All rights reserved.
-
-   3-Clause BSD License
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-       * Neither the name of Google Inc. nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   Code generated by the Protocol Buffer compiler is owned by the owner
-   of the input file used when generating it. This code is not
-   standalone and requires a support library to be linked with it. This
-   support library is itself covered by the above license.
-
-   The full license text is included at
-   third_party/protobuf/LICENSE.
-===============================================================================
-3. ITT API (ittapi)
-   Copyright (c) 2019 Intel Corporation. All rights reserved.
-
-   3-Clause BSD License
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-   2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-   3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
-   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
-   WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-   POSSIBILITY OF SUCH DAMAGE.
-
-   ittapi is dual licensed under BSD-3-Clause and GPL-2.0-only; unitrace uses
-   it under BSD-3-Clause. The full license text is included at
-   third_party/ittapi/LICENSE.
-===============================================================================
-4. INTEL GPU API HEADERS (Level Zero, compute-runtime, IGA)
-   Level Zero headers
-   Copyright (C) 2019-2026 Intel Corporation
-
-   compute-runtime headers
-   Copyright (C) 2021 Intel Corporation
-
-   IGA (Intel(R) Graphics Assembler) headers
-   Copyright (C) 2019-2021 Intel Corporation
-
-   MIT License
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in all
-   copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-   SOFTWARE.
-
-   The license texts and versions are recorded at third_party/level-zero/,
-   third_party/compute-runtime/ and third_party/iga/.
-===============================================================================
-
-Other names and brands may be claimed as the property of others.
diff --git a/tools/unitrace/third_party/compute-runtime/LICENSE b/tools/unitrace/third_party/compute-runtime/LICENSE
deleted file mode 100644
index 01b0c078..00000000
--- a/tools/unitrace/third_party/compute-runtime/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (C) 2021 Intel Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/tools/unitrace/third_party/compute-runtime/VERSION b/tools/unitrace/third_party/compute-runtime/VERSION
deleted file mode 100644
index 1bcd7857..00000000
--- a/tools/unitrace/third_party/compute-runtime/VERSION
+++ /dev/null
@@ -1,18 +0,0 @@
-Intel(R) Graphics Compute Runtime headers - fetched at build time from public upstream.
-
-Component:   compute-runtime headers: OpenCL tracing and private extension
-             headers (tracing_api.h, tracing_types.h, cl_ext_private.h) and
-             Intel Level Zero extension headers (ze_stypes.h, ze_intel_gpu.h,
-             driver_experimental/zex_*.h)
-Upstream:    https://github.com/intel/compute-runtime
-Version:     pinned by the commit in tools/unitrace/scripts/get_compute_runtime_headers.py,
-             the single source of truth (not repeated here)
-License:     MIT (see ./LICENSE)
-
-How it is used: scripts/get_compute_runtime_headers.py clones compute-runtime at
-the pinned commit and copies the headers into the build tree; unitrace compiles
-against them.
-
-To bump: update the commit in get_compute_runtime_headers.py, refresh LICENSE
-from upstream (LICENSE.md) at the new commit, and update
-tools/unitrace/third-party-programs.txt if the license or copyright changed.
diff --git a/tools/unitrace/third_party/iga/LICENSE b/tools/unitrace/third_party/iga/LICENSE
deleted file mode 100644
index 6ea8575d..00000000
--- a/tools/unitrace/third_party/iga/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-============================ begin_copyright_notice ============================
-
-Copyright (C) 2019-2021 Intel Corporation
-
-SPDX-License-Identifier: MIT
-
-============================= end_copyright_notice =============================
-
-
-The MIT License text:
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/tools/unitrace/third_party/iga/VERSION b/tools/unitrace/third_party/iga/VERSION
deleted file mode 100644
index 27baf0b4..00000000
--- a/tools/unitrace/third_party/iga/VERSION
+++ /dev/null
@@ -1,19 +0,0 @@
-IGA (Intel(R) Graphics Assembler) API headers - fetched at build time from public upstream.
-
-Component:   IGA C API headers from intel-graphics-compiler (iga.h,
-             iga_types_ext.hpp, iga_types_swsb.hpp, iga_bxml_ops.hpp,
-             iga_bxml_enums.hpp)
-Upstream:    https://github.com/intel/intel-graphics-compiler
-Version:     pinned by IGA_COMMIT_ID in tools/unitrace/CMakeLists.txt, the single
-             source of truth (not repeated here)
-License:     MIT (see ./LICENSE: upstream's LICENSE.md notice, followed by the
-             MIT License text it refers to)
-
-How it is used: scripts/get_iga_headers.py clones intel-graphics-compiler at
-IGA_COMMIT_ID and copies the IGA headers into the build tree; unitrace compiles
-against them. The iga64 library itself is loaded at runtime from the system and
-is not distributed with unitrace.
-
-To bump: update IGA_COMMIT_ID, refresh LICENSE from upstream at the new commit,
-and update tools/unitrace/third-party-programs.txt if the license or copyright
-changed.
diff --git a/tools/unitrace/third_party/ittapi/LICENSE b/tools/unitrace/third_party/ittapi/LICENSE
deleted file mode 100644
index 37478a55..00000000
--- a/tools/unitrace/third_party/ittapi/LICENSE
+++ /dev/null
@@ -1,8 +0,0 @@
-Copyright (c) 2019 Intel Corporation. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tools/unitrace/third_party/ittapi/VERSION b/tools/unitrace/third_party/ittapi/VERSION
deleted file mode 100644
index 3b9bbdf3..00000000
--- a/tools/unitrace/third_party/ittapi/VERSION
+++ /dev/null
@@ -1,17 +0,0 @@
-ITT API (ittapi) - built from source at build time from public upstream.
-
-Component:   ittapi (ittnotify static library and headers)
-Upstream:    https://github.com/intel/ittapi
-Version:     pinned by ITT_HASH in tools/unitrace/CMakeLists.txt, the single
-             source of truth (not repeated here)
-License:     BSD-3-Clause OR GPL-2.0-only (dual); used under BSD-3-Clause
-             (see ./LICENSE)
-
-How it is used: scripts/get_itt.py clones ittapi at ITT_HASH and builds
-libittnotify. unitrace_tool uses the ittapi headers to collect ITT task/frame
-annotations (BUILD_WITH_ITT); unitrace_mpi links libittnotify statically when
-BUILD_WITH_MPI is enabled.
-
-To bump: update ITT_HASH in tools/unitrace/CMakeLists.txt, refresh LICENSE from
-upstream (LICENSES/BSD-3-Clause.txt) at the new commit, and update
-tools/unitrace/third-party-programs.txt if the license changed.
diff --git a/tools/unitrace/third_party/level-zero/LICENSE b/tools/unitrace/third_party/level-zero/LICENSE
deleted file mode 100644
index 87fdb724..00000000
--- a/tools/unitrace/third_party/level-zero/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (C) 2019-2026 Intel Corporation
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/tools/unitrace/third_party/level-zero/VERSION b/tools/unitrace/third_party/level-zero/VERSION
deleted file mode 100644
index 522e7f68..00000000
--- a/tools/unitrace/third_party/level-zero/VERSION
+++ /dev/null
@@ -1,15 +0,0 @@
-Level Zero API headers - fetched at build time from public upstream.
-
-Component:   Level Zero (oneAPI Level Zero specification headers)
-Upstream:    https://github.com/oneapi-src/level-zero
-Version:     pinned by LEVEL_ZERO_COMMIT_ID in tools/unitrace/CMakeLists.txt, the
-             single source of truth (not repeated here)
-License:     MIT (see ./LICENSE)
-
-How it is used: scripts/get_ze_headers.py clones level-zero at
-LEVEL_ZERO_COMMIT_ID and copies the API headers into the build tree; unitrace
-compiles against them.
-
-To bump: update LEVEL_ZERO_COMMIT_ID, refresh LICENSE from upstream at the new
-version, and update tools/unitrace/third-party-programs.txt if the license or
-copyright changed.
diff --git a/tools/unitrace/third_party/opencl-headers/LICENSE b/tools/unitrace/third_party/opencl-headers/LICENSE
deleted file mode 100644
index d6456956..00000000
--- a/tools/unitrace/third_party/opencl-headers/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/tools/unitrace/third_party/opencl-headers/VERSION b/tools/unitrace/third_party/opencl-headers/VERSION
deleted file mode 100644
index c3892d40..00000000
--- a/tools/unitrace/third_party/opencl-headers/VERSION
+++ /dev/null
@@ -1,18 +0,0 @@
-Khronos OpenCL(TM) API headers - fetched at build time from public upstream when
-no OpenCL headers are installed on the build host.
-
-Component:   OpenCL-Headers (cl.h, cl_gl.h, cl_version.h, cl_platform.h,
-             cl_ext.h)
-Upstream:    https://github.com/KhronosGroup/OpenCL-Headers
-Version:     pinned by the commit in tools/unitrace/scripts/get_cl_headers.py,
-             the single source of truth (not repeated here)
-License:     Apache-2.0 (see ./LICENSE)
-
-How it is used: cmake/OpenCL.cmake uses the host's OpenCL headers if found;
-otherwise scripts/get_cl_headers.py clones OpenCL-Headers at the pinned commit
-and copies the headers into the build tree. Either way unitrace compiles
-against the Khronos API headers.
-
-To bump: update the commit in get_cl_headers.py, refresh LICENSE from upstream
-at the new commit, and update tools/unitrace/third-party-programs.txt if the
-license or copyright changed.
diff --git a/tools/unitrace/third_party/perfetto/LICENSE b/tools/unitrace/third_party/perfetto/LICENSE
deleted file mode 100644
index 681d4000..00000000
--- a/tools/unitrace/third_party/perfetto/LICENSE
+++ /dev/null
@@ -1,285 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-------------------
-
-Files: * except those files noted below
-
-   Copyright (c) 2017, The Android Open Source Project
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-------------------
-
-Files: src/trace_processor/perfetto_sql/stdlib/chromium/*, protos/third_party/chromium/*, test/trace_processor/diff_tests/stdlib/chrome/*
-
-   Copyright 2015 The Chromium Authors
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-      * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-      * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-      * Neither the name of Google LLC nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-------------------
-
-Files: src/trace_processor/perfetto_sql/syntaqlite/syntaqlite_perfetto.{c, h}
-
-   Copyright 2025 The syntaqlite Authors. All rights reserved.
-
-   Machine-generated amalgamation of syntaqlite runtime + Perfetto dialect
-   sources (https://github.com/LalitMaganti/syntaqlite). Portions derive
-   from SQLite's public-domain `parse.y` grammar.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-------------------
-
-Files: src/trace_processor/perfetto_sql/preprocessor/preprocessor_grammar.{c, h}
-
-The author disclaims copyright to this source code. In place of a legal notice, here is a blessing:
-
-May you do good and not evil.
-May you find forgiveness for yourself and forgive others.
-May you share freely, never taking more than you give.
-
-
-------------------
-
-Files: src/base/intrusive_tree.cc
-
-$OpenBSD: tree.h,v 1.31 2023/03/08 04:43:09 guenther Exp $
-
-Copyright 2002 Niels Provos <provos@citi.umich.edu>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tools/unitrace/third_party/perfetto/VERSION b/tools/unitrace/third_party/perfetto/VERSION
deleted file mode 100644
index 79de909b..00000000
--- a/tools/unitrace/third_party/perfetto/VERSION
+++ /dev/null
@@ -1,52 +0,0 @@
-Perfetto fused trace proto - fetched at build time from public upstream.
-
-Component:   perfetto (fused trace protos)
-Upstream:    https://github.com/google/perfetto
-Tag:         v56.1
-File:        protos/perfetto/trace/perfetto_trace.proto
-License:     Apache-2.0 (see ./LICENSE)
-
-perfetto_trace.proto
-  size:    707859 bytes
-  sha256:  69515f6fa6c0073de20f08c7ddee1b54befa788847af956ad5f74d113340f4c3
-  syntax:  proto2
-  package: perfetto.protos  (generated C++ namespace: perfetto::protos)
-
-source tarball (archive/refs/tags/v56.1.tar.gz)
-  sha256:  e7b94164193323695a81013ee82e1678bf434fc9fbb79f03b50fe1027bc93b5b
-  purpose: compile the trace schema as many small translation units.
-
-Why the source tarball: perfetto_trace.proto is an amalgamation of ~250 source
-protos. Generated as one file it becomes a single 19.6 MB .pb.cc - one
-translation unit that cannot be compiled in parallel and dominated the unitrace
-build (3m38s on its own, vs 46s wall for the split sources on 12 cores; in CI
-the perfetto step went from ~125s to ~27s on Linux and 116s to 45s on Windows).
-The amalgamation records its source list in "Begin of protos/..." markers, so
-cmake/Perfetto.cmake extracts those protos from the pinned source tarball,
-generates one .pb.cc per proto and compiles them in parallel. The generated
-classes and the wire format are the same as from the amalgamated file. If the
-tarball cannot be fetched, its hash does not match, or a listed proto is missing
-from it, the build falls back to the single-file flow (slower, same output).
-
-The proto is NOT vendored in the tree. The build fetches it from upstream,
-verifies it against the sha256 above, and compiles it with protoc built from
-source (see CMakeLists.txt, BUILD_WITH_PERFETTO; protobuf is always built from
-source, never taken from a system install). Only this LICENSE and VERSION file
-are kept in-tree as the license/SBOM record. Requires network access when
-BUILD_WITH_PERFETTO is enabled; the build degrades to JSON-only if the fetch
-fails.
-
-To bump to a new tag <tag>:
-  1. Download and hash:
-       BASE=https://raw.githubusercontent.com/google/perfetto/<tag>
-       curl -fsSL $BASE/protos/perfetto/trace/perfetto_trace.proto -o /tmp/perfetto_trace.proto
-       curl -fsSL $BASE/LICENSE -o LICENSE
-       sha256sum /tmp/perfetto_trace.proto ; wc -c /tmp/perfetto_trace.proto
-       curl -fsSL https://github.com/google/perfetto/archive/refs/tags/<tag>.tar.gz -o /tmp/perfetto-src.tar.gz
-       sha256sum /tmp/perfetto-src.tar.gz
-  2. Update PERFETTO_TAG, PERFETTO_PROTO_SHA256 and PERFETTO_SRC_SHA256 in
-     tools/unitrace/cmake/Perfetto.cmake. A stale PERFETTO_SRC_SHA256 does not
-     break the build, but silently falls back to the slow single-TU flow -
-     the configure log warns about the hash mismatch.
-  3. Update Tag / size / sha256 values above (both files).
-  4. Update tools/unitrace/third-party-programs.txt if the license changed.
diff --git a/tools/unitrace/third_party/protobuf/LICENSE b/tools/unitrace/third_party/protobuf/LICENSE
deleted file mode 100644
index 19b305b0..00000000
--- a/tools/unitrace/third_party/protobuf/LICENSE
+++ /dev/null
@@ -1,32 +0,0 @@
-Copyright 2008 Google Inc.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Code generated by the Protocol Buffer compiler is owned by the owner
-of the input file used when generating it.  This code is not
-standalone and requires a support library to be linked with it.  This
-support library is itself covered by the above license.
diff --git a/tools/unitrace/third_party/protobuf/VERSION b/tools/unitrace/third_party/protobuf/VERSION
deleted file mode 100644
index b553f493..00000000
--- a/tools/unitrace/third_party/protobuf/VERSION
+++ /dev/null
@@ -1,17 +0,0 @@
-Protocol Buffers (protobuf) - built from source at build time from public upstream.
-
-Component:   protobuf (libprotobuf, protoc)
-Upstream:    https://github.com/protocolbuffers/protobuf
-Version:     pinned by PROTOBUF_TAG in tools/unitrace/cmake/Perfetto.cmake, the
-             single source of truth (not repeated here)
-License:     BSD-3-Clause (see ./LICENSE)
-
-How it is used: scripts/get_protobuf.py clones PROTOBUF_TAG (shallow) and builds
-protobuf as static, position-independent libraries into
-<build>/protobuf-install. libprotobuf is linked statically into unitrace_tool
-with hidden symbols; protoc is a build-time tool only and is not shipped. Never
-taken from a system install.
-
-To bump: update PROTOBUF_TAG in tools/unitrace/cmake/Perfetto.cmake, refresh
-LICENSE from upstream at the new tag, and update
-tools/unitrace/third-party-programs.txt if the license changed.
diff --git a/tools/unitrace/utils/cl_api_tracer.h b/tools/unitrace/utils/cl_api_tracer.h
deleted file mode 100644
index 83446a45..00000000
--- a/tools/unitrace/utils/cl_api_tracer.h
+++ /dev/null
@@ -1,146 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_CL_API_TRACER_H_
-#define UNITRACE_UTILS_CL_API_TRACER_H_
-
-#include <CL/tracing_api.h>
-
-#include "utils/unitrace_assert.h"
-
-class ClApiTracer {
- public:
-  ClApiTracer(
-      cl_device_id device, cl_tracing_callback callback, void* user_data) {
-    UNITRACE_ASSERT(device != nullptr);
-
-    bool loaded = LoadTracingFunctions(device);
-    if (!loaded) {
-      return;
-    }
-
-    cl_int status = CL_SUCCESS;
-    status = clCreateTracingHandle_(device, callback, user_data, &handle_);
-    if (status != CL_SUCCESS) {
-      handle_ = nullptr;
-    }
-  }
-
-  ClApiTracer(const ClApiTracer& that) = delete;
-
-  ~ClApiTracer() {
-    if (handle_ != nullptr) {
-      cl_int status = CL_SUCCESS;
-      status = clDestroyTracingHandle_(handle_);
-      UNITRACE_ASSERT(status == CL_SUCCESS);
-    }
-  }
-
-  bool SetTracingFunction(ClFunctionId function) {
-    if (!IsValid()) {
-      return false;
-    }
-
-    cl_int status = CL_SUCCESS;
-    status = clSetTracingPoint_(handle_, function, CL_TRUE);
-    if (status != CL_SUCCESS) {
-      return false;
-    }
-
-    return true;
-  }
-
-  bool Enable() {
-    if (!IsValid()) {
-      return false;
-    }
-
-    cl_int status = CL_SUCCESS;
-    status = clEnableTracing_(handle_);
-    if (status != CL_SUCCESS) {
-      return false;
-    }
-
-    return true;
-  }
-
-  bool Disable() {
-    if (!IsValid()) {
-      return false;
-    }
-
-    cl_int status = CL_SUCCESS;
-    status = clDisableTracing_(handle_);
-    if (status != CL_SUCCESS) {
-      return false;
-    }
-
-    return true;
-  }
-
-  bool IsValid() const {
-    return (handle_ != nullptr);
-  }
-
- private:
-  bool LoadTracingFunctions(cl_device_id device) {
-    UNITRACE_ASSERT(device != nullptr);
-
-    cl_int status = CL_SUCCESS;
-
-    cl_platform_id platform = nullptr;
-    status = clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform),
-                             &platform, nullptr);
-    UNITRACE_ASSERT(status == CL_SUCCESS);
-
-    clCreateTracingHandle_ =
-      reinterpret_cast<decltype(clCreateTracingHandleINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clCreateTracingHandleINTEL"));
-    clSetTracingPoint_ =
-      reinterpret_cast<decltype(clSetTracingPointINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clSetTracingPointINTEL"));
-    clDestroyTracingHandle_ =
-      reinterpret_cast<decltype(clDestroyTracingHandleINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clDestroyTracingHandleINTEL"));
-    clEnableTracing_ =
-      reinterpret_cast<decltype(clEnableTracingINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clEnableTracingINTEL"));
-    clDisableTracing_ =
-      reinterpret_cast<decltype(clDisableTracingINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clDisableTracingINTEL"));
-    clGetTracingState_ =
-      reinterpret_cast<decltype(clGetTracingStateINTEL)*>(
-        clGetExtensionFunctionAddressForPlatform(
-          platform, "clGetTracingStateINTEL"));
-    
-    if (clCreateTracingHandle_ == nullptr ||
-        clSetTracingPoint_ == nullptr ||
-        clDestroyTracingHandle_ == nullptr ||
-        clEnableTracing_ == nullptr ||
-        clDisableTracing_ == nullptr ||
-        clGetTracingState_ == nullptr) {
-      return false;
-    }
-
-    return true;
-  }
-
-  cl_tracing_handle handle_ = nullptr;
-
-  decltype(clCreateTracingHandleINTEL)* clCreateTracingHandle_ = nullptr;
-  decltype(clSetTracingPointINTEL)* clSetTracingPoint_ = nullptr;
-  decltype(clDestroyTracingHandleINTEL)* clDestroyTracingHandle_ = nullptr;
-  decltype(clEnableTracingINTEL)* clEnableTracing_ = nullptr;
-  decltype(clDisableTracingINTEL)* clDisableTracing_ = nullptr;
-  decltype(clGetTracingStateINTEL)* clGetTracingState_ = nullptr;
-};
-
-#endif // UNITRACE_UTILS_CL_API_TRACER_H_
diff --git a/tools/unitrace/utils/cl_utils.h b/tools/unitrace/utils/cl_utils.h
deleted file mode 100644
index c7e0807e..00000000
--- a/tools/unitrace/utils/cl_utils.h
+++ /dev/null
@@ -1,517 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_CL_UTILS_H_
-#define UNITRACE_UTILS_CL_UTILS_H_
-
-#include <string.h>
-
-#include <string>
-#include <vector>
-
-#include <CL/cl.h>
-
-#include "utils/demangle.h"
-#include "utils/utils.h"
-
-#define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR 0x2033
-
-namespace utils {
-namespace cl {
-
-inline std::string GetDeviceVendor(cl_device_id device) {
-  char vendor[MAX_STR_SIZE] = { 0 };
-  cl_int status = clGetDeviceInfo(
-      device, CL_DEVICE_VENDOR, MAX_STR_SIZE, vendor, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  return vendor;
-}
-
-inline std::vector<cl_device_id> GetDeviceList(cl_device_type type) {
-  cl_int status = CL_SUCCESS;
-
-  cl_uint platform_count = 0;
-  status = clGetPlatformIDs(0, nullptr, &platform_count);
-  if (status != CL_SUCCESS || platform_count == 0) {
-    return std::vector<cl_device_id>();
-  }
-
-  std::vector<cl_platform_id> platform_list(platform_count, nullptr);
-  status = clGetPlatformIDs(platform_count, platform_list.data(), nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  std::vector<cl_device_id> result;
-  for (cl_uint i = 0; i < platform_count; ++i) {
-    cl_uint device_count = 0;
-
-    status = clGetDeviceIDs(
-        platform_list[i], type, 0, nullptr, &device_count);
-    if (status != CL_SUCCESS || device_count == 0) continue;
-
-    std::vector<cl_device_id> device_list(device_count, nullptr);
-    status = clGetDeviceIDs(
-        platform_list[i], type, device_count, device_list.data(), nullptr);
-    UNITRACE_ASSERT(status == CL_SUCCESS);
-
-    for (cl_uint j = 0; j < device_count; ++j) {
-      if (GetDeviceVendor(device_list[j]).find("Intel") != std::string::npos) {
-        result.push_back(device_list[j]);
-      }
-    }
-  }
-
-  return result;
-}
-
-inline std::vector<cl_device_id> CreateSubDeviceList(cl_device_id device) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_device_partition_property props[] = {
-    CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
-    CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE,
-    0};
-
-  cl_uint sub_device_count = 0;
-  status = clCreateSubDevices(device, props, 0, nullptr, &sub_device_count);
-  UNITRACE_ASSERT(status == CL_SUCCESS || status == CL_DEVICE_PARTITION_FAILED);
-
-  if (status == CL_DEVICE_PARTITION_FAILED || sub_device_count == 0) {
-    return std::vector<cl_device_id>();
-  }
-
-  std::vector<cl_device_id> sub_device_list(sub_device_count);
-  status = clCreateSubDevices(
-      device, props, sub_device_count, sub_device_list.data(), nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return sub_device_list;
-}
-
-inline void ReleaseSubDeviceList(
-    const std::vector<cl_device_id>& sub_device_list) {
-  for (auto sub_device : sub_device_list) {
-    cl_int status = clReleaseDevice(sub_device);
-    UNITRACE_ASSERT(status == CL_SUCCESS);
-  }
-}
-
-inline cl_device_id GetIntelDevice(cl_device_type type) {
-  cl_device_id target = nullptr;
-
-  std::vector<cl_device_id> device_list = GetDeviceList(type);
-  for (auto device : device_list) {
-    if (GetDeviceVendor(device).find("Intel") != std::string::npos) {
-      target = device;
-      break;
-    }
-  }
-
-  return target;
-}
-
-inline cl_device_id GetDeviceParent(cl_device_id device) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  cl_device_id parent = nullptr;
-  cl_int status = clGetDeviceInfo(
-      device, CL_DEVICE_PARENT_DEVICE, sizeof(cl_device_id), &parent, nullptr);
-  UNITRACE_ASSERT(status != CL_SUCCESS);
-
-  return parent;
-}
-
-inline std::string GetKernelName(cl_kernel kernel, bool demangle = false) {
-  UNITRACE_ASSERT(kernel != nullptr);
-
-  char name[MAX_STR_SIZE] = { 0 };
-  cl_int status = CL_SUCCESS;
-
-  status = clGetKernelInfo(
-      kernel, CL_KERNEL_FUNCTION_NAME, MAX_STR_SIZE, name, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  if (demangle) {
-    return utils::Demangle(name);
-  }
-  return name;
-}
-
-inline std::string GetDeviceName(cl_device_id device) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  char name[MAX_STR_SIZE] = { 0 };
-  cl_int status = clGetDeviceInfo(
-      device, CL_DEVICE_NAME, MAX_STR_SIZE, name, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return name;
-}
-
-inline cl_device_type GetDeviceType(cl_device_id device) {
-  UNITRACE_ASSERT(device != nullptr);
-
-  cl_device_type type = CL_DEVICE_TYPE_ALL;
-  cl_int status = clGetDeviceInfo(
-      device, CL_DEVICE_TYPE, sizeof(type), &type, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  UNITRACE_ASSERT(type != CL_DEVICE_TYPE_ALL);
-
-  return type;
-}
-
-inline cl_program GetProgram(cl_kernel kernel) {
-  UNITRACE_ASSERT(kernel != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_program program = nullptr;
-  
-  status = clGetKernelInfo(kernel, CL_KERNEL_PROGRAM, sizeof(cl_program),
-                           &program, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return program;
-}
-
-inline cl_context GetContext(cl_kernel kernel) {
-  UNITRACE_ASSERT(kernel != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_context context = nullptr;
-  
-  status = clGetKernelInfo(kernel, CL_KERNEL_CONTEXT, sizeof(cl_context),
-                           &context, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return context;
-}
-
-inline std::vector<cl_device_id> GetDeviceList(cl_program program) {
-  UNITRACE_ASSERT(program != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_uint device_count = 0;
-  status = clGetProgramInfo(program, CL_PROGRAM_NUM_DEVICES, sizeof(cl_uint),
-                            &device_count, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  if (device_count == 0) {
-    return std::vector<cl_device_id>();
-  }
-
-  std::vector<cl_device_id> device_list(device_count);
-  status = clGetProgramInfo(program, CL_PROGRAM_DEVICES,
-                            device_count * sizeof(cl_device_id),
-                            device_list.data(), nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return device_list;
-}
-
-inline cl_queue_properties* EnableQueueProfiling(
-    const cl_queue_properties* props) {
-  cl_queue_properties* props_with_prof = nullptr;
-
-  if (props == nullptr) {
-    props_with_prof = new cl_queue_properties[3];
-    props_with_prof[0] = CL_QUEUE_PROPERTIES;
-    props_with_prof[1] = CL_QUEUE_PROFILING_ENABLE;
-    props_with_prof[2] = 0;
-  } else {
-    int queue_props_id = -1;
-    int props_count = 0;
-    
-    // the end of the properties list is marked by 0 on the last even index
-    while (props[props_count] != 0) {
-      if (props[props_count] == CL_QUEUE_PROPERTIES) {
-        queue_props_id = props_count;
-      }
-      
-      // increase by 2 to always check even elements in properties list
-      props_count+=2;
-    }
-    UNITRACE_ASSERT(!(props_count&1));
-    UNITRACE_ASSERT(props[props_count] == 0);
-
-    if (queue_props_id >= 0 && queue_props_id + 1 < props_count) {
-      props_with_prof = new cl_queue_properties[props_count + 1];
-      for (int i = 0; i < props_count; ++i) {
-        props_with_prof[i] = props[i];
-      }
-      props_with_prof[queue_props_id + 1] |=
-        static_cast<unsigned long>(CL_QUEUE_PROFILING_ENABLE);
-      props_with_prof[props_count] = 0;
-    } else {
-      props_with_prof = new cl_queue_properties[props_count + 3];
-      for (int i = 0; i < props_count; ++i) {
-        props_with_prof[i] = props[i];
-      }
-      props_with_prof[props_count] = CL_QUEUE_PROPERTIES;
-      props_with_prof[props_count + 1] = CL_QUEUE_PROFILING_ENABLE;
-      props_with_prof[props_count + 2] = 0;
-    }
-  }
-
-  return props_with_prof;
-}
-
-inline bool CheckExtension(cl_device_id device, const char* extension) {
-  cl_int status = CL_SUCCESS;
-
-  size_t size = 0;
-  status = clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS, 0, nullptr, &size);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  if (size == 0) {
-    return false;
-  }
-
-  std::vector<char> buffer(size);
-  status = clGetDeviceInfo(
-      device, CL_DEVICE_EXTENSIONS, size, buffer.data(), nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  std::string extensions(buffer.begin(), buffer.end());
-  if (extensions.find(extension) != std::string::npos) {
-    return true;
-  }
-
-  return false;
-}
-
-inline size_t GetKernelSimdWidth(cl_device_id device, cl_kernel kernel) {
-  UNITRACE_ASSERT(device != nullptr && kernel != nullptr);
-  cl_int status = CL_SUCCESS;
-
-  if (!CheckExtension(device, "cl_intel_subgroups")) {
-    return 0;
-  }
-
-  typedef cl_int (*clGetKernelSubGroupInfoKHR)(
-      cl_kernel kernel, cl_device_id device,
-      cl_kernel_sub_group_info param_name, size_t input_value_size,
-      const void* input_value, size_t param_value_size,
-      void* param_value, size_t* param_value_size_ret);
-
-  cl_platform_id platform = nullptr;
-  status = clGetDeviceInfo(
-      device, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &platform, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  UNITRACE_ASSERT(platform != nullptr);
-
-  clGetKernelSubGroupInfoKHR func =
-    reinterpret_cast<clGetKernelSubGroupInfoKHR>(
-        clGetExtensionFunctionAddressForPlatform(
-            platform, "clGetKernelSubGroupInfoKHR"));
-  UNITRACE_ASSERT(func != nullptr);
-
-  size_t local_size[3]{0, 0, 0};
-
-  size_t simd_width = 0;
-  status = func(
-      kernel, device, CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR,
-      sizeof(size_t[3]), local_size, sizeof(size_t), &simd_width, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return simd_width;
-}
-
-inline cl_command_queue GetCommandQueue(cl_event event) {
-  UNITRACE_ASSERT(event != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_command_queue queue = nullptr;
-  status = clGetEventInfo(event, CL_EVENT_COMMAND_QUEUE,
-                          sizeof(cl_command_queue), &queue, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return queue;
-}
-
-inline cl_device_id GetDevice(cl_command_queue queue) {
-  UNITRACE_ASSERT(queue != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_device_id device = nullptr;
-  status = clGetCommandQueueInfo(queue, CL_QUEUE_DEVICE,
-                                 sizeof(cl_device_id), &device, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-
-  return device;
-}
-
-inline cl_ulong GetEventTimestamp(cl_event event, cl_profiling_info info) {
-  UNITRACE_ASSERT(event != nullptr);
-
-  cl_int status = CL_SUCCESS;
-  cl_ulong start = 0;
-
-  status = clGetEventProfilingInfo(
-      event, info, sizeof(cl_ulong), &start, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  return start;
-}
-
-inline cl_int GetEventStatus(cl_event event) {
-  UNITRACE_ASSERT(event != nullptr);
-  cl_int event_status = CL_QUEUED;
-  cl_int status = clGetEventInfo(
-      event, CL_EVENT_COMMAND_EXECUTION_STATUS,
-      sizeof(cl_int), &event_status, nullptr);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-  return event_status;
-}
-
-inline void GetTimestamps(
-    cl_device_id device,
-    cl_ulong* host_timestamp,
-    cl_ulong* device_timestamp) {
-  UNITRACE_ASSERT(device != nullptr);
-  UNITRACE_ASSERT(host_timestamp != nullptr);
-  UNITRACE_ASSERT(device_timestamp != nullptr);
-  cl_int status = clGetDeviceAndHostTimer(
-      device, device_timestamp, host_timestamp);
-  UNITRACE_ASSERT(status == CL_SUCCESS);
-#if defined(__gnu_linux__)
-  if (GetDeviceType(device) == CL_DEVICE_TYPE_CPU) {
-    *host_timestamp = utils::ConvertClockMonotonicToRaw(*host_timestamp);
-  }
-#endif
-}
-
-inline const char* GetErrorString(cl_int error) {
-  switch (error) {
-    case CL_SUCCESS:
-      return "CL_SUCCESS";
-    case CL_DEVICE_NOT_FOUND:
-      return "CL_DEVICE_NOT_FOUND";
-    case CL_DEVICE_NOT_AVAILABLE:
-      return "CL_DEVICE_NOT_AVAILABLE";
-    case CL_COMPILER_NOT_AVAILABLE:
-      return "CL_COMPILER_NOT_AVAILABLE";
-    case CL_MEM_OBJECT_ALLOCATION_FAILURE:
-      return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
-    case CL_OUT_OF_RESOURCES:
-      return "CL_OUT_OF_RESOURCES";
-    case CL_OUT_OF_HOST_MEMORY:
-      return "CL_OUT_OF_HOST_MEMORY";
-    case CL_PROFILING_INFO_NOT_AVAILABLE:
-      return "CL_PROFILING_INFO_NOT_AVAILABLE";
-    case CL_MEM_COPY_OVERLAP:
-      return "CL_MEM_COPY_OVERLAP";
-    case CL_IMAGE_FORMAT_MISMATCH:
-      return "CL_IMAGE_FORMAT_MISMATCH";
-    case CL_IMAGE_FORMAT_NOT_SUPPORTED:
-      return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
-    case CL_BUILD_PROGRAM_FAILURE:
-      return "CL_BUILD_PROGRAM_FAILURE";
-    case CL_MAP_FAILURE:
-      return "CL_MAP_FAILURE";
-    case CL_MISALIGNED_SUB_BUFFER_OFFSET:
-      return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
-    case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:
-      return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
-    case CL_COMPILE_PROGRAM_FAILURE:
-      return "CL_COMPILE_PROGRAM_FAILURE";
-    case CL_LINKER_NOT_AVAILABLE:
-      return "CL_LINKER_NOT_AVAILABLE";
-    case CL_LINK_PROGRAM_FAILURE:
-      return "CL_LINK_PROGRAM_FAILURE";
-    case CL_DEVICE_PARTITION_FAILED:
-      return "CL_DEVICE_PARTITION_FAILED";
-    case CL_KERNEL_ARG_INFO_NOT_AVAILABLE:
-      return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE";
-    case CL_INVALID_VALUE:
-      return "CL_INVALID_VALUE";
-    case CL_INVALID_DEVICE_TYPE:
-      return "CL_INVALID_DEVICE_TYPE";
-    case CL_INVALID_PLATFORM:
-      return "CL_INVALID_PLATFORM";
-    case CL_INVALID_DEVICE:
-      return "CL_INVALID_DEVICE";
-    case CL_INVALID_CONTEXT:
-      return "CL_INVALID_CONTEXT";
-    case CL_INVALID_QUEUE_PROPERTIES:
-      return "CL_INVALID_QUEUE_PROPERTIES";
-    case CL_INVALID_COMMAND_QUEUE:
-      return "CL_INVALID_COMMAND_QUEUE";
-    case CL_INVALID_HOST_PTR:
-      return "CL_INVALID_HOST_PTR";
-    case CL_INVALID_MEM_OBJECT:
-      return "CL_INVALID_MEM_OBJECT";
-    case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
-      return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
-    case CL_INVALID_IMAGE_SIZE:
-      return "CL_INVALID_IMAGE_SIZE";
-    case CL_INVALID_SAMPLER:
-      return "CL_INVALID_SAMPLER";
-    case CL_INVALID_BINARY:
-      return "CL_INVALID_BINARY";
-    case CL_INVALID_BUILD_OPTIONS:
-      return "CL_INVALID_BUILD_OPTIONS";
-    case CL_INVALID_PROGRAM:
-      return "CL_INVALID_PROGRAM";
-    case CL_INVALID_PROGRAM_EXECUTABLE:
-      return "CL_INVALID_PROGRAM_EXECUTABLE";
-    case CL_INVALID_KERNEL_NAME:
-      return "CL_INVALID_KERNEL_NAME";
-    case CL_INVALID_KERNEL_DEFINITION:
-      return "CL_INVALID_KERNEL_DEFINITION";
-    case CL_INVALID_KERNEL:
-      return "CL_INVALID_KERNEL";
-    case CL_INVALID_ARG_INDEX:
-      return "CL_INVALID_ARG_INDEX";
-    case CL_INVALID_ARG_VALUE:
-      return "CL_INVALID_ARG_VALUE";
-    case CL_INVALID_ARG_SIZE:
-      return "CL_INVALID_ARG_SIZE";
-    case CL_INVALID_KERNEL_ARGS:
-      return "CL_INVALID_KERNEL_ARGS";
-    case CL_INVALID_WORK_DIMENSION:
-      return "CL_INVALID_WORK_DIMENSION";
-    case CL_INVALID_WORK_GROUP_SIZE:
-      return "CL_INVALID_WORK_GROUP_SIZE";
-    case CL_INVALID_WORK_ITEM_SIZE:
-      return "CL_INVALID_WORK_ITEM_SIZE";
-    case CL_INVALID_GLOBAL_OFFSET:
-      return "CL_INVALID_GLOBAL_OFFSET";
-    case CL_INVALID_EVENT_WAIT_LIST:
-      return "CL_INVALID_EVENT_WAIT_LIST";
-    case CL_INVALID_EVENT:
-      return "CL_INVALID_EVENT";
-    case CL_INVALID_OPERATION:
-      return "CL_INVALID_OPERATION";
-    case CL_INVALID_GL_OBJECT:
-      return "CL_INVALID_GL_OBJECT";
-    case CL_INVALID_BUFFER_SIZE:
-      return "CL_INVALID_BUFFER_SIZE";
-    case CL_INVALID_MIP_LEVEL:
-      return "CL_INVALID_MIP_LEVEL";
-    case CL_INVALID_GLOBAL_WORK_SIZE:
-      return "CL_INVALID_GLOBAL_WORK_SIZE";
-    case CL_INVALID_PROPERTY:
-      return "CL_INVALID_PROPERTY";
-    case CL_INVALID_IMAGE_DESCRIPTOR:
-      return "CL_INVALID_IMAGE_DESCRIPTOR";
-    case CL_INVALID_COMPILER_OPTIONS:
-      return "CL_INVALID_COMPILER_OPTIONS";
-    case CL_INVALID_LINKER_OPTIONS:
-      return "CL_INVALID_LINKER_OPTIONS";
-    case CL_INVALID_DEVICE_PARTITION_COUNT:
-      return "CL_INVALID_DEVICE_PARTITION_COUNT";
-    case CL_INVALID_PIPE_SIZE:
-      return "CL_INVALID_PIPE_SIZE";
-    case CL_INVALID_DEVICE_QUEUE:
-      return "CL_INVALID_DEVICE_QUEUE";
-    default:
-      break;
-  }
-  return "UNKNOWN";
-}
-
-} // namespace cl
-} // namespace utils
-
-#endif // UNITRACE_UTILS_CL_UTILS_H_
\ No newline at end of file
diff --git a/tools/unitrace/utils/demangle.h b/tools/unitrace/utils/demangle.h
deleted file mode 100644
index d34dc4e9..00000000
--- a/tools/unitrace/utils/demangle.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef UNITRACE_UTILS_DEMANGLE_H_
-#define UNITRACE_UTILS_DEMANGLE_H_
-
-#if __has_include(<cxxabi.h>)
-#define HAVE_CXXABI 1
-#include <cxxabi.h>
-#include <cstring>
-#else
-#define HAVE_CXXABI 0
-#endif
-#include <string>
-
-#include "utils/unitrace_assert.h"
-
-namespace utils {
-
-static inline std::string Demangle(const char* name) {
-  UNITRACE_ASSERT(name != nullptr);
-
-#if HAVE_CXXABI
-  int status = 0;
-  char* demangled = abi::__cxa_demangle(name, nullptr, 0, &status);
-  if (status != 0) {
-    return name;
-  }
-
-  constexpr const char* const prefix_to_skip = "typeinfo name for ";
-  const size_t prefix_to_skip_len = strlen(prefix_to_skip);
-  const size_t shift =
-    (std::strncmp(demangled, prefix_to_skip, prefix_to_skip_len) == 0) ?
-    prefix_to_skip_len : 0;
-
-  std::string result(demangled + shift);
-  free(demangled);
-  return result;
-#else
-  return name;
-#endif
-}
-
-} // namespace utils
-
-#undef HAVE_CXXABI
-
-#endif // UNITRACE_UTILS_DEMANGLE_H_
\ No newline at end of file
diff --git a/tools/unitrace/utils/unilogger.h b/tools/unitrace/utils/unilogger.h
deleted file mode 100644
index 9fc8c327..00000000
--- a/tools/unitrace/utils/unilogger.h
+++ /dev/null
@@ -1,263 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_UNILOGGER_H_
-#define UNITRACE_UTILS_UNILOGGER_H_
-
-#include <iostream>
-#include <fstream>
-#include <mutex>
-#include <string>
-
-#ifndef _WIN32
-#include <unistd.h>
-#endif /* _WIN32 */
-#ifdef __linux__
-#include <dirent.h>
-#include <climits>
-#include <cstdlib>
-#include <cstring>
-#endif /* __linux__ */
-
-#include "utils/unitrace_assert.h"
-
-class UniLogger {
- public:
-  UniLogger(const std::string& filename, bool lazy_flush = false, bool lock_free = false, bool binary = false) {
-    if (!filename.empty()) {
-      // Binary mode for the Perfetto protobuf stream; text otherwise.
-      file_.open(filename, binary ? (std::ios::out | std::ios::binary) : std::ios::out);
-      if (!(file_.is_open())) {
-        std::cerr << "[ERROR] Failed to open file " << filename << " for writing. Do you have the right permission?" << std::endl;
-        exit(-1);
-      }
-    }
-    lazy_flush_ = lazy_flush;
-    lock_free_ = lock_free;
-    binary_ = binary;
-    log_file_name_ = filename;
-  }
-
-  UniLogger(const UniLogger& that) = delete;
-
-  ~UniLogger() {
-    // Close() is idempotent: if the stream was already closed early (e.g. when
-    // a session was stopped, see Close()), this is a no-op and does not touch
-    // the (now released) file.
-    Close();
-  }
-
-  // Flush buffered data and close the file so it is durable immediately, not
-  // only at teardown. Later Log()/Flush() calls become no-ops (never fall
-  // through to std::cerr). Idempotent: safe from an early stop and the dtor.
-  void Close() {
-    const std::lock_guard<std::mutex> lock(lock_);
-    if (closed_) {
-      return;
-    }
-    closed_ = true;
-    if (file_.is_open()) {
-      if (file_.tellp() == empty_pos_) {
-        // Nothing was written: close without flushing and remove the empty file.
-        file_.close();
-        std::remove(log_file_name_.c_str());
-      }
-      else {
-        // Data was written: flush it out, then close.
-        file_ << std::flush;
-        file_.close();
-      }
-    }
-  }
-
-#ifndef _WIN32
-  // Fork child: the inherited stream shares the parent's file offset and holds
-  // a copy of its unflushed bytes. Disown it WITHOUT flushing (those bytes are
-  // the parent's) and open our own file. Single-threaded context: no lock.
-  void ReopenAfterFork(const std::string& filename) {
-    if (!file_.is_open()) {
-      return;  // logging to stderr: nothing to disown
-    }
-    const std::string inherited_name = log_file_name_;
-    // Park the inherited state in a filebuf that is never destroyed, since its
-    // destructor would flush the copied bytes. One small leak per fork.
-    std::filebuf* orphan = new std::filebuf();
-    file_.rdbuf()->swap(*orphan);
-    file_.clear();
-    ReleaseInheritedDescriptor(inherited_name);
-
-    log_file_name_ = filename;
-    closed_ = false;
-    empty_pos_ = 0;
-    file_.open(filename, binary_ ? (std::ios::out | std::ios::binary) : std::ios::out);
-    if (!file_.is_open()) {
-      std::cerr << "[ERROR] Failed to open file " << filename << " for writing in forked process " << getpid() << std::endl;
-      // Stay silent rather than fall through to the std::cerr path in Log().
-      closed_ = true;
-    }
-  }
-
-  // atfork prepare/after hooks: hold lock_ across fork() so no other thread
-  // can leave it locked in the child. The forking thread owns the lock in both
-  // processes, so a plain unlock is valid in the parent and the child.
-  void LockForFork() { lock_.lock(); }
-  void UnlockAfterFork() { lock_.unlock(); }
-#endif /* _WIN32 */
-
-  void Log(const std::string& text) {
-    // Once closed, drop the write. Do NOT fall through to the std::cerr branch
-    // below (that path is only for the "never opened a file" case); a closed
-    // file must stay silent, not echo trace data to the terminal.
-    if (closed_) {
-      return;
-    }
-    if (file_.is_open()) {
-      if (lock_free_) {
-        file_ << text;
-        if (!lazy_flush_) {
-          file_ << std::flush;
-        }
-      }
-      else {
-        const std::lock_guard<std::mutex> lock(lock_);
-        file_ << text;
-        if (!lazy_flush_) {
-          file_ << std::flush;
-        }
-      }
-    } else {
-      std::cerr << text;
-      if (!lazy_flush_) {
-        std::cerr << std::flush;
-      }
-    }
-  }
-
-  // Binary write overload (raw bytes), used by the Perfetto protobuf emitter.
-  void Log(const void* data, size_t len) {
-    // Once closed, drop the write (mirrors the string Log above). A late
-    // protobuf packet after Close() must not fall through to the std::cerr
-    // branch below, which would spray raw binary bytes onto the terminal.
-    if (closed_) {
-      return;
-    }
-    const std::streamsize count = static_cast<std::streamsize>(len);
-    if (file_.is_open()) {
-      if (lock_free_) {
-        file_.write(static_cast<const char*>(data), count);
-        if (!lazy_flush_) {
-          file_ << std::flush;
-        }
-      }
-      else {
-        const std::lock_guard<std::mutex> lock(lock_);
-        file_.write(static_cast<const char*>(data), count);
-        if (!lazy_flush_) {
-          file_ << std::flush;
-        }
-      }
-    } else {
-      std::cerr.write(static_cast<const char*>(data), count);
-      if (!lazy_flush_) {
-        std::cerr << std::flush;
-      }
-    }
-  }
-
-  void Flush() {
-    if (closed_) {
-      return;
-    }
-    if (file_.is_open()) {
-      if (lock_free_) {
-        file_ << std::flush;
-      }
-      else {
-        const std::lock_guard<std::mutex> lock(lock_);
-        file_ << std::flush;
-      }
-    } else {
-      std::cerr << std::flush;
-    }
-  }
-
-  std::string GetLogFileName() const {
-    return log_file_name_;
-  }
-
-  std::iostream::pos_type GetLogFilePosition() {
-    return file_.tellp();
-  }
-
-  void SetEmptyPosition() {
-    if (file_.is_open()) {
-      empty_pos_ = file_.tellp();
-    }
-  }
-
-  bool IsEmpty() {
-    if (file_.is_open()) {
-      return file_.tellp() == empty_pos_;
-    }
-    return true;
-  }
-
-  // Returns true if logging to file, false if logging to screen
-  bool IsLogToFile() const {
-    return file_.is_open();
-  }
-
- private:
-#ifndef _WIN32
-  // Close the inherited descriptor behind the orphaned filebuf so the child
-  // does not hold the parent's file open. The stream API hides the fd; on Linux
-  // find it via /proc/self/fd, elsewhere leave it open (nothing writes to it).
-  static void ReleaseInheritedDescriptor(const std::string& name) {
-#ifdef __linux__
-    char target[PATH_MAX];
-    if (realpath(name.c_str(), target) == nullptr) {
-      return;
-    }
-    DIR* dir = opendir("/proc/self/fd");
-    if (dir == nullptr) {
-      return;
-    }
-    const int dir_fd = dirfd(dir);
-    while (struct dirent* ent = readdir(dir)) {
-      char* end = nullptr;
-      const long fd = strtol(ent->d_name, &end, 10);
-      if (end == ent->d_name || *end != '\0' || fd == dir_fd) {
-        continue;
-      }
-      char link[PATH_MAX];
-      const ssize_t n = readlinkat(dir_fd, ent->d_name, link, sizeof(link) - 1);
-      if (n < 0) {
-        continue;
-      }
-      link[n] = '\0';
-      if (strcmp(link, target) == 0) {
-        close(static_cast<int>(fd));
-        break;
-      }
-    }
-    closedir(dir);
-#else  /* __linux__ */
-    (void)name;
-#endif /* __linux__ */
-  }
-#endif /* _WIN32 */
-
-  std::string log_file_name_;
-  std::mutex lock_;
-  std::ofstream file_;
-  std::iostream::pos_type empty_pos_ = 0;
-  bool lazy_flush_;
-  bool lock_free_;	// caller deal with concurrency?
-  bool binary_ = false;
-  bool closed_ = false;	// true once Close() has flushed and released the file
-};
-
-#endif // UNITRACE_UTILS_UNILOGGER_H_
diff --git a/tools/unitrace/utils/unitrace_assert.h b/tools/unitrace/utils/unitrace_assert.h
deleted file mode 100644
index 1a94483b..00000000
--- a/tools/unitrace/utils/unitrace_assert.h
+++ /dev/null
@@ -1,27 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_UNITRACE_ASSERT_H_
-#define UNITRACE_UTILS_UNITRACE_ASSERT_H_
-
-#include <cstdio>
-#include <cstdlib>
-
-// UNITRACE_ASSERT is always active, also in release (NDEBUG) builds. It does
-// not use the standard assert() macro: <cassert> re-reads NDEBUG every time it
-// is included, so any later #include <cassert> in the same translation unit
-// would turn an assert()-based macro into a no-op.
-[[noreturn]] inline void UnitraceAssertFail(const char* expr, const char* file, int line,
-                                            const char* func) {
-  std::fprintf(stderr, "%s:%d: %s: Assertion `%s' failed.\n", file, line, func, expr);
-  std::fflush(stderr);
-  std::abort();
-}
-
-#define UNITRACE_ASSERT(X) \
-  ((X) ? static_cast<void>(0) : UnitraceAssertFail(#X, __FILE__, __LINE__, __func__))
-
-#endif  // UNITRACE_UTILS_UNITRACE_ASSERT_H_
diff --git a/tools/unitrace/utils/utils.h b/tools/unitrace/utils/utils.h
deleted file mode 100644
index 2f910bad..00000000
--- a/tools/unitrace/utils/utils.h
+++ /dev/null
@@ -1,270 +0,0 @@
-//==============================================================
-// Copyright (C) Intel Corporation
-//
-// SPDX-License-Identifier: MIT
-// =============================================================
-
-#ifndef UNITRACE_UTILS_UTILS_H_
-#define UNITRACE_UTILS_UTILS_H_
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <unistd.h>
-#include <sys/syscall.h>
-#endif
-
-#include <stdint.h>
-
-#include <fstream>
-#include <string>
-#include <vector>
-
-#include "utils/unitrace_assert.h"
-
-#ifdef _WIN32
-#define PTI_EXPORT __declspec(dllexport)
-#else
-#define PTI_EXPORT __attribute__ ((visibility ("default")))
-#endif
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-
-#define MAX_STR_SIZE 1024
-
-#define BYTES_IN_MBYTES (1024 * 1024)
-
-#define NSEC_IN_USEC 1000
-#define MSEC_IN_SEC  1000
-#define NSEC_IN_MSEC 1000000
-#define NSEC_IN_SEC  1000000000
-
-namespace utils {
-
-struct DeviceUUID {
-  uint16_t vendorID;
-  uint16_t deviceID;
-  uint16_t revisionID;
-  uint16_t pciDomain;
-  uint8_t pciBus;
-  uint8_t pciDevice;
-  uint8_t pciFunction;
-  uint8_t reserved[4];
-  uint8_t subDeviceId;
-};
-
-struct Comparator {
-  template<typename T>
-  bool operator()(const T& left, const T& right) const {
-    if (left.second != right.second) {
-      return left.second > right.second;
-    }
-    return left.first > right.first;
-  }
-};
-
-template<typename T>
-struct ComparatorPciAddress {
-  bool operator()(const T& left, const T& right) const {
-    if (left.BusNumber != right.BusNumber) {
-        return (left.BusNumber < right.BusNumber);
-    }
-    if (left.DeviceNumber != right.DeviceNumber) {
-        return (left.DeviceNumber < right.DeviceNumber);
-    }
-    return left.FunctionNumber < right.FunctionNumber;
-  }
-};
-
-#if defined(__gnu_linux__)
-
-inline uint64_t GetTime(clockid_t id) {
-  timespec ts{0,0};
-  int status = clock_gettime(id, &ts);
-  UNITRACE_ASSERT(status == 0);
-  return ts.tv_sec * NSEC_IN_SEC + ts.tv_nsec;
-}
-
-inline uint64_t ConvertClockMonotonicToRaw(uint64_t clock_monotonic) {
-  uint64_t raw = GetTime(CLOCK_MONOTONIC_RAW);
-  uint64_t monotonic = GetTime(CLOCK_MONOTONIC);
-  return (raw > monotonic) ?
-    clock_monotonic + (raw - monotonic) :
-    clock_monotonic - (monotonic - raw);
-}
-
-#endif
-
-inline std::string GetFilePath(const std::string& filename) {
-  UNITRACE_ASSERT(!filename.empty());
-
-  size_t pos = filename.find_last_of("/\\");
-  if (pos == std::string::npos) {
-    return "";
-  }
-
-  return filename.substr(0, pos + 1);
-}
-
-inline std::string GetExecutablePath() {
-  char buffer[MAX_STR_SIZE] = { 0 };
-#if defined(_WIN32)
-  DWORD status = GetModuleFileNameA(nullptr, buffer, MAX_STR_SIZE);
-  UNITRACE_ASSERT(status > 0);
-#else
-  ssize_t status = readlink("/proc/self/exe", buffer, MAX_STR_SIZE);
-  UNITRACE_ASSERT(status > 0);
-#endif
-  return GetFilePath(buffer);
-}
-
-inline std::string GetExecutableName() {
-  char buffer[MAX_STR_SIZE] = { 0 };
-#if defined(_WIN32)
-  DWORD status = GetModuleFileNameA(nullptr, buffer, MAX_STR_SIZE);
-  UNITRACE_ASSERT(status > 0);
-#else
-  ssize_t status = readlink("/proc/self/exe", buffer, MAX_STR_SIZE);
-  UNITRACE_ASSERT(status > 0);
-#endif
-  std::string path(buffer);
-  return path.substr(path.find_last_of("/\\") + 1);
-}
-
-inline std::vector<uint8_t> LoadBinaryFile(const std::string& path) {
-  std::vector<uint8_t> binary;
-  std::ifstream stream(path, std::ios::in | std::ios::binary);
-  if (!stream.good()) {
-    return binary;
-  }
-
-  stream.seekg(0, std::ifstream::end);
-  size_t size = stream.tellg();
-  stream.seekg(0, std::ifstream::beg);
-  if (size == 0) {
-    return binary;
-  }
-
-  binary.resize(size);
-  stream.read(reinterpret_cast<char *>(binary.data()), size);
-  return binary;
-}
-
-inline void SetEnv(const char* name, const char* value) {
-  UNITRACE_ASSERT(name != nullptr);
-  UNITRACE_ASSERT(value != nullptr);
-
-  int status = 0;
-#if defined(_WIN32)
-  std::string str = std::string(name) + "=" + value;
-  status = _putenv(str.c_str());
-  // _putenv only updates the CRT environment. Some consumers (and the static
-  // ittnotify that reads INTEL_LIBITTNOTIFY64 via GetEnvironmentVariableA) read
-  // the Win32 environment block, and CreateProcess inherits that block. Update
-  // it too so the value reaches them and is inherited by child processes.
-  SetEnvironmentVariableA(name, value);
-#else
-  status = setenv(name, value, 1);
-#endif
-  UNITRACE_ASSERT(status == 0);
-}
-
-inline std::string GetEnv(const char* name) {
-  UNITRACE_ASSERT(name != nullptr);
-#if defined(_WIN32)
-  char* value = nullptr;
-  errno_t status = _dupenv_s(&value, nullptr, name);
-  UNITRACE_ASSERT(status == 0);
-  if (value == nullptr) {
-    return std::string();
-  }
-  std::string result(value);
-  free(value);
-  return result;
-#else
-  const char* value = getenv(name);
-  if (value == nullptr) {
-    return std::string();
-  }
-  return std::string(value);
-#endif
-}
-
-inline uint32_t GetPid() {
-#if defined(_WIN32)
-  return GetCurrentProcessId();
-#else
-  return getpid();
-#endif
-}
-
-inline uint32_t GetTid() {
-#if defined(_WIN32)
-  return (uint32_t)GetCurrentThreadId();
-#else
-#ifdef SYS_gettid
-  return (uint32_t)syscall(SYS_gettid);
-#else
-  #error "SYS_gettid is unavailable on this system"
-#endif
-#endif
-}
-
-inline uint64_t GetSystemTime() {
-#if defined(_WIN32)
-  LARGE_INTEGER ticks{{0}};
-  LARGE_INTEGER frequency{{0}};
-  BOOL status = QueryPerformanceFrequency(&frequency);
-  UNITRACE_ASSERT(status != 0);
-  status = QueryPerformanceCounter(&ticks);
-  UNITRACE_ASSERT(status != 0);
-  return ticks.QuadPart * (NSEC_IN_SEC / frequency.QuadPart);
-#else
-  return GetTime(CLOCK_MONOTONIC_RAW);
-#endif
-}
-
-inline size_t LowerBound(const std::vector<uint64_t>& data, uint64_t value) {
-  size_t start = 0;
-  size_t end = data.size();
-  while (start < end) {
-    size_t middle = (start + end) / 2;
-    if (value <= data[middle]) {
-      end = middle;
-    } else {
-      start = middle + 1;
-    }
-  }
-  return start;
-}
-
-inline size_t UpperBound(const std::vector<uint64_t>& data, uint64_t value) {
-  size_t start = 0;
-  size_t end = data.size();
-  while (start < end) {
-    size_t middle = (start + end) / 2;
-    if (value >= data[middle]) {
-      start = middle + 1;
-    } else {
-      end = middle;
-    }
-  }
-  return start;
-}
-
-inline std::vector<std::string> SplitString(const std::string& s, char delimiter) {
-  std::vector<std::string> res;
-  size_t start = 0;
-  size_t end = 0;
-  while ((end = s.find(delimiter, start)) != std::string::npos) {
-    res.push_back(s.substr(start, end - start));
-    start = end + 1;
-  }
-  res.push_back(s.substr(start));
-  return res;
-}
-
-} // namespace utils
-
-#endif // UNITRACE_UTILS_UTILS_H_
diff --git a/tools/ze_tracer/README.md b/tools/ze_tracer/README.md
index a5f369ea..d63056a2 100644
--- a/tools/ze_tracer/README.md
+++ b/tools/ze_tracer/README.md
@@ -1,9 +1,3 @@
-# ⛔️ DEPRECATED: This project is no longer maintained
-
-> **Warning**: This repository is obsolete. We will not be providing updates or support.
-
-Please use [unitrace](../unitrace) instead. Unitrace has support of all the options. Report in case of any issue found. We will be happy to help.
-
 # Level Zero Tracer
 ## Overview
 This tool is an analogue of [Intercept Layer for OpenCL(TM) Applications](https://github.com/intel/opencl-intercept-layer) designed to support Level Zero.
@@ -134,7 +128,7 @@ All the API calls and kernels, which submission happens while collection disable
 - Windows (*under development*)
 
 ## Prerequisites
-- [CMake](https://cmake.org/) (version 3.12 and above)
+- [CMake](https://cmake.org/) (version 3.22 and above)
 - [Git](https://git-scm.com/) (version 1.8 and above)
 - [Python](https://www.python.org/) (version 2.7 and above)
 - [oneAPI Level Zero loader](https://github.com/oneapi-src/level-zero)
diff --git a/tools/ze_tracer/tool.cc b/tools/ze_tracer/tool.cc
index c3dd9631..d618b625 100644
--- a/tools/ze_tracer/tool.cc
+++ b/tools/ze_tracer/tool.cc
@@ -278,7 +278,7 @@ static TraceOptions ReadArgs() {
 }
 
 void EnableProfiling() {
-  ze_result_t status = zeInit(ZE_INIT_FLAG_GPU_ONLY);
+  ze_result_t status = utils::ze::InitGpuDrivers();
   PTI_ASSERT(status == ZE_RESULT_SUCCESS);
   tracer = ZeTracer::Create(ReadArgs());
 }
diff --git a/utils/gtpin_utils/CMakeLists.txt b/utils/gtpin_utils/CMakeLists.txt
index 5bb6b1a2..efe0f180 100644
--- a/utils/gtpin_utils/CMakeLists.txt
+++ b/utils/gtpin_utils/CMakeLists.txt
@@ -28,7 +28,7 @@ add_library(gtpin_tool_utils STATIC
 FindGTPinToolUtilsHeaders(gtpin_tool_utils)
 set_property(TARGET gtpin_tool_utils PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_include_directories(gtpin_tool_utils
-  PRIVATE "${PTI_GTPIN_TOOL_BASE_DIR}/../../sdk/src/utils")
+  PRIVATE "${PTI_GTPIN_TOOL_BASE_DIR}/../../utils")
 if(CMAKE_INCLUDE_PATH)
   target_include_directories(gtpin_tool_utils
     PUBLIC "${CMAKE_INCLUDE_PATH}")
diff --git a/utils/gtpin_utils/src/macro/add.cpp b/utils/gtpin_utils/src/macro/add.cpp
index 56223e59..1990fcf5 100644
--- a/utils/gtpin_utils/src/macro/add.cpp
+++ b/utils/gtpin_utils/src/macro/add.cpp
@@ -268,8 +268,11 @@ GtGenProcedure Macro::Add(const IGtKernelInstrument& instrumentor, const GtDstRe
   PTI_ASSERT(dst.DataType().Size() >= src0.DataType().Size() &&
              "Destination size should be no less than source size");
   uint64_t mask = Macro::GetMaskBySizeBytes(dst.DataType().Size());
-  PTI_ASSERT(static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
-             static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask) &&
+  // For an 8-byte destination the mask is all ones, which is -1 as int64_t,
+  // so the range check would reject every value; any 64-bit immediate fits.
+  PTI_ASSERT((dst.DataType().Size() >= sizeof(uint64_t) ||
+              (static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
+               static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask))) &&
              "Immediate value is too large for the destination size");
 
   IGtInsFactory& insF = instrumentor.Coder().InstructionFactory();
diff --git a/utils/gtpin_utils/src/macro/mul.cpp b/utils/gtpin_utils/src/macro/mul.cpp
index 7f75c6e9..8d03bd50 100644
--- a/utils/gtpin_utils/src/macro/mul.cpp
+++ b/utils/gtpin_utils/src/macro/mul.cpp
@@ -632,8 +632,11 @@ GtGenProcedure Macro::Mul(const IGtKernelInstrument& instrumentor, const GtDstRe
   PTI_ASSERT(dst.DataType().Size() >= src0.DataType().Size() &&
              "Destination size should be no less than source size");
   uint64_t mask = Macro::GetMaskBySizeBytes(dst.DataType().Size());
-  PTI_ASSERT(static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
-             static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask) &&
+  // For an 8-byte destination the mask is all ones, which is -1 as int64_t,
+  // so the range check would reject every value; any 64-bit immediate fits.
+  PTI_ASSERT((dst.DataType().Size() >= sizeof(uint64_t) ||
+              (static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
+               static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask))) &&
              "Immediate value is too large for the destination size");
 
   IGtInsFactory& insF = instrumentor.Coder().InstructionFactory();
diff --git a/utils/gtpin_utils/src/macro/sub.cpp b/utils/gtpin_utils/src/macro/sub.cpp
index 784d4b4c..2c75855d 100644
--- a/utils/gtpin_utils/src/macro/sub.cpp
+++ b/utils/gtpin_utils/src/macro/sub.cpp
@@ -152,8 +152,11 @@ GtGenProcedure Macro::Sub(const IGtKernelInstrument& instrumentor, const GtDstRe
   PTI_ASSERT(dst.DataType().Size() >= src0.DataType().Size() &&
              "Destination size should be no less than source size");
   uint64_t mask = Macro::GetMaskBySizeBytes(dst.DataType().Size());
-  PTI_ASSERT(static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
-             static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask) &&
+  // For an 8-byte destination the mask is all ones, which is -1 as int64_t,
+  // so the range check would reject every value; any 64-bit immediate fits.
+  PTI_ASSERT((dst.DataType().Size() >= sizeof(uint64_t) ||
+              (static_cast<int64_t>(srcI1.Value()) >= -static_cast<int64_t>(mask) &&
+               static_cast<int64_t>(srcI1.Value()) <= static_cast<int64_t>(mask))) &&
              "Immediate value is too large for the destination size");
 
   IGtInsFactory& insF = instrumentor.Coder().InstructionFactory();
diff --git a/utils/ze_utils.h b/utils/ze_utils.h
index 5a2b90f0..d5ba652c 100644
--- a/utils/ze_utils.h
+++ b/utils/ze_utils.h
@@ -21,9 +21,40 @@
 #include "pti_assert.h"
 #include "utils.h"
 
+#if !defined(_WIN32) && defined(ZE_API_VERSION_CURRENT_M) && \
+    ZE_API_VERSION_CURRENT_M >= ZE_MAKE_VERSION(1, 10)
+// Weak, so that a binary built with new headers still loads with an older
+// Level Zero loader that does not export zeInitDrivers (it is null then).
+extern "C" ZE_APIEXPORT ze_result_t ZE_APICALL zeInitDrivers(
+    uint32_t* pCount, ze_driver_handle_t* phDrivers,
+    ze_init_driver_type_desc_t* desc) __attribute__((weak));
+#define PTI_ZE_HAS_INIT_DRIVERS 1
+#endif
+
 namespace utils {
 namespace ze {
 
+// Initializes the Level Zero GPU drivers. Uses zeInitDrivers() (L0 1.10+) when
+// the loader provides it and it finds a GPU driver; falls back to zeInit()
+// otherwise, so error codes such as ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE are
+// still reported by zeInit(). Drivers are then listed with zeDriverGet().
+// On Windows only zeInit() is used (untested there).
+inline ze_result_t InitGpuDrivers() {
+#if defined(PTI_ZE_HAS_INIT_DRIVERS)
+  if (zeInitDrivers != nullptr) {
+    ze_init_driver_type_desc_t desc{
+        ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC, nullptr,
+        ZE_INIT_DRIVER_TYPE_FLAG_GPU};
+    uint32_t driver_count = 0;
+    ze_result_t status = zeInitDrivers(&driver_count, nullptr, &desc);
+    if (status == ZE_RESULT_SUCCESS && driver_count > 0) {
+      return status;
+    }
+  }
+#endif
+  return zeInit(ZE_INIT_FLAG_GPU_ONLY);
+}
+
 inline std::vector<ze_driver_handle_t> GetDriverList() {
   ze_result_t status = ZE_RESULT_SUCCESS;