feature: Implement zetMetricGroupGetGlobalTimestampsExp()

Resolves: LOCI-3072

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

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

@@ -104,7 +104,7 @@ ze_result_t MetricOALinuxImp::getMetricsTimerResolution(uint64_t &timerResolutio
 
     const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
     int32_t timestampFrequency;
-    int32_t ret = drm->getOATimestampFrequency(timestampFrequency);
+    int32_t ret = drm->getOaTimestampFrequency(timestampFrequency);
     if (ret < 0 || timestampFrequency == 0) {
         timerResolution = 0;
         result = ZE_RESULT_ERROR_UNKNOWN;

level_zero/tools/source/metrics/metric.h

@@ -41,8 +41,6 @@ class MetricSource {
     virtual ze_result_t getTimerResolution(uint64_t &resolution) = 0;
     virtual ze_result_t getTimestampValidBits(uint64_t &validBits) = 0;
     virtual ~MetricSource() = default;
-
-  private:
 };
 
 class MetricDeviceContext {
@@ -98,6 +96,10 @@ struct MetricGroup : _zet_metric_group_handle_t {
                                                  const uint8_t *pRawData, uint32_t *pSetCount,
                                                  uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
                                                  zet_typed_value_t *pMetricValues) = 0;
+    virtual ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                               uint64_t *globalTimestamp,
+                                               uint64_t *metricTimestamp) = 0;
+
     static MetricGroup *fromHandle(zet_metric_group_handle_t handle) {
         return static_cast<MetricGroup *>(handle);
     }

level_zero/tools/source/metrics/metric_ip_sampling_source.cpp

@@ -29,7 +29,7 @@ std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(con
 }
 
 IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
-    metricIPSamplingOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
+    metricIPSamplingpOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
 }
 
 ze_result_t IpSamplingMetricSourceImp::getTimerResolution(uint64_t &resolution) {
@@ -43,7 +43,7 @@ ze_result_t IpSamplingMetricSourceImp::getTimestampValidBits(uint64_t &validBits
 }
 
 void IpSamplingMetricSourceImp::enable() {
-    isEnabled = metricIPSamplingOsInterface->isDependencyAvailable();
+    isEnabled = metricIPSamplingpOsInterface->isDependencyAvailable();
 }
 
 bool IpSamplingMetricSourceImp::isAvailable() {
@@ -144,8 +144,8 @@ ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &co
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingOsInterface) {
-    this->metricIPSamplingOsInterface = std::move(metricIPSamplingOsInterface);
+void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface) {
+    this->metricIPSamplingpOsInterface = std::move(metricIPSamplingpOsInterface);
 }
 
 IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(IpSamplingMetricSourceImp &metricSource,
@@ -256,6 +256,37 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_
     return result;
 }
 
+ze_result_t getDeviceTimestamps(DeviceImp *deviceImp, const ze_bool_t synchronizedWithHost,
+                                uint64_t *globalTimestamp, uint64_t *metricTimestamp) {
+
+    ze_result_t result;
+    uint64_t hostTimestamp;
+    uint64_t deviceTimestamp;
+
+    result = deviceImp->getGlobalTimestamps(&hostTimestamp, &deviceTimestamp);
+    if (result != ZE_RESULT_SUCCESS) {
+        *globalTimestamp = 0;
+        *metricTimestamp = 0;
+    } else {
+        if (synchronizedWithHost) {
+            *globalTimestamp = hostTimestamp;
+        } else {
+            *globalTimestamp = deviceTimestamp;
+        }
+        *metricTimestamp = deviceTimestamp;
+        result = ZE_RESULT_SUCCESS;
+    }
+
+    return result;
+}
+
+ze_result_t IpSamplingMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                                             uint64_t *globalTimestamp,
+                                                             uint64_t *metricTimestamp) {
+    DeviceImp *deviceImp = static_cast<DeviceImp *>(&getMetricSource().getMetricDeviceContext().getDevice());
+    return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp);
+}
+
 ze_result_t IpSamplingMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
                                                                uint32_t &metricValueCount) {
 
@@ -559,6 +590,13 @@ void MultiDeviceIpSamplingMetricGroupImp::closeSubDeviceStreamers(std::vector<Ip
     }
 }
 
+ze_result_t MultiDeviceIpSamplingMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                                                        uint64_t *globalTimestamp,
+                                                                        uint64_t *metricTimestamp) {
+    DeviceImp *deviceImp = static_cast<DeviceImp *>(&subDeviceMetricGroup[0]->getMetricSource().getMetricDeviceContext().getDevice());
+    return getDeviceTimestamps(deviceImp, synchronizedWithHost, globalTimestamp, metricTimestamp);
+}
+
 std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetricGroupImp::create(
     std::vector<IpSamplingMetricGroupImp *> &subDeviceMetricGroup) {
     UNRECOVERABLE_IF(subDeviceMetricGroup.size() == 0);

level_zero/tools/source/metrics/metric_ip_sampling_source.h

@@ -25,9 +25,9 @@ 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> &metricIPSamplingOsInterface);
+    void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface);
     static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
-    MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingOsInterface.get(); }
+    MetricIpSamplingOsInterface *getMetricOsInterface() { return metricIPSamplingpOsInterface.get(); }
     IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
     const MetricDeviceContext &getMetricDeviceContext() const { return metricDeviceContext; }
     ze_result_t getTimerResolution(uint64_t &resolution) override;
@@ -38,7 +38,7 @@ class IpSamplingMetricSourceImp : public MetricSource {
     bool isEnabled = false;
 
     const MetricDeviceContext &metricDeviceContext;
-    std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingOsInterface = nullptr;
+    std::unique_ptr<MetricIpSamplingOsInterface> metricIPSamplingpOsInterface = nullptr;
     std::unique_ptr<MetricGroup> cachedMetricGroup = nullptr;
 };
 
@@ -80,6 +80,9 @@ struct IpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
                                          const uint8_t *pRawData, uint32_t *pSetCount,
                                          uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
                                          zet_typed_value_t *pMetricValues) override;
+    ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                       uint64_t *globalTimestamp,
+                                       uint64_t *metricTimestamp) override;
     zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
     ze_result_t streamerOpen(
         zet_context_handle_t hContext,
@@ -121,6 +124,9 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
                                          const uint8_t *pRawData, uint32_t *pSetCount,
                                          uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
                                          zet_typed_value_t *pMetricValues) override;
+    ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                       uint64_t *globalTimestamp,
+                                       uint64_t *metricTimestamp) override;
     zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
     ze_result_t streamerOpen(
         zet_context_handle_t hContext,

level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp

@@ -183,6 +183,14 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
 
             subDeviceMetricEnumeraion.readGlobalSymbol(globalSymbolOaMaxBufferSize.data(), maximumOaBufferSize);
         }
