Metrics IP Sampling Enumeration Support

This patch adds enumeration of metric group for
IP sampling.

Related-To: LOCI-2754


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

level_zero/tools/source/metrics/CMakeLists.txt

@@ -15,8 +15,11 @@ list(APPEND L0_SRCS_TOOLS_METRICS
      ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_streamer_imp.h
      ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_query_imp.cpp
      ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_query_imp.h
+     ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_source.cpp
      ${CMAKE_CURRENT_SOURCE_DIR}/metric_oa_source.h
      ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling.h
+     ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.h
+     ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_source.cpp
 )
 
 if(UNIX)

level_zero/tools/source/metrics/metric.cpp

@@ -7,15 +7,12 @@
 
 #include "level_zero/tools/source/metrics/metric.h"
 
-#include "shared/source/os_interface/os_library.h"
-
 #include "level_zero/core/source/device/device.h"
 #include "level_zero/core/source/device/device_imp.h"
 #include "level_zero/core/source/driver/driver.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/source/inc/ze_intel_gpu.h"
-#include "level_zero/tools/source/metrics/metric_oa_enumeration_imp.h"
-#include "level_zero/tools/source/metrics/metric_oa_query_imp.h"
+#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
 #include "level_zero/tools/source/metrics/metric_oa_source.h"
 
 #include <map>
@@ -23,156 +20,6 @@
 
 namespace L0 {
 
-OaMetricSourceImp::OsLibraryLoadPtr OaMetricSourceImp::osLibraryLoadFunction(NEO::OsLibrary::load);
-
-std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
-    return std::unique_ptr<OaMetricSourceImp>(new (std::nothrow) OaMetricSourceImp(metricDeviceContext));
-}
-
-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))) {
-}
-
-OaMetricSourceImp::~OaMetricSourceImp() = default;
-
-bool OaMetricSourceImp::checkDependencies() {
-
-    std::unique_ptr<NEO::OsLibrary> library = nullptr;
-
-    // Check Metrics Discovery availability.
-    library.reset(osLibraryLoadFunction(MetricEnumeration::getMetricsDiscoveryFilename()));
-    if (library == nullptr) {
-        PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics discovery %s\n", MetricEnumeration::getMetricsDiscoveryFilename());
-        return false;
-    }
-
-    // Check Metrics Library availability.
-    library.reset(osLibraryLoadFunction(MetricsLibrary::getFilename()));
-    if (library == nullptr) {
-        PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Unable to find metrics library %s\n", MetricsLibrary::getFilename());
-        return false;
-    }
-
-    return true;
-}
-
-void OaMetricSourceImp::enable() {
-    available = false;
-    if (loadDependencies()) {
-        available = true;
-    }
-}
-
-bool OaMetricSourceImp::isAvailable() {
-    return available;
-}
-
-ze_result_t OaMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
-    DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
-
-    if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
-        // Use one of the sub-device contexts to append to command list.
-        pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
-    }
-
-    auto &metricContext = pDeviceImp->getMetricDeviceContext();
-    auto &metricsLibrary = metricContext.getMetricSource<OaMetricSourceImp>().getMetricsLibrary();
-
-    // Obtain gpu commands.
-    CommandBufferData_1_0 commandBuffer = {};
-    commandBuffer.CommandsType = MetricsLibraryApi::ObjectType::OverrideFlushCaches;
-    commandBuffer.Override.Enable = true;
-    commandBuffer.Type = metricContext.getMetricSource<OaMetricSourceImp>().isComputeUsed()
-                             ? MetricsLibraryApi::GpuCommandBufferType::Compute
-                             : MetricsLibraryApi::GpuCommandBufferType::Render;
-
-    return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
-                                                                     : ZE_RESULT_ERROR_UNKNOWN;
-}
-
-bool OaMetricSourceImp::loadDependencies() {
-    bool result = true;
-    if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
-        result = false;
-        DEBUG_BREAK_IF(!result);
-    }
-    if (result && !metricsLibrary->load()) {
-        result = false;
-        DEBUG_BREAK_IF(!result);
-    }
-
-    // Set metric context initialization state.
-    setInitializationState(result
-                               ? ZE_RESULT_SUCCESS
-                               : ZE_RESULT_ERROR_UNKNOWN);
-
-    return result;
-}
-bool OaMetricSourceImp::isInitialized() {
-    return initializationState == ZE_RESULT_SUCCESS;
-}
-
-void OaMetricSourceImp::setInitializationState(const ze_result_t state) {
-    initializationState = state;
-}
-
-Device &OaMetricSourceImp::getDevice() {
-    return metricDeviceContext.getDevice();
-}
-
-MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
-    return *metricsLibrary;
-}
-MetricEnumeration &OaMetricSourceImp::getMetricEnumeration() {
-    return *metricEnumeration;
-}
-MetricStreamer *OaMetricSourceImp::getMetricStreamer() {
-    return pMetricStreamer;
-}
-
-void OaMetricSourceImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
-    this->pMetricStreamer = pMetricStreamer;
-}
-
-void OaMetricSourceImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
-    this->metricsLibrary.release();
-    this->metricsLibrary.reset(&metricsLibrary);
-}
-
-void OaMetricSourceImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
-    this->metricEnumeration.release();
-    this->metricEnumeration.reset(&metricEnumeration);
-}
-
-void OaMetricSourceImp::setUseCompute(const bool useCompute) {
-    this->useCompute = useCompute;
-}
-
-bool OaMetricSourceImp::isComputeUsed() const {
-    return useCompute;
-}
-
-ze_result_t OaMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
-    return getMetricEnumeration().metricGroupGet(*pCount, phMetricGroups);
-}
-
-uint32_t OaMetricSourceImp::getSubDeviceIndex() {
-    return metricDeviceContext.getSubDeviceIndex();
-}
-
-bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
-    return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
-}
-
-bool OaMetricSourceImp::isMetricGroupActivated() const {
-    return metricDeviceContext.isMetricGroupActivated();
-}
-
-bool OaMetricSourceImp::isImplicitScalingCapable() const {
-    return metricDeviceContext.isImplicitScalingCapable();
-}
-
 std::unique_ptr<MetricDeviceContext> MetricDeviceContext::create(Device &device) {
     return std::make_unique<MetricDeviceContext>(device);
 }
