Metrics IP Sampling Add Support for Streamer APIs

This Patch adds support for collecting IP Metrics using
StreamerOpen, StreamerClose and StreamerReadData

Related-To: LOCI-2755
Related-To: LOCI-2756

Signed-off-by: Joshua Santosh Ranjan <[email protected]>

Author: joshuaranjan

level_zero/tools/source/metrics/CMakeLists.txt

@@ -20,6 +20,8 @@ list(APPEND L0_SRCS_TOOLS_METRICS
      ${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
+     ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.h
+     ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_streamer.cpp
 )
 
 if(UNIX)

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

@@ -81,7 +81,17 @@ ze_result_t MetricIpSamplingLinuxImp::startMeasurement(uint32_t &notifyEveryNRep
     auto ioctlHelper = drm->getIoctlHelper();
     uint32_t euStallFdParameter = ioctlHelper->getEuStallFdParameter();
     std::array<uint64_t, 10u> properties;
-    if (!ioctlHelper->getEuStallProperties(properties, maxDssBufferSize, samplingUnit, defaultPollPeriodNs, deviceImp.getPhysicalSubDeviceId())) {
+    auto engineInfo = drm->getEngineInfo();
+    if (engineInfo == nullptr) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    auto classInstance = engineInfo->getEngineInstance(deviceImp.getPhysicalSubDeviceId(), aub_stream::ENGINE_CCS);
+    if (classInstance == nullptr) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    if (!ioctlHelper->getEuStallProperties(properties, maxDssBufferSize, samplingUnit, defaultPollPeriodNs,
+                                           classInstance->engineInstance)) {
         return ZE_RESULT_ERROR_UNKNOWN;
     }
 
@@ -107,18 +117,22 @@ ze_result_t MetricIpSamplingLinuxImp::startMeasurement(uint32_t &notifyEveryNRep
 
 ze_result_t MetricIpSamplingLinuxImp::stopMeasurement() {
 
-    int32_t ret = NEO::SysCalls::close(stream);
-    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (ret < 0), stderr, "close() failed errno = %d | ret = %d \n",
-                       errno, ret);
+    int32_t disableStatus = NEO::SysCalls::ioctl(stream, I915_PERF_IOCTL_DISABLE, 0);
+    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (disableStatus < 0), stderr,
+                       "I915_PERF_IOCTL_DISABLE failed errno = %d | ret = %d \n", errno, disableStatus);
+
+    int32_t closeStatus = NEO::SysCalls::close(stream);
+    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (closeStatus < 0), stderr,
+                       "close() failed errno = %d | ret = %d \n", errno, closeStatus);
     stream = -1;
 
-    return (ret == 0) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
+    return ((closeStatus == 0) && (disableStatus == 0)) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
 }
 
 ze_result_t MetricIpSamplingLinuxImp::readData(uint8_t *pRawData, size_t *pRawDataSize) {
 
-    ssize_t ret = NEO::SysCalls::pread(stream, pRawData, *pRawDataSize, 0u);
-    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (ret < 0), stderr, "pread() failed errno = %d | ret = %d \n",
+    ssize_t ret = NEO::SysCalls::read(stream, pRawData, *pRawDataSize);
+    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (ret < 0), stderr, "read() failed errno = %d | ret = %d \n",
                        errno, ret);
 
     if (ret >= 0) {
@@ -127,6 +141,12 @@ ze_result_t MetricIpSamplingLinuxImp::readData(uint8_t *pRawData, size_t *pRawDa
     }
 
     *pRawDataSize = 0;
+
+    // If read needs to try again, do not return error
+    if (errno == EINTR || errno == EAGAIN || errno == EBUSY) {
+        return ZE_RESULT_SUCCESS;
+    }
+
     return ZE_RESULT_ERROR_UNKNOWN;
 }
 

level_zero/tools/source/metrics/metric_ip_sampling_source.cpp

@@ -160,25 +160,17 @@ ze_result_t IpSamplingMetricGroupImp::calculateMetricValuesExp(const zet_metric_
 }
 
 bool IpSamplingMetricGroupImp::activate() {
-    return false;
+    // There is no hardware specific activation, since metric collection starts in streamer open
+    return true;
 }
 
 bool IpSamplingMetricGroupImp::deactivate() {
-    return false;
+    return true;
 }
 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,

level_zero/tools/source/metrics/metric_ip_sampling_source.h

@@ -14,6 +14,7 @@ namespace L0 {
 
 struct IpSamplingMetricImp;
 struct IpSamplingMetricGroupImp;
+struct IpSamplingMetricStreamerImp;
 
 class IpSamplingMetricSourceImp : public MetricSource {
 
@@ -26,10 +27,13 @@ class IpSamplingMetricSourceImp : public MetricSource {
     ze_result_t appendMetricMemoryBarrier(CommandList &commandList) override;
     void setMetricOsInterface(std::unique_ptr<MetricIpSamplingOsInterface> &metricOsInterface);
     static std::unique_ptr<IpSamplingMetricSourceImp> create(const MetricDeviceContext &metricDeviceContext);
+    MetricIpSamplingOsInterface *getMetricOsInterface() { return metricOsInterface.get(); }
+    IpSamplingMetricStreamerImp *pActiveStreamer = nullptr;
 
   protected:
     void cacheMetricGroup();
     bool isEnabled = false;
+
     const MetricDeviceContext &metricDeviceContext;
     std::unique_ptr<MetricIpSamplingOsInterface> metricOsInterface = nullptr;
     std::unique_ptr<IpSamplingMetricGroupImp> cachedMetricGroup = nullptr;

level_zero/tools/source/metrics/metric_ip_sampling_streamer.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/metrics/metric_ip_sampling_streamer.h"
+
+#include "level_zero/tools/source/metrics/metric.h"
+#include "level_zero/tools/source/metrics/metric_ip_sampling_source.h"
+#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+#include <level_zero/zet_api.h>
+
+namespace L0 {
+
+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) {
+
+    auto device = Device::fromHandle(hDevice);
+
+    // Check whether metric group is activated.
+    if (!device->getMetricDeviceContext().isMetricGroupActivated(this->toHandle())) {
+        return ZE_RESULT_NOT_READY;
+    }
+
+    auto &metricSource = device->getMetricDeviceContext().getMetricSource<IpSamplingMetricSourceImp>();
+    // Check whether metric streamer is already open.
+    if (metricSource.pActiveStreamer != nullptr) {
+        return ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE;
+    }
+
+    auto pStreamerImp = new IpSamplingMetricStreamerImp(metricSource);
+    UNRECOVERABLE_IF(pStreamerImp == nullptr);
+
+    const ze_result_t result = metricSource.getMetricOsInterface()->startMeasurement(desc->notifyEveryNReports, desc->samplingPeriod);
+    if (result == ZE_RESULT_SUCCESS) {
+        metricSource.pActiveStreamer = pStreamerImp;
+        pStreamerImp->attachEvent(hNotificationEvent);
+    } else {
+        delete pStreamerImp;
+        pStreamerImp = nullptr;
+        return result;
+    }
+
+    *phMetricStreamer = pStreamerImp->toHandle();
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t IpSamplingMetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) {
+
+    // Return required size if requested.
+    if (*pRawDataSize == 0) {
+        *pRawDataSize = ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(maxReportCount);
+        return ZE_RESULT_SUCCESS;
+    }
+
+    // If there is a difference in pRawDataSize and maxReportCount, use the minimum value for reading.
+    if (maxReportCount != UINT32_MAX) {
+        size_t maxSizeRequired = ipSamplingSource.getMetricOsInterface()->getRequiredBufferSize(maxReportCount);
+        *pRawDataSize = std::min(maxSizeRequired, *pRawDataSize);
+    }
+
+    return ipSamplingSource.getMetricOsInterface()->readData(pRawData, pRawDataSize);
+}
+
+ze_result_t IpSamplingMetricStreamerImp::close() {
+
+    const ze_result_t result = ipSamplingSource.getMetricOsInterface()->stopMeasurement();
+    detachEvent();
+    ipSamplingSource.pActiveStreamer = nullptr;
+    delete this;
+
+    return result;
+}
+
+Event::State IpSamplingMetricStreamerImp::getNotificationState() {
+
+    return ipSamplingSource.getMetricOsInterface()->isNReportsAvailable()
+               ? Event::State::STATE_SIGNALED
+               : Event::State::STATE_INITIAL;
+}
+
+ze_result_t IpSamplingMetricStreamerImp::appendStreamerMarker(CommandList &commandList, uint32_t value) {
+
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+void IpSamplingMetricStreamerImp::attachEvent(ze_event_handle_t hNotificationEvent) {
+    // Associate notification event with metric streamer.
+    pNotificationEvent = Event::fromHandle(hNotificationEvent);
+    if (pNotificationEvent != nullptr) {
+        pNotificationEvent->metricStreamer = this;
+    }
+}
+
+void IpSamplingMetricStreamerImp::detachEvent() {
+    // Release notification event.
+    if (pNotificationEvent != nullptr) {
+        pNotificationEvent->metricStreamer = nullptr;
+    }
+}
+
+} // namespace L0

level_zero/tools/source/metrics/metric_ip_sampling_streamer.h

@@ -0,0 +1,33 @@
+/*
+ * 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 {
+
+class IpSamplingMetricSourceImp;
+
+struct IpSamplingMetricStreamerImp : MetricStreamer {
+
+    IpSamplingMetricStreamerImp(IpSamplingMetricSourceImp &ipSamplingSource) : ipSamplingSource(ipSamplingSource) {}
+    ~IpSamplingMetricStreamerImp() override{};
+    ze_result_t readData(uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData) override;
+    ze_result_t close() override;
+    Event::State getNotificationState() override;
+    ze_result_t appendStreamerMarker(CommandList &commandList, uint32_t value) override;
+    void attachEvent(ze_event_handle_t hNotificationEvent);
+    void detachEvent();
+
+  protected:
+    Event *pNotificationEvent = nullptr;
+    IpSamplingMetricSourceImp &ipSamplingSource;
+};
+
+} // namespace L0

level_zero/tools/test/unit_tests/sources/metrics/CMakeLists.txt

@@ -20,6 +20,9 @@ target_sources(${TARGET_NAME} PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_streamer_3.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_initialization.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_enumeration.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_fixture.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/metric_ip_sampling_fixture.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_streamer.cpp
 
 )