+
+        pAdapter->OpenMetricsDevice(&pMetricsDevice);
+        if (pMetricsDevice == nullptr) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", 0);
+            cleanupMetricsDiscovery();
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+
     } else {
         auto &deviceImp = *static_cast<DeviceImp *>(&metricSource.getDevice());
         const uint32_t subDeviceIndex = deviceImp.getPhysicalSubDeviceId();
@@ -216,7 +224,9 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
             for (size_t i = 0; i < deviceImp.numSubDevices; i++) {
                 deviceImp.subDevices[i]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().cleanupMetricsDiscovery();
             }
-        } else if (pMetricsDevice) {
+        }
+
+        if (pMetricsDevice) {
 
             // Close metrics device for one sub device or root device.
             pAdapter->CloseMetricsDevice(pMetricsDevice);
@@ -263,6 +273,7 @@ ze_result_t MetricEnumeration::cacheMetricInformation() {
         // Cache and aggregate all metric groups from all sub devices.
         for (uint32_t i = 0; i < metricGroupCount; i++) {
             auto metricGroupRootDevice = new OaMetricGroupImp();
+            metricGroupRootDevice->setMetricSource(&metricSource);
 
             for (auto subDevice : deviceImp.subDevices) {
                 MetricGroup *metricGroupSubDevice = subDevice->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>().getMetricEnumeration().getMetricGroupByIndex(i);
@@ -826,6 +837,46 @@ ze_result_t OaMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_ca
     return result;
 }
 
+ze_result_t OaMetricGroupImp::getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                                     uint64_t *globalTimestamp,
+                                                     uint64_t *metricTimestamp) {
+    ze_result_t result;
+    OaMetricSourceImp *metricSource = getMetricSource();
+    const auto deviceImp = static_cast<DeviceImp *>(&metricSource->getMetricDeviceContext().getDevice());
+
+    uint64_t hostTimestamp;
+    uint64_t deviceTimestamp;
+
+    result = deviceImp->getGlobalTimestamps(&hostTimestamp, &deviceTimestamp);
+    if (result != ZE_RESULT_SUCCESS) {
+        *globalTimestamp = 0;
+        *metricTimestamp = 0;
+    } else {
+        if (synchronizedWithHost) {
+            *globalTimestamp = hostTimestamp;
+        } else {
+            *globalTimestamp = deviceTimestamp;
+        }
+
+        uint32_t cpuId;
+        MetricsDiscovery::ECompletionCode mdapiRetVal;
+        MetricsDiscovery::IMetricsDevice_1_5 *metricDevice;
+        metricDevice = getMetricSource()->getMetricEnumeration().getMetricDevice();
+
+        // MDAPI returns GPU timestamps in nanoseconds
+        mdapiRetVal = metricDevice->GetGpuCpuTimestamps(metricTimestamp, &hostTimestamp, &cpuId);
+        if (mdapiRetVal != MetricsDiscovery::CC_OK) {
+            *globalTimestamp = 0;
+            *metricTimestamp = 0;
+            result = ZE_RESULT_ERROR_NOT_AVAILABLE;
+        } else {
+            result = ZE_RESULT_SUCCESS;
+        }
+    }
+
+    return result;
+}
+
 ze_result_t OaMetricGroupImp::getCalculatedMetricCount(const size_t rawDataSize,
                                                        uint32_t &metricValueCount) {
     metricValueCount = 0;

level_zero/tools/source/metrics/metric_oa_enumeration_imp.h

@@ -35,6 +35,7 @@ struct MetricEnumeration {
     uint32_t getMaxOaBufferSize() const { return maximumOaBufferSize; }
     bool readGlobalSymbol(const char *name, uint32_t &symbolValue);
     bool readGlobalSymbol(const char *name, uint64_t &symbolValue);
+    MetricsDiscovery::IMetricsDevice_1_5 *getMetricDevice() { return pMetricsDevice; };
 
   protected:
     ze_result_t initialize();
@@ -92,6 +93,9 @@ struct OaMetricGroupImp : MetricGroup {
                                          const uint8_t *pRawData, uint32_t *pSetCount,
                                          uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
                                          zet_typed_value_t *pMetricValues) override;
+    ze_result_t getMetricTimestampsExp(const ze_bool_t synchronizedWithHost,
+                                       uint64_t *globalTimestamp,
+                                       uint64_t *metricTimestamp) override;
     ze_result_t initialize(const zet_metric_group_properties_t &sourceProperties,
                            MetricsDiscovery::IMetricSet_1_5 &metricSet,
                            MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
@@ -131,6 +135,8 @@ struct OaMetricGroupImp : MetricGroup {
                                MetricsDiscovery::IConcurrentGroup_1_5 &concurrentGroup,
                                const std::vector<Metric *> &metrics,
                                MetricSource &metricSource);
+    OaMetricSourceImp *getMetricSource() { return metricSource; }
+    void setMetricSource(OaMetricSourceImp *inputMetricSource) { metricSource = inputMetricSource; }
     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;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -55,5 +55,24 @@ void MetricIpSamplingFixture::TearDown() {
     MultiDeviceFixture::tearDown();
 }
 
+void MetricIpSamplingTimestampFixture::SetUp() {
+    DeviceFixture::setUp();
+    auto mockMetricIpSamplingOsInterface = new MockMetricIpSamplingOsInterface();
+    osInterfaceVector.push_back(mockMetricIpSamplingOsInterface);
+    std::unique_ptr<MetricIpSamplingOsInterface> metricIpSamplingOsInterface = std::unique_ptr<MetricIpSamplingOsInterface>(mockMetricIpSamplingOsInterface);
+
+    auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
+    metricSource.setMetricOsInterface(metricIpSamplingOsInterface);
+
+    auto &metricOaSource = device->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    metricOaSource.setInitializationState(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
+
+    GlobalDriverHandle = static_cast<_ze_driver_handle_t *>(driverHandle.get());
+}
+
+void MetricIpSamplingTimestampFixture::TearDown() {
+    DeviceFixture::tearDown();
+}
+
 } // namespace ult
 } // namespace L0

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

@@ -64,6 +64,16 @@ class MetricIpSamplingFixture : public MultiDeviceFixture,
     std::vector<L0::Device *> testDevices = {};
 };
 
+class MetricIpSamplingTimestampFixture : public DeviceFixture,
+                                         public ::testing::Test {
+  public:
+    void SetUp();
+    void TearDown();
+
+    DebugManagerStateRestore restorer;
+    std::vector<MockMetricIpSamplingOsInterface *> osInterfaceVector = {};
+};
+
 class MetricIpSamplingCalculateMetricsFixture : public MetricIpSamplingFixture {
   public:
     void addHeader(uint8_t *rawDataOut, size_t rawDataOutSize, uint8_t *rawDataIn, size_t rawDataInSize, uint32_t setIndex) {

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

@@ -218,8 +218,12 @@ void MetricMultiDeviceFixture::openMetricsAdapter() {
         .Times(2)
         .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK)));
 
+    EXPECT_CALL(adapter, OpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+
     EXPECT_CALL(adapter, CloseMetricsDevice(_))
-        .Times(2)
+        .Times(3)
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
 
     EXPECT_CALL(adapterGroup, GetAdapter(_))

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

@@ -112,6 +112,7 @@ class Mock<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
 
     MetricsDiscovery::TTypedValue_1_0 symbolValue = {};
     bool forceGetSymbolByNameFail = false;
+    bool forceGetGpuCpuTimestampsFail = false;
     TTypedValue_1_0 *GetGlobalSymbolValueByName(const char *name) override {
         bool found = false;
         if (forceGetSymbolByNameFail) {
@@ -133,7 +134,20 @@ class Mock<IMetricsDevice_1_5> : public IMetricsDevice_1_5 {
     }
 
     MOCK_METHOD(TCompletionCode, GetLastError, (), (override));
-    MOCK_METHOD(TCompletionCode, GetGpuCpuTimestamps, (uint64_t * gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId), (override));
+
+    TCompletionCode GetGpuCpuTimestamps(uint64_t *gpuTimestampNs, uint64_t *cpuTimestampNs, uint32_t *cpuId) override {
+        if (forceGetGpuCpuTimestampsFail) {
+            *gpuTimestampNs = 0;
+            *cpuTimestampNs = 0;
+            *cpuId = 0;
+            return MetricsDiscovery::CC_ERROR_GENERAL;
+        }
+
+        *gpuTimestampNs += 10;
+        *cpuTimestampNs += 10;
+        *cpuId = 0;
+        return MetricsDiscovery::CC_OK;
+    }
 };
 
 template <>

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

@@ -228,6 +228,104 @@ TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingM
     }
 }
 
+TEST_F(MetricIpSamplingEnumerationTest, GivenEnumerationIsSuccessfulOnMulitDeviceWhenReadingMetricsTimestampThenResultIsSuccess) {
+
+    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);
+        ze_bool_t synchronizedWithHost = true;
+        uint64_t globalTimestamp = 0;
+        uint64_t metricTimestamp = 0;
+
+        EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    }
+}
+
+using MetricIpSamplingTimestampTest = MetricIpSamplingTimestampFixture;
+
+TEST_F(MetricIpSamplingTimestampTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated) {
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
+
+    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);
+
+    ze_bool_t synchronizedWithHost = true;
+    uint64_t globalTimestamp = 0;
+    uint64_t metricTimestamp = 0;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    EXPECT_NE(globalTimestamp, 0UL);
+    EXPECT_NE(metricTimestamp, 0UL);
+
+    synchronizedWithHost = false;
+    globalTimestamp = 0;
+    metricTimestamp = 0;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    EXPECT_NE(globalTimestamp, 0UL);
+    EXPECT_NE(metricTimestamp, 0UL);
+
+    DebugManager.flags.EnableImplicitScaling.set(1);
+    globalTimestamp = 0;
+    metricTimestamp = 0;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    EXPECT_NE(globalTimestamp, 0UL);
+    EXPECT_NE(metricTimestamp, 0UL);
+}
+
+TEST_F(MetricIpSamplingTimestampTest, GivenGetCpuGpuTimeIsFalseWhenReadingMetricsFrequencyThenValuesAreZero) {
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->getMetricDeviceContext().enableMetricApi());
+
+    neoDevice->setOSTime(new FalseCpuGpuTime());
+
+    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);
+
+    ze_bool_t synchronizedWithHost = true;
+    uint64_t globalTimestamp = 1;
+    uint64_t metricTimestamp = 1;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroups[0], synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_DEVICE_LOST);
+    EXPECT_EQ(globalTimestamp, 0UL);
+    EXPECT_EQ(metricTimestamp, 0UL);
+}
+
 using MetricIpSamplingCalculateMetricsTest = MetricIpSamplingCalculateMetricsFixture;
 
 TEST_F(MetricIpSamplingCalculateMetricsTest, GivenEnumerationIsSuccessfulWhenCalculateMultipleMetricValuesExpIsCalledThenValidDataIsReturned) {

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

@@ -624,7 +624,7 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern
 
     mockOAOsInterface->getMetricsTimerResolutionReturn = ZE_RESULT_ERROR_UNKNOWN;
     mockOAOsInterface->getResolutionCallCount = 0;
-    mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimestampValidBits()
+    mockOAOsInterface->failGetResolutionOnCall = 2; // getTimestampValidBits() also calls getTimerResolution()
 
     EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_ERROR_UNKNOWN);
     EXPECT_EQ(metricGroupProperties.domain, 0u);
