diff --git a/CHANGELOG.md b/CHANGELOG.md
index 52c8e2b0..06b1e4aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,6 @@
 # Level zero loader changelog
+## Unreleased
+* feature: Add validation layer Timing Checker (`ZEL_ENABLE_TIMING_CHECKER`) for host-side per-API timing with summary, CSV and live-log output modes
 ## v1.30.0
 * Remove SPDLog from project entirely
 * Add New custom C++ smaller Logger, to replace SPDLog
diff --git a/scripts/generate_code.py b/scripts/generate_code.py
index 1df32400..514d7326 100644
--- a/scripts/generate_code.py
+++ b/scripts/generate_code.py
@@ -182,6 +182,7 @@ def _mako_loader_cpp(path, namespace, tags, version, specs, meta):
     'handle_lifetime.h.mako' : ('handle_lifetime_tracking', 'handle_lifetime.h'),
     'handle_lifetime.cpp.mako' : ('handle_lifetime_tracking', 'handle_lifetime.cpp'),
     'certification.h.mako' : ('checkers/certification/generated', 'certification.h'),
+    'timing.h.mako' : ('checkers/timing/generated', 'timing.h'),
     'to_string.h.mako' : ('../../utils', 'to_string.h'),
 }
 
diff --git a/scripts/templates/validation/timing.h.mako b/scripts/templates/validation/timing.h.mako
new file mode 100644
index 00000000..024cf01e
--- /dev/null
+++ b/scripts/templates/validation/timing.h.mako
@@ -0,0 +1,63 @@
+<%!
+import re
+from templates import helper as th
+%><%
+    n=namespace
+    N=n.upper()
+%>/*
+ * ***THIS FILE IS GENERATED. ***
+ * See timing.h.mako for modifications
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file ${name}
+ *
+ */
+#pragma once
+#include "../zel_global_timing_state.h"
+#include "${n}_entry_points.h"
+
+namespace validation_layer {
+class ${N}timingCheckerGenerated : public ${N}ValidationEntryPoints {
+public:
+    %for obj in th.extract_objs(specs, r"function"):
+    <%
+    param_lines = [line for line in th.make_param_lines(n, tags, obj, format=["type", "name", "delim"])]
+    is_void_params = len(param_lines) == 1 and "void" in param_lines[0]
+    func_name = th.make_func_name(n, tags, obj)
+    %>virtual ze_result_t ${func_name}Prologue( \
+%for line in param_lines:
+${line} \
+%endfor
+) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t ${func_name}Epilogue( \
+%if not is_void_params:
+%for line in param_lines:
+${line} \
+%endfor
+, ${obj['return_type']} result) override {
+%else:
+${obj['return_type']} result ) override {
+%endif
+        GlobalTimingState::getInstance().recordEnd("${func_name}");
+        return ZE_RESULT_SUCCESS;
+    }
+    %endfor
+%if n == 'ze':
+    // Experimental Intel extension for counter-based events
+    virtual ze_result_t zexCounterBasedEventCreate2Prologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zexCounterBasedEventCreate2Epilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zexCounterBasedEventCreate2");
+        return ZE_RESULT_SUCCESS;
+    }
+%endif
+};
+} // namespace validation_layer
diff --git a/source/layers/validation/README.md b/source/layers/validation/README.md
index 800b9ff5..c3c971e9 100644
--- a/source/layers/validation/README.md
+++ b/source/layers/validation/README.md
@@ -23,6 +23,7 @@ By default, no validation modes will be enabled. The individual validation modes
 - `ZE_ENABLE_THREADING_VALIDATION` (Not yet Implemented)
 - `ZEL_ENABLE_CERTIFICATION_CHECKER`
 - `ZEL_ENABLE_SYSTEM_RESOURCE_TRACKER_CHECKER`
+- `ZEL_ENABLE_TIMING_CHECKER`
 
 ## Validation Modes
 
@@ -141,6 +142,42 @@ export ZEL_LOADER_LOGGING_LEVEL=debug
 
 See [System Resource Tracker documentation](checkers/system_resource_tracker/system_resource_tracker.md) for detailed usage and CSV format.
 
