feature: Support for metrics group exp extension

Support zet_metric_global_timestamps_resolution_exp_t

Resolves: LOCI-4350

Signed-off-by: Matias Cabral <matias.a.cabral@intel.com>

level_zero/tools/source/metrics/CMakeLists.txt

@@ -20,7 +20,7 @@ target_sources(${L0_STATIC_LIB_NAME}
                ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.h
                ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.cpp
-               ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/os_interface_metric.h
 )
 
 add_subdirectories()

level_zero/tools/source/metrics/linux/os_metric_ip_sampling_imp_linux.cpp

@@ -18,7 +18,8 @@
 
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/device/device_imp.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/metric.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 #include <algorithm>
 
@@ -39,6 +40,7 @@ class MetricIpSamplingLinuxImp : public MetricIpSamplingOsInterface {
     uint32_t getUnitReportSize() override;
     bool isNReportsAvailable() override;
     bool isDependencyAvailable() override;
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
 
   private:
     int32_t stream = -1;
@@ -51,18 +53,17 @@ MetricIpSamplingLinuxImp::MetricIpSamplingLinuxImp(Device &device) : device(devi
 
 ze_result_t MetricIpSamplingLinuxImp::getNearestSupportedSamplingUnit(uint32_t &samplingPeriodNs, uint32_t &samplingUnit) {
 
-    static constexpr uint64_t nsecPerSec = 1000000000ull;
     static constexpr uint32_t samplingClockGranularity = 251u;
     static constexpr uint32_t minSamplingUnit = 1u;
     static constexpr uint32_t maxSamplingUnit = 7u;
-    const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+
-    int32_t gpuTimeStampfrequency = 0;
+    uint64_t gpuTimeStampfrequency = 0;
-    int32_t ret = drm->getTimestampFrequency(gpuTimeStampfrequency);
+    ze_result_t ret = getMetricsTimerResolution(gpuTimeStampfrequency);
-    if (ret < 0 || gpuTimeStampfrequency == 0) {
+    if (ret != ZE_RESULT_SUCCESS) {
-        return ZE_RESULT_ERROR_UNKNOWN;
+        return ret;
     }
 
-    uint64_t gpuClockPeriodNs = nsecPerSec / static_cast<uint64_t>(gpuTimeStampfrequency);
+    uint64_t gpuClockPeriodNs = nsecPerSec / gpuTimeStampfrequency;
     uint64_t numberOfClocks = samplingPeriodNs / gpuClockPeriodNs;
 
     samplingUnit = std::clamp(static_cast<uint32_t>(numberOfClocks / samplingClockGranularity), minSamplingUnit, maxSamplingUnit);
@@ -205,6 +206,24 @@ bool MetricIpSamplingLinuxImp::isDependencyAvailable() {
     return status == ZE_RESULT_SUCCESS ? true : false;
 }
 
+ze_result_t MetricIpSamplingLinuxImp::getMetricsTimerResolution(uint64_t &timerResolution) {
+    ze_result_t result = ZE_RESULT_SUCCESS;
+
+    const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+    int32_t gpuTimeStampfrequency = 0;
+    int32_t ret = drm->getTimestampFrequency(gpuTimeStampfrequency);
+    if (ret < 0 || gpuTimeStampfrequency == 0) {
+        timerResolution = 0;
+        result = ZE_RESULT_ERROR_UNKNOWN;
+        PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "getTimestampFrequency() failed errno = %d | ret = %d \n",
+                           errno, ret);
+    } else {
+        timerResolution = static_cast<uint64_t>(gpuTimeStampfrequency);
+    }
+
+    return result;
+}
+
 std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {
     return std::make_unique<MetricIpSamplingLinuxImp>(device);
 }

level_zero/tools/source/metrics/linux/os_metric_oa_enumeration_imp_linux.cpp

@@ -1,10 +1,11 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
+#include "shared/source/debug_settings/debug_settings_manager.h"
 #include "shared/source/os_interface/linux/drm_neo.h"
 #include "shared/source/os_interface/linux/sys_calls.h"
 #include "shared/source/os_interface/os_interface.h"
@@ -12,6 +13,7 @@
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 #include <sys/stat.h>
 #include <sys/sysmacros.h>
@@ -81,5 +83,38 @@ MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
 
     return nullptr;
 }
+class MetricOALinuxImp : public MetricOAOsInterface {
+  public:
+    MetricOALinuxImp(Device &device);
+    ~MetricOALinuxImp() override = default;
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
+
+  private:
+    Device &device;
+};
+
+MetricOALinuxImp::MetricOALinuxImp(Device &device) : device(device) {}
+
+std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
+    return std::make_unique<MetricOALinuxImp>(device);
+}
+
+ze_result_t MetricOALinuxImp::getMetricsTimerResolution(uint64_t &timerResolution) {
+    ze_result_t result = ZE_RESULT_SUCCESS;
+
+    const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+    int32_t timestampFrequency;
+    int32_t ret = drm->getOATimestampFrequency(timestampFrequency);
+    if (ret < 0 || timestampFrequency == 0) {
+        timerResolution = 0;
+        result = ZE_RESULT_ERROR_UNKNOWN;
+        PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "getOATimestampFrequenc() failed errno = %d | ret = %d \n",
+                           errno, ret);
+    } else {
+        timerResolution = static_cast<uint64_t>(timestampFrequency);
+    }
+
+    return result;
+}
 
 } // namespace L0

level_zero/tools/source/metrics/metric.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -122,7 +122,7 @@ void MetricDeviceContext::activateMetricGroupsDeferred(uint32_t count, zet_metri
     for (auto index = 0u; index < count; index++) {
 
         zet_metric_group_handle_t hMetricGroup = MetricGroup::fromHandle(phMetricGroups[index])->getMetricGroupForSubDevice(subDeviceIndex);
-        zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
+        zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         MetricGroup::fromHandle(hMetricGroup)->getProperties(&properties);
         auto domain = properties.domain;
         // Domain already associated with the same handle.
@@ -259,4 +259,36 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
     return MetricGroup::fromHandle(hMetricGroup)->streamerOpen(hContext, hDevice, pDesc, hNotificationEvent, phMetricStreamer);
 }
 
+ze_result_t MetricGroup::getMetricGroupExtendedProperties(MetricSource &metricSource, void *pNext) {
+    ze_result_t retVal = ZE_RESULT_ERROR_INVALID_ARGUMENT;
+
+    while (pNext) {
+        zet_base_desc_t *extendedProperties = reinterpret_cast<zet_base_desc_t *>(pNext);
+
+        if (extendedProperties->stype == ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES) {
+
+            zet_metric_global_timestamps_resolution_exp_t *metricsTimestampProperties =
+                reinterpret_cast<zet_metric_global_timestamps_resolution_exp_t *>(extendedProperties);
+
+            retVal = metricSource.getTimerResolution(metricsTimestampProperties->timerResolution);
+            if (retVal != ZE_RESULT_SUCCESS) {
+                metricsTimestampProperties->timerResolution = 0;
+                metricsTimestampProperties->timestampValidBits = 0;
+                return retVal;
+            }
+
+            retVal = metricSource.getTimestampValidBits(metricsTimestampProperties->timestampValidBits);
+            if (retVal != ZE_RESULT_SUCCESS) {
+                metricsTimestampProperties->timerResolution = 0;
+                metricsTimestampProperties->timestampValidBits = 0;
+                return retVal;
+            }
+        }
+
+        pNext = const_cast<void *>(extendedProperties->pNext);
+    }
+
+    return retVal;
+}
+
 } // namespace L0