@@ -640,6 +640,157 @@ TEST_F(MetricEnumerationTest, GivenValidMetricGroupWhenReadingFrequencyAndIntern
     mockOAOsInterface->failGetResolutionOnCall = 0;
 }
 
+TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenReadingMetricsFrequencyThenValuesAreUpdated) {
+
+    // 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 = {};
+
+    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);
+
+    ze_bool_t synchronizedWithHost = true;
+    uint64_t globalTimestamp = 0;
+    uint64_t metricTimestamp = 0;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    EXPECT_NE(globalTimestamp, 0UL);
+    EXPECT_NE(metricTimestamp, 0UL);
+
+    synchronizedWithHost = false;
+    globalTimestamp = 0;
+    metricTimestamp = 0;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_SUCCESS);
+    EXPECT_NE(globalTimestamp, 0UL);
+    EXPECT_NE(metricTimestamp, 0UL);
+}
+
+TEST_F(MetricEnumerationTest, GivenEnumerationIsSuccessfulWhenFailingToReadMetricsOrDeviceTimestampsThenValuesAreZero) {
+
+    // 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 = {};
+
+    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);
+
+    ze_bool_t synchronizedWithHost = true;
+    uint64_t globalTimestamp = 1;
+    uint64_t metricTimestamp = 1;
+    metricsDevice.forceGetGpuCpuTimestampsFail = true;
+
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_NOT_AVAILABLE);
+    EXPECT_EQ(globalTimestamp, 0UL);
+    EXPECT_EQ(metricTimestamp, 0UL);
+    metricsDevice.forceGetGpuCpuTimestampsFail = false;
+
+    globalTimestamp = 1;
+    metricTimestamp = 1;
+    neoDevice->setOSTime(new FalseCpuGpuTime());
+    EXPECT_EQ(L0::zetMetricGroupGetGlobalTimestampsExp(metricGroupHandle, synchronizedWithHost, &globalTimestamp, &metricTimestamp), ZE_RESULT_ERROR_DEVICE_LOST);
+    EXPECT_EQ(globalTimestamp, 0UL);
+    EXPECT_EQ(metricTimestamp, 0UL);
+}
+
 TEST_F(MetricEnumerationTest, givenValidArgumentsWhenZetMetricGetIsCalledThenReturnsCorrectMetric) {
 
     // Metrics Discovery device.

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

@@ -170,8 +170,12 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
         .Times(subDeviceCount)
         .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
 
+    EXPECT_CALL(mockAdapter, OpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&mockDevice), Return(TCompletionCode::CC_OK)));
+
     EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