+### `ZEL_ENABLE_TIMING_CHECKER`
+
+The Timing Checker measures the host-side (CPU) duration of every Level Zero API
+call and aggregates per-API statistics (call count, total, min, max and average
+time in nanoseconds). It is inspired by the host-function timing in Intel's
+unitrace profiler, ported into the validation layer.
+
+For each API call the checker stamps a high-resolution monotonic timestamp in the
+Prologue and reads it again in the Epilogue. The clock is
+`QueryPerformanceCounter` on Windows and `clock_gettime(CLOCK_MONOTONIC_RAW)`
+elsewhere. The measured span is dominated by the underlying driver call and is
+consistent across calls, making it suitable for relative host-cost analysis.
+
+> **Note:** Device-side (GPU execution) timing is not provided. The validation
+> layer receives handles by value and the Epilogue runs after the driver call, so
+> it cannot inject the timestamp events that GPU timing requires.
+
+To enable, set:
+```bash
+export ZE_ENABLE_VALIDATION_LAYER=1
+export ZEL_ENABLE_TIMING_CHECKER=1
+export ZEL_ENABLE_LOADER_LOGGING=1
+export ZEL_LOADER_LOG_CONSOLE=1   # optional: log to stderr instead of a file
+```
+
+Output modes (each independently controlled):
+
+| Environment Variable | Default | Description |
+|---|---|---|
+| `ZEL_ENABLE_TIMING_CHECKER` | `0` | Enable the checker; a per-API summary table is logged at teardown |
+| `ZEL_TIMING_CHECKER_CSV` | (unset) | Also export the per-API statistics to a CSV file (the process id is appended to the filename) |
+| `ZEL_TIMING_CHECKER_LIVE` | `0` | Also log each call's duration as it happens (verbose) |
+
+The summary and live output are emitted through the loader logger, so logging
+must be enabled as shown above for them to be visible.
+
 ## Testing
 
 There is a small set of negative test cases designed to test the validation layer in the [level zero tests repo](https://github.com/oneapi-src/level-zero-tests/tree/master/negative_tests).   
diff --git a/source/layers/validation/checkers/CMakeLists.txt b/source/layers/validation/checkers/CMakeLists.txt
index dd185762..bc134a14 100644
--- a/source/layers/validation/checkers/CMakeLists.txt
+++ b/source/layers/validation/checkers/CMakeLists.txt
@@ -5,3 +5,4 @@ add_subdirectory(performance)
 add_subdirectory(parameter_validation)
 add_subdirectory(template)
 add_subdirectory(system_resource_tracker)
+add_subdirectory(timing)
diff --git a/source/layers/validation/checkers/timing/CMakeLists.txt b/source/layers/validation/checkers/timing/CMakeLists.txt
new file mode 100644
index 00000000..65fe4afc
--- /dev/null
+++ b/source/layers/validation/checkers/timing/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (C) 2026 Intel Corporation
+# SPDX-License-Identifier: MIT
+
+target_sources(${TARGET_NAME}
+    PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/zel_timing_checker.h
+        ${CMAKE_CURRENT_LIST_DIR}/zel_timing_checker.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/zel_global_timing_state.h
+        ${CMAKE_CURRENT_LIST_DIR}/generated/ze_timing.h
+        ${CMAKE_CURRENT_LIST_DIR}/generated/zes_timing.h
+        ${CMAKE_CURRENT_LIST_DIR}/generated/zet_timing.h
+        ${CMAKE_CURRENT_LIST_DIR}/generated/zer_timing.h
+)
diff --git a/source/layers/validation/checkers/timing/generated/ze_timing.h b/source/layers/validation/checkers/timing/generated/ze_timing.h
new file mode 100644
index 00000000..99fc92f9
--- /dev/null
+++ b/source/layers/validation/checkers/timing/generated/ze_timing.h
@@ -0,0 +1,1804 @@
+/*
+ * ***THIS FILE IS GENERATED. ***
+ * See timing.h.mako for modifications
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file ze_timing.h
+ *
+ */
+#pragma once
+#include "../zel_global_timing_state.h"
+#include "ze_entry_points.h"
+
+namespace validation_layer {
+class ZEtimingCheckerGenerated : public ZEValidationEntryPoints {
+public:
+    virtual ze_result_t zeInitPrologue( ze_init_flags_t flags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeInitEpilogue( ze_init_flags_t flags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeInit");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetPrologue( uint32_t* pCount, ze_driver_handle_t* phDrivers ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetEpilogue( uint32_t* pCount, ze_driver_handle_t* phDrivers , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeInitDriversPrologue( uint32_t* pCount, ze_driver_handle_t* phDrivers, ze_init_driver_type_desc_t* desc ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeInitDriversEpilogue( uint32_t* pCount, ze_driver_handle_t* phDrivers, ze_init_driver_type_desc_t* desc , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeInitDrivers");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetApiVersionPrologue( ze_driver_handle_t hDriver, ze_api_version_t* version ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetApiVersionEpilogue( ze_driver_handle_t hDriver, ze_api_version_t* version , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetApiVersion");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetPropertiesPrologue( ze_driver_handle_t hDriver, ze_driver_properties_t* pDriverProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetPropertiesEpilogue( ze_driver_handle_t hDriver, ze_driver_properties_t* pDriverProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetIpcPropertiesPrologue( ze_driver_handle_t hDriver, ze_driver_ipc_properties_t* pIpcProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetIpcPropertiesEpilogue( ze_driver_handle_t hDriver, ze_driver_ipc_properties_t* pIpcProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetIpcProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetExtensionPropertiesPrologue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_driver_extension_properties_t* pExtensionProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetExtensionPropertiesEpilogue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_driver_extension_properties_t* pExtensionProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetExtensionProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetExtensionFunctionAddressPrologue( ze_driver_handle_t hDriver, const char* name, void** ppFunctionAddress ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetExtensionFunctionAddressEpilogue( ze_driver_handle_t hDriver, const char* name, void** ppFunctionAddress , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetExtensionFunctionAddress");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetLastErrorDescriptionPrologue( ze_driver_handle_t hDriver, const char** ppString ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetLastErrorDescriptionEpilogue( ze_driver_handle_t hDriver, const char** ppString , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetLastErrorDescription");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetDefaultContextPrologue( ze_driver_handle_t hDriver ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverGetDefaultContextEpilogue( ze_driver_handle_t hDriver , ze_context_handle_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverGetDefaultContext");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetPrologue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_device_handle_t* phDevices ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetEpilogue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_device_handle_t* phDevices , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRootDevicePrologue( ze_device_handle_t hDevice, ze_device_handle_t* phRootDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRootDeviceEpilogue( ze_device_handle_t hDevice, ze_device_handle_t* phRootDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetRootDevice");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetSubDevicesPrologue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_handle_t* phSubdevices ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetSubDevicesEpilogue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_handle_t* phSubdevices , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetSubDevices");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetPropertiesPrologue( ze_device_handle_t hDevice, ze_device_properties_t* pDeviceProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetPropertiesEpilogue( ze_device_handle_t hDevice, ze_device_properties_t* pDeviceProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetComputePropertiesPrologue( ze_device_handle_t hDevice, ze_device_compute_properties_t* pComputeProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetComputePropertiesEpilogue( ze_device_handle_t hDevice, ze_device_compute_properties_t* pComputeProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetComputeProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetModulePropertiesPrologue( ze_device_handle_t hDevice, ze_device_module_properties_t* pModuleProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetModulePropertiesEpilogue( ze_device_handle_t hDevice, ze_device_module_properties_t* pModuleProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetModuleProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetCommandQueueGroupPropertiesPrologue( ze_device_handle_t hDevice, uint32_t* pCount, ze_command_queue_group_properties_t* pCommandQueueGroupProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetCommandQueueGroupPropertiesEpilogue( ze_device_handle_t hDevice, uint32_t* pCount, ze_command_queue_group_properties_t* pCommandQueueGroupProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetCommandQueueGroupProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetMemoryPropertiesPrologue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_memory_properties_t* pMemProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetMemoryPropertiesEpilogue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_memory_properties_t* pMemProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetMemoryProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetMemoryAccessPropertiesPrologue( ze_device_handle_t hDevice, ze_device_memory_access_properties_t* pMemAccessProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetMemoryAccessPropertiesEpilogue( ze_device_handle_t hDevice, ze_device_memory_access_properties_t* pMemAccessProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetMemoryAccessProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetCachePropertiesPrologue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_cache_properties_t* pCacheProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetCachePropertiesEpilogue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_cache_properties_t* pCacheProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetCacheProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetImagePropertiesPrologue( ze_device_handle_t hDevice, ze_device_image_properties_t* pImageProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetImagePropertiesEpilogue( ze_device_handle_t hDevice, ze_device_image_properties_t* pImageProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetImageProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetExternalMemoryPropertiesPrologue( ze_device_handle_t hDevice, ze_device_external_memory_properties_t* pExternalMemoryProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetExternalMemoryPropertiesEpilogue( ze_device_handle_t hDevice, ze_device_external_memory_properties_t* pExternalMemoryProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetExternalMemoryProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetP2PPropertiesPrologue( ze_device_handle_t hDevice, ze_device_handle_t hPeerDevice, ze_device_p2p_properties_t* pP2PProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetP2PPropertiesEpilogue( ze_device_handle_t hDevice, ze_device_handle_t hPeerDevice, ze_device_p2p_properties_t* pP2PProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetP2PProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceCanAccessPeerPrologue( ze_device_handle_t hDevice, ze_device_handle_t hPeerDevice, ze_bool_t* value ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceCanAccessPeerEpilogue( ze_device_handle_t hDevice, ze_device_handle_t hPeerDevice, ze_bool_t* value , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceCanAccessPeer");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetStatusPrologue( ze_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetStatusEpilogue( ze_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetStatus");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetGlobalTimestampsPrologue( ze_device_handle_t hDevice, uint64_t* hostTimestamp, uint64_t* deviceTimestamp ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetGlobalTimestampsEpilogue( ze_device_handle_t hDevice, uint64_t* hostTimestamp, uint64_t* deviceTimestamp , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetGlobalTimestamps");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceSynchronizePrologue( ze_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceSynchronizeEpilogue( ze_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceSynchronize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetAggregatedCopyOffloadIncrementValuePrologue( ze_device_handle_t hDevice, uint32_t* incrementValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetAggregatedCopyOffloadIncrementValueEpilogue( ze_device_handle_t hDevice, uint32_t* incrementValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetAggregatedCopyOffloadIncrementValue");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRuntimeRequirementsPrologue( ze_device_handle_t hDevice, const void* pObjDesc, size_t* pSize, char* pRequirements ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRuntimeRequirementsEpilogue( ze_device_handle_t hDevice, const void* pObjDesc, size_t* pSize, char* pRequirements , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetRuntimeRequirements");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRuntimeRequirementsKeyPrologue( ze_device_handle_t hDevice, const char** pKey ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetRuntimeRequirementsKeyEpilogue( ze_device_handle_t hDevice, const char** pKey , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetRuntimeRequirementsKey");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceValidateRuntimeRequirementsPrologue( ze_device_handle_t hDevice, const char* pRequirements, ze_validate_runtime_requirements_output_t* pOut ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceValidateRuntimeRequirementsEpilogue( ze_device_handle_t hDevice, const char* pRequirements, ze_validate_runtime_requirements_output_t* pOut , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceValidateRuntimeRequirements");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextCreatePrologue( ze_driver_handle_t hDriver, const ze_context_desc_t* desc, ze_context_handle_t* phContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextCreateEpilogue( ze_driver_handle_t hDriver, const ze_context_desc_t* desc, ze_context_handle_t* phContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextCreateExPrologue( ze_driver_handle_t hDriver, const ze_context_desc_t* desc, uint32_t numDevices, ze_device_handle_t* phDevices, ze_context_handle_t* phContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextCreateExEpilogue( ze_driver_handle_t hDriver, const ze_context_desc_t* desc, uint32_t numDevices, ze_device_handle_t* phDevices, ze_context_handle_t* phContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextCreateEx");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextDestroyPrologue( ze_context_handle_t hContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextDestroyEpilogue( ze_context_handle_t hContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextGetStatusPrologue( ze_context_handle_t hContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextGetStatusEpilogue( ze_context_handle_t hContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextGetStatus");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_queue_desc_t* desc, ze_command_queue_handle_t* phCommandQueue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_queue_desc_t* desc, ze_command_queue_handle_t* phCommandQueue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueDestroyPrologue( ze_command_queue_handle_t hCommandQueue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueDestroyEpilogue( ze_command_queue_handle_t hCommandQueue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueExecuteCommandListsPrologue( ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_fence_handle_t hFence ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueExecuteCommandListsEpilogue( ze_command_queue_handle_t hCommandQueue, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_fence_handle_t hFence , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueExecuteCommandLists");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueSynchronizePrologue( ze_command_queue_handle_t hCommandQueue, uint64_t timeout ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueSynchronizeEpilogue( ze_command_queue_handle_t hCommandQueue, uint64_t timeout , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueSynchronize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueGetOrdinalPrologue( ze_command_queue_handle_t hCommandQueue, uint32_t* pOrdinal ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueGetOrdinalEpilogue( ze_command_queue_handle_t hCommandQueue, uint32_t* pOrdinal , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueGetOrdinal");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueGetIndexPrologue( ze_command_queue_handle_t hCommandQueue, uint32_t* pIndex ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandQueueGetIndexEpilogue( ze_command_queue_handle_t hCommandQueue, uint32_t* pIndex , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandQueueGetIndex");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_list_desc_t* desc, ze_command_list_handle_t* phCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_list_desc_t* desc, ze_command_list_handle_t* phCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreateImmediatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_queue_desc_t* altdesc, ze_command_list_handle_t* phCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreateImmediateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_command_queue_desc_t* altdesc, ze_command_list_handle_t* phCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListCreateImmediate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListDestroyPrologue( ze_command_list_handle_t hCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListDestroyEpilogue( ze_command_list_handle_t hCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListClosePrologue( ze_command_list_handle_t hCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCloseEpilogue( ze_command_list_handle_t hCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListClose");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListResetPrologue( ze_command_list_handle_t hCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListResetEpilogue( ze_command_list_handle_t hCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWriteGlobalTimestampPrologue( ze_command_list_handle_t hCommandList, uint64_t* dstptr, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWriteGlobalTimestampEpilogue( ze_command_list_handle_t hCommandList, uint64_t* dstptr, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendWriteGlobalTimestamp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListHostSynchronizePrologue( ze_command_list_handle_t hCommandList, uint64_t timeout ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListHostSynchronizeEpilogue( ze_command_list_handle_t hCommandList, uint64_t timeout , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListHostSynchronize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetDeviceHandlePrologue( ze_command_list_handle_t hCommandList, ze_device_handle_t* phDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetDeviceHandleEpilogue( ze_command_list_handle_t hCommandList, ze_device_handle_t* phDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListGetDeviceHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetContextHandlePrologue( ze_command_list_handle_t hCommandList, ze_context_handle_t* phContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetContextHandleEpilogue( ze_command_list_handle_t hCommandList, ze_context_handle_t* phContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListGetContextHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetOrdinalPrologue( ze_command_list_handle_t hCommandList, uint32_t* pOrdinal ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetOrdinalEpilogue( ze_command_list_handle_t hCommandList, uint32_t* pOrdinal , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListGetOrdinal");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateGetIndexPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t* pIndex ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateGetIndexEpilogue( ze_command_list_handle_t hCommandListImmediate, uint32_t* pIndex , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListImmediateGetIndex");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListIsImmediatePrologue( ze_command_list_handle_t hCommandList, ze_bool_t* pIsImmediate ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListIsImmediateEpilogue( ze_command_list_handle_t hCommandList, ze_bool_t* pIsImmediate , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListIsImmediate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendBarrierPrologue( ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendBarrierEpilogue( ze_command_list_handle_t hCommandList, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendBarrier");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryRangesBarrierPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryRangesBarrierEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryRangesBarrier");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextSystemBarrierPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextSystemBarrierEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextSystemBarrier");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryCopy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyWithParametersPrologue( ze_command_list_handle_t hCommandList, void* dstptr, const void* srcptr, size_t size, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyWithParametersEpilogue( ze_command_list_handle_t hCommandList, void* dstptr, const void* srcptr, size_t size, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryCopyWithParameters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryFillPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryFillEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryFill");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryFillWithParametersPrologue( ze_command_list_handle_t hCommandList, void* ptr, const void* pattern, size_t pattern_size, size_t size, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryFillWithParametersEpilogue( ze_command_list_handle_t hCommandList, void* ptr, const void* pattern, size_t pattern_size, size_t size, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryFillWithParameters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyRegionPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyRegionEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryCopyRegion");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyFromContextPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryCopyFromContextEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryCopyFromContext");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyRegionPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyRegionEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopyRegion");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyToMemoryPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyToMemoryEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopyToMemory");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyFromMemoryPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyFromMemoryEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopyFromMemory");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryPrefetchPrologue( ze_command_list_handle_t hCommandList, const void* ptr, size_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemoryPrefetchEpilogue( ze_command_list_handle_t hCommandList, const void* ptr, size_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemoryPrefetch");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemAdvisePrologue( ze_command_list_handle_t hCommandList, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_advice_t advice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendMemAdviseEpilogue( ze_command_list_handle_t hCommandList, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_advice_t advice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendMemAdvise");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolCreatePrologue( ze_context_handle_t hContext, const ze_event_pool_desc_t* desc, uint32_t numDevices, ze_device_handle_t* phDevices, ze_event_pool_handle_t* phEventPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolCreateEpilogue( ze_context_handle_t hContext, const ze_event_pool_desc_t* desc, uint32_t numDevices, ze_device_handle_t* phDevices, ze_event_pool_handle_t* phEventPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolDestroyPrologue( ze_event_pool_handle_t hEventPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolDestroyEpilogue( ze_event_pool_handle_t hEventPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCreatePrologue( ze_event_pool_handle_t hEventPool, const ze_event_desc_t* desc, ze_event_handle_t* phEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCreateEpilogue( ze_event_pool_handle_t hEventPool, const ze_event_desc_t* desc, ze_event_handle_t* phEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_event_counter_based_desc_t* desc, ze_event_handle_t* phEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_event_counter_based_desc_t* desc, ze_event_handle_t* phEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCounterBasedCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventDestroyPrologue( ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventDestroyEpilogue( ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetIpcHandlePrologue( ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t* phIpc ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetIpcHandleEpilogue( ze_event_pool_handle_t hEventPool, ze_ipc_event_pool_handle_t* phIpc , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolGetIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolPutIpcHandlePrologue( ze_context_handle_t hContext, ze_ipc_event_pool_handle_t hIpc ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolPutIpcHandleEpilogue( ze_context_handle_t hContext, ze_ipc_event_pool_handle_t hIpc , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolPutIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolOpenIpcHandlePrologue( ze_context_handle_t hContext, ze_ipc_event_pool_handle_t hIpc, ze_event_pool_handle_t* phEventPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolOpenIpcHandleEpilogue( ze_context_handle_t hContext, ze_ipc_event_pool_handle_t hIpc, ze_event_pool_handle_t* phEventPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolOpenIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolCloseIpcHandlePrologue( ze_event_pool_handle_t hEventPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolCloseIpcHandleEpilogue( ze_event_pool_handle_t hEventPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolCloseIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedGetIpcHandlePrologue( ze_event_handle_t hEvent, ze_ipc_event_counter_based_handle_t* phIpc ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedGetIpcHandleEpilogue( ze_event_handle_t hEvent, ze_ipc_event_counter_based_handle_t* phIpc , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCounterBasedGetIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedOpenIpcHandlePrologue( ze_context_handle_t hContext, ze_ipc_event_counter_based_handle_t hIpc, ze_event_handle_t* phEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedOpenIpcHandleEpilogue( ze_context_handle_t hContext, ze_ipc_event_counter_based_handle_t hIpc, ze_event_handle_t* phEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCounterBasedOpenIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedCloseIpcHandlePrologue( ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedCloseIpcHandleEpilogue( ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCounterBasedCloseIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedGetDeviceAddressPrologue( ze_event_handle_t hEvent, uint64_t* completionValue, uint64_t* deviceAddress ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventCounterBasedGetDeviceAddressEpilogue( ze_event_handle_t hEvent, uint64_t* completionValue, uint64_t* deviceAddress , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventCounterBasedGetDeviceAddress");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendSignalEventPrologue( ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendSignalEventEpilogue( ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendSignalEvent");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWaitOnEventsPrologue( ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t* phEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWaitOnEventsEpilogue( ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t* phEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendWaitOnEvents");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostSignalPrologue( ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostSignalEpilogue( ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventHostSignal");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostSynchronizePrologue( ze_event_handle_t hEvent, uint64_t timeout ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostSynchronizeEpilogue( ze_event_handle_t hEvent, uint64_t timeout , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventHostSynchronize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryStatusPrologue( ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryStatusEpilogue( ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventQueryStatus");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendEventResetPrologue( ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendEventResetEpilogue( ze_command_list_handle_t hCommandList, ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendEventReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostResetPrologue( ze_event_handle_t hEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventHostResetEpilogue( ze_event_handle_t hEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventHostReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryKernelTimestampPrologue( ze_event_handle_t hEvent, ze_kernel_timestamp_result_t* dstptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryKernelTimestampEpilogue( ze_event_handle_t hEvent, ze_kernel_timestamp_result_t* dstptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventQueryKernelTimestamp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendQueryKernelTimestampsPrologue( ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t* phEvents, void* dstptr, const size_t* pOffsets, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendQueryKernelTimestampsEpilogue( ze_command_list_handle_t hCommandList, uint32_t numEvents, ze_event_handle_t* phEvents, void* dstptr, const size_t* pOffsets, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendQueryKernelTimestamps");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetEventPoolPrologue( ze_event_handle_t hEvent, ze_event_pool_handle_t* phEventPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetEventPoolEpilogue( ze_event_handle_t hEvent, ze_event_pool_handle_t* phEventPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventGetEventPool");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetSignalScopePrologue( ze_event_handle_t hEvent, ze_event_scope_flags_t* pSignalScope ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetSignalScopeEpilogue( ze_event_handle_t hEvent, ze_event_scope_flags_t* pSignalScope , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventGetSignalScope");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetWaitScopePrologue( ze_event_handle_t hEvent, ze_event_scope_flags_t* pWaitScope ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventGetWaitScopeEpilogue( ze_event_handle_t hEvent, ze_event_scope_flags_t* pWaitScope , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventGetWaitScope");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetContextHandlePrologue( ze_event_pool_handle_t hEventPool, ze_context_handle_t* phContext ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetContextHandleEpilogue( ze_event_pool_handle_t hEventPool, ze_context_handle_t* phContext , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolGetContextHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetFlagsPrologue( ze_event_pool_handle_t hEventPool, ze_event_pool_flags_t* pFlags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventPoolGetFlagsEpilogue( ze_event_pool_handle_t hEventPool, ze_event_pool_flags_t* pFlags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventPoolGetFlags");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceCreatePrologue( ze_command_queue_handle_t hCommandQueue, const ze_fence_desc_t* desc, ze_fence_handle_t* phFence ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceCreateEpilogue( ze_command_queue_handle_t hCommandQueue, const ze_fence_desc_t* desc, ze_fence_handle_t* phFence , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFenceCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceDestroyPrologue( ze_fence_handle_t hFence ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceDestroyEpilogue( ze_fence_handle_t hFence , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFenceDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceHostSynchronizePrologue( ze_fence_handle_t hFence, uint64_t timeout ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceHostSynchronizeEpilogue( ze_fence_handle_t hFence, uint64_t timeout , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFenceHostSynchronize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceQueryStatusPrologue( ze_fence_handle_t hFence ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceQueryStatusEpilogue( ze_fence_handle_t hFence , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFenceQueryStatus");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceResetPrologue( ze_fence_handle_t hFence ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFenceResetEpilogue( ze_fence_handle_t hFence , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFenceReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetPropertiesPrologue( ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_properties_t* pImageProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetPropertiesEpilogue( ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_properties_t* pImageProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t* phImage ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t* phImage , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageDestroyPrologue( ze_image_handle_t hImage ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageDestroyEpilogue( ze_image_handle_t hImage , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocSharedPrologue( ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t* device_desc, const ze_host_mem_alloc_desc_t* host_desc, size_t size, size_t alignment, ze_device_handle_t hDevice, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocSharedEpilogue( ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t* device_desc, const ze_host_mem_alloc_desc_t* host_desc, size_t size, size_t alignment, ze_device_handle_t hDevice, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemAllocShared");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocDevicePrologue( ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t* device_desc, size_t size, size_t alignment, ze_device_handle_t hDevice, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocDeviceEpilogue( ze_context_handle_t hContext, const ze_device_mem_alloc_desc_t* device_desc, size_t size, size_t alignment, ze_device_handle_t hDevice, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemAllocDevice");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocHostPrologue( ze_context_handle_t hContext, const ze_host_mem_alloc_desc_t* host_desc, size_t size, size_t alignment, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemAllocHostEpilogue( ze_context_handle_t hContext, const ze_host_mem_alloc_desc_t* host_desc, size_t size, size_t alignment, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemAllocHost");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemFreePrologue( ze_context_handle_t hContext, void* ptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemFreeEpilogue( ze_context_handle_t hContext, void* ptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemFree");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAllocPropertiesPrologue( ze_context_handle_t hContext, const void* ptr, ze_memory_allocation_properties_t* pMemAllocProperties, ze_device_handle_t* phDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAllocPropertiesEpilogue( ze_context_handle_t hContext, const void* ptr, ze_memory_allocation_properties_t* pMemAllocProperties, ze_device_handle_t* phDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetAllocProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAddressRangePrologue( ze_context_handle_t hContext, const void* ptr, void** pBase, size_t* pSize ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAddressRangeEpilogue( ze_context_handle_t hContext, const void* ptr, void** pBase, size_t* pSize , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetAddressRange");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandlePrologue( ze_context_handle_t hContext, const void* ptr, ze_ipc_mem_handle_t* pIpcHandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandleEpilogue( ze_context_handle_t hContext, const void* ptr, ze_ipc_mem_handle_t* pIpcHandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandleFromFileDescriptorExpPrologue( ze_context_handle_t hContext, uint64_t handle, ze_ipc_mem_handle_t* pIpcHandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandleFromFileDescriptorExpEpilogue( ze_context_handle_t hContext, uint64_t handle, ze_ipc_mem_handle_t* pIpcHandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetIpcHandleFromFileDescriptorExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetFileDescriptorFromIpcHandleExpPrologue( ze_context_handle_t hContext, ze_ipc_mem_handle_t ipcHandle, uint64_t* pHandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetFileDescriptorFromIpcHandleExpEpilogue( ze_context_handle_t hContext, ze_ipc_mem_handle_t ipcHandle, uint64_t* pHandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetFileDescriptorFromIpcHandleExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemPutIpcHandlePrologue( ze_context_handle_t hContext, ze_ipc_mem_handle_t handle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemPutIpcHandleEpilogue( ze_context_handle_t hContext, ze_ipc_mem_handle_t handle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemPutIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemOpenIpcHandlePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle, ze_ipc_memory_flags_t flags, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemOpenIpcHandleEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle, ze_ipc_memory_flags_t flags, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemOpenIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemCloseIpcHandlePrologue( ze_context_handle_t hContext, const void* ptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemCloseIpcHandleEpilogue( ze_context_handle_t hContext, const void* ptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemCloseIpcHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemSetAtomicAccessAttributeExpPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_atomic_attr_exp_flags_t attr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemSetAtomicAccessAttributeExpEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_atomic_attr_exp_flags_t attr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemSetAtomicAccessAttributeExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAtomicAccessAttributeExpPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_atomic_attr_exp_flags_t* pAttr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetAtomicAccessAttributeExpEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* ptr, size_t size, ze_memory_atomic_attr_exp_flags_t* pAttr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetAtomicAccessAttributeExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t* desc, ze_module_handle_t* phModule, ze_module_build_log_handle_t* phBuildLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_module_desc_t* desc, ze_module_handle_t* phModule, ze_module_build_log_handle_t* phBuildLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleDestroyPrologue( ze_module_handle_t hModule ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleDestroyEpilogue( ze_module_handle_t hModule , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleDynamicLinkPrologue( uint32_t numModules, ze_module_handle_t* phModules, ze_module_build_log_handle_t* phLinkLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleDynamicLinkEpilogue( uint32_t numModules, ze_module_handle_t* phModules, ze_module_build_log_handle_t* phLinkLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleDynamicLink");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleBuildLogDestroyPrologue( ze_module_build_log_handle_t hModuleBuildLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleBuildLogDestroyEpilogue( ze_module_build_log_handle_t hModuleBuildLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleBuildLogDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleBuildLogGetStringPrologue( ze_module_build_log_handle_t hModuleBuildLog, size_t* pSize, char* pBuildLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleBuildLogGetStringEpilogue( ze_module_build_log_handle_t hModuleBuildLog, size_t* pSize, char* pBuildLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleBuildLogGetString");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetNativeBinaryPrologue( ze_module_handle_t hModule, size_t* pSize, uint8_t* pModuleNativeBinary ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetNativeBinaryEpilogue( ze_module_handle_t hModule, size_t* pSize, uint8_t* pModuleNativeBinary , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleGetNativeBinary");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetGlobalPointerPrologue( ze_module_handle_t hModule, const char* pGlobalName, size_t* pSize, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetGlobalPointerEpilogue( ze_module_handle_t hModule, const char* pGlobalName, size_t* pSize, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleGetGlobalPointer");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetKernelNamesPrologue( ze_module_handle_t hModule, uint32_t* pCount, const char** pNames ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetKernelNamesEpilogue( ze_module_handle_t hModule, uint32_t* pCount, const char** pNames , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleGetKernelNames");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetPropertiesPrologue( ze_module_handle_t hModule, ze_module_properties_t* pModuleProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetPropertiesEpilogue( ze_module_handle_t hModule, ze_module_properties_t* pModuleProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelCreatePrologue( ze_module_handle_t hModule, const ze_kernel_desc_t* desc, ze_kernel_handle_t* phKernel ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelCreateEpilogue( ze_module_handle_t hModule, const ze_kernel_desc_t* desc, ze_kernel_handle_t* phKernel , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelDestroyPrologue( ze_kernel_handle_t hKernel ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelDestroyEpilogue( ze_kernel_handle_t hKernel , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetFunctionPointerPrologue( ze_module_handle_t hModule, const char* pFunctionName, void** pfnFunction ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleGetFunctionPointerEpilogue( ze_module_handle_t hModule, const char* pFunctionName, void** pfnFunction , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleGetFunctionPointer");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetGroupSizePrologue( ze_kernel_handle_t hKernel, uint32_t groupSizeX, uint32_t groupSizeY, uint32_t groupSizeZ ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetGroupSizeEpilogue( ze_kernel_handle_t hKernel, uint32_t groupSizeX, uint32_t groupSizeY, uint32_t groupSizeZ , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSetGroupSize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSuggestGroupSizePrologue( ze_kernel_handle_t hKernel, uint32_t globalSizeX, uint32_t globalSizeY, uint32_t globalSizeZ, uint32_t* groupSizeX, uint32_t* groupSizeY, uint32_t* groupSizeZ ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSuggestGroupSizeEpilogue( ze_kernel_handle_t hKernel, uint32_t globalSizeX, uint32_t globalSizeY, uint32_t globalSizeZ, uint32_t* groupSizeX, uint32_t* groupSizeY, uint32_t* groupSizeZ , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSuggestGroupSize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSuggestMaxCooperativeGroupCountPrologue( ze_kernel_handle_t hKernel, uint32_t* totalGroupCount ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSuggestMaxCooperativeGroupCountEpilogue( ze_kernel_handle_t hKernel, uint32_t* totalGroupCount , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSuggestMaxCooperativeGroupCount");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetArgumentValuePrologue( ze_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize, const void* pArgValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetArgumentValueEpilogue( ze_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize, const void* pArgValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSetArgumentValue");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetIndirectAccessPrologue( ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t flags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetIndirectAccessEpilogue( ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t flags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSetIndirectAccess");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetIndirectAccessPrologue( ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t* pFlags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetIndirectAccessEpilogue( ze_kernel_handle_t hKernel, ze_kernel_indirect_access_flags_t* pFlags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetIndirectAccess");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetSourceAttributesPrologue( ze_kernel_handle_t hKernel, uint32_t* pSize, char** pString ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetSourceAttributesEpilogue( ze_kernel_handle_t hKernel, uint32_t* pSize, char** pString , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetSourceAttributes");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetCacheConfigPrologue( ze_kernel_handle_t hKernel, ze_cache_config_flags_t flags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetCacheConfigEpilogue( ze_kernel_handle_t hKernel, ze_cache_config_flags_t flags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSetCacheConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetPropertiesPrologue( ze_kernel_handle_t hKernel, ze_kernel_properties_t* pKernelProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetPropertiesEpilogue( ze_kernel_handle_t hKernel, ze_kernel_properties_t* pKernelProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetNamePrologue( ze_kernel_handle_t hKernel, size_t* pSize, char* pName ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetNameEpilogue( ze_kernel_handle_t hKernel, size_t* pSize, char* pName , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetName");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelEpilogue( ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t* pLaunchFuncArgs, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchKernel");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelWithParametersPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelWithParametersEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchKernelWithParameters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelWithArgumentsPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelWithArgumentsEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchKernelWithArguments");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchCooperativeKernelPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchCooperativeKernelEpilogue( ze_command_list_handle_t hCommandList, ze_kernel_handle_t hKernel, const ze_group_count_t* pLaunchFuncArgs, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchCooperativeKernel");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelIndirectPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchKernelIndirectEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchKernelIndirect");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchMultipleKernelsIndirectPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, ze_kernel_handle_t* phKernels, const uint32_t* pCountBuffer, const ze_group_count_t* pLaunchArgumentsBuffer, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendLaunchMultipleKernelsIndirectEpilogue( ze_command_list_handle_t hCommandList, uint32_t numKernels, ze_kernel_handle_t* phKernels, const uint32_t* pCountBuffer, const ze_group_count_t* pLaunchArgumentsBuffer, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendLaunchMultipleKernelsIndirect");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextMakeMemoryResidentPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, void* ptr, size_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextMakeMemoryResidentEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, void* ptr, size_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextMakeMemoryResident");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextEvictMemoryPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, void* ptr, size_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextEvictMemoryEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, void* ptr, size_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextEvictMemory");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextMakeImageResidentPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextMakeImageResidentEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextMakeImageResident");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextEvictImagePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeContextEvictImageEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_image_handle_t hImage , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeContextEvictImage");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeSamplerCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t* desc, ze_sampler_handle_t* phSampler ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeSamplerCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_sampler_desc_t* desc, ze_sampler_handle_t* phSampler , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeSamplerCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeSamplerDestroyPrologue( ze_sampler_handle_t hSampler ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeSamplerDestroyEpilogue( ze_sampler_handle_t hSampler , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeSamplerDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemReservePrologue( ze_context_handle_t hContext, const void* pStart, size_t size, void** pptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemReserveEpilogue( ze_context_handle_t hContext, const void* pStart, size_t size, void** pptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemReserve");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemFreePrologue( ze_context_handle_t hContext, const void* ptr, size_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemFreeEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemFree");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemQueryPageSizePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t size, size_t* pagesize ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemQueryPageSizeEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t size, size_t* pagesize , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemQueryPageSize");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemGetPropertiesPrologue( ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMem, ze_physical_mem_properties_t* pMemProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemGetPropertiesEpilogue( ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMem, ze_physical_mem_properties_t* pMemProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zePhysicalMemGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemCreatePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_physical_mem_desc_t* desc, ze_physical_mem_handle_t* phPhysicalMemory ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemCreateEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, ze_physical_mem_desc_t* desc, ze_physical_mem_handle_t* phPhysicalMemory , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zePhysicalMemCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemDestroyPrologue( ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMemory ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zePhysicalMemDestroyEpilogue( ze_context_handle_t hContext, ze_physical_mem_handle_t hPhysicalMemory , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zePhysicalMemDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemMapPrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_physical_mem_handle_t hPhysicalMemory, size_t offset, ze_memory_access_attribute_t access ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemMapEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_physical_mem_handle_t hPhysicalMemory, size_t offset, ze_memory_access_attribute_t access , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemMap");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemUnmapPrologue( ze_context_handle_t hContext, const void* ptr, size_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemUnmapEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemUnmap");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemSetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t access ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemSetAccessAttributeEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t access , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemSetAccessAttribute");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemGetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t* access, size_t* outSize ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeVirtualMemGetAccessAttributeEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t* access, size_t* outSize , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeVirtualMemGetAccessAttribute");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetGlobalOffsetExpPrologue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSetGlobalOffsetExpEpilogue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSetGlobalOffsetExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetBinaryExpPrologue( ze_kernel_handle_t hKernel, size_t* pSize, uint8_t* pKernelBinary ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetBinaryExpEpilogue( ze_kernel_handle_t hKernel, size_t* pSize, uint8_t* pKernelBinary , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetBinaryExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceImportExternalSemaphoreExtPrologue( ze_device_handle_t hDevice, const ze_external_semaphore_ext_desc_t* desc, ze_external_semaphore_ext_handle_t* phSemaphore ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceImportExternalSemaphoreExtEpilogue( ze_device_handle_t hDevice, const ze_external_semaphore_ext_desc_t* desc, ze_external_semaphore_ext_handle_t* phSemaphore , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceImportExternalSemaphoreExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceReleaseExternalSemaphoreExtPrologue( ze_external_semaphore_ext_handle_t hSemaphore ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceReleaseExternalSemaphoreExtEpilogue( ze_external_semaphore_ext_handle_t hSemaphore , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceReleaseExternalSemaphoreExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendSignalExternalSemaphoreExtPrologue( ze_command_list_handle_t hCommandList, uint32_t numSemaphores, ze_external_semaphore_ext_handle_t* phSemaphores, ze_external_semaphore_signal_params_ext_t* signalParams, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendSignalExternalSemaphoreExtEpilogue( ze_command_list_handle_t hCommandList, uint32_t numSemaphores, ze_external_semaphore_ext_handle_t* phSemaphores, ze_external_semaphore_signal_params_ext_t* signalParams, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendSignalExternalSemaphoreExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWaitExternalSemaphoreExtPrologue( ze_command_list_handle_t hCommandList, uint32_t numSemaphores, ze_external_semaphore_ext_handle_t* phSemaphores, ze_external_semaphore_wait_params_ext_t* waitParams, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendWaitExternalSemaphoreExtEpilogue( ze_command_list_handle_t hCommandList, uint32_t numSemaphores, ze_external_semaphore_ext_handle_t* phSemaphores, ze_external_semaphore_wait_params_ext_t* waitParams, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendWaitExternalSemaphoreExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCreateExtPrologue( ze_driver_handle_t hDriver, const ze_rtas_builder_ext_desc_t* pDescriptor, ze_rtas_builder_ext_handle_t* phBuilder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCreateExtEpilogue( ze_driver_handle_t hDriver, const ze_rtas_builder_ext_desc_t* pDescriptor, ze_rtas_builder_ext_handle_t* phBuilder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderCreateExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderGetBuildPropertiesExtPrologue( ze_rtas_builder_ext_handle_t hBuilder, const ze_rtas_builder_build_op_ext_desc_t* pBuildOpDescriptor, ze_rtas_builder_ext_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderGetBuildPropertiesExtEpilogue( ze_rtas_builder_ext_handle_t hBuilder, const ze_rtas_builder_build_op_ext_desc_t* pBuildOpDescriptor, ze_rtas_builder_ext_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderGetBuildPropertiesExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverRTASFormatCompatibilityCheckExtPrologue( ze_driver_handle_t hDriver, ze_rtas_format_ext_t rtasFormatA, ze_rtas_format_ext_t rtasFormatB ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverRTASFormatCompatibilityCheckExtEpilogue( ze_driver_handle_t hDriver, ze_rtas_format_ext_t rtasFormatA, ze_rtas_format_ext_t rtasFormatB , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverRTASFormatCompatibilityCheckExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderBuildExtPrologue( ze_rtas_builder_ext_handle_t hBuilder, const ze_rtas_builder_build_op_ext_desc_t* pBuildOpDescriptor, void* pScratchBuffer, size_t scratchBufferSizeBytes, void* pRtasBuffer, size_t rtasBufferSizeBytes, ze_rtas_parallel_operation_ext_handle_t hParallelOperation, void* pBuildUserPtr, ze_rtas_aabb_ext_t* pBounds, size_t* pRtasBufferSizeBytes ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderBuildExtEpilogue( ze_rtas_builder_ext_handle_t hBuilder, const ze_rtas_builder_build_op_ext_desc_t* pBuildOpDescriptor, void* pScratchBuffer, size_t scratchBufferSizeBytes, void* pRtasBuffer, size_t rtasBufferSizeBytes, ze_rtas_parallel_operation_ext_handle_t hParallelOperation, void* pBuildUserPtr, ze_rtas_aabb_ext_t* pBounds, size_t* pRtasBufferSizeBytes , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderBuildExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCommandListAppendCopyExtPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCommandListAppendCopyExtEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderCommandListAppendCopyExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderDestroyExtPrologue( ze_rtas_builder_ext_handle_t hBuilder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderDestroyExtEpilogue( ze_rtas_builder_ext_handle_t hBuilder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderDestroyExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationCreateExtPrologue( ze_driver_handle_t hDriver, ze_rtas_parallel_operation_ext_handle_t* phParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationCreateExtEpilogue( ze_driver_handle_t hDriver, ze_rtas_parallel_operation_ext_handle_t* phParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationCreateExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationGetPropertiesExtPrologue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation, ze_rtas_parallel_operation_ext_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationGetPropertiesExtEpilogue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation, ze_rtas_parallel_operation_ext_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationGetPropertiesExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationJoinExtPrologue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationJoinExtEpilogue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationJoinExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationDestroyExtPrologue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationDestroyExtEpilogue( ze_rtas_parallel_operation_ext_handle_t hParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationDestroyExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetVectorWidthPropertiesExtPrologue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_vector_width_properties_ext_t* pVectorWidthProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetVectorWidthPropertiesExtEpilogue( ze_device_handle_t hDevice, uint32_t* pCount, ze_device_vector_width_properties_ext_t* pVectorWidthProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetVectorWidthPropertiesExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetAllocationPropertiesExpPrologue( ze_kernel_handle_t hKernel, uint32_t* pCount, ze_kernel_allocation_exp_properties_t* pAllocationProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelGetAllocationPropertiesExpEpilogue( ze_kernel_handle_t hKernel, uint32_t* pCount, ze_kernel_allocation_exp_properties_t* pAllocationProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelGetAllocationPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandleWithPropertiesPrologue( ze_context_handle_t hContext, const void* ptr, void* pNext, ze_ipc_mem_handle_t* pIpcHandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetIpcHandleWithPropertiesEpilogue( ze_context_handle_t hContext, const void* ptr, void* pNext, ze_ipc_mem_handle_t* pIpcHandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetIpcHandleWithProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceReserveCacheExtEpilogue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceReserveCacheExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceSetCacheAdviceExtPrologue( ze_device_handle_t hDevice, void* ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceSetCacheAdviceExtEpilogue( ze_device_handle_t hDevice, void* ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceSetCacheAdviceExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryTimestampsExpPrologue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_kernel_timestamp_result_t* pTimestamps ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryTimestampsExpEpilogue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_kernel_timestamp_result_t* pTimestamps , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventQueryTimestampsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetMemoryPropertiesExpPrologue( ze_image_handle_t hImage, ze_image_memory_properties_exp_t* pMemoryProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetMemoryPropertiesExpEpilogue( ze_image_handle_t hImage, ze_image_memory_properties_exp_t* pMemoryProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageGetMemoryPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageViewCreateExtPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t hImage, ze_image_handle_t* phImageView ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageViewCreateExtEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t hImage, ze_image_handle_t* phImageView , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageViewCreateExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageViewCreateExpPrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t hImage, ze_image_handle_t* phImageView ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageViewCreateExpEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const ze_image_desc_t* desc, ze_image_handle_t hImage, ze_image_handle_t* phImageView , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageViewCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSchedulingHintExpPrologue( ze_kernel_handle_t hKernel, ze_scheduling_hint_exp_desc_t* pHint ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeKernelSchedulingHintExpEpilogue( ze_kernel_handle_t hKernel, ze_scheduling_hint_exp_desc_t* pHint , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeKernelSchedulingHintExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDevicePciGetPropertiesExtPrologue( ze_device_handle_t hDevice, ze_pci_ext_properties_t* pPciProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDevicePciGetPropertiesExtEpilogue( ze_device_handle_t hDevice, ze_pci_ext_properties_t* pPciProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDevicePciGetPropertiesExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyToMemoryExtPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyToMemoryExtEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopyToMemoryExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyFromMemoryExtPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListAppendImageCopyFromMemoryExtEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListAppendImageCopyFromMemoryExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetAllocPropertiesExtPrologue( ze_context_handle_t hContext, ze_image_handle_t hImage, ze_image_allocation_ext_properties_t* pImageAllocProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetAllocPropertiesExtEpilogue( ze_context_handle_t hContext, ze_image_handle_t hImage, ze_image_allocation_ext_properties_t* pImageAllocProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageGetAllocPropertiesExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleInspectLinkageExtPrologue( ze_linkage_inspection_ext_desc_t* pInspectDesc, uint32_t numModules, ze_module_handle_t* phModules, ze_module_build_log_handle_t* phLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeModuleInspectLinkageExtEpilogue( ze_linkage_inspection_ext_desc_t* pInspectDesc, uint32_t numModules, ze_module_handle_t* phModules, ze_module_build_log_handle_t* phLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeModuleInspectLinkageExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemFreeExtPrologue( ze_context_handle_t hContext, const ze_memory_free_ext_desc_t* pMemFreeDesc, void* ptr ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemFreeExtEpilogue( ze_context_handle_t hContext, const ze_memory_free_ext_desc_t* pMemFreeDesc, void* ptr , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemFreeExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetExpPrologue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_fabric_vertex_handle_t* phVertices ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetExpEpilogue( ze_driver_handle_t hDriver, uint32_t* pCount, ze_fabric_vertex_handle_t* phVertices , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricVertexGetExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetSubVerticesExpPrologue( ze_fabric_vertex_handle_t hVertex, uint32_t* pCount, ze_fabric_vertex_handle_t* phSubvertices ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetSubVerticesExpEpilogue( ze_fabric_vertex_handle_t hVertex, uint32_t* pCount, ze_fabric_vertex_handle_t* phSubvertices , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricVertexGetSubVerticesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetPropertiesExpPrologue( ze_fabric_vertex_handle_t hVertex, ze_fabric_vertex_exp_properties_t* pVertexProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetPropertiesExpEpilogue( ze_fabric_vertex_handle_t hVertex, ze_fabric_vertex_exp_properties_t* pVertexProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricVertexGetPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetDeviceExpPrologue( ze_fabric_vertex_handle_t hVertex, ze_device_handle_t* phDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricVertexGetDeviceExpEpilogue( ze_fabric_vertex_handle_t hVertex, ze_device_handle_t* phDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricVertexGetDeviceExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetFabricVertexExpPrologue( ze_device_handle_t hDevice, ze_fabric_vertex_handle_t* phVertex ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDeviceGetFabricVertexExpEpilogue( ze_device_handle_t hDevice, ze_fabric_vertex_handle_t* phVertex , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDeviceGetFabricVertexExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetExpPrologue( ze_fabric_vertex_handle_t hVertexA, ze_fabric_vertex_handle_t hVertexB, uint32_t* pCount, ze_fabric_edge_handle_t* phEdges ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetExpEpilogue( ze_fabric_vertex_handle_t hVertexA, ze_fabric_vertex_handle_t hVertexB, uint32_t* pCount, ze_fabric_edge_handle_t* phEdges , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricEdgeGetExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetVerticesExpPrologue( ze_fabric_edge_handle_t hEdge, ze_fabric_vertex_handle_t* phVertexA, ze_fabric_vertex_handle_t* phVertexB ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetVerticesExpEpilogue( ze_fabric_edge_handle_t hEdge, ze_fabric_vertex_handle_t* phVertexA, ze_fabric_vertex_handle_t* phVertexB , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricEdgeGetVerticesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetPropertiesExpPrologue( ze_fabric_edge_handle_t hEdge, ze_fabric_edge_exp_properties_t* pEdgeProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeFabricEdgeGetPropertiesExpEpilogue( ze_fabric_edge_handle_t hEdge, ze_fabric_edge_exp_properties_t* pEdgeProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeFabricEdgeGetPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryKernelTimestampsExtPrologue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_event_query_kernel_timestamps_results_ext_properties_t* pResults ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeEventQueryKernelTimestampsExtEpilogue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_event_query_kernel_timestamps_results_ext_properties_t* pResults , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeEventQueryKernelTimestampsExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCreateExpPrologue( ze_driver_handle_t hDriver, const ze_rtas_builder_exp_desc_t* pDescriptor, ze_rtas_builder_exp_handle_t* phBuilder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderCreateExpEpilogue( ze_driver_handle_t hDriver, const ze_rtas_builder_exp_desc_t* pDescriptor, ze_rtas_builder_exp_handle_t* phBuilder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderGetBuildPropertiesExpPrologue( ze_rtas_builder_exp_handle_t hBuilder, const ze_rtas_builder_build_op_exp_desc_t* pBuildOpDescriptor, ze_rtas_builder_exp_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderGetBuildPropertiesExpEpilogue( ze_rtas_builder_exp_handle_t hBuilder, const ze_rtas_builder_build_op_exp_desc_t* pBuildOpDescriptor, ze_rtas_builder_exp_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderGetBuildPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverRTASFormatCompatibilityCheckExpPrologue( ze_driver_handle_t hDriver, ze_rtas_format_exp_t rtasFormatA, ze_rtas_format_exp_t rtasFormatB ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeDriverRTASFormatCompatibilityCheckExpEpilogue( ze_driver_handle_t hDriver, ze_rtas_format_exp_t rtasFormatA, ze_rtas_format_exp_t rtasFormatB , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeDriverRTASFormatCompatibilityCheckExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderBuildExpPrologue( ze_rtas_builder_exp_handle_t hBuilder, const ze_rtas_builder_build_op_exp_desc_t* pBuildOpDescriptor, void* pScratchBuffer, size_t scratchBufferSizeBytes, void* pRtasBuffer, size_t rtasBufferSizeBytes, ze_rtas_parallel_operation_exp_handle_t hParallelOperation, void* pBuildUserPtr, ze_rtas_aabb_exp_t* pBounds, size_t* pRtasBufferSizeBytes ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderBuildExpEpilogue( ze_rtas_builder_exp_handle_t hBuilder, const ze_rtas_builder_build_op_exp_desc_t* pBuildOpDescriptor, void* pScratchBuffer, size_t scratchBufferSizeBytes, void* pRtasBuffer, size_t rtasBufferSizeBytes, ze_rtas_parallel_operation_exp_handle_t hParallelOperation, void* pBuildUserPtr, ze_rtas_aabb_exp_t* pBounds, size_t* pRtasBufferSizeBytes , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderBuildExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderDestroyExpPrologue( ze_rtas_builder_exp_handle_t hBuilder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASBuilderDestroyExpEpilogue( ze_rtas_builder_exp_handle_t hBuilder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASBuilderDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationCreateExpPrologue( ze_driver_handle_t hDriver, ze_rtas_parallel_operation_exp_handle_t* phParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationCreateExpEpilogue( ze_driver_handle_t hDriver, ze_rtas_parallel_operation_exp_handle_t* phParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationGetPropertiesExpPrologue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ze_rtas_parallel_operation_exp_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationGetPropertiesExpEpilogue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ze_rtas_parallel_operation_exp_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationGetPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationJoinExpPrologue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationJoinExpEpilogue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationJoinExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationDestroyExpPrologue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeRTASParallelOperationDestroyExpEpilogue( ze_rtas_parallel_operation_exp_handle_t hParallelOperation , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeRTASParallelOperationDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetPitchFor2dImagePrologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t imageWidth, size_t imageHeight, unsigned int elementSizeInBytes, size_t * rowPitch ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeMemGetPitchFor2dImageEpilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, size_t imageWidth, size_t imageHeight, unsigned int elementSizeInBytes, size_t * rowPitch , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeMemGetPitchFor2dImage");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetDeviceOffsetExpPrologue( ze_image_handle_t hImage, uint64_t* pDeviceOffset ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeImageGetDeviceOffsetExpEpilogue( ze_image_handle_t hImage, uint64_t* pDeviceOffset , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeImageGetDeviceOffsetExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreateCloneExpPrologue( ze_command_list_handle_t hCommandList, ze_command_list_handle_t* phClonedCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListCreateCloneExpEpilogue( ze_command_list_handle_t hCommandList, ze_command_list_handle_t* phClonedCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListCreateCloneExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateAppendCommandListsExpPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateAppendCommandListsExpEpilogue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListImmediateAppendCommandListsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateAppendCommandListsWithParametersPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListImmediateAppendCommandListsWithParametersEpilogue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, const void* pNext, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListImmediateAppendCommandListsWithParameters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetNextCommandIdExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListGetNextCommandIdExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( 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 ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpEpilogue( 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 , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListGetNextCommandIdWithKernelsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandsExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListUpdateMutableCommandsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListUpdateMutableCommandSignalEventExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListUpdateMutableCommandWaitEventsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpEpilogue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zeCommandListUpdateMutableCommandKernelsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zexCounterBasedEventCreate2Prologue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zexCounterBasedEventCreate2Epilogue( ze_context_handle_t hContext, ze_device_handle_t hDevice, const void* desc, ze_event_handle_t* phEvent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zexCounterBasedEventCreate2");
+        return ZE_RESULT_SUCCESS;
+    }
+};
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/generated/zer_timing.h b/source/layers/validation/checkers/timing/generated/zer_timing.h
new file mode 100644
index 00000000..fc43b4a2
--- /dev/null
+++ b/source/layers/validation/checkers/timing/generated/zer_timing.h
@@ -0,0 +1,52 @@
+/*
+ * ***THIS FILE IS GENERATED. ***
+ * See timing.h.mako for modifications
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zer_timing.h
+ *
+ */
+#pragma once
+#include "../zel_global_timing_state.h"
+#include "zer_entry_points.h"
+
+namespace validation_layer {
+class ZERtimingCheckerGenerated : public ZERValidationEntryPoints {
+public:
+    virtual ze_result_t zerGetLastErrorDescriptionPrologue( const char** ppString ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerGetLastErrorDescriptionEpilogue( const char** ppString , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zerGetLastErrorDescription");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerTranslateDeviceHandleToIdentifierPrologue( ze_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerTranslateDeviceHandleToIdentifierEpilogue( ze_device_handle_t hDevice , uint32_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zerTranslateDeviceHandleToIdentifier");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerTranslateIdentifierToDeviceHandlePrologue( uint32_t identifier ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerTranslateIdentifierToDeviceHandleEpilogue( uint32_t identifier , ze_device_handle_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zerTranslateIdentifierToDeviceHandle");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerGetDefaultContextPrologue( void ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zerGetDefaultContextEpilogue( ze_context_handle_t result ) override {
+        GlobalTimingState::getInstance().recordEnd("zerGetDefaultContext");
+        return ZE_RESULT_SUCCESS;
+    }
+};
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/generated/zes_timing.h b/source/layers/validation/checkers/timing/generated/zes_timing.h
new file mode 100644
index 00000000..b0c881c5
--- /dev/null
+++ b/source/layers/validation/checkers/timing/generated/zes_timing.h
@@ -0,0 +1,1276 @@
+/*
+ * ***THIS FILE IS GENERATED. ***
+ * See timing.h.mako for modifications
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zes_timing.h
+ *
+ */
+#pragma once
+#include "../zel_global_timing_state.h"
+#include "zes_entry_points.h"
+
+namespace validation_layer {
+class ZEStimingCheckerGenerated : public ZESValidationEntryPoints {
+public:
+    virtual ze_result_t zesInitPrologue( zes_init_flags_t flags ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesInitEpilogue( zes_init_flags_t flags , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesInit");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetPrologue( uint32_t* pCount, zes_driver_handle_t* phDrivers ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetEpilogue( uint32_t* pCount, zes_driver_handle_t* phDrivers , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetExtensionPropertiesPrologue( zes_driver_handle_t hDriver, uint32_t* pCount, zes_driver_extension_properties_t* pExtensionProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetExtensionPropertiesEpilogue( zes_driver_handle_t hDriver, uint32_t* pCount, zes_driver_extension_properties_t* pExtensionProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverGetExtensionProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetExtensionFunctionAddressPrologue( zes_driver_handle_t hDriver, const char* name, void** ppFunctionAddress ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetExtensionFunctionAddressEpilogue( zes_driver_handle_t hDriver, const char* name, void** ppFunctionAddress , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverGetExtensionFunctionAddress");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetPrologue( zes_driver_handle_t hDriver, uint32_t* pCount, zes_device_handle_t* phDevices ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetEpilogue( zes_driver_handle_t hDriver, uint32_t* pCount, zes_device_handle_t* phDevices , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetPropertiesPrologue( zes_device_handle_t hDevice, zes_device_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetPropertiesEpilogue( zes_device_handle_t hDevice, zes_device_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetStatePrologue( zes_device_handle_t hDevice, zes_device_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetStateEpilogue( zes_device_handle_t hDevice, zes_device_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetPrologue( zes_device_handle_t hDevice, ze_bool_t force ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetEpilogue( zes_device_handle_t hDevice, ze_bool_t force , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetExtPrologue( zes_device_handle_t hDevice, zes_reset_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetExtEpilogue( zes_device_handle_t hDevice, zes_reset_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceResetExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceProcessesGetStatePrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_process_state_t* pProcesses ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceProcessesGetStateEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_process_state_t* pProcesses , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceProcessesGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetPropertiesPrologue( zes_device_handle_t hDevice, zes_pci_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetPropertiesEpilogue( zes_device_handle_t hDevice, zes_pci_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDevicePciGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetStatePrologue( zes_device_handle_t hDevice, zes_pci_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetStateEpilogue( zes_device_handle_t hDevice, zes_pci_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDevicePciGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetBarsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_pci_bar_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetBarsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_pci_bar_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDevicePciGetBars");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetStatsPrologue( zes_device_handle_t hDevice, zes_pci_stats_t* pStats ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciGetStatsEpilogue( zes_device_handle_t hDevice, zes_pci_stats_t* pStats , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDevicePciGetStats");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceSetOverclockWaiverPrologue( zes_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceSetOverclockWaiverEpilogue( zes_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceSetOverclockWaiver");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetOverclockDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pOverclockDomains ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetOverclockDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pOverclockDomains , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetOverclockDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetOverclockControlsPrologue( zes_device_handle_t hDevice, zes_overclock_domain_t domainType, uint32_t* pAvailableControls ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetOverclockControlsEpilogue( zes_device_handle_t hDevice, zes_overclock_domain_t domainType, uint32_t* pAvailableControls , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetOverclockControls");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetOverclockSettingsPrologue( zes_device_handle_t hDevice, ze_bool_t onShippedState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceResetOverclockSettingsEpilogue( zes_device_handle_t hDevice, ze_bool_t onShippedState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceResetOverclockSettings");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceReadOverclockStatePrologue( zes_device_handle_t hDevice, zes_overclock_mode_t* pOverclockMode, ze_bool_t* pWaiverSetting, ze_bool_t* pOverclockState, zes_pending_action_t* pPendingAction, ze_bool_t* pPendingReset ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceReadOverclockStateEpilogue( zes_device_handle_t hDevice, zes_overclock_mode_t* pOverclockMode, ze_bool_t* pWaiverSetting, ze_bool_t* pOverclockState, zes_pending_action_t* pPendingAction, ze_bool_t* pPendingReset , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceReadOverclockState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumOverclockDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_overclock_handle_t* phDomainHandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumOverclockDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_overclock_handle_t* phDomainHandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumOverclockDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainPropertiesPrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_properties_t* pDomainProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainPropertiesEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_properties_t* pDomainProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetDomainProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainVFPropertiesPrologue( zes_overclock_handle_t hDomainHandle, zes_vf_property_t* pVFProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainVFPropertiesEpilogue( zes_overclock_handle_t hDomainHandle, zes_vf_property_t* pVFProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetDomainVFProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainControlPropertiesPrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, zes_control_property_t* pControlProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetDomainControlPropertiesEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, zes_control_property_t* pControlProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetDomainControlProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlCurrentValuePrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double* pValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlCurrentValueEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double* pValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetControlCurrentValue");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlPendingValuePrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double* pValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlPendingValueEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double* pValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetControlPendingValue");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockSetControlUserValuePrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double pValue, zes_pending_action_t* pPendingAction ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockSetControlUserValueEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, double pValue, zes_pending_action_t* pPendingAction , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockSetControlUserValue");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlStatePrologue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, zes_control_state_t* pControlState, zes_pending_action_t* pPendingAction ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetControlStateEpilogue( zes_overclock_handle_t hDomainHandle, zes_overclock_control_t DomainControl, zes_control_state_t* pControlState, zes_pending_action_t* pPendingAction , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetControlState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetVFPointValuesPrologue( zes_overclock_handle_t hDomainHandle, zes_vf_type_t VFType, zes_vf_array_type_t VFArrayType, uint32_t PointIndex, uint32_t* PointValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockGetVFPointValuesEpilogue( zes_overclock_handle_t hDomainHandle, zes_vf_type_t VFType, zes_vf_array_type_t VFArrayType, uint32_t PointIndex, uint32_t* PointValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockGetVFPointValues");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockSetVFPointValuesPrologue( zes_overclock_handle_t hDomainHandle, zes_vf_type_t VFType, uint32_t PointIndex, uint32_t PointValue ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesOverclockSetVFPointValuesEpilogue( zes_overclock_handle_t hDomainHandle, zes_vf_type_t VFType, uint32_t PointIndex, uint32_t PointValue , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesOverclockSetVFPointValues");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumDiagnosticTestSuitesPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_diag_handle_t* phDiagnostics ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumDiagnosticTestSuitesEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_diag_handle_t* phDiagnostics , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumDiagnosticTestSuites");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsGetPropertiesPrologue( zes_diag_handle_t hDiagnostics, zes_diag_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsGetPropertiesEpilogue( zes_diag_handle_t hDiagnostics, zes_diag_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDiagnosticsGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsGetTestsPrologue( zes_diag_handle_t hDiagnostics, uint32_t* pCount, zes_diag_test_t* pTests ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsGetTestsEpilogue( zes_diag_handle_t hDiagnostics, uint32_t* pCount, zes_diag_test_t* pTests , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDiagnosticsGetTests");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsRunTestsPrologue( zes_diag_handle_t hDiagnostics, uint32_t startIndex, uint32_t endIndex, zes_diag_result_t* pResult ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDiagnosticsRunTestsEpilogue( zes_diag_handle_t hDiagnostics, uint32_t startIndex, uint32_t endIndex, zes_diag_result_t* pResult , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDiagnosticsRunTests");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEccAvailablePrologue( zes_device_handle_t hDevice, ze_bool_t* pAvailable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEccAvailableEpilogue( zes_device_handle_t hDevice, ze_bool_t* pAvailable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEccAvailable");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEccConfigurablePrologue( zes_device_handle_t hDevice, ze_bool_t* pConfigurable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEccConfigurableEpilogue( zes_device_handle_t hDevice, ze_bool_t* pConfigurable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEccConfigurable");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetEccStatePrologue( zes_device_handle_t hDevice, zes_device_ecc_properties_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetEccStateEpilogue( zes_device_handle_t hDevice, zes_device_ecc_properties_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetEccState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceSetEccStatePrologue( zes_device_handle_t hDevice, const zes_device_ecc_desc_t* newState, zes_device_ecc_properties_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceSetEccStateEpilogue( zes_device_handle_t hDevice, const zes_device_ecc_desc_t* newState, zes_device_ecc_properties_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceSetEccState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumEngineGroupsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_engine_handle_t* phEngine ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumEngineGroupsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_engine_handle_t* phEngine , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumEngineGroups");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetPropertiesPrologue( zes_engine_handle_t hEngine, zes_engine_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetPropertiesEpilogue( zes_engine_handle_t hEngine, zes_engine_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesEngineGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetActivityPrologue( zes_engine_handle_t hEngine, zes_engine_stats_t* pStats ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetActivityEpilogue( zes_engine_handle_t hEngine, zes_engine_stats_t* pStats , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesEngineGetActivity");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEventRegisterPrologue( zes_device_handle_t hDevice, zes_event_type_flags_t events ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEventRegisterEpilogue( zes_device_handle_t hDevice, zes_event_type_flags_t events , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEventRegister");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverEventListenPrologue( ze_driver_handle_t hDriver, uint32_t timeout, uint32_t count, zes_device_handle_t* phDevices, uint32_t* pNumDeviceEvents, zes_event_type_flags_t* pEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverEventListenEpilogue( ze_driver_handle_t hDriver, uint32_t timeout, uint32_t count, zes_device_handle_t* phDevices, uint32_t* pNumDeviceEvents, zes_event_type_flags_t* pEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverEventListen");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverEventListenExPrologue( ze_driver_handle_t hDriver, uint64_t timeout, uint32_t count, zes_device_handle_t* phDevices, uint32_t* pNumDeviceEvents, zes_event_type_flags_t* pEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverEventListenExEpilogue( ze_driver_handle_t hDriver, uint64_t timeout, uint32_t count, zes_device_handle_t* phDevices, uint32_t* pNumDeviceEvents, zes_event_type_flags_t* pEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverEventListenEx");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFabricPortsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_fabric_port_handle_t* phPort ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFabricPortsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_fabric_port_handle_t* phPort , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumFabricPorts");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetPropertiesPrologue( zes_fabric_port_handle_t hPort, zes_fabric_port_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetPropertiesEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_port_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetLinkTypePrologue( zes_fabric_port_handle_t hPort, zes_fabric_link_type_t* pLinkType ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetLinkTypeEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_link_type_t* pLinkType , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetLinkType");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetConfigPrologue( zes_fabric_port_handle_t hPort, zes_fabric_port_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetConfigEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_port_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortSetConfigPrologue( zes_fabric_port_handle_t hPort, const zes_fabric_port_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortSetConfigEpilogue( zes_fabric_port_handle_t hPort, const zes_fabric_port_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortSetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetStatePrologue( zes_fabric_port_handle_t hPort, zes_fabric_port_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetStateEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_port_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetThroughputPrologue( zes_fabric_port_handle_t hPort, zes_fabric_port_throughput_t* pThroughput ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetThroughputEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_port_throughput_t* pThroughput , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetThroughput");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetFabricErrorCountersPrologue( zes_fabric_port_handle_t hPort, zes_fabric_port_error_counters_t* pErrors ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetFabricErrorCountersEpilogue( zes_fabric_port_handle_t hPort, zes_fabric_port_error_counters_t* pErrors , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetFabricErrorCounters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetMultiPortThroughputPrologue( zes_device_handle_t hDevice, uint32_t numPorts, zes_fabric_port_handle_t* phPort, zes_fabric_port_throughput_t** pThroughput ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFabricPortGetMultiPortThroughputEpilogue( zes_device_handle_t hDevice, uint32_t numPorts, zes_fabric_port_handle_t* phPort, zes_fabric_port_throughput_t** pThroughput , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFabricPortGetMultiPortThroughput");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFansPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_fan_handle_t* phFan ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFansEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_fan_handle_t* phFan , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumFans");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetPropertiesPrologue( zes_fan_handle_t hFan, zes_fan_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetPropertiesEpilogue( zes_fan_handle_t hFan, zes_fan_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetConfigPrologue( zes_fan_handle_t hFan, zes_fan_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetConfigEpilogue( zes_fan_handle_t hFan, zes_fan_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanGetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetDefaultModePrologue( zes_fan_handle_t hFan ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetDefaultModeEpilogue( zes_fan_handle_t hFan , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanSetDefaultMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetFixedSpeedModePrologue( zes_fan_handle_t hFan, const zes_fan_speed_t* speed ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetFixedSpeedModeEpilogue( zes_fan_handle_t hFan, const zes_fan_speed_t* speed , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanSetFixedSpeedMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetSpeedTableModePrologue( zes_fan_handle_t hFan, const zes_fan_speed_table_t* speedTable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanSetSpeedTableModeEpilogue( zes_fan_handle_t hFan, const zes_fan_speed_table_t* speedTable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanSetSpeedTableMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetStatePrologue( zes_fan_handle_t hFan, zes_fan_speed_units_t units, int32_t* pSpeed ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFanGetStateEpilogue( zes_fan_handle_t hFan, zes_fan_speed_units_t units, int32_t* pSpeed , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFanGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFirmwaresPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_firmware_handle_t* phFirmware ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFirmwaresEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_firmware_handle_t* phFirmware , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumFirmwares");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetPropertiesPrologue( zes_firmware_handle_t hFirmware, zes_firmware_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetPropertiesEpilogue( zes_firmware_handle_t hFirmware, zes_firmware_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareFlashPrologue( zes_firmware_handle_t hFirmware, void* pImage, uint32_t size ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareFlashEpilogue( zes_firmware_handle_t hFirmware, void* pImage, uint32_t size , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareFlash");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetFlashProgressPrologue( zes_firmware_handle_t hFirmware, uint32_t* pCompletionPercent ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetFlashProgressEpilogue( zes_firmware_handle_t hFirmware, uint32_t* pCompletionPercent , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareGetFlashProgress");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetConsoleLogsPrologue( zes_firmware_handle_t hFirmware, size_t* pSize, char* pFirmwareLog ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetConsoleLogsEpilogue( zes_firmware_handle_t hFirmware, size_t* pSize, char* pFirmwareLog , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareGetConsoleLogs");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFrequencyDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_freq_handle_t* phFrequency ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumFrequencyDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_freq_handle_t* phFrequency , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumFrequencyDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetPropertiesPrologue( zes_freq_handle_t hFrequency, zes_freq_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetPropertiesEpilogue( zes_freq_handle_t hFrequency, zes_freq_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetAvailableClocksPrologue( zes_freq_handle_t hFrequency, uint32_t* pCount, double* phFrequency ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetAvailableClocksEpilogue( zes_freq_handle_t hFrequency, uint32_t* pCount, double* phFrequency , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyGetAvailableClocks");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetRangePrologue( zes_freq_handle_t hFrequency, zes_freq_range_t* pLimits ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetRangeEpilogue( zes_freq_handle_t hFrequency, zes_freq_range_t* pLimits , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyGetRange");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencySetRangePrologue( zes_freq_handle_t hFrequency, const zes_freq_range_t* pLimits ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencySetRangeEpilogue( zes_freq_handle_t hFrequency, const zes_freq_range_t* pLimits , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencySetRange");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetStatePrologue( zes_freq_handle_t hFrequency, zes_freq_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetStateEpilogue( zes_freq_handle_t hFrequency, zes_freq_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetThrottleTimePrologue( zes_freq_handle_t hFrequency, zes_freq_throttle_time_t* pThrottleTime ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyGetThrottleTimeEpilogue( zes_freq_handle_t hFrequency, zes_freq_throttle_time_t* pThrottleTime , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyGetThrottleTime");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetCapabilitiesPrologue( zes_freq_handle_t hFrequency, zes_oc_capabilities_t* pOcCapabilities ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetCapabilitiesEpilogue( zes_freq_handle_t hFrequency, zes_oc_capabilities_t* pOcCapabilities , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetCapabilities");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetFrequencyTargetPrologue( zes_freq_handle_t hFrequency, double* pCurrentOcFrequency ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetFrequencyTargetEpilogue( zes_freq_handle_t hFrequency, double* pCurrentOcFrequency , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetFrequencyTarget");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetFrequencyTargetPrologue( zes_freq_handle_t hFrequency, double CurrentOcFrequency ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetFrequencyTargetEpilogue( zes_freq_handle_t hFrequency, double CurrentOcFrequency , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcSetFrequencyTarget");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetVoltageTargetPrologue( zes_freq_handle_t hFrequency, double* pCurrentVoltageTarget, double* pCurrentVoltageOffset ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetVoltageTargetEpilogue( zes_freq_handle_t hFrequency, double* pCurrentVoltageTarget, double* pCurrentVoltageOffset , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetVoltageTarget");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetVoltageTargetPrologue( zes_freq_handle_t hFrequency, double CurrentVoltageTarget, double CurrentVoltageOffset ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetVoltageTargetEpilogue( zes_freq_handle_t hFrequency, double CurrentVoltageTarget, double CurrentVoltageOffset , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcSetVoltageTarget");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetModePrologue( zes_freq_handle_t hFrequency, zes_oc_mode_t CurrentOcMode ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetModeEpilogue( zes_freq_handle_t hFrequency, zes_oc_mode_t CurrentOcMode , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcSetMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetModePrologue( zes_freq_handle_t hFrequency, zes_oc_mode_t* pCurrentOcMode ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetModeEpilogue( zes_freq_handle_t hFrequency, zes_oc_mode_t* pCurrentOcMode , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetIccMaxPrologue( zes_freq_handle_t hFrequency, double* pOcIccMax ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetIccMaxEpilogue( zes_freq_handle_t hFrequency, double* pOcIccMax , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetIccMax");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetIccMaxPrologue( zes_freq_handle_t hFrequency, double ocIccMax ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetIccMaxEpilogue( zes_freq_handle_t hFrequency, double ocIccMax , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcSetIccMax");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetTjMaxPrologue( zes_freq_handle_t hFrequency, double* pOcTjMax ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcGetTjMaxEpilogue( zes_freq_handle_t hFrequency, double* pOcTjMax , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcGetTjMax");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetTjMaxPrologue( zes_freq_handle_t hFrequency, double ocTjMax ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFrequencyOcSetTjMaxEpilogue( zes_freq_handle_t hFrequency, double ocTjMax , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFrequencyOcSetTjMax");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumLedsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_led_handle_t* phLed ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumLedsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_led_handle_t* phLed , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumLeds");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedGetPropertiesPrologue( zes_led_handle_t hLed, zes_led_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedGetPropertiesEpilogue( zes_led_handle_t hLed, zes_led_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesLedGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedGetStatePrologue( zes_led_handle_t hLed, zes_led_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedGetStateEpilogue( zes_led_handle_t hLed, zes_led_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesLedGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedSetStatePrologue( zes_led_handle_t hLed, ze_bool_t enable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedSetStateEpilogue( zes_led_handle_t hLed, ze_bool_t enable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesLedSetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedSetColorPrologue( zes_led_handle_t hLed, const zes_led_color_t* pColor ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesLedSetColorEpilogue( zes_led_handle_t hLed, const zes_led_color_t* pColor , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesLedSetColor");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumMemoryModulesPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_mem_handle_t* phMemory ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumMemoryModulesEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_mem_handle_t* phMemory , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumMemoryModules");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetPropertiesPrologue( zes_mem_handle_t hMemory, zes_mem_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetPropertiesEpilogue( zes_mem_handle_t hMemory, zes_mem_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesMemoryGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetStatePrologue( zes_mem_handle_t hMemory, zes_mem_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetStateEpilogue( zes_mem_handle_t hMemory, zes_mem_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesMemoryGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetBandwidthPrologue( zes_mem_handle_t hMemory, zes_mem_bandwidth_t* pBandwidth ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesMemoryGetBandwidthEpilogue( zes_mem_handle_t hMemory, zes_mem_bandwidth_t* pBandwidth , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesMemoryGetBandwidth");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPerformanceFactorDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_perf_handle_t* phPerf ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPerformanceFactorDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_perf_handle_t* phPerf , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumPerformanceFactorDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorGetPropertiesPrologue( zes_perf_handle_t hPerf, zes_perf_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorGetPropertiesEpilogue( zes_perf_handle_t hPerf, zes_perf_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPerformanceFactorGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorGetConfigPrologue( zes_perf_handle_t hPerf, double* pFactor ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorGetConfigEpilogue( zes_perf_handle_t hPerf, double* pFactor , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPerformanceFactorGetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorSetConfigPrologue( zes_perf_handle_t hPerf, double factor ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPerformanceFactorSetConfigEpilogue( zes_perf_handle_t hPerf, double factor , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPerformanceFactorSetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPowerDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_pwr_handle_t* phPower ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPowerDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_pwr_handle_t* phPower , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumPowerDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetCardPowerDomainPrologue( zes_device_handle_t hDevice, zes_pwr_handle_t* phPower ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetCardPowerDomainEpilogue( zes_device_handle_t hDevice, zes_pwr_handle_t* phPower , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetCardPowerDomain");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetPropertiesPrologue( zes_pwr_handle_t hPower, zes_power_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetPropertiesEpilogue( zes_pwr_handle_t hPower, zes_power_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetEnergyCounterPrologue( zes_pwr_handle_t hPower, zes_power_energy_counter_t* pEnergy ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetEnergyCounterEpilogue( zes_pwr_handle_t hPower, zes_power_energy_counter_t* pEnergy , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetEnergyCounter");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsPrologue( zes_pwr_handle_t hPower, zes_power_sustained_limit_t* pSustained, zes_power_burst_limit_t* pBurst, zes_power_peak_limit_t* pPeak ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsEpilogue( zes_pwr_handle_t hPower, zes_power_sustained_limit_t* pSustained, zes_power_burst_limit_t* pBurst, zes_power_peak_limit_t* pPeak , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetLimits");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsPrologue( zes_pwr_handle_t hPower, const zes_power_sustained_limit_t* pSustained, const zes_power_burst_limit_t* pBurst, const zes_power_peak_limit_t* pPeak ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsEpilogue( zes_pwr_handle_t hPower, const zes_power_sustained_limit_t* pSustained, const zes_power_burst_limit_t* pBurst, const zes_power_peak_limit_t* pPeak , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerSetLimits");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetEnergyThresholdPrologue( zes_pwr_handle_t hPower, zes_energy_threshold_t* pThreshold ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetEnergyThresholdEpilogue( zes_pwr_handle_t hPower, zes_energy_threshold_t* pThreshold , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetEnergyThreshold");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetEnergyThresholdPrologue( zes_pwr_handle_t hPower, double threshold ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetEnergyThresholdEpilogue( zes_pwr_handle_t hPower, double threshold , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerSetEnergyThreshold");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetUsagePrologue( zes_pwr_handle_t hPower, uint32_t* pInstantPower, uint32_t* pAveragePower ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetUsageEpilogue( zes_pwr_handle_t hPower, uint32_t* pInstantPower, uint32_t* pAveragePower , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetUsage");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPsusPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_psu_handle_t* phPsu ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumPsusEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_psu_handle_t* phPsu , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumPsus");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPsuGetPropertiesPrologue( zes_psu_handle_t hPsu, zes_psu_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPsuGetPropertiesEpilogue( zes_psu_handle_t hPsu, zes_psu_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPsuGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPsuGetStatePrologue( zes_psu_handle_t hPsu, zes_psu_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPsuGetStateEpilogue( zes_psu_handle_t hPsu, zes_psu_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPsuGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumRasErrorSetsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_ras_handle_t* phRas ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumRasErrorSetsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_ras_handle_t* phRas , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumRasErrorSets");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetPropertiesPrologue( zes_ras_handle_t hRas, zes_ras_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetPropertiesEpilogue( zes_ras_handle_t hRas, zes_ras_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetConfigPrologue( zes_ras_handle_t hRas, zes_ras_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetConfigEpilogue( zes_ras_handle_t hRas, zes_ras_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasSetConfigPrologue( zes_ras_handle_t hRas, const zes_ras_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasSetConfigEpilogue( zes_ras_handle_t hRas, const zes_ras_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasSetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStatePrologue( zes_ras_handle_t hRas, ze_bool_t clear, zes_ras_state_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStateEpilogue( zes_ras_handle_t hRas, ze_bool_t clear, zes_ras_state_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumSchedulersPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_sched_handle_t* phScheduler ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumSchedulersEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_sched_handle_t* phScheduler , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumSchedulers");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetPropertiesPrologue( zes_sched_handle_t hScheduler, zes_sched_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetPropertiesEpilogue( zes_sched_handle_t hScheduler, zes_sched_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetCurrentModePrologue( zes_sched_handle_t hScheduler, zes_sched_mode_t* pMode ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetCurrentModeEpilogue( zes_sched_handle_t hScheduler, zes_sched_mode_t* pMode , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerGetCurrentMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetTimeoutModePropertiesPrologue( zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeout_properties_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetTimeoutModePropertiesEpilogue( zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeout_properties_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerGetTimeoutModeProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetTimesliceModePropertiesPrologue( zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeslice_properties_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerGetTimesliceModePropertiesEpilogue( zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeslice_properties_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerGetTimesliceModeProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetTimeoutModePrologue( zes_sched_handle_t hScheduler, zes_sched_timeout_properties_t* pProperties, ze_bool_t* pNeedReload ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetTimeoutModeEpilogue( zes_sched_handle_t hScheduler, zes_sched_timeout_properties_t* pProperties, ze_bool_t* pNeedReload , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerSetTimeoutMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetTimesliceModePrologue( zes_sched_handle_t hScheduler, zes_sched_timeslice_properties_t* pProperties, ze_bool_t* pNeedReload ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetTimesliceModeEpilogue( zes_sched_handle_t hScheduler, zes_sched_timeslice_properties_t* pProperties, ze_bool_t* pNeedReload , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerSetTimesliceMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetExclusiveModePrologue( zes_sched_handle_t hScheduler, ze_bool_t* pNeedReload ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetExclusiveModeEpilogue( zes_sched_handle_t hScheduler, ze_bool_t* pNeedReload , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerSetExclusiveMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetComputeUnitDebugModePrologue( zes_sched_handle_t hScheduler, ze_bool_t* pNeedReload ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesSchedulerSetComputeUnitDebugModeEpilogue( zes_sched_handle_t hScheduler, ze_bool_t* pNeedReload , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesSchedulerSetComputeUnitDebugMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumStandbyDomainsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_standby_handle_t* phStandby ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumStandbyDomainsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_standby_handle_t* phStandby , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumStandbyDomains");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbyGetPropertiesPrologue( zes_standby_handle_t hStandby, zes_standby_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbyGetPropertiesEpilogue( zes_standby_handle_t hStandby, zes_standby_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesStandbyGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbyGetModePrologue( zes_standby_handle_t hStandby, zes_standby_promo_mode_t* pMode ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbyGetModeEpilogue( zes_standby_handle_t hStandby, zes_standby_promo_mode_t* pMode , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesStandbyGetMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbySetModePrologue( zes_standby_handle_t hStandby, zes_standby_promo_mode_t mode ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesStandbySetModeEpilogue( zes_standby_handle_t hStandby, zes_standby_promo_mode_t mode , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesStandbySetMode");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumTemperatureSensorsPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_temp_handle_t* phTemperature ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumTemperatureSensorsEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_temp_handle_t* phTemperature , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumTemperatureSensors");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetPropertiesPrologue( zes_temp_handle_t hTemperature, zes_temp_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetPropertiesEpilogue( zes_temp_handle_t hTemperature, zes_temp_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesTemperatureGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetConfigPrologue( zes_temp_handle_t hTemperature, zes_temp_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetConfigEpilogue( zes_temp_handle_t hTemperature, zes_temp_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesTemperatureGetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureSetConfigPrologue( zes_temp_handle_t hTemperature, const zes_temp_config_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureSetConfigEpilogue( zes_temp_handle_t hTemperature, const zes_temp_config_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesTemperatureSetConfig");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetStatePrologue( zes_temp_handle_t hTemperature, double* pTemperature ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesTemperatureGetStateEpilogue( zes_temp_handle_t hTemperature, double* pTemperature , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesTemperatureGetState");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciLinkSpeedUpdateExtPrologue( zes_device_handle_t hDevice, ze_bool_t shouldDowngrade, zes_device_action_t* pendingAction ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDevicePciLinkSpeedUpdateExtEpilogue( zes_device_handle_t hDevice, ze_bool_t shouldDowngrade, zes_device_action_t* pendingAction , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDevicePciLinkSpeedUpdateExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsExtPrologue( zes_pwr_handle_t hPower, uint32_t* pCount, zes_power_limit_ext_desc_t* pSustained ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsExtEpilogue( zes_pwr_handle_t hPower, uint32_t* pCount, zes_power_limit_ext_desc_t* pSustained , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetLimitsExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsExtPrologue( zes_pwr_handle_t hPower, uint32_t* pCount, zes_power_limit_ext_desc_t* pSustained ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsExtEpilogue( zes_pwr_handle_t hPower, uint32_t* pCount, zes_power_limit_ext_desc_t* pSustained , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerSetLimitsExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsExt2Prologue( zes_pwr_handle_t hPower, uint32_t* pLimit ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerGetLimitsExt2Epilogue( zes_pwr_handle_t hPower, uint32_t* pLimit , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerGetLimitsExt2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsExt2Prologue( zes_pwr_handle_t hPower, const uint32_t limit ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesPowerSetLimitsExt2Epilogue( zes_pwr_handle_t hPower, const uint32_t limit , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesPowerSetLimitsExt2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetActivityExtPrologue( zes_engine_handle_t hEngine, uint32_t* pCount, zes_engine_stats_t* pStats ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesEngineGetActivityExtEpilogue( zes_engine_handle_t hEngine, uint32_t* pCount, zes_engine_stats_t* pStats , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesEngineGetActivityExt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStateExpPrologue( zes_ras_handle_t hRas, uint32_t* pCount, zes_ras_state_exp_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStateExpEpilogue( zes_ras_handle_t hRas, uint32_t* pCount, zes_ras_state_exp_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetStateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasClearStateExpPrologue( zes_ras_handle_t hRas, zes_ras_error_category_exp_t category ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasClearStateExpEpilogue( zes_ras_handle_t hRas, zes_ras_error_category_exp_t category , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasClearStateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetSupportedCategoriesExpPrologue( zes_ras_handle_t hRas, uint32_t* pCount, zes_ras_error_category_exp_t* pCategories ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetSupportedCategoriesExpEpilogue( zes_ras_handle_t hRas, uint32_t* pCount, zes_ras_error_category_exp_t* pCategories , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetSupportedCategoriesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStateExp2Prologue( zes_ras_handle_t hRas, const uint32_t count, const zes_ras_error_category_exp_t* pCategories, zes_ras_state_exp2_t* pState ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetStateExp2Epilogue( zes_ras_handle_t hRas, const uint32_t count, const zes_ras_error_category_exp_t* pCategories, zes_ras_state_exp2_t* pState , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetStateExp2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetConfigExpPrologue( zes_ras_handle_t hRas, const uint32_t count, zes_ras_config_exp_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasGetConfigExpEpilogue( zes_ras_handle_t hRas, const uint32_t count, zes_ras_config_exp_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasGetConfigExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasSetConfigExpPrologue( zes_ras_handle_t hRas, const uint32_t count, const zes_ras_config_exp_t* pConfig ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesRasSetConfigExpEpilogue( zes_ras_handle_t hRas, const uint32_t count, const zes_ras_config_exp_t* pConfig , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesRasSetConfigExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetSecurityVersionExpPrologue( zes_firmware_handle_t hFirmware, char* pVersion ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareGetSecurityVersionExpEpilogue( zes_firmware_handle_t hFirmware, char* pVersion , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareGetSecurityVersionExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareSetSecurityVersionExpPrologue( zes_firmware_handle_t hFirmware ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesFirmwareSetSecurityVersionExpEpilogue( zes_firmware_handle_t hFirmware , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesFirmwareSetSecurityVersionExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetSubDevicePropertiesExpPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_subdevice_exp_properties_t* pSubdeviceProps ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceGetSubDevicePropertiesExpEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_subdevice_exp_properties_t* pSubdeviceProps , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceGetSubDevicePropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetDeviceByUuidExpPrologue( zes_driver_handle_t hDriver, zes_uuid_t uuid, zes_device_handle_t* phDevice, ze_bool_t* onSubdevice, uint32_t* subdeviceId ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDriverGetDeviceByUuidExpEpilogue( zes_driver_handle_t hDriver, zes_uuid_t uuid, zes_device_handle_t* phDevice, ze_bool_t* onSubdevice, uint32_t* subdeviceId , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDriverGetDeviceByUuidExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumActiveVFExpPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_vf_handle_t* phVFhandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumActiveVFExpEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_vf_handle_t* phVFhandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumActiveVFExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFPropertiesExpPrologue( zes_vf_handle_t hVFhandle, zes_vf_exp_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFPropertiesExpEpilogue( zes_vf_handle_t hVFhandle, zes_vf_exp_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFMemoryUtilizationExpPrologue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_mem_exp_t* pMemUtil ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFMemoryUtilizationExpEpilogue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_mem_exp_t* pMemUtil , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFMemoryUtilizationExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFEngineUtilizationExpPrologue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_engine_exp_t* pEngineUtil ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFEngineUtilizationExpEpilogue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_engine_exp_t* pEngineUtil , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFEngineUtilizationExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementSetVFTelemetryModeExpPrologue( zes_vf_handle_t hVFhandle, zes_vf_info_util_exp_flags_t flags, ze_bool_t enable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementSetVFTelemetryModeExpEpilogue( zes_vf_handle_t hVFhandle, zes_vf_info_util_exp_flags_t flags, ze_bool_t enable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementSetVFTelemetryModeExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementSetVFTelemetrySamplingIntervalExpPrologue( zes_vf_handle_t hVFhandle, zes_vf_info_util_exp_flags_t flag, uint64_t samplingInterval ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementSetVFTelemetrySamplingIntervalExpEpilogue( zes_vf_handle_t hVFhandle, zes_vf_info_util_exp_flags_t flag, uint64_t samplingInterval , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementSetVFTelemetrySamplingIntervalExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumEnabledVFExpPrologue( zes_device_handle_t hDevice, uint32_t* pCount, zes_vf_handle_t* phVFhandle ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesDeviceEnumEnabledVFExpEpilogue( zes_device_handle_t hDevice, uint32_t* pCount, zes_vf_handle_t* phVFhandle , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesDeviceEnumEnabledVFExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFCapabilitiesExpPrologue( zes_vf_handle_t hVFhandle, zes_vf_exp_capabilities_t* pCapability ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFCapabilitiesExpEpilogue( zes_vf_handle_t hVFhandle, zes_vf_exp_capabilities_t* pCapability , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFCapabilitiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFMemoryUtilizationExp2Prologue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_mem_exp2_t* pMemUtil ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFMemoryUtilizationExp2Epilogue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_mem_exp2_t* pMemUtil , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFMemoryUtilizationExp2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFEngineUtilizationExp2Prologue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_engine_exp2_t* pEngineUtil ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFEngineUtilizationExp2Epilogue( zes_vf_handle_t hVFhandle, uint32_t* pCount, zes_vf_util_engine_exp2_t* pEngineUtil , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFEngineUtilizationExp2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFCapabilitiesExp2Prologue( zes_vf_handle_t hVFhandle, zes_vf_exp2_capabilities_t* pCapability ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zesVFManagementGetVFCapabilitiesExp2Epilogue( zes_vf_handle_t hVFhandle, zes_vf_exp2_capabilities_t* pCapability , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zesVFManagementGetVFCapabilitiesExp2");
+        return ZE_RESULT_SUCCESS;
+    }
+};
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/generated/zet_timing.h b/source/layers/validation/checkers/timing/generated/zet_timing.h
new file mode 100644
index 00000000..1e338071
--- /dev/null
+++ b/source/layers/validation/checkers/timing/generated/zet_timing.h
@@ -0,0 +1,572 @@
+/*
+ * ***THIS FILE IS GENERATED. ***
+ * See timing.h.mako for modifications
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zet_timing.h
+ *
+ */
+#pragma once
+#include "../zel_global_timing_state.h"
+#include "zet_entry_points.h"
+
+namespace validation_layer {
+class ZETtimingCheckerGenerated : public ZETValidationEntryPoints {
+public:
+    virtual ze_result_t zetModuleGetDebugInfoPrologue( zet_module_handle_t hModule, zet_module_debug_info_format_t format, size_t* pSize, uint8_t* pDebugInfo ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetModuleGetDebugInfoEpilogue( zet_module_handle_t hModule, zet_module_debug_info_format_t format, size_t* pSize, uint8_t* pDebugInfo , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetModuleGetDebugInfo");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceGetDebugPropertiesPrologue( zet_device_handle_t hDevice, zet_device_debug_properties_t* pDebugProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceGetDebugPropertiesEpilogue( zet_device_handle_t hDevice, zet_device_debug_properties_t* pDebugProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDeviceGetDebugProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugAttachPrologue( zet_device_handle_t hDevice, const zet_debug_config_t* config, zet_debug_session_handle_t* phDebug ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugAttachEpilogue( zet_device_handle_t hDevice, const zet_debug_config_t* config, zet_debug_session_handle_t* phDebug , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugAttach");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugDetachPrologue( zet_debug_session_handle_t hDebug ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugDetachEpilogue( zet_debug_session_handle_t hDebug , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugDetach");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadEventPrologue( zet_debug_session_handle_t hDebug, uint64_t timeout, zet_debug_event_t* event ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadEventEpilogue( zet_debug_session_handle_t hDebug, uint64_t timeout, zet_debug_event_t* event , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugReadEvent");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugAcknowledgeEventPrologue( zet_debug_session_handle_t hDebug, const zet_debug_event_t* event ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugAcknowledgeEventEpilogue( zet_debug_session_handle_t hDebug, const zet_debug_event_t* event , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugAcknowledgeEvent");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugInterruptPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugInterruptEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugInterrupt");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugResumePrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugResumeEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugResume");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadMemoryPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t* desc, size_t size, void* buffer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadMemoryEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t* desc, size_t size, void* buffer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugReadMemory");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugWriteMemoryPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t* desc, size_t size, const void* buffer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugWriteMemoryEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t* desc, size_t size, const void* buffer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugWriteMemory");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugGetRegisterSetPropertiesPrologue( zet_device_handle_t hDevice, uint32_t* pCount, zet_debug_regset_properties_t* pRegisterSetProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugGetRegisterSetPropertiesEpilogue( zet_device_handle_t hDevice, uint32_t* pCount, zet_debug_regset_properties_t* pRegisterSetProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugGetRegisterSetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugGetThreadRegisterSetPropertiesPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t* pCount, zet_debug_regset_properties_t* pRegisterSetProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugGetThreadRegisterSetPropertiesEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t* pCount, zet_debug_regset_properties_t* pRegisterSetProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugGetThreadRegisterSetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadRegistersPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void* pRegisterValues ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugReadRegistersEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void* pRegisterValues , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugReadRegisters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugWriteRegistersPrologue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void* pRegisterValues ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDebugWriteRegistersEpilogue( zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void* pRegisterValues , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDebugWriteRegisters");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetPrologue( zet_device_handle_t hDevice, uint32_t* pCount, zet_metric_group_handle_t* phMetricGroups ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetEpilogue( zet_device_handle_t hDevice, uint32_t* pCount, zet_metric_group_handle_t* phMetricGroups , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetPropertiesPrologue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetPropertiesEpilogue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMetricValuesPrologue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t* pRawData, uint32_t* pMetricValueCount, zet_typed_value_t* pMetricValues ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMetricValuesEpilogue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t* pRawData, uint32_t* pMetricValueCount, zet_typed_value_t* pMetricValues , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupCalculateMetricValues");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGetPrologue( zet_metric_group_handle_t hMetricGroup, uint32_t* pCount, zet_metric_handle_t* phMetrics ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGetEpilogue( zet_metric_group_handle_t hMetricGroup, uint32_t* pCount, zet_metric_handle_t* phMetrics , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGet");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGetPropertiesPrologue( zet_metric_handle_t hMetric, zet_metric_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGetPropertiesEpilogue( zet_metric_handle_t hMetric, zet_metric_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGetProperties");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetContextActivateMetricGroupsPrologue( zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t count, zet_metric_group_handle_t* phMetricGroups ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetContextActivateMetricGroupsEpilogue( zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t count, zet_metric_group_handle_t* phMetricGroups , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetContextActivateMetricGroups");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerOpenPrologue( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, zet_metric_streamer_desc_t* desc, ze_event_handle_t hNotificationEvent, zet_metric_streamer_handle_t* phMetricStreamer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerOpenEpilogue( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, zet_metric_streamer_desc_t* desc, ze_event_handle_t hNotificationEvent, zet_metric_streamer_handle_t* phMetricStreamer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricStreamerOpen");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricStreamerMarkerPrologue( zet_command_list_handle_t hCommandList, zet_metric_streamer_handle_t hMetricStreamer, uint32_t value ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricStreamerMarkerEpilogue( zet_command_list_handle_t hCommandList, zet_metric_streamer_handle_t hMetricStreamer, uint32_t value , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetCommandListAppendMetricStreamerMarker");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerClosePrologue( zet_metric_streamer_handle_t hMetricStreamer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerCloseEpilogue( zet_metric_streamer_handle_t hMetricStreamer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricStreamerClose");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerReadDataPrologue( zet_metric_streamer_handle_t hMetricStreamer, uint32_t maxReportCount, size_t* pRawDataSize, uint8_t* pRawData ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricStreamerReadDataEpilogue( zet_metric_streamer_handle_t hMetricStreamer, uint32_t maxReportCount, size_t* pRawDataSize, uint8_t* pRawData , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricStreamerReadData");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryPoolCreatePrologue( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t* desc, zet_metric_query_pool_handle_t* phMetricQueryPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryPoolCreateEpilogue( zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t* desc, zet_metric_query_pool_handle_t* phMetricQueryPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryPoolCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryPoolDestroyPrologue( zet_metric_query_pool_handle_t hMetricQueryPool ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryPoolDestroyEpilogue( zet_metric_query_pool_handle_t hMetricQueryPool , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryPoolDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryCreatePrologue( zet_metric_query_pool_handle_t hMetricQueryPool, uint32_t index, zet_metric_query_handle_t* phMetricQuery ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryCreateEpilogue( zet_metric_query_pool_handle_t hMetricQueryPool, uint32_t index, zet_metric_query_handle_t* phMetricQuery , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryDestroyPrologue( zet_metric_query_handle_t hMetricQuery ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryDestroyEpilogue( zet_metric_query_handle_t hMetricQuery , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryResetPrologue( zet_metric_query_handle_t hMetricQuery ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryResetEpilogue( zet_metric_query_handle_t hMetricQuery , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryReset");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricQueryBeginPrologue( zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricQueryBeginEpilogue( zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetCommandListAppendMetricQueryBegin");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricQueryEndPrologue( zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricQueryEndEpilogue( zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetCommandListAppendMetricQueryEnd");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricMemoryBarrierPrologue( zet_command_list_handle_t hCommandList ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMetricMemoryBarrierEpilogue( zet_command_list_handle_t hCommandList , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetCommandListAppendMetricMemoryBarrier");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryGetDataPrologue( zet_metric_query_handle_t hMetricQuery, size_t* pRawDataSize, uint8_t* pRawData ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricQueryGetDataEpilogue( zet_metric_query_handle_t hMetricQuery, size_t* pRawDataSize, uint8_t* pRawData , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricQueryGetData");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetKernelGetProfileInfoPrologue( zet_kernel_handle_t hKernel, zet_profile_properties_t* pProfileProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetKernelGetProfileInfoEpilogue( zet_kernel_handle_t hKernel, zet_profile_properties_t* pProfileProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetKernelGetProfileInfo");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpCreatePrologue( zet_context_handle_t hContext, const zet_tracer_exp_desc_t* desc, zet_tracer_exp_handle_t* phTracer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpCreateEpilogue( zet_context_handle_t hContext, const zet_tracer_exp_desc_t* desc, zet_tracer_exp_handle_t* phTracer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetTracerExpCreate");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpDestroyPrologue( zet_tracer_exp_handle_t hTracer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpDestroyEpilogue( zet_tracer_exp_handle_t hTracer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetTracerExpDestroy");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetProloguesPrologue( zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t* pCoreCbs ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetProloguesEpilogue( zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t* pCoreCbs , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetTracerExpSetPrologues");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetEpiloguesPrologue( zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t* pCoreCbs ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetEpiloguesEpilogue( zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t* pCoreCbs , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetTracerExpSetEpilogues");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetEnabledPrologue( zet_tracer_exp_handle_t hTracer, ze_bool_t enable ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetTracerExpSetEnabledEpilogue( zet_tracer_exp_handle_t hTracer, ze_bool_t enable , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetTracerExpSetEnabled");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceGetConcurrentMetricGroupsExpPrologue( zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t * phMetricGroups, uint32_t * pMetricGroupsCountPerConcurrentGroup, uint32_t * pConcurrentGroupCount ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceGetConcurrentMetricGroupsExpEpilogue( zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t * phMetricGroups, uint32_t * pMetricGroupsCountPerConcurrentGroup, uint32_t * pConcurrentGroupCount , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDeviceGetConcurrentMetricGroupsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerCreateExpPrologue( zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t* phMetricGroups, zet_metric_tracer_exp_desc_t* desc, ze_event_handle_t hNotificationEvent, zet_metric_tracer_exp_handle_t* phMetricTracer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerCreateExpEpilogue( zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t* phMetricGroups, zet_metric_tracer_exp_desc_t* desc, ze_event_handle_t hNotificationEvent, zet_metric_tracer_exp_handle_t* phMetricTracer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDestroyExpPrologue( zet_metric_tracer_exp_handle_t hMetricTracer ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDestroyExpEpilogue( zet_metric_tracer_exp_handle_t hMetricTracer , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerEnableExpPrologue( zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerEnableExpEpilogue( zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerEnableExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDisableExpPrologue( zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDisableExpEpilogue( zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerDisableExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerReadDataExpPrologue( zet_metric_tracer_exp_handle_t hMetricTracer, size_t* pRawDataSize, uint8_t* pRawData ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerReadDataExpEpilogue( zet_metric_tracer_exp_handle_t hMetricTracer, size_t* pRawDataSize, uint8_t* pRawData , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerReadDataExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderCreateExpPrologue( zet_metric_tracer_exp_handle_t hMetricTracer, zet_metric_decoder_exp_handle_t* phMetricDecoder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderCreateExpEpilogue( zet_metric_tracer_exp_handle_t hMetricTracer, zet_metric_decoder_exp_handle_t* phMetricDecoder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricDecoderCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderDestroyExpPrologue( zet_metric_decoder_exp_handle_t phMetricDecoder ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderDestroyExpEpilogue( zet_metric_decoder_exp_handle_t phMetricDecoder , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricDecoderDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderGetDecodableMetricsExpPrologue( zet_metric_decoder_exp_handle_t hMetricDecoder, uint32_t* pCount, zet_metric_handle_t* phMetrics ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDecoderGetDecodableMetricsExpEpilogue( zet_metric_decoder_exp_handle_t hMetricDecoder, uint32_t* pCount, zet_metric_handle_t* phMetrics , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricDecoderGetDecodableMetricsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDecodeExpPrologue( zet_metric_decoder_exp_handle_t phMetricDecoder, size_t* pRawDataSize, uint8_t* pRawData, uint32_t metricsCount, zet_metric_handle_t* phMetrics, uint32_t* pSetCount, uint32_t* pMetricEntriesCountPerSet, uint32_t* pMetricEntriesCount, zet_metric_entry_exp_t* pMetricEntries ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricTracerDecodeExpEpilogue( zet_metric_decoder_exp_handle_t phMetricDecoder, size_t* pRawDataSize, uint8_t* pRawData, uint32_t metricsCount, zet_metric_handle_t* phMetrics, uint32_t* pSetCount, uint32_t* pMetricEntriesCountPerSet, uint32_t* pMetricEntriesCount, zet_metric_entry_exp_t* pMetricEntries , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricTracerDecodeExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMarkerExpPrologue( zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetCommandListAppendMarkerExpEpilogue( zet_command_list_handle_t hCommandList, zet_metric_group_handle_t hMetricGroup, uint32_t value , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetCommandListAppendMarkerExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceEnableMetricsExpPrologue( zet_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceEnableMetricsExpEpilogue( zet_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDeviceEnableMetricsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceDisableMetricsExpPrologue( zet_device_handle_t hDevice ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceDisableMetricsExpEpilogue( zet_device_handle_t hDevice , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDeviceDisableMetricsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMultipleMetricValuesExpPrologue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t* pRawData, uint32_t* pSetCount, uint32_t* pTotalMetricValueCount, uint32_t* pMetricCounts, zet_typed_value_t* pMetricValues ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMultipleMetricValuesExpEpilogue( zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t* pRawData, uint32_t* pSetCount, uint32_t* pTotalMetricValueCount, uint32_t* pMetricCounts, zet_typed_value_t* pMetricValues , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupCalculateMultipleMetricValuesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetGlobalTimestampsExpPrologue( zet_metric_group_handle_t hMetricGroup, ze_bool_t synchronizedWithHost, uint64_t* globalTimestamp, uint64_t* metricTimestamp ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetGlobalTimestampsExpEpilogue( zet_metric_group_handle_t hMetricGroup, ze_bool_t synchronizedWithHost, uint64_t* globalTimestamp, uint64_t* metricTimestamp , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupGetGlobalTimestampsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetExportDataExpPrologue( zet_metric_group_handle_t hMetricGroup, const uint8_t* pRawData, size_t rawDataSize, size_t* pExportDataSize, uint8_t * pExportData ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupGetExportDataExpEpilogue( zet_metric_group_handle_t hMetricGroup, const uint8_t* pRawData, size_t rawDataSize, size_t* pExportDataSize, uint8_t * pExportData , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupGetExportDataExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMetricExportDataExpPrologue( ze_driver_handle_t hDriver, zet_metric_group_calculation_type_t type, size_t exportDataSize, const uint8_t* pExportData, zet_metric_calculate_exp_desc_t* pCalculateDescriptor, uint32_t* pSetCount, uint32_t* pTotalMetricValueCount, uint32_t* pMetricCounts, zet_typed_value_t* pMetricValues ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCalculateMetricExportDataExpEpilogue( ze_driver_handle_t hDriver, zet_metric_group_calculation_type_t type, size_t exportDataSize, const uint8_t* pExportData, zet_metric_calculate_exp_desc_t* pCalculateDescriptor, uint32_t* pSetCount, uint32_t* pTotalMetricValueCount, uint32_t* pMetricCounts, zet_typed_value_t* pMetricValues , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupCalculateMetricExportDataExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetExpPrologue( zet_device_handle_t hDevice, uint32_t* pCount, zet_metric_programmable_exp_handle_t* phMetricProgrammables ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetExpEpilogue( zet_device_handle_t hDevice, uint32_t* pCount, zet_metric_programmable_exp_handle_t* phMetricProgrammables , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricProgrammableGetExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetPropertiesExpPrologue( zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_exp_properties_t* pProperties ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetPropertiesExpEpilogue( zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_exp_properties_t* pProperties , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricProgrammableGetPropertiesExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetParamInfoExpPrologue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t* pParameterCount, zet_metric_programmable_param_info_exp_t* pParameterInfo ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetParamInfoExpEpilogue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t* pParameterCount, zet_metric_programmable_param_info_exp_t* pParameterInfo , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricProgrammableGetParamInfoExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetParamValueInfoExpPrologue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterOrdinal, uint32_t* pValueInfoCount, zet_metric_programmable_param_value_info_exp_t* pValueInfo ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricProgrammableGetParamValueInfoExpEpilogue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterOrdinal, uint32_t* pValueInfoCount, zet_metric_programmable_param_value_info_exp_t* pValueInfo , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricProgrammableGetParamValueInfoExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricCreateFromProgrammableExp2Prologue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterCount, zet_metric_programmable_param_value_exp_t* pParameterValues, const char* pName, const char* pDescription, uint32_t* pMetricHandleCount, zet_metric_handle_t* phMetricHandles ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricCreateFromProgrammableExp2Epilogue( zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterCount, zet_metric_programmable_param_value_exp_t* pParameterValues, const char* pName, const char* pDescription, uint32_t* pMetricHandleCount, zet_metric_handle_t* phMetricHandles , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricCreateFromProgrammableExp2");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricCreateFromProgrammableExpPrologue( zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_param_value_exp_t* pParameterValues, uint32_t parameterCount, const char* pName, const char* pDescription, uint32_t* pMetricHandleCount, zet_metric_handle_t* phMetricHandles ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricCreateFromProgrammableExpEpilogue( zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_param_value_exp_t* pParameterValues, uint32_t parameterCount, const char* pName, const char* pDescription, uint32_t* pMetricHandleCount, zet_metric_handle_t* phMetricHandles , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricCreateFromProgrammableExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceCreateMetricGroupsFromMetricsExpPrologue( zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, const char * pMetricGroupNamePrefix, const char * pDescription, uint32_t * pMetricGroupCount, zet_metric_group_handle_t* phMetricGroup ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetDeviceCreateMetricGroupsFromMetricsExpEpilogue( zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t * phMetrics, const char * pMetricGroupNamePrefix, const char * pDescription, uint32_t * pMetricGroupCount, zet_metric_group_handle_t* phMetricGroup , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetDeviceCreateMetricGroupsFromMetricsExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCreateExpPrologue( zet_device_handle_t hDevice, const char* pName, const char* pDescription, zet_metric_group_sampling_type_flags_t samplingType, zet_metric_group_handle_t* phMetricGroup ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCreateExpEpilogue( zet_device_handle_t hDevice, const char* pName, const char* pDescription, zet_metric_group_sampling_type_flags_t samplingType, zet_metric_group_handle_t* phMetricGroup , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupCreateExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupAddMetricExpPrologue( zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric, size_t * pErrorStringSize, char* pErrorString ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupAddMetricExpEpilogue( zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric, size_t * pErrorStringSize, char* pErrorString , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupAddMetricExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupRemoveMetricExpPrologue( zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupRemoveMetricExpEpilogue( zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupRemoveMetricExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCloseExpPrologue( zet_metric_group_handle_t hMetricGroup ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupCloseExpEpilogue( zet_metric_group_handle_t hMetricGroup , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupCloseExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupDestroyExpPrologue( zet_metric_group_handle_t hMetricGroup ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricGroupDestroyExpEpilogue( zet_metric_group_handle_t hMetricGroup , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricGroupDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDestroyExpPrologue( zet_metric_handle_t hMetric ) override {
+        GlobalTimingState::getInstance().recordStart();
+        return ZE_RESULT_SUCCESS;
+    }
+    virtual ze_result_t zetMetricDestroyExpEpilogue( zet_metric_handle_t hMetric , ze_result_t result) override {
+        GlobalTimingState::getInstance().recordEnd("zetMetricDestroyExp");
+        return ZE_RESULT_SUCCESS;
+    }
+};
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/zel_global_timing_state.h b/source/layers/validation/checkers/timing/zel_global_timing_state.h
new file mode 100644
index 00000000..a674e3ab
--- /dev/null
+++ b/source/layers/validation/checkers/timing/zel_global_timing_state.h
@@ -0,0 +1,84 @@
+/*
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zel_global_timing_state.h
+ *
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <string>
+
+#include "ze_api.h"
+
+namespace validation_layer {
+
+// Per-API host timing aggregation. Modeled on unitrace's ZeFunctionTime
+// (tools/unitrace/src/levelzero/ze_collector.h). All values are in nanoseconds
+// except call_count.
+struct FunctionTime {
+    uint64_t total_time = 0;
+    uint64_t min_time = 0;
+    uint64_t max_time = 0;
+    uint64_t call_count = 0;
+};
+
+// Engine for the timing checker. Records the host-side duration of every L0 API
+// call (the span between its Prologue and Epilogue) and aggregates per-API
+// statistics. A single instance is shared by the generated ze/zes/zet/zer
+// timing checkers.
+//
+// The host clock primitive is ported from unitrace's UniTimer
+// (tools/unitrace/src/unitimer.h): a high-resolution monotonic counter
+// (QueryPerformanceCounter on Windows, CLOCK_MONOTONIC_RAW elsewhere).
+class GlobalTimingState {
+public:
+    static GlobalTimingState &getInstance() {
+        static GlobalTimingState instance;
+        return instance;
+    }
+
+    // Configure output modes from environment variables. Called once when the
+    // checker is enabled.
+    void configure();
+
+    // Prologue hook: stamp the per-thread start time.
+    void recordStart();
+
+    // Epilogue hook: compute the elapsed host time for this call and fold it
+    // into the per-API statistics. Optionally emits a live log line.
+    void recordEnd(const char *functionName);
+
+    // Teardown reporting.
+    void printSummary();
+    void writeCsv();
+
+    bool liveLoggingEnabled() const { return liveLogging_; }
+
+    // High-resolution monotonic host timestamp in nanoseconds.
+    static uint64_t getHostTimestampNs();
+
+private:
+    GlobalTimingState() = default;
+
+    std::mutex stats_mutex_;
+    std::map<std::string, FunctionTime> stats_;
+
+    bool liveLogging_ = false;
+    std::string csvPath_;
+
+    // Single-slot per-thread start time, matching unitrace's
+    // thread_local ze_instance_data.start_time_host. L0 host APIs are not
+    // re-entrant through the validation layer, so no stack is required; a
+    // value orphaned by another handler's failing Prologue is simply
+    // overwritten by the next Prologue.
+    static thread_local uint64_t apiStartTime_;
+};
+
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/zel_timing_checker.cpp b/source/layers/validation/checkers/timing/zel_timing_checker.cpp
new file mode 100644
index 00000000..97adafda
--- /dev/null
+++ b/source/layers/validation/checkers/timing/zel_timing_checker.cpp
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zel_timing_checker.cpp
+ *
+ */
+#include "zel_timing_checker.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <vector>
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <ctime>
+#include <unistd.h>
+#endif
+
+namespace validation_layer {
+
+constexpr uint64_t NSEC_IN_SEC = 1000000000ULL;
+
+thread_local uint64_t GlobalTimingState::apiStartTime_ = 0;
+
+class timingChecker timing_checker;
+
+uint64_t GlobalTimingState::getHostTimestampNs() {
+#if defined(_WIN32)
+    static LARGE_INTEGER frequency = {};
+    if (frequency.QuadPart == 0) {
+        QueryPerformanceFrequency(&frequency);
+    }
+    LARGE_INTEGER ticks;
+    QueryPerformanceCounter(&ticks);
+    if (frequency.QuadPart == 0) {
+        return 0;
+    }
+    return static_cast<uint64_t>(ticks.QuadPart) * (NSEC_IN_SEC / static_cast<uint64_t>(frequency.QuadPart));
+#else
+    struct timespec ts;
+    if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) != 0) {
+        return 0;
+    }
+    return static_cast<uint64_t>(ts.tv_sec) * NSEC_IN_SEC + static_cast<uint64_t>(ts.tv_nsec);
+#endif
+}
+
+void GlobalTimingState::configure() {
+    liveLogging_ = getenv_tobool("ZEL_TIMING_CHECKER_LIVE");
+    csvPath_ = getenv_string("ZEL_TIMING_CHECKER_CSV");
+}
+
+void GlobalTimingState::recordStart() {
+    apiStartTime_ = getHostTimestampNs();
+}
+
+void GlobalTimingState::recordEnd(const char *functionName) {
+    const uint64_t end = getHostTimestampNs();
+    // A start time of 0 means the matching Prologue did not run on this thread
+    // (e.g. another handler short-circuited the call); skip it.
+    if (apiStartTime_ == 0 || end < apiStartTime_) {
+        return;
+    }
+    const uint64_t elapsed = end - apiStartTime_;
+    apiStartTime_ = 0;
+
+    {
+        const std::lock_guard<std::mutex> lock(stats_mutex_);
+        auto it = stats_.find(functionName);
+        if (it == stats_.end()) {
+            FunctionTime stat;
+            stat.total_time = elapsed;
+            stat.min_time = elapsed;
+            stat.max_time = elapsed;
+            stat.call_count = 1;
+            stats_.insert({functionName, stat});
+        } else {
+            it->second.total_time += elapsed;
+            it->second.call_count += 1;
+            if (elapsed < it->second.min_time) {
+                it->second.min_time = elapsed;
+            }
+            if (elapsed > it->second.max_time) {
+                it->second.max_time = elapsed;
+            }
+        }
+    }
+
+    if (liveLogging_ && context.logger != nullptr) {
+        context.logger->log_info("[timing] " + std::string(functionName) + " " +
+                                 std::to_string(elapsed) + " ns");
+    }
+}
+
+void GlobalTimingState::printSummary() {
+    std::vector<std::pair<std::string, FunctionTime>> entries;
+    {
+        const std::lock_guard<std::mutex> lock(stats_mutex_);
+        entries.assign(stats_.begin(), stats_.end());
+    }
+    if (entries.empty() || context.logger == nullptr) {
+        return;
+    }
+
+    std::sort(entries.begin(), entries.end(),
+              [](const std::pair<std::string, FunctionTime> &a,
+                 const std::pair<std::string, FunctionTime> &b) {
+                  return a.second.total_time > b.second.total_time;
+              });
+
+    std::ostringstream out;
+    out << "\n==== Level Zero Host API Timing (ns) ====\n";
+    out << std::left << std::setw(48) << "Function" << std::right << std::setw(10) << "Calls"
+        << std::setw(16) << "Total" << std::setw(14) << "Min" << std::setw(14) << "Max"
+        << std::setw(14) << "Avg" << "\n";
+    for (const auto &entry : entries) {
+        const FunctionTime &t = entry.second;
+        const uint64_t avg = t.call_count ? (t.total_time / t.call_count) : 0;
+        out << std::left << std::setw(48) << entry.first << std::right << std::setw(10)
+            << t.call_count << std::setw(16) << t.total_time << std::setw(14) << t.min_time
+            << std::setw(14) << t.max_time << std::setw(14) << avg << "\n";
+    }
+    context.logger->log_info(out.str());
+}
+
+void GlobalTimingState::writeCsv() {
+    if (csvPath_.empty()) {
+        return;
+    }
+
+    std::vector<std::pair<std::string, FunctionTime>> entries;
+    {
+        const std::lock_guard<std::mutex> lock(stats_mutex_);
+        entries.assign(stats_.begin(), stats_.end());
+    }
+
+    // Append the process id so concurrent processes do not clobber each other,
+    // matching the System Resource Tracker checker.
+#if defined(_WIN32)
+    const unsigned long pid = static_cast<unsigned long>(GetCurrentProcessId());
+#else
+    const unsigned long pid = static_cast<unsigned long>(getpid());
+#endif
+    std::string uniquePath = csvPath_;
+    const auto dot = uniquePath.find_last_of('.');
+    if (dot == std::string::npos) {
+        uniquePath += "_" + std::to_string(pid) + ".csv";
+    } else {
+        uniquePath = uniquePath.substr(0, dot) + "_" + std::to_string(pid) + uniquePath.substr(dot);
+    }
+
+    std::ofstream csv(uniquePath, std::ios::out | std::ios::trunc);
+    if (!csv.is_open()) {
+        if (context.logger != nullptr) {
+            context.logger->log_error("Failed to open timing CSV file: " + uniquePath);
+        }
+        return;
+    }
+
+    csv << "Function,Calls,TotalNs,MinNs,MaxNs,AvgNs\n";
+    for (const auto &entry : entries) {
+        const FunctionTime &t = entry.second;
+        const uint64_t avg = t.call_count ? (t.total_time / t.call_count) : 0;
+        csv << entry.first << "," << t.call_count << "," << t.total_time << "," << t.min_time
+            << "," << t.max_time << "," << avg << "\n";
+    }
+    csv.flush();
+    csv.close();
+
+    if (context.logger != nullptr) {
+        context.logger->log_info("Timing checker CSV written: " + uniquePath);
+    }
+}
+
+timingChecker::timingChecker() {
+    enabletiming = getenv_tobool("ZEL_ENABLE_TIMING_CHECKER");
+    if (enabletiming) {
+        GlobalTimingState::getInstance().configure();
+        timingChecker::ZEtimingChecker *zeChecker = new timingChecker::ZEtimingChecker;
+        timingChecker::ZEStimingChecker *zesChecker = new timingChecker::ZEStimingChecker;
+        timingChecker::ZETtimingChecker *zetChecker = new timingChecker::ZETtimingChecker;
+        timingChecker::ZERtimingChecker *zerChecker = new timingChecker::ZERtimingChecker;
+        timing_checker.zeValidation = zeChecker;
+        timing_checker.zetValidation = zetChecker;
+        timing_checker.zesValidation = zesChecker;
+        timing_checker.zerValidation = zerChecker;
+        validation_layer::context.getInstance().validationHandlers.push_back(&timing_checker);
+    }
+}
+
+timingChecker::~timingChecker() {
+    if (enabletiming) {
+        GlobalTimingState::getInstance().printSummary();
+        GlobalTimingState::getInstance().writeCsv();
+        delete timing_checker.zeValidation;
+        delete timing_checker.zetValidation;
+        delete timing_checker.zesValidation;
+        delete timing_checker.zerValidation;
+    }
+}
+
+} // namespace validation_layer
diff --git a/source/layers/validation/checkers/timing/zel_timing_checker.h b/source/layers/validation/checkers/timing/zel_timing_checker.h
new file mode 100644
index 00000000..e28e2958
--- /dev/null
+++ b/source/layers/validation/checkers/timing/zel_timing_checker.h
@@ -0,0 +1,37 @@
+/*
+ *
+ * Copyright (C) 2026 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * @file zel_timing_checker.h
+ *
+ */
+
+#pragma once
+
+#include "generated/ze_timing.h"
+#include "generated/zes_timing.h"
+#include "generated/zet_timing.h"
+#include "generated/zer_timing.h"
+#include "ze_api.h"
+#include "ze_validation_layer.h"
+#include "zel_global_timing_state.h"
+
+namespace validation_layer {
+
+class __zedlllocal timingChecker : public validationChecker {
+public:
+  timingChecker();
+  ~timingChecker();
+  class ZEtimingChecker : public ZEtimingCheckerGenerated {};
+  class ZEStimingChecker : public ZEStimingCheckerGenerated {};
+  class ZETtimingChecker : public ZETtimingCheckerGenerated {};
+  class ZERtimingChecker : public ZERtimingCheckerGenerated {};
+
+  bool enabletiming = false;
+
+  GlobalTimingState &globalTimingState = GlobalTimingState::getInstance();
+};
+extern class timingChecker timing_checker;
+} // namespace validation_layer
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 28995c22..6c9ad2b8 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1159,3 +1159,7 @@ set_property(TEST test_validation_layer_api_tracing_immediate_cmdlist PROPERTY E
 
 add_test(NAME test_validation_layer_api_tracing_command_queue COMMAND tests --gtest_filter=ValidationLayerApiTracing.GivenValidationLayerEnabledWithTraceLevelLoggingWhenCallingCommandQueueApisThenTracingDoesNotCrash)
 set_property(TEST test_validation_layer_api_tracing_command_queue PROPERTY ENVIRONMENT "ZE_ENABLE_VALIDATION_LAYER=1;ZEL_ENABLE_LOADER_LOGGING=1;ZEL_LOADER_LOGGING_LEVEL=trace;ZE_ENABLE_NULL_DRIVER=1")
+
+# Timing Checker - host-side per-API timing must be transparent to results
+add_test(NAME test_validation_layer_timing_checker COMMAND tests --gtest_filter=ValidationLayerTimingChecker.GivenTimingCheckerEnabledWhenCallingApisThenResultsAreUnchangedAndNoCrash)
+set_property(TEST test_validation_layer_timing_checker PROPERTY ENVIRONMENT "ZE_ENABLE_VALIDATION_LAYER=1;ZEL_ENABLE_TIMING_CHECKER=1;ZE_ENABLE_NULL_DRIVER=1;ZEL_TEST_NULL_DRIVER_TYPE=GPU")
diff --git a/test/loader_validation_layer.cpp b/test/loader_validation_layer.cpp
index 62d3538f..e556215d 100644
--- a/test/loader_validation_layer.cpp
+++ b/test/loader_validation_layer.cpp
@@ -1056,3 +1056,54 @@ TEST(
     uint32_t deviceCount = 0;
     EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_HANDLE, zeDeviceGet(nullptr, &deviceCount, nullptr));
 }
+
+// Verify that enabling the Timing Checker is transparent: it records host-side
+// timing for every API call without altering results or crashing. The per-API
+// summary is emitted by the checker at teardown.
+TEST(
+    ValidationLayerTimingChecker,
+    GivenTimingCheckerEnabledWhenCallingApisThenResultsAreUnchangedAndNoCrash) {
+
+    putenv_safe(const_cast<char *>("ZE_ENABLE_VALIDATION_LAYER=1"));
+    putenv_safe(const_cast<char *>("ZEL_ENABLE_TIMING_CHECKER=1"));
+    putenv_safe(const_cast<char *>("ZE_ENABLE_NULL_DRIVER=1"));
+    putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_TYPE=GPU"));
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInit(ZE_INIT_FLAG_GPU_ONLY));
+
+    uint32_t pInitDriversCount = 0;
+    ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
+    desc.flags = UINT32_MAX;
+    desc.pNext = nullptr;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
+    EXPECT_GT(pInitDriversCount, 0);
+
+    uint32_t driverCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGet(&driverCount, nullptr));
+    EXPECT_GT(driverCount, 0);
+
+    std::vector<ze_driver_handle_t> drivers(driverCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDriverGet(&driverCount, drivers.data()));
+
+    uint32_t deviceCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDeviceGet(drivers[0], &deviceCount, nullptr));
+    EXPECT_GT(deviceCount, 0);
+
+    std::vector<ze_device_handle_t> devices(deviceCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDeviceGet(drivers[0], &deviceCount, devices.data()));
+
+    ze_context_desc_t context_desc = {};
+    context_desc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
+    ze_context_handle_t context = nullptr;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeContextCreate(drivers[0], &context_desc, &context));
+    EXPECT_NE(context, nullptr);
+
+    ze_command_list_desc_t cmdlist_desc = {};
+    cmdlist_desc.stype = ZE_STRUCTURE_TYPE_COMMAND_LIST_DESC;
+    ze_command_list_handle_t commandList = nullptr;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListCreate(context, devices[0], &cmdlist_desc, &commandList));
+    EXPECT_NE(commandList, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeCommandListDestroy(commandList));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeContextDestroy(context));
+}