@@ -186,6 +33,7 @@ MetricDeviceContext::MetricDeviceContext(Device &inputDevice) : device(inputDevi
 
     multiDeviceCapable = !isSubDevice && device.isImplicitScalingCapable();
     metricSources[MetricSource::SourceType::Oa] = OaMetricSourceImp::create(*this);
+    metricSources[MetricSource::SourceType::IpSampling] = IpSamplingMetricSourceImp::create(*this);
 }
 
 bool MetricDeviceContext::enable() {
@@ -205,7 +53,17 @@ ze_result_t MetricDeviceContext::metricGroupGet(uint32_t *pCount, zet_metric_gro
     uint32_t requestCount = *pCount;
     for (auto const &entry : metricSources) {
         auto const &metricSource = entry.second;
+
+        if (!metricSource->isAvailable()) {
+            continue;
+        }
+
         result = metricSource->metricGroupGet(&requestCount, phMetricGroups);
+        if (result == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
+            result = ZE_RESULT_SUCCESS;
+            continue;
+        }
+
         if (result != ZE_RESULT_SUCCESS) {
             break;
         }
@@ -278,16 +136,22 @@ ze_result_t MetricDeviceContext::deActivateAllDomains() {
 }
 
 ze_result_t MetricDeviceContext::appendMetricMemoryBarrier(CommandList &commandList) {
-    ze_result_t result = ZE_RESULT_SUCCESS;
+
+    bool isSuccess = false;
     for (auto const &entry : metricSources) {
         auto const &metricSource = entry.second;
+        if (!metricSource->isAvailable()) {
+            continue;
+        }
 
-        result = metricSource->appendMetricMemoryBarrier(commandList);
-        if (result != ZE_RESULT_SUCCESS) {
+        ze_result_t result = metricSource->appendMetricMemoryBarrier(commandList);
+        if (result == ZE_RESULT_SUCCESS) {
+            isSuccess = true;
+        } else if (result != ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
             return result;
         }
     }
-    return result;
+    return isSuccess == false ? ZE_RESULT_ERROR_UNSUPPORTED_FEATURE : ZE_RESULT_SUCCESS;
 }
 
 bool MetricDeviceContext::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
@@ -328,10 +192,6 @@ Device &MetricDeviceContext::getDevice() const {
 
 ze_result_t MetricDeviceContext::enableMetricApi() {
 
-    if (!OaMetricSourceImp::checkDependencies()) {
-        return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
-    }
-
     bool failed = false;
 
     auto driverHandle = L0::DriverHandle::fromHandle(GlobalDriverHandle);
@@ -350,7 +210,7 @@ ze_result_t MetricDeviceContext::enableMetricApi() {
         failed |= !rootDevice->metricContext->enable();
 
         if (failed) {
-            continue;
+            break;
         }
 
         // Initialize sub devices.
@@ -375,9 +235,4 @@ ze_result_t metricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_
     return MetricGroup::fromHandle(hMetricGroup)->streamerOpen(hContext, hDevice, pDesc, hNotificationEvent, phMetricStreamer);
 }
 
-template <>
-OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
-    return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));
-}
-
 } // namespace L0

level_zero/tools/source/metrics/metric.h

@@ -27,7 +27,8 @@ class MetricSource {
   public:
     enum class SourceType {
         Undefined,
-        Oa
+        Oa,
+        IpSampling
     };
     virtual void enable() = 0;
     virtual bool isAvailable() = 0;
@@ -72,7 +73,6 @@ struct Metric : _zet_metric_handle_t {
 
     virtual ze_result_t getProperties(zet_metric_properties_t *pProperties) = 0;
 
-    static Metric *create(zet_metric_properties_t &properties);
     static Metric *fromHandle(zet_metric_handle_t handle) { return static_cast<Metric *>(handle); }
     inline zet_metric_handle_t toHandle() { return this; }
 };

level_zero/tools/source/metrics/metric_ip_sampling_source.cpp

@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
+
+#include "level_zero/tools/source/metrics/metric.h"
+#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include <level_zero/zet_api.h>
+
+namespace L0 {
+constexpr uint32_t ipSamplinMetricCount = 10u;
+constexpr uint32_t ipSamplinDomainId = 100u;
+
+std::unique_ptr<IpSamplingMetricSourceImp> IpSamplingMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
+    return std::unique_ptr<IpSamplingMetricSourceImp>(new (std::nothrow) IpSamplingMetricSourceImp(metricDeviceContext));
+}
+
+IpSamplingMetricSourceImp::IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext) : metricDeviceContext(metricDeviceContext) {
+    metricOsInterface = MetricIpSamplingOsInterface::create(metricDeviceContext.getDevice());
+}
+
+void IpSamplingMetricSourceImp::enable() {
+    isEnabled = metricOsInterface->isDependencyAvailable();
+}
+
+bool IpSamplingMetricSourceImp::isAvailable() {
+    return isEnabled;
+}
+
+void IpSamplingMetricSourceImp::cacheMetricGroup() {
+
+    std::vector<IpSamplingMetricImp> metrics = {};
+    metrics.reserve(ipSamplinMetricCount);
+
+    zet_metric_properties_t metricProperties = {};
+
+    metricProperties.stype = ZET_STRUCTURE_TYPE_METRIC_PROPERTIES;
+    metricProperties.pNext = nullptr;
+    strcpy_s(metricProperties.component, ZET_MAX_METRIC_COMPONENT, "XVE");
+    metricProperties.tierNumber = 4;
+    metricProperties.resultType = ZET_VALUE_TYPE_UINT64;
+
+    // Preparing properties for IP seperately because of unique values
+    strcpy_s(metricProperties.name, ZET_MAX_METRIC_NAME, "IP");
+    strcpy_s(metricProperties.description, ZET_MAX_METRIC_DESCRIPTION, "IP address");
+    metricProperties.metricType = ZET_METRIC_TYPE_IP_EXP;
+    strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Address");
+    metrics.push_back(IpSamplingMetricImp(metricProperties));
+
+    std::vector<std::pair<const char *, const char *>> metricPropertiesList = {
+        {"Active", "Active cycles"},
+        {"ControlStall", "Stall on control"},
+        {"PipeStall", "Stall on pipe"},
+        {"SendStall", "Stall on send"},
+        {"DistStall", "Stall on distance"},
+        {"SbidStall", "Stall on scoreboard"},
+        {"SyncStall", "Stall on sync"},
+        {"InstrFetchStall", "Stall on instruction fetch"},
+        {"OtherStall", "Stall on other condition"},
+    };
+
+    // Preparing properties for others because of common values
+    metricProperties.metricType = ZET_METRIC_TYPE_EVENT;
+    strcpy_s(metricProperties.resultUnits, ZET_MAX_METRIC_RESULT_UNITS, "Events");
+
+    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));
+    }
+
+    cachedMetricGroup = IpSamplingMetricGroupImp::create(metrics);
+    DEBUG_BREAK_IF(cachedMetricGroup == nullptr);
+}
+
+ze_result_t IpSamplingMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
+
+    if (!isEnabled) {
+        *pCount = 0;
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    if (*pCount == 0) {
+        *pCount = 1;
+        return ZE_RESULT_SUCCESS;
+    }
+
+    if (cachedMetricGroup == nullptr) {
+        cacheMetricGroup();
+    }
+
+    DEBUG_BREAK_IF(phMetricGroups == nullptr);
+    phMetricGroups[0] = cachedMetricGroup->toHandle();
+    *pCount = 1;
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t IpSamplingMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+void IpSamplingMetricSourceImp::setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface) {
+    this->metricOsInterface = std::move(metricOsInterface);
+}
+
+IpSamplingMetricGroupImp::IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics) {
+    this->metrics.reserve(metrics.size());
+    for (const auto &metric : metrics) {
+        this->metrics.push_back(std::make_unique<IpSamplingMetricImp>(metric));
+    }
+
+    properties.stype = ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES;
+    properties.pNext = nullptr;
+    strcpy_s(properties.name, ZET_MAX_METRIC_GROUP_NAME, "EuStallSampling");
+    strcpy_s(properties.description, ZET_MAX_METRIC_GROUP_DESCRIPTION, "EU stall sampling");
+    properties.samplingType = ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED;
+    properties.domain = ipSamplinDomainId;
+    properties.metricCount = ipSamplinMetricCount;
+}
+
+ze_result_t IpSamplingMetricGroupImp::getProperties(zet_metric_group_properties_t *pProperties) {
+    *pProperties = properties;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t IpSamplingMetricGroupImp::metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) {
+
+    if (*pCount == 0) {
+        *pCount = static_cast<uint32_t>(metrics.size());
+        return ZE_RESULT_SUCCESS;
+    }
+    // User is expected to allocate space.
+    DEBUG_BREAK_IF(phMetrics == nullptr);
+
+    *pCount = std::min(*pCount, static_cast<uint32_t>(metrics.size()));
+
+    for (uint32_t i = 0; i < *pCount; i++) {
+        phMetrics[i] = metrics[i]->toHandle();
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t IpSamplingMetricGroupImp::calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
+                                                            const uint8_t *pRawData, uint32_t *pMetricValueCount,
+                                                            zet_typed_value_t *pMetricValues) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
+                                                               const uint8_t *pRawData, uint32_t *pSetCount,
+                                                               uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
+                                                               zet_typed_value_t *pMetricValues) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool IpSamplingMetricGroupImp::activate() {
+    return false;
+}
+
+bool IpSamplingMetricGroupImp::deactivate() {
+    return false;
+}
+zet_metric_group_handle_t IpSamplingMetricGroupImp::getMetricGroupForSubDevice(const uint32_t subDeviceIndex) {
+    return toHandle();
+}
+
+ze_result_t IpSamplingMetricGroupImp::streamerOpen(
+    zet_context_handle_t hContext,
+    zet_device_handle_t hDevice,
+    zet_metric_streamer_desc_t *desc,
+    ze_event_handle_t hNotificationEvent,
+    zet_metric_streamer_handle_t *phMetricStreamer) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t IpSamplingMetricGroupImp::metricQueryPoolCreate(
+    zet_context_handle_t hContext,
+    zet_device_handle_t hDevice,
+    const zet_metric_query_pool_desc_t *desc,
+    zet_metric_query_pool_handle_t *phMetricQueryPool) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+std::unique_ptr<IpSamplingMetricGroupImp> IpSamplingMetricGroupImp::create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics) {
+    return std::unique_ptr<IpSamplingMetricGroupImp>(new (std::nothrow) IpSamplingMetricGroupImp(ipSamplingMetrics));
+}
+
+IpSamplingMetricImp::IpSamplingMetricImp(zet_metric_properties_t &properties) : properties(properties) {
+}
+
+ze_result_t IpSamplingMetricImp::getProperties(zet_metric_properties_t *pProperties) {
+    *pProperties = properties;
+    return ZE_RESULT_SUCCESS;
+}
+
+template <>
+IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const {
+    return static_cast<IpSamplingMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::IpSampling));
+}
+
+} // namespace L0