-        .Times(subDeviceCount)
+        .Times(subDeviceCount + 1)
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
 
     setupDefaultMocksForMetricDevice(mockDevice);
@@ -310,6 +314,58 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
     EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
 }
 
+TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesAndOpenAdapterOnRootDeviceFailsThenCLeanUpIsDone) {
+
+    // Use first root device.
+    auto &metricSource = devices[0]->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+    Mock<IAdapterGroup_1_9> mockAdapterGroup;
+    Mock<IAdapter_1_9> mockAdapter;
+    Mock<IMetricsDevice_1_5> mockDevice;
+
+    EXPECT_CALL(*mockMetricsLibrary, load())
+        .Times(1)
+        .WillOnce(Return(true));
+
+    EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
+        .Times(1)
+        .WillOnce(Return(ZE_RESULT_SUCCESS));
+
+    EXPECT_CALL(*Mock<MetricEnumeration>::g_mockApi, MockOpenAdapterGroup(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(&mockAdapterGroup), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(*mockMetricEnumeration, getMetricsAdapter())
+        .Times(1)
+        .WillOnce(Return(&mockAdapter));
+
+    EXPECT_CALL(mockAdapter, OpenMetricsSubDevice(_, _))
+        .Times(subDeviceCount)
+        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&mockDevice), Return(TCompletionCode::CC_OK)));
+
+    EXPECT_CALL(mockAdapter, OpenMetricsDevice(_))
+        .Times(1)
+        .WillOnce(DoAll(::testing::SetArgPointee<0>(nullptr), Return(TCompletionCode::CC_ERROR_GENERAL)));
+
+    EXPECT_CALL(mockAdapter, CloseMetricsDevice(_))
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    setupDefaultMocksForMetricDevice(mockDevice);
+
+    EXPECT_CALL(mockAdapterGroup, Close())
+        .Times(1)
+        .WillOnce(Return(TCompletionCode::CC_OK));
+
+    // Use root device.
+    devices[0]->getMetricDeviceContext().setSubDeviceIndex(0);
+    mockMetricsLibrary->initializationState = ZE_RESULT_SUCCESS;
+
+    EXPECT_EQ(metricSource.loadDependencies(), true);
+    EXPECT_EQ(mockMetricEnumeration->openMetricsDiscovery(), ZE_RESULT_ERROR_NOT_AVAILABLE);
+}
+
 TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) {
 
     metricsDeviceParams.Version.MajorNumber = 0;