Metric Api: Metric enumeration for all sub devices.

Signed-off-by: Robert Krzemien <robert.krzemien@intel.com>
Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>

Related-To: LOCI-2422

level_zero/tools/source/metrics/metric_enumeration_imp.cpp

@@ -48,6 +48,14 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
     return ZE_RESULT_SUCCESS;
 }
 
+MetricGroup *MetricEnumeration::getMetricGroupByIndex(const uint32_t index) {
+    return metricGroups[index];
+}
+
+uint32_t MetricEnumeration::getMetricGroupCount() {
+    return static_cast<uint32_t>(metricGroups.size());
+}
+
 bool MetricEnumeration::isInitialized() {
 
     if (initializationState == ZE_RESULT_ERROR_UNINITIALIZED) {
@@ -128,11 +136,11 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
         // Open metrics device for each sub device.
         const auto &deviceImp = *static_cast<DeviceImp *>(&device);
 
-        for (uint32_t i = 0; i < deviceImp.subDevices.size(); i++) {
+        for (size_t i = 0; i < deviceImp.subDevices.size(); i++) {
 
             auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice;
 
-            pAdapter->OpenMetricsSubDevice(i, &metricsDevice);
+            pAdapter->OpenMetricsSubDevice(static_cast<uint32_t>(i), &metricsDevice);
 
             if (metricsDevice == nullptr) {
                 NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "unable to open metrics device %u\n", i);
@@ -160,11 +168,6 @@ ze_result_t MetricEnumeration::openMetricsDiscovery() {
 }
 
 ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
-    for (uint32_t i = 0; i < metricGroups.size(); ++i) {
-        delete metricGroups[i];
-    }
-
-    metricGroups.clear();
 
     if (pAdapter) {
 
@@ -174,7 +177,7 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
             // Close metrics device for each sub device.
             const auto &deviceImp = *static_cast<DeviceImp *>(&device);
 
-            for (uint32_t i = 0; i < deviceImp.subDevices.size(); i++) {
+            for (size_t i = 0; i < deviceImp.subDevices.size(); i++) {
 
                 auto &metricsDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().pMetricsDevice;
 
@@ -182,6 +185,14 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
                     pAdapter->CloseMetricsDevice(metricsDevice);
                     metricsDevice = nullptr;
                 }
+
+                auto &metricGroupsSubDevice = deviceImp.subDevices[i]->getMetricContext().getMetricEnumeration().metricGroups;
+
+                for (size_t j = 0; j < metricGroupsSubDevice.size(); ++j) {
+                    auto metricGroupSubDevice = MetricGroup::fromHandle(metricGroupsSubDevice[j]);
+                    delete metricGroupSubDevice;
+                }
+                metricGroupsSubDevice.clear();
             }
         } else if (pMetricsDevice) {
 
@@ -191,6 +202,11 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
         }
     }
 
+    for (size_t i = 0; i < metricGroups.size(); ++i) {
+        delete metricGroups[i];
+    }
+    metricGroups.clear();
+
     if (hMetricsDiscovery != nullptr) {
         openAdapterGroup = nullptr;
         hMetricsDiscovery.reset();
@@ -201,19 +217,38 @@ ze_result_t MetricEnumeration::cleanupMetricsDiscovery() {
 
 ze_result_t MetricEnumeration::cacheMetricInformation() {
 
-    MetricsDiscovery::IMetricsDevice_1_5 *pMetricsDevice = nullptr;
-
     auto &device = metricContext.getDevice();
 
     if (device.isMultiDeviceCapable()) {
 
-        // Get metric information from sub device 0.
+        ze_result_t result = ZE_RESULT_SUCCESS;
-        const auto &deviceImp = *static_cast<DeviceImp *>(&device);
-        pMetricsDevice = deviceImp.subDevices[0]->getMetricContext().getMetricEnumeration().pMetricsDevice;
-    } else {
 
-        // Get metric information from root or sub device.
+        // Get metric information from all sub devices.
-        pMetricsDevice = this->pMetricsDevice;
+        const auto &deviceImp = *static_cast<DeviceImp *>(&device);
+        for (auto subDevice : deviceImp.subDevices) {
+            result = subDevice->getMetricContext().getMetricEnumeration().cacheMetricInformation();
+            if (ZE_RESULT_SUCCESS != result) {
+                return result;
+            }
+        }
+
+        // Get metric groups count for one sub device.
+        const uint32_t metricGroupCount = deviceImp.subDevices[0]->getMetricContext().getMetricEnumeration().getMetricGroupCount();
+
+        // Cache and aggregate all metric groups from all sub devices.
+        for (uint32_t i = 0; i < metricGroupCount; i++) {
+            auto metricGroupRootDevice = new MetricGroupImp();
+
+            for (auto subDevice : deviceImp.subDevices) {
+                MetricGroup *metricGroupSubDevice = subDevice->getMetricContext().getMetricEnumeration().getMetricGroupByIndex(i);
+
+                metricGroupRootDevice->getMetricGroups().push_back(metricGroupSubDevice);
+            }
+
+            metricGroups.push_back(metricGroupRootDevice);
+        }
+
+        return result;
     }
 
     DEBUG_BREAK_IF(pMetricsDevice == nullptr);
@@ -457,7 +492,7 @@ zet_value_type_t MetricEnumeration::getMetricResultType(
 
 MetricGroupImp ::~MetricGroupImp() {
 
-    for (uint32_t i = 0; i < metrics.size(); ++i) {
+    for (size_t i = 0; i < metrics.size(); ++i) {
         delete metrics[i];
     }
 
@@ -465,7 +500,11 @@ MetricGroupImp ::~MetricGroupImp() {
 };
 
 ze_result_t MetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
+    if (metricGroups.size() > 0) {
+        *pProperties = MetricGroup::getProperties(metricGroups[0]);
+    } else {
         copyProperties(properties, *pProperties);
+    }
     return ZE_RESULT_SUCCESS;
 }
 
@@ -480,18 +519,22 @@ zet_metric_group_properties_t MetricGroup::getProperties(const zet_metric_group_
 }
 
 ze_result_t MetricGroupImp::getMetric(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
+
+    if (metricGroups.size() > 0) {
+        auto metricGroupSubDevice = MetricGroup::fromHandle(metricGroups[0]);
+        return metricGroupSubDevice->getMetric(pCount, phMetrics);
+    }
+
     if (*pCount == 0) {
         *pCount = static_cast<uint32_t>(metrics.size());
         return ZE_RESULT_SUCCESS;
-    } else if (*pCount > metrics.size()) {
+    }
+    // User is expected to allocate space.
+    DEBUG_BREAK_IF(phMetrics == nullptr);
+
+    if (*pCount > metrics.size()) {
         *pCount = static_cast<uint32_t>(metrics.size());
     }
-
-    // User is expected to allocate space.
-    if (phMetrics == nullptr) {
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-
     for (uint32_t i = 0; i < *pCount; i++) {
         phMetrics[i] = metrics[i]->toHandle();
     }
@@ -663,6 +706,10 @@ uint32_t MetricGroupImp::getRawReportSize() {
                : pMetricSetParams->QueryReportSize;
 }
 
+std::vector<zet_metric_group_handle_t> &MetricGroupImp::getMetricGroups() {
+    return metricGroups;
+}
+
 void MetricGroupImp::copyProperties(const zet_metric_group_properties_t &source,
                                     zet_metric_group_properties_t &destination) {
     destination = source;

level_zero/tools/source/metrics/metric_enumeration_imp.h

@@ -22,6 +22,8 @@ struct MetricEnumeration {
     virtual ~MetricEnumeration();
 
     ze_result_t metricGroupGet(uint32_t &count, zet_metric_group_handle_t *phMetricGroups);
+    MetricGroup *getMetricGroupByIndex(const uint32_t index);
+    uint32_t getMetricGroupCount();
 
     virtual bool isInitialized();
 
@@ -98,6 +100,8 @@ struct MetricGroupImp : MetricGroup {
     ze_result_t readIoStream(uint32_t &reportCount, uint8_t &reportData) override;
     ze_result_t closeIoStream() override;
 
+    std::vector<zet_metric_group_handle_t> &getMetricGroups();
+
   protected:
     void copyProperties(const zet_metric_group_properties_t &source,
                         zet_metric_group_properties_t &destination);
@@ -118,6 +122,8 @@ struct MetricGroupImp : MetricGroup {
     };
     MetricsDiscovery::IMetricSet_1_5 *pReferenceMetricSet = nullptr;
     MetricsDiscovery::IConcurrentGroup_1_5 *pReferenceConcurrentGroup = nullptr;
+
+    std::vector<zet_metric_group_handle_t> metricGroups;
 };
 
 struct MetricImp : Metric {

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

@@ -146,6 +146,9 @@ void MetricMultiDeviceFixture::TearDown() {
 
 void MetricMultiDeviceFixture::openMetricsAdapter() {
 
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
     EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
         .Times(0);
 
@@ -153,13 +156,13 @@ void MetricMultiDeviceFixture::openMetricsAdapter() {
         .Times(1)
         .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
 
-    EXPECT_CALL(adapter, OpenMetricsDevice(_))
+    EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK)));
 
     EXPECT_CALL(adapter, CloseMetricsDevice(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(TCompletionCode::CC_OK));
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
 
     EXPECT_CALL(adapterGroup, GetAdapter(_))
         .Times(0);
@@ -171,6 +174,9 @@ void MetricMultiDeviceFixture::openMetricsAdapter() {
 
 void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
 
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
     EXPECT_CALL(*mockMetricEnumeration, loadMetricsDiscovery())
         .Times(0);
 
@@ -178,13 +184,13 @@ void MetricMultiDeviceFixture::openMetricsAdapterGroup() {
         .Times(1)
         .WillOnce(DoAll(::testing::SetArgPointee<0>(&adapterGroup), Return(TCompletionCode::CC_OK)));
 
-    EXPECT_CALL(adapter, OpenMetricsDevice(_))
+    EXPECT_CALL(adapter, OpenMetricsSubDevice(_, _))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(DoAll(::testing::SetArgPointee<0>(&metricsDevice), Return(TCompletionCode::CC_OK)));
+        .WillRepeatedly(DoAll(::testing::SetArgPointee<1>(&metricsDevice), Return(TCompletionCode::CC_OK)));
 
     EXPECT_CALL(adapter, CloseMetricsDevice(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(TCompletionCode::CC_OK));
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
 }
 
 void MetricMultiDeviceContextFixture::SetUp() {

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

@@ -886,6 +886,9 @@ using MultiDeviceMetricEnumerationTest = Test<MetricMultiDeviceContextFixture>;
 
 TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedMetricGroupWhenzetContextActivateMetricGroupsIsCalledThenReturnsSuccess) {
 
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -923,11 +926,11 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM
         .WillRepeatedly(Return(&metricsDeviceParams));
 
     EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricsConcurrentGroup));
+        .WillRepeatedly(Return(&metricsConcurrentGroup));
 
     EXPECT_CALL(metricsConcurrentGroup, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
         .WillRepeatedly(Return(&metricsConcurrentGroupParams));
 
     EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
@@ -937,12 +940,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM
         .WillRepeatedly(Return(&metricsSetParams));
 
     EXPECT_CALL(metricsSet, GetMetric(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metric));
+        .WillRepeatedly(Return(&metric));
 
     EXPECT_CALL(metric, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricParams));
+        .WillRepeatedly(Return(&metricParams));
 
     EXPECT_CALL(metricsSet, SetApiFiltering(_))
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
@@ -963,6 +966,9 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndValidEventBasedM
 
 TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsWithTheSameDomainsWhenzetContextActivateMetricGroupsIsCalledThenReturnsFail) {
 
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
     // Metrics Discovery device.
     metricsDeviceParams.ConcurrentGroupsCount = 1;
 
@@ -1010,15 +1016,17 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW
         .WillRepeatedly(Return(&metricsDeviceParams));
 
     EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricsConcurrentGroup0));
+        .WillRepeatedly(Return(&metricsConcurrentGroup0));
 
     EXPECT_CALL(metricsConcurrentGroup0, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
         .WillRepeatedly(Return(&metricsConcurrentGroupParams0));
 
     EXPECT_CALL(metricsConcurrentGroup0, GetMetricSet(_))
-        .Times(2)
+        .Times(subDeviceCount * 2)
+        .WillOnce(Return(&metricsSet0))
+        .WillOnce(Return(&metricsSet1))
         .WillOnce(Return(&metricsSet0))
         .WillOnce(Return(&metricsSet1));
 
@@ -1029,12 +1037,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW
         .WillRepeatedly(Return(&metricsSetParams1));
 
     EXPECT_CALL(metricsSet0, GetMetric(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metric0));
+        .WillRepeatedly(Return(&metric0));
 
     EXPECT_CALL(metricsSet1, GetMetric(_))
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metric1));
+        .WillRepeatedly(Return(&metric1));
 
     EXPECT_CALL(metricsSet0, SetApiFiltering(_))
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
@@ -1043,12 +1051,12 @@ TEST_F(MultiDeviceMetricEnumerationTest, givenMultipleDevicesAndTwoMetricGroupsW
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
 
     EXPECT_CALL(metric0, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricParams0));
+        .WillRepeatedly(Return(&metricParams0));
 
     EXPECT_CALL(metric1, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricParams1));
+        .WillRepeatedly(Return(&metricParams1));
 
     // Metric group count.
     uint32_t metricGroupCount = 0;
@@ -2259,7 +2267,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
 
     // Use first root device.
     auto &metricContext = devices[0]->getMetricContext();
-    const uint32_t subDeviceCount = static_cast<uint32_t>(devices.size());
+    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;
@@ -2289,8 +2298,8 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
         .WillRepeatedly(Return(TCompletionCode::CC_OK));
 
     EXPECT_CALL(mockDevice, GetParams())
-        .Times(1)
+        .Times(subDeviceCount)
-        .WillOnce(Return(&metricsDeviceParams));
+        .WillRepeatedly(Return(&metricsDeviceParams));
 
     // Use root device.
     metricContext.setSubDeviceIndex(0);
@@ -2345,6 +2354,125 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenRootDeviceWhenLoadDependenciesIsCa
     EXPECT_EQ(mockMetricEnumeration->baseIsInitialized(), false);
 }
 
+TEST_F(MetricEnumerationMultiDeviceTest, givenIncorrectMetricsDiscoveryInterfaceVersionWhenZetGetMetricGroupIsCalledThenReturnsFail) {
+
+    metricsDeviceParams.Version.MajorNumber = 0;
+    metricsDeviceParams.Version.MinorNumber = 1;
+
+    openMetricsAdapter();
+
+    EXPECT_CALL(metricsDevice, GetParams())
+        .Times(1)
+        .WillOnce(Return(&metricsDeviceParams));
+
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_ERROR_UNKNOWN);
+    EXPECT_EQ(metricGroupCount, 0u);
+}
+
+TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetPropertiestIsCalledThenReturnSuccess) {
+
+    // Use first root device.
+    auto &deviceImp = *static_cast<DeviceImp *>(devices[0]);
+    const uint32_t subDeviceCount = static_cast<uint32_t>(deviceImp.subDevices.size());
+
+    // 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";
+    metricsSetParams.MetricsCount = 1;
+
+    // Metrics Discovery:: metric.
+    Mock<IMetric_1_0> metric;
+    TMetricParams_1_0 metricParams = {};
+    metricParams.SymbolName = "Metric symbol name";
+    metricParams.ShortName = "Metric short name";
+    metricParams.LongName = "Metric long name";
+    metricParams.ResultType = MetricsDiscovery::TMetricResultType::RESULT_UINT64;
+    metricParams.MetricType = MetricsDiscovery::TMetricType::METRIC_TYPE_RATIO;
+    zet_metric_properties_t metricProperties = {};
+
+    // One api: metric group handle.
+    zet_metric_group_handle_t metricGroupHandle = {};
+    zet_metric_group_properties_t metricGroupProperties = {};
+
+    openMetricsAdapter();
+
+    EXPECT_CALL(metricsDevice, GetParams())
+        .WillRepeatedly(Return(&metricsDeviceParams));
+
+    EXPECT_CALL(metricsDevice, GetConcurrentGroup(_))
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricsConcurrentGroup));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetParams())
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricsConcurrentGroupParams));
+
+    EXPECT_CALL(metricsConcurrentGroup, GetMetricSet(_))
+        .WillRepeatedly(Return(&metricsSet));
+
+    EXPECT_CALL(metricsSet, GetParams())
+        .WillRepeatedly(Return(&metricsSetParams));
+
+    EXPECT_CALL(metricsSet, GetMetric(_))
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metric));
+
+    EXPECT_CALL(metric, GetParams())
+        .Times(subDeviceCount)
+        .WillRepeatedly(Return(&metricParams));
+
+    EXPECT_CALL(metricsSet, SetApiFiltering(_))
+        .WillRepeatedly(Return(TCompletionCode::CC_OK));
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(devices[0]->toHandle(), &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(devices[0]->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);
+
+    // Obtain metric.
+    uint32_t metricCount = 0;
+    zet_metric_handle_t metricHandle = {};
+    EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricCount, 1u);
+    EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
+    EXPECT_NE(metricHandle, nullptr);
+
+    // Obtain metric params.
+    EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(strcmp(metricProperties.name, metricParams.SymbolName), 0);
+    EXPECT_EQ(strcmp(metricProperties.description, metricParams.LongName), 0);
+    EXPECT_EQ(metricProperties.metricType, ZET_METRIC_TYPE_RATIO);
+    EXPECT_EQ(metricProperties.resultType, ZET_VALUE_TYPE_UINT64);
+}
+
 class MetricEnumerationTestMetricTypes : public MetricEnumerationTest,
                                          public ::testing::WithParamInterface<MetricsDiscovery::TMetricType> {
   public: