refactor: make all metric and group have a metric source

Related-To: NEO-8783


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

level_zero/tools/source/metrics/metric.h

@@ -43,10 +43,12 @@ class MetricSource {
     virtual ze_result_t activateMetricGroupsPreferDeferred(uint32_t count, zet_metric_group_handle_t *phMetricGroups) = 0;
     virtual ze_result_t activateMetricGroupsAlreadyDeferred() = 0;
     virtual ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) = 0;
-    virtual ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
+    ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
                                   const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
                                   zet_metric_group_sampling_type_flag_t samplingType,
-                                          zet_metric_group_handle_t *pMetricGroupHandle) = 0;
+                                  zet_metric_group_handle_t *pMetricGroupHandle) {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    };
     virtual ~MetricSource() = default;
     uint32_t getType() const {
         return type;
@@ -118,6 +120,18 @@ struct Metric : _zet_metric_handle_t {
     inline zet_metric_handle_t toHandle() { return this; }
 };
 
+struct MetricImp : public Metric {
+
+    MetricSource &getMetricSource() {
+        return metricSource;
+    }
+    ~MetricImp() override = default;
+    MetricImp(MetricSource &metricSource) : metricSource(metricSource) {}
+
+  protected:
+    MetricSource &metricSource;
+};
+
 struct MetricGroup : _zet_metric_group_handle_t {
     virtual ~MetricGroup() = default;
     MetricGroup() {}
@@ -168,9 +182,11 @@ struct MetricGroupImp : public MetricGroup {
     }
     ~MetricGroupImp() override = default;
     MetricGroupImp(MetricSource &metricSource) : metricSource(metricSource) {}
+    bool isImmutable() { return isPredefined; }
 
   protected:
     MetricSource &metricSource;
+    bool isPredefined = true;
 };
 
 struct MetricGroupCalculateHeader {

level_zero/tools/source/metrics/metric_device_context_create.cpp

@@ -29,12 +29,6 @@ ze_result_t MetricDeviceContext::metricGroupCreate(const char name[ZET_MAX_METRI
 ze_result_t OaMetricSourceImp::metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
-ze_result_t OaMetricSourceImp::metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
-                                                 const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
-                                                 zet_metric_group_sampling_type_flag_t samplingType,
-                                                 zet_metric_group_handle_t *pMetricGroupHandle) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
 
 ze_result_t metricProgrammableGetProperties(
     zet_metric_programmable_exp_handle_t hMetricProgrammable,

level_zero/tools/source/metrics/metric_ip_sampling_source.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -93,7 +93,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
     strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address");
     metricProperties.metricType = ZET_METRIC_TYPE_IP;
     strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Address");
-    metrics.push_back(IpSamplingMetricImp(metricProperties));
+    metrics.push_back(IpSamplingMetricImp(*this, metricProperties));
 
     std::vector<std::pair<const char *, const char *>> metricPropertiesList = {
         {"Active", "Active cycles"},
@@ -114,7 +114,7 @@ void IpSamplingMetricSourceImp::cacheMetricGroup() {
     for (auto &property : metricPropertiesList) {
         strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, property.first);
         strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, property.second);
-        metrics.push_back(IpSamplingMetricImp(metricProperties));
+        metrics.push_back(IpSamplingMetricImp(*this, metricProperties));
     }
 
     cachedMetricGroup = IpSamplingMetricGroupImp::create(*this, metrics);
@@ -654,7 +654,7 @@ std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp> MultiDeviceIpSamplingMetric
     return std::unique_ptr<MultiDeviceIpSamplingMetricGroupImp>(new (std::nothrow) MultiDeviceIpSamplingMetricGroupImp(metricSource, subDeviceMetricGroup));
 }
 
-IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {
+IpSamplingMetricImp::IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties) : MetricImp(metricSource), properties(properties) {
 }
 
 ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pProperties) {

level_zero/tools/source/metrics/metric_ip_sampling_source.h

@@ -31,12 +31,6 @@ class IpSamplingMetricSourceImp : public MetricSource {
     ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
         return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
-    ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
-                                  const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
-                                  zet_metric_group_sampling_type_flag_t samplingType,
-                                  zet_metric_group_handle_t *pMetricGroupHandle) override {
-        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
     bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
     void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricIPSamplingpOsInterface);
     static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
@@ -171,9 +165,9 @@ struct MultiDeviceIpSamplingMetricGroupImp : public IpSamplingMetricGroupBase {
     std::vector<IpSamplingMetricGroupImp *> subDeviceMetricGroup = {};
 };
 
-struct IpSamplingMetricImp : public Metric {
+struct IpSamplingMetricImp : public MetricImp {
     ~IpSamplingMetricImp() override = default;
-    IpSamplingMetricImp(zet_metric_properties_t &properties);
+    IpSamplingMetricImp(MetricSource &metricSource, zet_metric_properties_t &properties);
     ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
     ze_result_t destroy() override {
         return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;

level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -433,7 +433,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
 
         zet_metric_properties_t properties = {};
         getL0MetricPropertiesFromMdapiMetric(properties, pSourceMetric);
-        auto pMetric = OaMetricImp::create(properties);
+        auto pMetric = OaMetricImp::create(metricSource, properties);
         UNRECOVERABLE_IF(pMetric == nullptr);
 
         metrics.push_back(pMetric);
@@ -447,7 +447,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
         zet_metric_properties_t properties = {};
         getL0MetricPropertiesFromMdapiInformation(properties, pSourceInformation);
 
-        auto pMetric = OaMetricImp::create(properties);
+        auto pMetric = OaMetricImp::create(metricSource, properties);
         UNRECOVERABLE_IF(pMetric == nullptr);
 
         metrics.push_back(pMetric);
@@ -1086,8 +1086,8 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties,
     return pMetricGroup;
 }
 
-Metric *OaMetricImp::create(zet_metric_properties_t &properties) {
+Metric *OaMetricImp::create(MetricSource &metricSource, zet_metric_properties_t &properties) {
-    auto pMetric = new OaMetricImp();
+    auto pMetric = new OaMetricImp(metricSource);
     UNRECOVERABLE_IF(pMetric == nullptr);
     pMetric->initialize(properties);
     pMetric->isPredefined = true;

level_zero/tools/source/metrics/metric_oa_enumeration_imp.h

@@ -195,7 +195,6 @@ struct OaMetricGroupImp : public MetricGroupImp {
     uint32_t getRawReportSize();
     const MetricEnumeration &getMetricEnumeration() const;
     void setCachedExportDataHeapSize(size_t size);
-    bool isImmutable() { return isPredefined; }
 
   protected:
     void copyProperties(const zet_metric_group_properties_t &source,
@@ -219,16 +218,17 @@ struct OaMetricGroupImp : public MetricGroupImp {
 
     std::vector<zet_metric_group_handle_t> metricGroups;
     size_t cachedExportDataHeapSize = 0;
-    bool isPredefined{};
 
   private:
     ze_result_t openForDevice(Device *pDevice, zet_metric_streamer_desc_t &desc,
                               zet_metric_streamer_handle_t *phMetricStreamer);
 };
 
-struct OaMetricImp : public Metric {
+struct OaMetricImp : public MetricImp {
     ~OaMetricImp() override{};
 
+    OaMetricImp(MetricSource &metricSource) : MetricImp(metricSource) {}
+
     ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
 
     ze_result_t destroy() override {
@@ -237,7 +237,7 @@ struct OaMetricImp : public Metric {
 
     ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
 
-    static Metric *create(zet_metric_properties_t &properties);
+    static Metric *create(MetricSource &metricSource, zet_metric_properties_t &properties);
 
     bool isImmutable() { return isPredefined; }
 

level_zero/tools/source/metrics/metric_oa_source.h

@@ -45,10 +45,6 @@ class OaMetricSourceImp : public MetricSource {
     ze_result_t activateMetricGroupsPreferDeferred(const uint32_t count,
                                                    zet_metric_group_handle_t *phMetricGroups) override;
     ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override;
-    ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
-                                  const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
-                                  zet_metric_group_sampling_type_flag_t samplingType,
-                                  zet_metric_group_handle_t *pMetricGroupHandle) override;
     bool isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const;
     bool isMetricGroupActivatedInHw() const;
     void setUseCompute(const bool useCompute);

level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -206,6 +206,9 @@ class SingleMetricCollector : public Collector {
     SingleMetricCollector(ExecutionContext *executionCtxt,
                           const char *metricGroupName,
                           const zet_metric_group_sampling_type_flag_t samplingType);
+    SingleMetricCollector(ExecutionContext *executionCtxt,
+                          zet_metric_group_handle_t metricGroup,
+                          const zet_metric_group_sampling_type_flag_t samplingType);
     ~SingleMetricCollector() override = default;
 
     bool prefixCommands() override = 0;

level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -23,33 +23,15 @@ SingleMetricCollector::SingleMetricCollector(ExecutionContext *executionCtxt,
     : Collector(executionCtxt), samplingType(samplingType) {
 
     metricGroup = zmu::findMetricGroup(metricGroupName, samplingType, executionCtxt->getDeviceHandle(0));
+    zmu::printMetricGroupAndMetricProperties(metricGroup);
+}
 
-    if (zmu::TestSettings::get()->verboseLevel.get() >= zmu::LogLevel::DEBUG) {
+SingleMetricCollector::SingleMetricCollector(ExecutionContext *executionCtxt,
-        zet_metric_group_properties_t metricGroupProperties = {};
+                                             zet_metric_group_handle_t metricGroup,
-        // Obtain metric group properties to check the group name and sampling type.
+                                             const zet_metric_group_sampling_type_flag_t samplingType)
-        VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties));
+    : Collector(executionCtxt), metricGroup(metricGroup), samplingType(samplingType) {
-        zmu::printMetricGroupProperties(metricGroupProperties);
 
-        // Print metrics from metric group.
+    zmu::printMetricGroupAndMetricProperties(metricGroup);
-        uint32_t metricCount = 0;
-        std::vector<zet_metric_handle_t> metrics = {};
-
-        // Obtain metrics count for verbose purpose.
-        VALIDATECALL(zetMetricGet(metricGroup, &metricCount, nullptr));
-
-        // Obtain metrics for verbose purpose.
-        metrics.resize(metricCount);
-        VALIDATECALL(zetMetricGet(metricGroup, &metricCount, metrics.data()));
-
-        // Enumerate metric group metrics for verbose purpose.
-        for (uint32_t j = 0; j < metricCount; ++j) {
-
-            const zet_metric_handle_t metric = metrics[j];
-            zet_metric_properties_t metricProperties = {};
-            VALIDATECALL(zetMetricGetProperties(metric, &metricProperties));
-            zmu::printMetricProperties(metricProperties);
-        }
-    }
 }
 
 ///////////////////////////////////

level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -196,6 +196,35 @@ ze_command_list_handle_t createImmediateCommandList(ze_context_handle_t &context
     return commandList;
 }
 
+void printMetricGroupAndMetricProperties(zet_metric_group_handle_t metricGroup) {
+    if (TestSettings::get()->verboseLevel.get() >= LogLevel::DEBUG) {
+        zet_metric_group_properties_t metricGroupProperties = {};
+        // Obtain metric group properties to check the group name and sampling type.
+        VALIDATECALL(zetMetricGroupGetProperties(metricGroup, &metricGroupProperties));
+        printMetricGroupProperties(metricGroupProperties);
+
+        // Print metrics from metric group.
+        uint32_t metricCount = 0;
+        std::vector<zet_metric_handle_t> metrics = {};
+
+        // Obtain metrics count for verbose purpose.
+        VALIDATECALL(zetMetricGet(metricGroup, &metricCount, nullptr));
+
+        // Obtain metrics for verbose purpose.
+        metrics.resize(metricCount);
+        VALIDATECALL(zetMetricGet(metricGroup, &metricCount, metrics.data()));
+
+        // Enumerate metric group metrics for verbose purpose.
+        for (uint32_t j = 0; j < metricCount; ++j) {
+
+            const zet_metric_handle_t metric = metrics[j];
+            zet_metric_properties_t metricProperties = {};
+            VALIDATECALL(zetMetricGetProperties(metric, &metricProperties));
+            printMetricProperties(metricProperties);
+        }
+    }
+}
+
 void printMetricGroupProperties(const zet_metric_group_properties_t &properties) {
     LOG(LogLevel::DEBUG) << "METRIC GROUP: "
                          << "name: " << properties.name << ", "

level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_util.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -85,6 +85,7 @@ ze_command_queue_handle_t createCommandQueue(ze_context_handle_t &contextHandle,
 ze_command_list_handle_t createCommandList(ze_context_handle_t &contextHandle, ze_device_handle_t &deviceHandle);
 ze_command_list_handle_t createImmediateCommandList(ze_context_handle_t &contextHandle, ze_device_handle_t &deviceHandle);
 void printMetricGroupProperties(const zet_metric_group_properties_t &properties);
+void printMetricGroupAndMetricProperties(zet_metric_group_handle_t metricGroup);
 void printMetricProperties(const zet_metric_properties_t &properties);
 void sleep(uint32_t milliseconds);
 bool getTestMachineConfiguration(TestMachineConfiguration &machineConfig);

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

@@ -13,8 +13,9 @@ namespace ult {
 
 class MockMetricSource : public L0::MetricSource {
   public:
+    bool isAvailableReturn = false;
     void enable() override {}
-    bool isAvailable() override { return false; }
+    bool isAvailable() override { return isAvailableReturn; }
     ze_result_t appendMetricMemoryBarrier(L0::CommandList &commandList) override { return ZE_RESULT_ERROR_UNKNOWN; }
     ze_result_t metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) override { return ZE_RESULT_ERROR_UNKNOWN; }
     ze_result_t getTimerResolution(uint64_t &resolution) override { return ZE_RESULT_ERROR_UNKNOWN; }
@@ -24,11 +25,8 @@ class MockMetricSource : public L0::MetricSource {
     ze_result_t metricProgrammableGet(uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables) override {
         return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
-    ze_result_t metricGroupCreate(const char name[ZET_MAX_METRIC_GROUP_NAME],
+    void setType(uint32_t type) {
-                                  const char description[ZET_MAX_METRIC_GROUP_DESCRIPTION],
+        this->type = type;
-                                  zet_metric_group_sampling_type_flag_t samplingType,
-                                  zet_metric_group_handle_t *pMetricGroupHandle) override {
-        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
     ~MockMetricSource() override = default;
 };
@@ -104,5 +102,17 @@ class MockMetricGroup : public L0::MetricGroupImp {
     }
 };
 
+class MockMetric : public L0::MetricImp {
+  public:
+    ~MockMetric() override = default;
+    MockMetric(MetricSource &metricSource) : L0::MetricImp(metricSource) {}
+    ze_result_t getProperties(zet_metric_properties_t *pProperties) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    ze_result_t destroy() override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+};
+
 } // namespace ult
 } // namespace L0

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -344,6 +344,7 @@ TEST_F(MetricEnumerationMultiDeviceTest, givenValidArgumentsWhenZetMetricGetProp
     EXPECT_EQ(zetMetricGet(metricGroupHandle, &metricCount, &metricHandle), ZE_RESULT_SUCCESS);
     EXPECT_NE(metricHandle, nullptr);
     EXPECT_TRUE(static_cast<OaMetricImp *>(metricHandle)->isImmutable());
+    EXPECT_TRUE(static_cast<OaMetricImp *>(metricHandle)->getMetricSource().isAvailable());
 
     // Obtain metric params.
     EXPECT_EQ(zetMetricGetProperties(metricHandle, &metricProperties), ZE_RESULT_SUCCESS);