level_zero/tools/source/metrics/metric.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "level_zero/core/source/event/event.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include <level_zero/zet_api.h>
 
 #include "metrics_discovery_api.h"
@@ -24,6 +25,8 @@ namespace L0 {
 struct CommandList;
 struct MetricStreamer;
 
+static constexpr uint64_t nsecPerSec = 1000000000ull;
+
 class MetricSource {
   public:
     enum class SourceType {
@@ -35,7 +38,11 @@ class MetricSource {
     virtual bool isAvailable() = 0;
     virtual ze_result_t appendMetricMemoryBarrier(CommandList &commandList) = 0;
     virtual ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) = 0;
+    virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0;
+    virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
     virtual ~MetricSource() = default;
+
+  private:
 };
 
 class MetricDeviceContext {
@@ -109,6 +116,7 @@ struct MetricGroup : _zet_metric_group_handle_t {
         zet_device_handle_t hDevice,
         const zet_metric_query_pool_desc_t *desc,
         zet_metric_query_pool_handle_t *phMetricQueryPool) = 0;
+    ze_result_t getMetricGroupExtendedProperties(MetricSource &metricSource, void *pnext);
 };
 
 struct MetricGroupCalculateHeader {

level_zero/tools/source/metrics/metric_ip_sampling_source.cpp

@@ -8,12 +8,14 @@
 #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/string.h"
 
+#include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/device/device_imp.h"
 #include "level_zero/tools/source/metrics/metric.h"
 #include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include <level_zero/zet_api.h>
 
 #include <cstring>
@@ -27,11 +29,21 @@ std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(con
 }
 
 IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
-    metricOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
+    metricIPSamplingOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
+}
+
+ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) {
+    resolution = metricDeviceContext.getDevice().getNEODevice()->getDeviceInfo().outProfilingTimerClock;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t IpSamplingMetricSourceImp::getTimestampValidBits(uint64_t &validBits) {
+    validBits = metricDeviceContext.getDevice().getNEODevice()->getHardwareInfo().capabilityTable.timestampValidBits;
+    return ZE_RESULT_SUCCESS;
 }
 
 void IpSamplingMetricSourceImp::enable() {
-    isEnabled = metricOsInterface->isDependencyAvailable();
+    isEnabled = metricIPSamplingOsInterface->isDependencyAvailable();
 }
 
 bool IpSamplingMetricSourceImp::isAvailable() {
@@ -132,8 +144,8 @@ ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &co
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface) {
+void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingOsInterface) {
-    this->metricOsInterface = std::move(metricOsInterface);
+    this->metricIPSamplingOsInterface = std::move(metricIPSamplingOsInterface);
 }
 
 IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
@@ -153,7 +165,14 @@ IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &me
 }
 
 ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
+    void *pNext = pProperties->pNext;
     *pProperties = properties;
+    pProperties->pNext = pNext;
+
+    if (pNext) {
+        return getMetricGroupExtendedProperties(metricSource, pNext);
+    }
+
     return ZE_RESULT_SUCCESS;
 }
 

level_zero/tools/source/metrics/metric_ip_sampling_source.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include "level_zero/tools/source/metrics/metric.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace L0 {
 
@@ -25,18 +25,20 @@ class IpSamplingMetricSourceImp : public MetricSource {
     bool isAvailable() override;
     ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override;
     ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
-    void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface);
+    void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingOsInterface);
     static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
-    MetricIpSamplingOsInterface *getMetricOsInterface() { return metricOsInterface.get(); }
+    MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingOsInterface.get(); }
     IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
     const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
+    ze_result_t getTimerResolution(uint64_t &resolution) override;
+    ze_result_t getTimestampValidBits(uint64_t &validBits) override;
 
   protected:
     void cacheMetricGroup();
     bool isEnabled = false;
 
     const MetricDeviceContext &metricDeviceContext;
-    std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
+    std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingOsInterface = nullptr;
     std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
 };
 
@@ -95,7 +97,7 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
 
   private:
     std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
-    zet_metric_group_properties_t properties = {};
+    zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     ze_result_t getCalculatedMetricCount(const size_t rawDataSize, uint32_t &metricValueCount);
     ze_result_t getCalculatedMetricValues(const zet_metric_group_calculation_type_t type, const size_t rawDataSize, const uint8_t *pRawData,
                                           uint32_t &metricValueCount,

level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp

@@ -10,7 +10,7 @@
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/tools/source/metrics/metric.h"
 #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include <level_zero/zet_api.h>
 
 #include <string.h>

level_zero/tools/source/metrics/metric_ip_sampling_streamer.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include "level_zero/tools/source/metrics/metric.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace L0 {
 

level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp

@@ -68,11 +68,22 @@ bool MetricEnumeration::isInitialized() {
     return initializationState == ZE_RESULT_SUCCESS;
 }
 
-void MetricEnumeration::readGlobalSymbols() {
+bool MetricEnumeration::readGlobalSymbol(const char *name, uint32_t &symbolValue) {
-    auto symbolValue = pMetricsDevice->GetGlobalSymbolValueByName(globalSymbolOaMaxBufferSize.data());
+    auto tempValue = pMetricsDevice->GetGlobalSymbolValueByName(name);
-    if (symbolValue != nullptr) {
+    if (tempValue != nullptr) {
-        maximumOaBufferSize = symbolValue->ValueUInt32;
+        symbolValue = tempValue->ValueUInt32;
+        return true;
     }
+    return false;
+}
+
+bool MetricEnumeration::readGlobalSymbol(const char *name, uint64_t &symbolValue) {
+    auto tempValue = pMetricsDevice->GetGlobalSymbolValueByName(name);
+    if (tempValue != nullptr) {
+        symbolValue = tempValue->ValueUInt64;
+        return true;
+    }
+    return false;
 }
 
 ze_result_t MetricEnumeration::initialize() {
@@ -169,7 +180,8 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
                 cleanupMetricsDiscovery();
                 return ZE_RESULT_ERROR_NOT_AVAILABLE;
             }
-            subDeviceMetricEnumeraion.readGlobalSymbols();
+
+            subDeviceMetricEnumeraion.readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize);
         }
     } else {
         auto &deviceImp = *static_cast<DeviceImp *>(&metricSource.getDevice());
@@ -188,7 +200,7 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
             return ZE_RESULT_ERROR_NOT_AVAILABLE;
         }
 
-        readGlobalSymbols();
+        readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize);
     }
 
     return ZE_RESULT_SUCCESS;