level_zero/tools/source/metrics/metric_ip_sampling_source.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "level_zero/tools/source/metrics/metric.h"
+#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+
+namespace L0 {
+
+struct IpSamplingMetricImp;
+struct IpSamplingMetricGroupImp;
+
+class IpSamplingMetricSourceImp : public MetricSource {
+
+  public:
+    IpSamplingMetricSourceImp(const MetricDeviceContext &metricDeviceContext);
+    virtual ~IpSamplingMetricSourceImp() = default;
+    void enable() override;
+    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);
+    static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
+
+  protected:
+    void cacheMetricGroup();
+    bool isEnabled = false;
+    const MetricDeviceContext &metricDeviceContext;
+    std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
+    std::unique_ptr<IpSamplingMetricGroupImp> cachedMetricGroup = nullptr;
+};
+
+struct IpSamplingMetricGroupImp : public MetricGroup {
+    IpSamplingMetricGroupImp(std::vector<IpSamplingMetricImp> &metrics);
+    virtual ~IpSamplingMetricGroupImp() = default;
+
+    ze_result_t getProperties(zet_metric_group_properties_t *pProperties) override;
+    ze_result_t metricGet(uint32_t *pCount, zet_metric_handle_t *phMetrics) override;
+    ze_result_t calculateMetricValues(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
+                                      const uint8_t *pRawData, uint32_t *pMetricValueCount,
+                                      zet_typed_value_t *pMetricValues) override;
+    ze_result_t calculateMetricValuesExp(const zet_metric_group_calculation_type_t type, size_t rawDataSize,
+                                         const uint8_t *pRawData, uint32_t *pSetCount,
+                                         uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts,
+                                         zet_typed_value_t *pMetricValues) override;
+    bool activate() override;
+    bool deactivate() override;
+    zet_metric_group_handle_t getMetricGroupForSubDevice(const uint32_t subDeviceIndex) override;
+    ze_result_t streamerOpen(
+        zet_context_handle_t hContext,
+        zet_device_handle_t hDevice,
+        zet_metric_streamer_desc_t *desc,
+        ze_event_handle_t hNotificationEvent,
+        zet_metric_streamer_handle_t *phMetricStreamer) override;
+    ze_result_t metricQueryPoolCreate(
+        zet_context_handle_t hContext,
+        zet_device_handle_t hDevice,
+        const zet_metric_query_pool_desc_t *desc,
+        zet_metric_query_pool_handle_t *phMetricQueryPool) override;
+    static std::unique_ptr<IpSamplingMetricGroupImp> create(std::vector<IpSamplingMetricImp> &ipSamplingMetrics);
+
+  private:
+    std::vector<std::unique_ptr<IpSamplingMetricImp>> metrics = {};
+    zet_metric_group_properties_t properties = {};
+};
+
+struct IpSamplingMetricImp : public Metric {
+    virtual ~IpSamplingMetricImp() = default;
+    IpSamplingMetricImp(zet_metric_properties_t &properties);
+    ze_result_t getProperties(zet_metric_properties_t *pProperties) override;
+
+  private:
+    zet_metric_properties_t properties;
+};
+
+template <>
+IpSamplingMetricSourceImp &MetricDeviceContext::getMetricSource<IpSamplingMetricSourceImp>() const;
+
+} // namespace L0

level_zero/tools/source/metrics/metric_oa_enumeration_imp.cpp

@@ -33,7 +33,7 @@ ze_result_t MetricEnumeration::metricGroupGet(uint32_t &count,
                                               zet_metric_group_handle_t *phMetricGroups) {
     ze_result_t result = initialize();
     if (result != ZE_RESULT_SUCCESS) {
-        return result;
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
     if (count == 0) {
@@ -354,7 +354,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
         properties.metricType = getMetricType(pSourceMetricParams->MetricType);
         properties.resultType = getMetricResultType(pSourceMetricParams->ResultType);
 
-        auto pMetric = Metric::create(properties);
+        auto pMetric = OaMetricImp::create(properties);
         UNRECOVERABLE_IF(pMetric == nullptr);
 
         metrics.push_back(pMetric);
@@ -385,7 +385,7 @@ ze_result_t MetricEnumeration::createMetrics(MetricsDiscovery::IMetricSet_1_5 &m
                                     ? ZET_VALUE_TYPE_BOOL8
                                     : ZET_VALUE_TYPE_UINT64;
 
-        auto pMetric = Metric::create(properties);
+        auto pMetric = OaMetricImp::create(properties);
         UNRECOVERABLE_IF(pMetric == nullptr);
 
         metrics.push_back(pMetric);
@@ -927,7 +927,7 @@ MetricGroup *OaMetricGroupImp::create(zet_metric_group_properties_t &properties,
     return pMetricGroup;
 }
 
-Metric *Metric::create(zet_metric_properties_t &properties) {
+Metric *OaMetricImp::create(zet_metric_properties_t &properties) {
     auto pMetric = new OaMetricImp();
     UNRECOVERABLE_IF(pMetric == nullptr);
     pMetric->initialize(properties);

level_zero/tools/source/metrics/metric_oa_enumeration_imp.h

@@ -164,6 +164,8 @@ struct OaMetricImp : Metric {
 
     ze_result_t initialize(const zet_metric_properties_t &sourceProperties);
 
+    static Metric *create(zet_metric_properties_t &properties);
+
   protected:
     void copyProperties(const zet_metric_properties_t &source,
                         zet_metric_properties_t &destination);

level_zero/tools/source/metrics/metric_oa_source.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/metrics/metric_oa_source.h"
+
+#include "shared/source/os_interface/os_library.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_oa_enumeration_imp.h"
+#include "level_zero/tools/source/metrics/metric_oa_query_imp.h"
+
+namespace L0 {
+
+OaMetricSourceImp::OsLibraryLoadPtr OaMetricSourceImp::osLibraryLoadFunction(NEO::OsLibrary::load);
+
+std::unique_ptr<OaMetricSourceImp> OaMetricSourceImp::create(const MetricDeviceContext &metricDeviceContext) {
+    return std::unique_ptr<OaMetricSourceImp>(new (std::nothrow) OaMetricSourceImp(metricDeviceContext));
+}
+
+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))) {
+}
+
+OaMetricSourceImp::~OaMetricSourceImp() = default;
+
+void OaMetricSourceImp::enable() {
+    loadDependencies();
+}
+
+bool OaMetricSourceImp::isAvailable() {
+    return isInitialized();
+}
+
+ze_result_t OaMetricSourceImp::appendMetricMemoryBarrier(CommandList &commandList) {
+    DeviceImp *pDeviceImp = static_cast<DeviceImp *>(commandList.device);
+
+    if (pDeviceImp->metricContext->isImplicitScalingCapable()) {
+        // Use one of the sub-device contexts to append to command list.
+        pDeviceImp = static_cast<DeviceImp *>(pDeviceImp->subDevices[0]);
+    }
+
+    auto &metricContext = pDeviceImp->getMetricDeviceContext();
+    auto &metricsLibrary = metricContext.getMetricSource<OaMetricSourceImp>().getMetricsLibrary();
+
+    // Obtain gpu commands.
+    CommandBufferData_1_0 commandBuffer = {};
+    commandBuffer.CommandsType = MetricsLibraryApi::ObjectType::OverrideFlushCaches;
+    commandBuffer.Override.Enable = true;
+    commandBuffer.Type = metricContext.getMetricSource<OaMetricSourceImp>().isComputeUsed()
+                             ? MetricsLibraryApi::GpuCommandBufferType::Compute
+                             : MetricsLibraryApi::GpuCommandBufferType::Render;
+
+    return metricsLibrary.getGpuCommands(commandList, commandBuffer) ? ZE_RESULT_SUCCESS
+                                                                     : ZE_RESULT_ERROR_UNKNOWN;
+}
+
+bool OaMetricSourceImp::loadDependencies() {
+    bool result = true;
+    if (metricEnumeration->loadMetricsDiscovery() != ZE_RESULT_SUCCESS) {
+        result = false;
+        DEBUG_BREAK_IF(!result);
+    }
+    if (result && !metricsLibrary->load()) {
+        result = false;
+        DEBUG_BREAK_IF(!result);
+    }
+
+    // Set metric context initialization state.
+    setInitializationState(result
+                               ? ZE_RESULT_SUCCESS
+                               : ZE_RESULT_ERROR_UNKNOWN);
+
+    return result;
+}
+bool OaMetricSourceImp::isInitialized() {
+    return initializationState == ZE_RESULT_SUCCESS;
+}
+
+void OaMetricSourceImp::setInitializationState(const ze_result_t state) {
+    initializationState = state;
+}
+
+Device &OaMetricSourceImp::getDevice() {
+    return metricDeviceContext.getDevice();
+}
+
+MetricsLibrary &OaMetricSourceImp::getMetricsLibrary() {
+    return *metricsLibrary;
+}
+MetricEnumeration &OaMetricSourceImp::getMetricEnumeration() {
+    return *metricEnumeration;
+}
+MetricStreamer *OaMetricSourceImp::getMetricStreamer() {
+    return pMetricStreamer;
+}
+
+void OaMetricSourceImp::setMetricStreamer(MetricStreamer *pMetricStreamer) {
+    this->pMetricStreamer = pMetricStreamer;
+}
+
+void OaMetricSourceImp::setMetricsLibrary(MetricsLibrary &metricsLibrary) {
+    this->metricsLibrary.release();
+    this->metricsLibrary.reset(&metricsLibrary);
+}
+
+void OaMetricSourceImp::setMetricEnumeration(MetricEnumeration &metricEnumeration) {
+    this->metricEnumeration.release();
+    this->metricEnumeration.reset(&metricEnumeration);
+}
+
+void OaMetricSourceImp::setUseCompute(const bool useCompute) {
+    this->useCompute = useCompute;
+}
+
+bool OaMetricSourceImp::isComputeUsed() const {
+    return useCompute;
+}
+
+ze_result_t OaMetricSourceImp::metricGroupGet(uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups) {
+    return getMetricEnumeration().metricGroupGet(*pCount, phMetricGroups);
+}
+
+uint32_t OaMetricSourceImp::getSubDeviceIndex() {
+    return metricDeviceContext.getSubDeviceIndex();
+}
+
+bool OaMetricSourceImp::isMetricGroupActivated(const zet_metric_group_handle_t hMetricGroup) const {
+    return metricDeviceContext.isMetricGroupActivated(hMetricGroup);
+}
+
+bool OaMetricSourceImp::isMetricGroupActivated() const {
+    return metricDeviceContext.isMetricGroupActivated();
+}
+
+bool OaMetricSourceImp::isImplicitScalingCapable() const {
+    return metricDeviceContext.isImplicitScalingCapable();
+}
+
+template <>
+OaMetricSourceImp &MetricDeviceContext::getMetricSource<OaMetricSourceImp>() const {
+    return static_cast<OaMetricSourceImp &>(*metricSources.at(MetricSource::SourceType::Oa));
+}
+
+} // namespace L0

level_zero/tools/source/metrics/metric_oa_source.h

@@ -60,7 +60,6 @@ class OaMetricSourceImp : public MetricSource {
     std::unique_ptr<MetricsLibrary> metricsLibrary = nullptr;
     MetricStreamer *pMetricStreamer = nullptr;
     bool useCompute = false;
-    bool available = false;
 };
 
 template <>

level_zero/tools/source/metrics/os_metric_ip_sampling.h

@@ -5,6 +5,8 @@
  *
  */
 
+#pragma once
+
 #include <level_zero/zet_api.h>
 
 #include <memory>