@@ -334,8 +346,7 @@ MetricEnumeration::cacheMetricGroup(MetricsDiscovery::IMetricSet_1_5 &metricSet,
         // Obtain params once again - updated after SetApiFiltering
         pMetricSetParams = metricSet.GetParams();
 
-        zet_metric_group_properties_t properties = {};
+        zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
-        properties.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
         snprintf(properties.name, sizeof(properties.name), "%s",
                  pMetricSetParams->SymbolName); // To always have null-terminated string
         snprintf(properties.description, sizeof(properties.description), "%s",
@@ -519,22 +530,28 @@ OaMetricGroupImp ::~OaMetricGroupImp() {
 };
 
 ze_result_t OaMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
+
+    ze_result_t status = ZE_RESULT_SUCCESS;
     if (metricGroups.size() > 0) {
-        *pProperties = OaMetricGroupImp::getProperties(metricGroups[0]);
+        status = OaMetricGroupImp::getProperties(metricGroups[0], pProperties);
     } else {
+
+        void *pNext = pProperties->pNext;
         copyProperties(properties, *pProperties);
+        pProperties->pNext = pNext;
+        if (pNext) {
+            status = getMetricGroupExtendedProperties(*metricSource, pNext);
+        }
     }
-    return ZE_RESULT_SUCCESS;
+
+    return status;
 }
 
-zet_metric_group_properties_t OaMetricGroupImp::getProperties(const zet_metric_group_handle_t handle) {
+ze_result_t OaMetricGroupImp::getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties) {
     auto metricGroup = MetricGroup::fromHandle(handle);
     UNRECOVERABLE_IF(!metricGroup);
 
-    zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
+    return metricGroup->getProperties(pProperties);
-    metricGroup->getProperties(&properties);
-
-    return properties;
 }
 
 ze_result_t OaMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {

level_zero/tools/source/metrics/metric_oa_enumeration_imp.h

@@ -16,6 +16,7 @@
 namespace L0 {
 
 static constexpr std::string_view globalSymbolOaMaxBufferSize = "OABufferMaxSize";
+static constexpr std::string_view globalSymbolOaMaxTimestamp = "MaxTimestamp";
 
 class OaMetricSourceImp;
 
@@ -32,6 +33,8 @@ struct MetricEnumeration {
     virtual ze_result_t loadMetricsDiscovery();
     void getMetricsDiscoveryFilename(std::vector<const char *> &names) const;
     uint32_t getMaxOaBufferSize() const { return maximumOaBufferSize; }
+    bool readGlobalSymbol(const char *name, uint32_t &symbolValue);
+    bool readGlobalSymbol(const char *name, uint64_t &symbolValue);
 
   protected:
     ze_result_t initialize();
@@ -56,7 +59,6 @@ struct MetricEnumeration {
     getMetricType(const MetricsDiscovery::TInformationType sourceInformationType) const;
     zet_value_type_t
     getMetricResultType(const MetricsDiscovery::TMetricResultType sourceMetricResultType) const;
-    void readGlobalSymbols();
 
   protected:
     OaMetricSourceImp &metricSource;
@@ -129,7 +131,7 @@ struct OaMetricGroupImp : MetricGroup {
                                MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
                                const std::vector<Metric *> &metrics,
                                MetricSource &metricSource);
-    static zet_metric_group_properties_t getProperties(const zet_metric_group_handle_t handle);
+    static ze_result_t getProperties(const zet_metric_group_handle_t handle, zet_metric_group_properties_t *pProperties);
     uint32_t getRawReportSize();
     const MetricEnumeration &getMetricEnumeration() const;
 
@@ -148,9 +150,7 @@ struct OaMetricGroupImp : MetricGroup {
 
     // Cached metrics.
     std::vector<Metric *> metrics;
-    zet_metric_group_properties_t properties{
+    zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
-        ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES,
-    };
     MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr;
     MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;
 

level_zero/tools/source/metrics/metric_oa_query_imp.cpp

@@ -397,7 +397,8 @@ ConfigurationHandle_1_0 MetricsLibrary::addConfiguration(zet_metric_group_handle
 
     // Create metrics library configuration.
     auto metricGroup = MetricGroup::fromHandle(handle);
-    auto properties = OaMetricGroupImp::getProperties(handle);
+    zet_metric_group_properties_t properties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    OaMetricGroupImp::getProperties(handle, &properties);
     auto configuration = createConfiguration(metricGroup, properties);
 
     // Cache configuration if valid.
@@ -604,7 +605,8 @@ bool OaMetricQueryPoolImp::allocateGpuMemory() {
 
 bool OaMetricQueryPoolImp::createMetricQueryPool() {
     // Validate metric group query - only event based is supported.
-    auto metricGroupProperites = OaMetricGroupImp::getProperties(hMetricGroup);
+    zet_metric_group_properties_t metricGroupProperites = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    OaMetricGroupImp::getProperties(hMetricGroup, &metricGroupProperites);
     const bool validMetricGroup = metricGroupProperites.samplingType == ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     if (!validMetricGroup) {

level_zero/tools/source/metrics/metric_oa_source.cpp

@@ -26,6 +26,7 @@ std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceC
 OaMetricSourceImp::OaMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext),
                                                                                        metricEnumeration(std::unique_ptr<MetricEnumeration>(new(std::nothrow) MetricEnumeration(*this))),
                                                                                        metricsLibrary(std::unique_ptr<MetricsLibrary>(new(std::nothrow) MetricsLibrary(*this))) {
+    metricOAOsInterface = MetricOAOsInterface::create(metricDeviceContext.getDevice());
 }
 
 OaMetricSourceImp::~OaMetricSourceImp() = default;
@@ -34,6 +35,39 @@ void OaMetricSourceImp::enable() {
     loadDependencies();
 }
 
+ze_result_t OaMetricSourceImp::getTimerResolution(uint64_t &resolution) {
+
+    ze_result_t result = getMetricOsInterface()->getMetricsTimerResolution(resolution);
+    if (result != ZE_RESULT_SUCCESS) {
+        resolution = 0;
+    }
+
+    return result;
+}
+
+ze_result_t OaMetricSourceImp::getTimestampValidBits(uint64_t &validBits) {
+    ze_result_t retVal = ZE_RESULT_SUCCESS;
+
+    uint64_t maxNanoSeconds = 0;
+    if (!metricEnumeration->readGlobalSymbol(globalSymbolOaMaxTimestamp.data(), maxNanoSeconds)) {
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+    }
+
+    uint64_t timerFreqquency;
+    retVal = getTimerResolution(timerFreqquency);
+    if (retVal != ZE_RESULT_SUCCESS) {
+        validBits = 0;
+        return retVal;
+    }
+
+    uint64_t maxTimeStamp = maxNanoSeconds * timerFreqquency / nsecPerSec;
+
+    auto bits = std::bitset<64>(maxTimeStamp);
+    validBits = bits.count();
+
+    return retVal;
+}
+
 bool OaMetricSourceImp::isAvailable() {
     return isInitialized();
 }
@@ -143,6 +177,10 @@ bool OaMetricSourceImp::isImplicitScalingCapable() const {
     return metricDeviceContext.isImplicitScalingCapable();
 }
 
+void OaMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface) {
+    this->metricOAOsInterface = std::move(metricOAOsInterface);
+}
+
 template <>
 OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
     return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));

level_zero/tools/source/metrics/metric_oa_source.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -38,6 +38,9 @@ class OaMetricSourceImp : public MetricSource {
     void setMetricsLibrary(MetricsLibrary &metricsLibrary);
     void setMetricEnumeration(MetricEnumeration &metricEnumeration);
 
+    ze_result_t getTimerResolution(uint64_t &resolution) override;
+    ze_result_t getTimestampValidBits(uint64_t &validBits) override;
+
     ze_result_t activateMetricGroups();
     ze_result_t activateMetricGroupsDeferred(const uint32_t count,
                                              zet_metric_group_handle_t *phMetricGroups);
@@ -49,6 +52,8 @@ class OaMetricSourceImp : public MetricSource {
     bool isImplicitScalingCapable() const;
     const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
     static std::unique_ptr<OaMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
+    void setMetricOsInterface(std::unique_ptr<MetricOAOsInterface> &metricOAOsInterface);
+    MetricOAOsInterface *getMetricOsInterface() { return metricOAOsInterface.get(); }
     using OsLibraryLoadPtr = std::add_pointer<NEO::OsLibrary *(const std::string &)>::type;
     static OsLibraryLoadPtr osLibraryLoadFunction;
 
@@ -59,6 +64,7 @@ class OaMetricSourceImp : public MetricSource {
     std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
     MetricStreamer *pMetricStreamer = nullptr;
     bool useCompute = false;
+    std::unique_ptr<MetricOAOsInterface> metricOAOsInterface = nullptr;
 };
 
 template <>

level_zero/tools/source/metrics/metric_oa_streamer_imp.cpp

@@ -258,7 +258,7 @@ ze_result_t OaMetricGroupImp::openForDevice(Device *pDevice, zet_metric_streamer
     }
 
     // Check metric group sampling type.
-    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     getProperties(&metricGroupProperties);
     if (metricGroupProperties.samplingType != ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED) {
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;

level_zero/tools/source/metrics/os_interface_metric.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,10 +14,16 @@
 namespace L0 {
 
 struct Device;
-
+class MetricOsInterface {
-class MetricIpSamplingOsInterface {
   public:
-    virtual ~MetricIpSamplingOsInterface() = default;
+    virtual ~MetricOsInterface() = default;
+    virtual ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) = 0;
+    static std::unique_ptr<MetricOsInterface> create(Device &device);
+};
+
+class MetricIpSamplingOsInterface : public MetricOsInterface {
+  public:
+    ~MetricIpSamplingOsInterface() override = default;
     virtual ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) = 0;
     virtual ze_result_t stopMeasurement() = 0;
     virtual ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) = 0;
@@ -28,4 +34,10 @@ class MetricIpSamplingOsInterface {
     static std::unique_ptr<MetricIpSamplingOsInterface> create(Device &device);
 };
 
+class MetricOAOsInterface : public MetricOsInterface {
+  public:
+    ~MetricOAOsInterface() override = default;
+    static std::unique_ptr<MetricOAOsInterface> create(Device &device);
+};
+
 } // namespace L0

level_zero/tools/source/metrics/windows/os_metric_ip_sampling_imp_windows.cpp

@@ -1,12 +1,12 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
 #include "level_zero/core/source/device/device.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace L0 {
 
@@ -34,6 +34,9 @@ class MetricIpSamplingWindowsImp : public MetricIpSamplingOsInterface {
     bool isDependencyAvailable() override {
         return false;
     }
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
 };
 
 std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {

level_zero/tools/source/metrics/windows/os_metric_oa_enumeration_imp_windows.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -70,4 +70,24 @@ MetricsDiscovery::IAdapter_1_9 *MetricEnumeration::getMetricsAdapter() {
     return nullptr;
 }
 
+class MetricOAWindowsImp : public MetricOAOsInterface {
+  public:
+    MetricOAWindowsImp(Device &device);
+    ~MetricOAWindowsImp() override = default;
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override;
+
+  private:
+    Device &device;
+};
+
+MetricOAWindowsImp::MetricOAWindowsImp(Device &device) : device(device) {}
+
+std::unique_ptr<MetricOAOsInterface> MetricOAOsInterface::create(Device &device) {
+    return std::make_unique<MetricOAWindowsImp>(device);
+}
+
+ze_result_t MetricOAWindowsImp::getMetricsTimerResolution(uint64_t &timerResolution) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
 } // namespace L0

level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux.cpp

@@ -8,7 +8,7 @@
 #include "shared/test/common/test_macros/hw_test.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace L0 {
 namespace ult {

level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux_pvc_prelim.cpp

@@ -18,7 +18,7 @@
 #include "shared/test/common/test_macros/hw_test.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace NEO {
 namespace SysCalls {

level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux_pvc_upstream.cpp

@@ -9,7 +9,7 @@
 #include "shared/test/common/libult/linux/drm_mock.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
 namespace L0 {

level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_oa_query_pool_linux.cpp

@@ -12,6 +12,7 @@
 #include "shared/test/common/mocks/mock_io_functions.h"
 #include "shared/test/common/test_macros/test.h"
 
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h"
 
 #include "gmock/gmock.h"
@@ -221,6 +222,32 @@ class MetricEnumerationTestLinux : public MetricContextFixture,
     }
 };
 
+TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGettingOATimerResolutionThenReturnSuccess) {
+
+    std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
+    uint64_t timerResolution;
+    OAOsInterface->getMetricsTimerResolution(timerResolution);
+    EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(timerResolution, 123456UL);
+}
+
+TEST_F(MetricEnumerationTestLinux, givenDrmFailureWhenGettingOATimerResolutionThenReturnError) {
+
+    std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
+    uint64_t timerResolution;
+    OAOsInterface->getMetricsTimerResolution(timerResolution);
+    auto drm = static_cast<DrmMock *>(device->getOsInterface().getDriverModel()->as<NEO::Drm>());
+    drm->storedRetVal = -1;
+
+    EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(timerResolution, 0UL);
+
+    drm->storedRetVal = 0;
+    drm->storedOaTimestampFrequency = 0;
+    EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(timerResolution, 0UL);
+}
+
 TEST_F(MetricEnumerationTestLinux, givenCorrectLinuxDrmAdapterWhenGetMetricsAdapterThenReturnSuccess) {
 
     auto adapterGroupParams = TAdapterGroupParams_1_6{};

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,7 +8,7 @@
 #pragma once
 #include "shared/test/common/test_macros/test.h"
 
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 namespace L0 {
 namespace ult {
@@ -19,6 +19,7 @@ class MockMetricIpSamplingOsInterface : public MetricIpSamplingOsInterface {
     ze_result_t startMeasurementReturn = ZE_RESULT_SUCCESS;
     ze_result_t stopMeasurementReturn = ZE_RESULT_SUCCESS;
     ze_result_t readDataReturn = ZE_RESULT_SUCCESS;
+    ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
     uint32_t getUnitReportSizeReturn = 64;
     bool isNReportsAvailableReturn = true;
     bool isDependencyAvailableReturn = true;
@@ -53,6 +54,11 @@ class MockMetricIpSamplingOsInterface : public MetricIpSamplingOsInterface {
     bool isDependencyAvailable() override {
         return isDependencyAvailableReturn;
     }
+
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
+        timerResolution = 1000;
+        return getMetricsTimerResolutionReturn;
+    }
 };
 
 } // namespace ult

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.cpp

@@ -13,7 +13,7 @@
 #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 #include "level_zero/tools/source/metrics/metric_oa_streamer_imp.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 using namespace MetricsLibraryApi;
 
@@ -23,32 +23,22 @@ using ::testing::Return;
 namespace L0 {
 namespace ult {
 
-class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {
-
-  public:
-    ~MockIpSamplingOsInterface() override = default;
-    ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override {
-        return ZE_RESULT_ERROR_UNKNOWN;
-    }
-    ze_result_t stopMeasurement() override { return ZE_RESULT_ERROR_UNKNOWN; }
-    ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override { return ZE_RESULT_ERROR_UNKNOWN; }
-    uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override { return 0; }
-    uint32_t getUnitReportSize() override { return 0; }
-    bool isNReportsAvailable() override { return false; }
-    bool isDependencyAvailable() override { return false; }
-};
-
 void MetricContextFixture::setUp() {
 
     // Call base class.
     DeviceFixture::setUp();
 
     // Initialize metric api.
+    mockOAOsInterface = new MockOAOsInterface();
+    std::unique_ptr<MetricOAOsInterface> metricOAOsInterface =
+        std::unique_ptr<MetricOAOsInterface>(mockOAOsInterface);
     auto &metricSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    metricSource.setMetricOsInterface(metricOAOsInterface);
     metricSource.setInitializationState(ZE_RESULT_SUCCESS);
 
+    mockIpSamplingOsInterface = new MockIpSamplingOsInterface();
     std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface =
-        std::unique_ptr<MetricIpSamplingOsInterface>(new MockIpSamplingOsInterface());
+        std::unique_ptr<MetricIpSamplingOsInterface>(mockIpSamplingOsInterface);
     auto &ipMetricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
     ipMetricSource.setMetricOsInterface(metricIpSamplingOsInterface);
 
@@ -136,11 +126,6 @@ void MetricContextFixture::openMetricsAdapterGroup() {
 void MetricContextFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice) {
     EXPECT_CALL(metricDevice, GetParams())
         .WillRepeatedly(testing::Return(&metricsDeviceParams));
-
-    defaultMaximumOaBufferSize.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
-    defaultMaximumOaBufferSize.ValueUInt32 = 1024;
-    EXPECT_CALL(metricDevice, GetGlobalSymbolValueByName(_))
-        .WillRepeatedly(testing::Return(&defaultMaximumOaBufferSize));
 }
 
 void MetricMultiDeviceFixture::setUp() {
@@ -336,11 +321,6 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
 void MetricMultiDeviceFixture::setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice) {
     EXPECT_CALL(metricDevice, GetParams())
         .WillRepeatedly(testing::Return(&metricsDeviceParams));
-
-    defaultMaximumOaBufferSize.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
-    defaultMaximumOaBufferSize.ValueUInt32 = 1024;
-    EXPECT_CALL(metricDevice, GetGlobalSymbolValueByName(_))
-        .WillRepeatedly(testing::Return(&defaultMaximumOaBufferSize));
 }
 
 void MetricStreamerMultiDeviceFixture::cleanup(zet_device_handle_t &hDevice, zet_metric_streamer_handle_t &hStreamer) {

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa.h

@@ -143,6 +143,45 @@ struct Mock<MetricQuery> : public MetricQuery {
     MOCK_METHOD(ze_result_t, destroy, (), (override));
 };
 
+class MockIpSamplingOsInterface : public MetricIpSamplingOsInterface {
+
+  public:
+    ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
+    ~MockIpSamplingOsInterface() override = default;
+    ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    ze_result_t stopMeasurement() override { return ZE_RESULT_ERROR_UNKNOWN; }
+    ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override { return ZE_RESULT_ERROR_UNKNOWN; }
+    uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override { return 0; }
+    uint32_t getUnitReportSize() override { return 0; }
+    bool isNReportsAvailable() override { return false; }
+    bool isDependencyAvailable() override { return false; }
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
+        timerResolution = 12500000UL;
+        return getMetricsTimerResolutionReturn;
+    }
+};
+class MockOAOsInterface : public MetricOAOsInterface {
+  public:
+    ~MockOAOsInterface() override = default;
+    ze_result_t getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
+    uint8_t failGetResolutionOnCall = 0;
+    uint8_t getResolutionCallCount = 0;
+    ze_result_t getMetricsTimerResolution(uint64_t &timerResolution) override {
+        ze_result_t retVal;
+        getResolutionCallCount++;
+        if ((failGetResolutionOnCall) && (getResolutionCallCount >= failGetResolutionOnCall)) {
+            timerResolution = 0UL;
+            retVal = getMetricsTimerResolutionReturn;
+        } else {
+            timerResolution = 25000000UL; // PVC as reference
+            retVal = ZE_RESULT_SUCCESS;
+        }
+        return retVal;
+    }
+};
+
 class MetricContextFixture : public DeviceFixture {
 
   protected:
@@ -167,6 +206,8 @@ class MetricContextFixture : public DeviceFixture {
     MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
     MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
     void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
+    MockOAOsInterface *mockOAOsInterface;
+    MockIpSamplingOsInterface *mockIpSamplingOsInterface;
 };
 
 class MetricMultiDeviceFixture : public MultiDeviceFixture {
@@ -198,7 +239,7 @@ class MetricMultiDeviceFixture : public MultiDeviceFixture {
     Mock<IAdapter_1_9> adapter;
     Mock<IMetricsDevice_1_5> metricsDevice;
     MetricsDiscovery::TMetricsDeviceParams_1_2 metricsDeviceParams = {};
-    MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
+    //    MetricsDiscovery::TTypedValue_1_0 defaultMaximumOaBufferSize = {};
     void setupDefaultMocksForMetricDevice(Mock<IMetricsDevice_1_5> &metricDevice);
 };
 

level_zero/tools/test/unit_tests/sources/metrics/mock_metric_oa_enumeration.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -109,7 +109,29 @@ class Mock<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
     MOCK_METHOD(IOverride_1_2 *, GetOverrideByName, (const char *symbolName), (override));
     MOCK_METHOD(IConcurrentGroup_1_5 *, GetConcurrentGroup, (uint32_t index), (override));
     MOCK_METHOD(TGlobalSymbol_1_0 *, GetGlobalSymbol, (uint32_t index), (override));
-    MOCK_METHOD(TTypedValue_1_0 *, GetGlobalSymbolValueByName, (const char *name), (override));
+
+    MetricsDiscovery::TTypedValue_1_0 symbolValue = {};
+    bool forceGetSymbolByNameFail = false;
+    TTypedValue_1_0 *GetGlobalSymbolValueByName(const char *name) override {
+        bool found = false;
+        if (forceGetSymbolByNameFail) {
+            return nullptr;
+        } else if (std::strcmp(name, "OABufferMaxSize") == 0) {
+            symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT32;
+            symbolValue.ValueUInt32 = 1024;
+            found = true;
+        } else if (std::strcmp(name, "MaxTimestamp") == 0) {
+            symbolValue.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
+            symbolValue.ValueUInt64 = 171798691800UL; // PVC as refference
+            found = true;
+        }
+        if (found) {
+            return &symbolValue;
+        }
+
+        return nullptr;
+    }
+
     MOCK_METHOD(TCompletionCode, GetLastError, (), (override));
     MOCK_METHOD(TCompletionCode, GetGpuCpuTimestamps, (uint64_t * gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId), (override));
 };

level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_enumeration.cpp

@@ -11,7 +11,7 @@
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
 #include <level_zero/zet_api.h>
@@ -104,7 +104,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
 
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(metricGroupProperties.domain, 100u);
         EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
@@ -150,7 +150,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenDependenciesAvailableWhenMetricGrou
         zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data());
         ASSERT_NE(metricGroups[0], nullptr);
 
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties);
 
         uint32_t metricCount = 0;
@@ -188,7 +188,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -197,6 +197,37 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulThenDummyAct
         EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), device->toHandle(), 0, nullptr), ZE_RESULT_SUCCESS);
     }
 }
+
+TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyAndValidBitsThenConfirmAreTheSameAsDevice) {
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, testDevices[0]->getMetricDeviceContext().enableMetricApi());
+
+    for (auto device : testDevices) {
+
+        ze_device_properties_t deviceProps = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES_1_2, nullptr};
+        device->getProperties(&deviceProps);
+
+        uint32_t metricGroupCount = 0;
+        zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr);
+        EXPECT_EQ(metricGroupCount, 1u);
+
+        std::vector<zet_metric_group_handle_t> metricGroups;
+        metricGroups.resize(metricGroupCount);
+
+        ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
+        ASSERT_NE(metricGroups[0], nullptr);
+
+        zet_metric_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
+
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
+        EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
+        EXPECT_EQ(strcmp(metricGroupProperties.description, "EU stall sampling"), 0);
+        EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
+        EXPECT_EQ(metricTimestampProperties.timerResolution, deviceProps.timerResolution);
+        EXPECT_EQ(metricTimestampProperties.timestampValidBits, deviceProps.timestampValidBits);
+    }
+}
+
 using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture;
 
 TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned) {
@@ -207,7 +238,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
     for (auto device : testDevices) {
 
         auto expectedSetCount = 2u;
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -220,7 +251,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -258,7 +289,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
 
     for (auto device : testDevices) {
 
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if ((props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) == 0) {
@@ -269,7 +300,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
             metricGroups.resize(metricGroupCount);
             ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
             ASSERT_NE(metricGroups[0], nullptr);
-            zet_metric_group_properties_t metricGroupProperties;
+            zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
             EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
             EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -298,7 +329,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
     for (auto device : testDevices) {
 
         auto expectedSetCount = 2u;
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -310,7 +341,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
             metricGroups.resize(metricGroupCount);
             ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
             ASSERT_NE(metricGroups[0], nullptr);
-            zet_metric_group_properties_t metricGroupProperties;
+            zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
             EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
             EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -345,7 +376,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
     std::vector<zet_typed_value_t> metricValues(30);
 
     for (auto device : testDevices) {
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
             uint32_t metricGroupCount = 0;
@@ -354,7 +385,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
             metricGroups.resize(metricGroupCount);
             ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
             ASSERT_NE(metricGroups[0], nullptr);
-            zet_metric_group_properties_t metricGroupProperties;
+            zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
             EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
             EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -378,7 +409,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
     for (auto device : testDevices) {
 
         auto expectedSetCount = 2u;
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -391,7 +422,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -440,7 +471,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -470,7 +501,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -506,7 +537,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -535,7 +566,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, WhenCalculateMultipleMetricValuesEx
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -562,7 +593,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
     for (auto device : testDevices) {
 
         auto expectedSetCount = 2u;
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -575,7 +606,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -612,7 +643,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -646,7 +677,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -674,7 +705,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -707,7 +738,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithBad
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -732,7 +763,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCal
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -755,7 +786,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStream
     for (auto device : testDevices) {
 
         auto expectedSetCount = 2u;
-        ze_device_properties_t props{};
+        ze_device_properties_t props = {};
         device->getProperties(&props);
 
         if (props.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE) {
@@ -767,7 +798,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenDataOverflowOccurredWhenStream
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -811,7 +842,7 @@ TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWithCAL
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 
@@ -837,7 +868,7 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenQueryPoo
         metricGroups.resize(metricGroupCount);
         ASSERT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, metricGroups.data()), ZE_RESULT_SUCCESS);
         ASSERT_NE(metricGroups[0], nullptr);
-        zet_metric_group_properties_t metricGroupProperties;
+        zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
         EXPECT_EQ(zetMetricGroupGetProperties(metricGroups[0], &metricGroupProperties), ZE_RESULT_SUCCESS);
         EXPECT_EQ(strcmp(metricGroupProperties.name, "EuStallSampling"), 0);
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_ip_sampling_streamer.cpp

@@ -11,7 +11,7 @@
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
 #include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/metric_ip_sampling_fixture.h"
 #include "level_zero/tools/test/unit_tests/sources/metrics/mock_metric_ip_sampling.h"
 #include <level_zero/zet_api.h>

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_1.cpp

@@ -223,7 +223,7 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetGetMetricGroupProperties
 
     // One api: metric group handle.
     zet_metric_group_handle_t metricGroupHandle = {};
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     openMetricsAdapter();
 
@@ -393,6 +393,253 @@ TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenRet
     EXPECT_EQ(metricCount, 1u);
 }
 
+TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyAndValidBitsThenConfirmExpectedValuesAreReturned) {
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+    metricsConcurrentGroupParams.Description = "OA description";
+
+    // Metrics Discovery:: metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.MetricsCount = 0;
+    metricsSetParams.SymbolName = "Metric set name";
+    metricsSetParams.ShortName = "Metric set description";
+
+    // One api: metric group handle.
+    zet_metric_group_handle_t metricGroupHandle = {};
+    zet_metric_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
+
+    MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
+    defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
+    defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
+
+    openMetricsAdapter();
+
+    setupDefaultMocksForMetricDevice(metricsDevice);
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(1)
+        .WillOnce(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(1)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Metric group properties.
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupProperties.domain, 0u);
+    EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
+    EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
+    EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
+    EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
+
+    EXPECT_EQ(metricTimestampProperties.timerResolution, 25000000UL);
+    EXPECT_EQ(metricTimestampProperties.timestampValidBits, 32UL);
+}
+
+TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingPropertiesAndIncorrectStructPassedThenFailsWithInvalidArgument) {
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+    metricsConcurrentGroupParams.Description = "OA description";
+
+    // Metrics Discovery:: metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.MetricsCount = 0;
+    metricsSetParams.SymbolName = "Metric set name";
+    metricsSetParams.ShortName = "Metric set description";
+
+    // One api: metric group handle.
+    zet_metric_group_handle_t metricGroupHandle = {};
+    zet_metric_properties_t metricProperties = {ZET_STRUCTURE_TYPE_METRIC_PROPERTIES, nullptr};
+
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricProperties};
+
+    MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
+    defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
+    defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
+
+    openMetricsAdapter();
+
+    setupDefaultMocksForMetricDevice(metricsDevice);
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(1)
+        .WillOnce(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(1)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Metric group properties.
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_INVALID_ARGUMENT);
+}
+
+TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndInternalFailuresValuesReturnZero) {
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+    metricsConcurrentGroupParams.Description = "OA description";
+
+    // Metrics Discovery:: metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_5> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_4 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_OCL;
+    metricsSetParams.MetricsCount = 0;
+    metricsSetParams.SymbolName = "Metric set name";
+    metricsSetParams.ShortName = "Metric set description";
+
+    // One api: metric group handle.
+
+    zet_metric_group_handle_t metricGroupHandle = {};
+    zet_metric_global_timestamps_resolution_exp_t metricTimestampProperties = {ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES, nullptr};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, &metricTimestampProperties};
+
+    MetricsDiscovery::TTypedValue_1_0 defaultMaxTimestamp = {};
+    defaultMaxTimestamp.ValueType = MetricsDiscovery::TValueType::VALUE_TYPE_UINT64;
+    defaultMaxTimestamp.ValueUInt64 = UINT64_MAX;
+
+    openMetricsAdapter();
+
+    setupDefaultMocksForMetricDevice(metricsDevice);
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(1)
+        .WillOnce(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(1)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(device->toHandle(), &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Metric group properties.
+    mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
+    mockOAOsInterface->failGetResolutionOnCall = 1;
+
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(metricGroupProperties.domain, 0u);
+    EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
+    EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
+    EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
+    EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
+
+    EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
+    EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
+
+    mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
+    mockOAOsInterface->failGetResolutionOnCall = 0;
+
+    metricsDevice.forceGetSymbolByNameFail = true;
+
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_NOT_AVAILABLE);
+    EXPECT_EQ(metricGroupProperties.domain, 0u);
+    EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
+    EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
+    EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
+    EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
+
+    EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
+    EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
+
+    metricsDevice.forceGetSymbolByNameFail = false;
+
+    mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
+    mockOAOsInterface->getResolutionCallCount = 0;
+    mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimestampValidBits()
+
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(metricGroupProperties.domain, 0u);
+    EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED);
+    EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
+    EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
+    EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
+
+    EXPECT_EQ(metricTimestampProperties.timerResolution, 0UL);
+    EXPECT_EQ(metricTimestampProperties.timestampValidBits, 0UL);
+
+    mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_SUCCESS;
+    mockOAOsInterface->failGetResolutionOnCall = 0;
+}
+
 TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenReturnsCorrectMetric) {
 
     // Metrics Discovery device.
@@ -1060,10 +1307,10 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW
     EXPECT_NE(metricGroupHandles[0], nullptr);
     EXPECT_NE(metricGroupHandles[1], nullptr);
 
-    zet_metric_group_properties_t properties0;
+    zet_metric_group_properties_t properties0 = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[0], &properties0));
 
-    zet_metric_group_properties_t properties1;
+    zet_metric_group_properties_t properties1 = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     EXPECT_EQ(ZE_RESULT_SUCCESS, zetMetricGroupGetProperties(metricGroupHandles[1], &properties1));
 
     // Activate metric groups.
@@ -1246,6 +1493,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsWh
     // One api: metric group.
     zet_metric_group_handle_t metricGroupHandle[2] = {};
     zet_metric_group_properties_t metricGroupProperties[2] = {};
+    metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     openMetricsAdapter();
 
@@ -1315,6 +1564,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithDifferentDomainsAt
     // One api: metric group.
     zet_metric_group_handle_t metricGroupHandle[2] = {};
     zet_metric_group_properties_t metricGroupProperties[2] = {};
+    metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     openMetricsAdapter();
 
@@ -1382,6 +1633,8 @@ TEST_F(MetricEnumerationTest, givenActivateTwoMetricGroupsWithTheSameDomainsWhen
     // One api: metric group.
     zet_metric_group_handle_t metricGroupHandle[2] = {};
     zet_metric_group_properties_t metricGroupProperties[2] = {};
+    metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     openMetricsAdapter();
 
@@ -1502,6 +1755,8 @@ TEST_F(MetricEnumerationTest, GivenAlreadyActivatedMetricGroupWhenzetContextActi
     // One api: metric group.
     zet_metric_group_handle_t metricGroupHandle[2] = {};
     zet_metric_group_properties_t metricGroupProperties[2] = {};
+    metricGroupProperties[0] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+    metricGroupProperties[1] = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     openMetricsAdapter();
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_enumeration_2.cpp

@@ -256,8 +256,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenSubDeviceWhenOpenMetricsDiscoveryI
         .Times(1)
         .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
 
-    EXPECT_CALL(mockDevice, GetGlobalSymbolValueByName(_))
+    mockDevice.forceGetSymbolByNameFail = true;
-        .WillRepeatedly(testing::Return(nullptr));
 
     EXPECT_EQ(mockMetricEnumerationSubDevices[1]->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
     EXPECT_EQ(mockMetricEnumerationSubDevices[1]->getMaxOaBufferSize(), 0u);

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_1.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -26,7 +26,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateIsC
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -87,7 +87,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectMetricGroupTypeWhenZetMetricQueryPoolC
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -139,7 +139,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectParameterWhenZetMetricQueryPoolCreateI
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -199,7 +199,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextWhenZetMetricQueryPoolCreateIsC
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -236,7 +236,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectContextDataWhenZetMetricQueryPoolCreat
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -269,7 +269,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectGpuReportSizeWhenZetMetricQueryPoolCre
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};
@@ -329,7 +329,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryCreateIsCalle
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -400,7 +400,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectSlotIndexWhenZetMetricQueryCreateIsCal
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -469,7 +469,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryResetIsCalled
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -543,7 +543,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -620,7 +620,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
     zet_command_list_handle_t commandListHandle = commandList->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -786,7 +786,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetCommandListAppendMetri
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -898,7 +898,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAppendMetricQ
 
     Mock<MetricGroup> metricGroup;
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -1014,7 +1014,7 @@ TEST_F(MetricQueryPoolTest, givenIncorrectArgumentsWhenZetMetricQueryGetDataIsCa
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -1130,7 +1130,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -1274,7 +1274,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryGetDataIsCall
     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_DEVICE;
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     uint32_t queriesCount = 10;

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_2.cpp

@@ -37,7 +37,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenStreamerIsOpenThenQueryPool
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -636,7 +636,7 @@ TEST_F(MetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGroupsIsCalle
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     TypedValue_1_0 value = {};

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_3.cpp

@@ -28,7 +28,7 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricQueryPoolDestroyIs
     zet_device_handle_t metricDevice = device->toHandle();
 
     Mock<MetricGroup> metricGroup;
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle[2] = {};
@@ -136,7 +136,7 @@ TEST_F(MetricQueryPoolTest, givenMetricQueryIsActiveWhenMetricGroupDeactivateIsC
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -334,7 +334,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetMetricQueryPo
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -468,7 +468,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenImplicitScalingIsEnabledWhenMetricsA
     metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
     metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
     TypedValue_1_0 value = {};
     value.Type = ValueType::Uint32;
@@ -571,7 +571,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenEnableWalkerPartitionIsOnWhenZetComm
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -753,7 +753,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedMetricsLibraryContextWhenZetMe
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_pool_handle_t poolHandle = {};

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_4.cpp

@@ -52,7 +52,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenFailedGetDataWhenZetMetricQueryGetDa
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -215,7 +215,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenZetCommandListAp
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     ze_event_pool_handle_t eventPoolHandle = {};
@@ -401,7 +401,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetSizeWhenZetCo
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -549,7 +549,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenInvalidCommandBufferGetWhenZetComman
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_query_pool_5.cpp

@@ -65,7 +65,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenValidArgumentsWhenZetMetricGroupCalc
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};
@@ -239,7 +239,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenCorrectArgumentsWhenActivateMetricGr
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     TypedValue_1_0 value = {};
@@ -375,7 +375,7 @@ TEST_F(MultiDeviceMetricQueryPoolTest, givenMetricQueryPoolIsDestroyedWhenMetric
 
     zet_metric_group_handle_t metricGroupHandle = {};
 
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     zet_metric_query_handle_t queryHandle = {};

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp

@@ -39,7 +39,7 @@ TEST_F(MetricStreamerTest, givenInvalidMetricGroupTypeWhenZetMetricStreamerOpenI
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
@@ -67,7 +67,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -167,7 +167,7 @@ TEST_F(MetricStreamerTest, givenRawReportSizeAsZeroWhenZetMetricStreamerOpenIsCa
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -334,7 +334,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerOpenIsCalledT
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -436,7 +436,7 @@ TEST_F(MetricStreamerTest, givenCorrectArgumentsWhenZetMetricQueryPoolCreateExtI
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricGroupProperties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED;
 
     // One api: query pool handle.
@@ -519,7 +519,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetMetricStreamerReadDataIsC
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -616,7 +616,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -721,7 +721,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
     streamerDesc.samplingPeriod = 1000;
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
     metricsDeviceParams.ConcurrentGroupsCount = 1;
     Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
     TConcurrentGroupParams_1_0 metricsConcurrentGroupParams = {};
@@ -822,7 +822,7 @@ TEST_F(MetricStreamerTest, givenInvalidArgumentsWhenZetCommandListAppendMetricSt
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -933,7 +933,7 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetCommandListAppendMetricStre
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
@@ -1073,7 +1073,7 @@ TEST_F(MetricStreamerTest, givenMultipleMarkerInsertionsWhenZetCommandListAppend
     // One api: metric group handle.
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_2.cpp

@@ -37,7 +37,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenInvalidMetricGroupTypeWhenZetMetricSt
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -114,7 +114,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsWhenZetMetricStreamerOp
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
     Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
@@ -202,7 +202,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetMetri
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
     Mock<IConcurrentGroup_1_5> metricsConcurrentGroup;
@@ -379,7 +379,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenValidArgumentsAndCloseIoStreamFailsWh
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -774,7 +774,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenMultipleMarkerInsertionsWhenZetComman
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 

level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_3.cpp

@@ -41,7 +41,7 @@ TEST_F(MetricStreamerMultiDeviceTest, givenEnableWalkerPartitionIsOnWhenZetComma
 
     Mock<MetricGroup> metricGroup;
     zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
-    zet_metric_group_properties_t metricGroupProperties = {};
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
 
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 

level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_ip_sampling_windows.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,7 +8,7 @@
 #include "shared/test/common/test_macros/hw_test.h"
 
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include "level_zero/tools/source/metrics/os_interface_metric.h"
 
 using ::testing::_;
 using ::testing::Return;
@@ -31,7 +31,7 @@ class MetricIpSamplingWindowsTest : public DeviceFixture,
 };
 
 TEST_F(MetricIpSamplingWindowsTest, WhenIpSamplingOsInterfaceIsUsedReturnUnsupported) {
-
+    uint64_t timerResolution;
     EXPECT_FALSE(metricIpSamplingOsInterface->isDependencyAvailable());
     EXPECT_FALSE(metricIpSamplingOsInterface->isNReportsAvailable());
     EXPECT_EQ(metricIpSamplingOsInterface->getRequiredBufferSize(0), 0);
@@ -40,6 +40,7 @@ TEST_F(MetricIpSamplingWindowsTest, WhenIpSamplingOsInterfaceIsUsedReturnUnsuppo
     uint32_t dummy;
     EXPECT_EQ(metricIpSamplingOsInterface->startMeasurement(dummy, dummy), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
     EXPECT_EQ(metricIpSamplingOsInterface->stopMeasurement(), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
+    EXPECT_EQ(metricIpSamplingOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
 }
 
 } // namespace ult

level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_oa_enumeration_windows.cpp

@@ -42,6 +42,8 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
 
     setupDefaultMocksForMetricDevice(metricsDevice);
 
+    std::unique_ptr<MetricOAOsInterface> OAOsInterface = MetricOAOsInterface::create(*device);
+
     EXPECT_CALL(adapterGroup, GetParams())
         .Times(1)
         .WillOnce(Return(&adapterGroupParams));
@@ -61,6 +63,9 @@ TEST_F(MetricEnumerationTestWindows, givenCorrectWindowsAdapterWhenGetMetricsAda
         .WillOnce([&]() { return mockMetricEnumeration->baseGetMetricsAdapter(); });
 
     EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_SUCCESS);
+
+    uint64_t timerResolution;
+    EXPECT_EQ(OAOsInterface->getMetricsTimerResolution(timerResolution), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
 }
 } // namespace ult
 } // namespace L0

shared/source/os_interface/linux/drm_neo.cpp

@@ -817,6 +817,11 @@ int Drm::getTimestampFrequency(int &frequency) {
     return getParamIoctl(DrmParam::ParamCsTimestampFrequency, &frequency);
 }
 
+int Drm::getOATimestampFrequency(int &frequency) {
+    frequency = 0;
+    return getParamIoctl(DrmParam::ParamOATimestampFrequency, &frequency);
+}
+
 bool Drm::queryEngineInfo() {
     return Drm::queryEngineInfo(false);
 }

shared/source/os_interface/linux/drm_neo.h

@@ -97,6 +97,7 @@ class Drm : public DriverModel {
     int getEnabledPooledEu(int &enabled);
     int getMinEuInPool(int &minEUinPool);
     int getTimestampFrequency(int &frequency);
+    int getOATimestampFrequency(int &frequency);
 
     MOCKABLE_VIRTUAL int queryGttSize(uint64_t &gttSizeOutput);
     bool isPreemptionSupported() const { return preemptionSupported; }

shared/source/os_interface/linux/drm_wrappers.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -291,6 +291,7 @@ enum class DrmParam {
     ParamSubsliceTotal,
     ParamMinEuInPool,
     ParamCsTimestampFrequency,
+    ParamOATimestampFrequency,
     ParamHasVmBind,
     ParamHasPageFault,
     QueryEngineInfo,

shared/source/os_interface/linux/ioctl_helper.cpp

@@ -289,6 +289,8 @@ int IoctlHelper::getDrmParamValueBase(DrmParam drmParam) const {
         return I915_TILING_NONE;
     case DrmParam::TilingY:
         return I915_TILING_Y;
+    case DrmParam::ParamOATimestampFrequency:
+        return I915_PARAM_OA_TIMESTAMP_FREQUENCY;
     default:
         UNRECOVERABLE_IF(true);
         return 0;
@@ -315,6 +317,8 @@ std::string IoctlHelper::getDrmParamStringBase(DrmParam drmParam) const {
         return "I915_PARAM_MIN_EU_IN_POOL";
     case DrmParam::ParamCsTimestampFrequency:
         return "I915_PARAM_CS_TIMESTAMP_FREQUENCY";
+    case DrmParam::ParamOATimestampFrequency:
+        return "I915_PARAM_OA_TIMESTAMP_FREQUENCY";
     default:
         UNRECOVERABLE_IF(true);
         return "";

shared/test/common/libult/linux/drm_mock.cpp

@@ -101,6 +101,10 @@ int DrmMock::ioctl(DrmIoctl request, void *arg) {
             *gp->value = this->storedCsTimestampFrequency;
             return this->storedRetVal;
         }
+        if (gp->param == I915_PARAM_OA_TIMESTAMP_FREQUENCY) {
+            *gp->value = this->storedOaTimestampFrequency;
+            return this->storedRetVal;
+        }
     }
 
     if ((request == DrmIoctl::GemContextCreateExt) && (arg != nullptr)) {

shared/test/common/libult/linux/drm_mock.h

@@ -200,6 +200,7 @@ class DrmMock : public Drm {
     int storedExecSoftPin = 0;
     int storedRetValForVmId = 1;
     int storedCsTimestampFrequency = 1000;
+    int storedOaTimestampFrequency = 123456;
     bool disableSomeTopology = false;
     bool allowDebugAttach = false;
     bool allowDebugAttachCallBase = false;

shared/test/unit_test/os_interface/linux/drm_tests.cpp

@@ -905,6 +905,28 @@ TEST(DrmTest, givenPrintIoctlDebugFlagNotSetWhenGettingTimestampFrequencyThenCap
     EXPECT_EQ(std::string::npos, outputString.find(expectedString));
 }
 
+TEST(DrmTest, givenPrintIoctlDebugFlagSetWhenGettingOATimestampFrequencyThenCaptureExpectedOutput) {
+    DebugManagerStateRestore restore;
+    DebugManager.flags.PrintIoctlEntries.set(true);
+
+    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
+    DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
+
+    int frequency = 0;
+
+    testing::internal::CaptureStdout(); // start capturing
+
+    int ret = drm.getOATimestampFrequency(frequency);
+    DebugManager.flags.PrintIoctlEntries.set(false);
+    std::string outputString = testing::internal::GetCapturedStdout(); // stop capturing
+
+    EXPECT_EQ(0, ret);
+    EXPECT_EQ(123456, frequency);
+
+    std::string expectedString = "DRM_IOCTL_I915_GETPARAM: param: I915_PARAM_OA_TIMESTAMP_FREQUENCY, output value: 123456, retCode: 0";
+    EXPECT_NE(std::string::npos, outputString.find(expectedString));
+}
+
 TEST(DrmTest, givenProgramDebuggingWhenCreatingContextThenUnrecoverableContextIsSet) {
     auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
     executionEnvironment->setDebuggingMode(NEO::DebuggingMode::Online);