Metrics Add Os specific implementation Structure for IP Sampling

This patch adds OS specific implementation for IP Sampling.
Implementation for linux is provided as part of this patch.

Related-To: LOCI-2787

--- master-files
level_zero/tools/source/metrics/linux/os_metric_ip_sampling_imp_linux.cpp
level_zero/tools/source/metrics/os_metric_ip_sampling.h
level_zero/tools/source/metrics/windows/os_metric_ip_sampling_imp_windows.cpp
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux_prelim.cpp
level_zero/tools/test/unit_tests/sources/metrics/linux/test_metric_ip_sampling_linux_upstream.cpp
level_zero/tools/test/unit_tests/sources/metrics/windows/test_metric_ip_sampling_windows.cpp
--- master-files

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

Author: joshuaranjan

level_zero/core/source/device/device_imp.cpp

@@ -1184,4 +1184,16 @@ NEO::Device *DeviceImp::getActiveDevice() const {
     return this->neoDevice;
 }
 
+uint32_t DeviceImp::getPhysicalSubDeviceId() {
+    if (!neoDevice->isSubDevice()) {
+        uint32_t deviceBitField = static_cast<uint32_t>(neoDevice->getDeviceBitfield().to_ulong());
+        if (neoDevice->getDeviceBitfield().count() > 1) {
+            // Clear all set bits other than the right most bit
+            deviceBitField &= ~deviceBitField + 1;
+        }
+        return Math::log2(deviceBitField);
+    }
+    return static_cast<NEO::SubDevice *>(neoDevice)->getSubDeviceIndex();
+}
+
 } // namespace L0

level_zero/core/source/device/device_imp.h

@@ -100,6 +100,7 @@ struct DeviceImp : public Device {
 
     bool toPhysicalSliceId(const NEO::TopologyMap &topologyMap, uint32_t &slice, uint32_t &subslice, uint32_t &deviceIndex);
     bool toApiSliceId(const NEO::TopologyMap &topologyMap, uint32_t &slice, uint32_t &subslice, uint32_t deviceIndex);
+    uint32_t getPhysicalSubDeviceId();
 
     bool isSubdevice = false;
     void *execEnvironment = nullptr;

level_zero/tools/source/metrics/CMakeLists.txt

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

level_zero/tools/source/metrics/linux/CMakeLists.txt

@@ -8,6 +8,7 @@ set(L0_SRCS_TOOLS_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_oa_query_imp_linux.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_oa_enumeration_imp_linux.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling_imp_linux.cpp
 )
 
 if(UNIX)

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

@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/helpers/constants.h"
+#include "shared/source/os_interface/linux/drm_neo.h"
+#include "shared/source/os_interface/linux/ioctl_helper.h"
+#include "shared/source/os_interface/linux/sys_calls.h"
+#include "shared/source/os_interface/os_interface.h"
+#include "shared/source/xe_hpc_core/hw_cmds_base.h"
+
+#include "level_zero/core/source/device/device.h"
+#include "level_zero/core/source/device/device_imp.h"
+#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+
+#include <algorithm>
+
+namespace L0 {
+
+constexpr uint32_t maxDssBufferSize = 512 * KB;
+constexpr uint32_t defaultPollPeriodNs = 10000000u;
+constexpr uint32_t unitReportSize = 64u;
+
+class MetricIpSamplingLinuxImp : public MetricIpSamplingOsInterface {
+  public:
+    MetricIpSamplingLinuxImp(Device &device);
+    ~MetricIpSamplingLinuxImp() override = default;
+    ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override;
+    ze_result_t stopMeasurement() override;
+    ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override;
+    uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override;
+    uint32_t getUnitReportSize() override;
+    bool isNReportsAvailable() override;
+    bool isDependencyAvailable() override;
+
+  private:
+    int32_t stream = -1;
+    Device &device;
+
+    ze_result_t getNearestSupportedSamplingUnit(uint32_t &samplingPeriodNs, uint32_t &samplingRate);
+};
+
+MetricIpSamplingLinuxImp::MetricIpSamplingLinuxImp(Device &device) : device(device) {}
+
+ze_result_t MetricIpSamplingLinuxImp::getNearestSupportedSamplingUnit(uint32_t &samplingPeriodNs, uint32_t &samplingUnit) {
+
+    static constexpr uint64_t nsecPerSec = 1000000000ull;
+    static constexpr uint32_t samplingClockGranularity = 251u;
+    static constexpr uint32_t minSamplingUnit = 1u;
+    static constexpr uint32_t maxSamplingUnit = 7u;
+    const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+    int32_t gpuTimeStampfrequency = 0;
+    int32_t ret = drm->getTimestampFrequency(gpuTimeStampfrequency);
+    if (ret < 0) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    uint64_t gpuClockPeriodNs = nsecPerSec / static_cast<uint64_t>(gpuTimeStampfrequency);
+    uint64_t numberOfClocks = samplingPeriodNs / gpuClockPeriodNs;
+
+    samplingUnit = std::clamp(static_cast<uint32_t>(numberOfClocks / samplingClockGranularity), minSamplingUnit, maxSamplingUnit);
+    samplingPeriodNs = samplingUnit * samplingClockGranularity * static_cast<uint32_t>(gpuClockPeriodNs);
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t MetricIpSamplingLinuxImp::startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) {
+
+    const auto drm = device.getOsInterface().getDriverModel()->as<NEO::Drm>();
+
+    uint32_t samplingUnit = 0;
+    if (getNearestSupportedSamplingUnit(samplingPeriodNs, samplingUnit) != ZE_RESULT_SUCCESS) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    DeviceImp &deviceImp = static_cast<DeviceImp &>(device);
+
+    auto ioctlHelper = drm->getIoctlHelper();
+    uint32_t euStallFdParameter = ioctlHelper->getEuStallFdParameter();
+    std::array<uint64_t, 10u> properties;
+    if (!ioctlHelper->getEuStallProperties(properties, maxDssBufferSize, samplingUnit, defaultPollPeriodNs, deviceImp.getPhysicalSubDeviceId())) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    struct drm_i915_perf_open_param param = {
+        .flags = I915_PERF_FLAG_FD_CLOEXEC |
+                 euStallFdParameter |
+                 I915_PERF_FLAG_FD_NONBLOCK,
+        .num_properties = sizeof(properties) / 16,
+        .properties_ptr = reinterpret_cast<uintptr_t>(properties.data()),
+    };
+
+    stream = drm->ioctl(DRM_IOCTL_I915_PERF_OPEN, &param);
+    if (stream < 0) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    int32_t ret = NEO::SysCalls::ioctl(stream, I915_PERF_IOCTL_ENABLE, 0);
+    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (ret < 0), stderr,
+                       "PRELIM_I915_PERF_IOCTL_ENABLE failed errno = %d | ret = %d \n", errno, ret);
+
+    return (ret == 0) ? ZE_RESULT_SUCCESS : ZE_RESULT_ERROR_UNKNOWN;
+}
+
+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);
+    stream = -1;
+
+    return (ret == 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",
+                       errno, ret);
+
+    if (ret >= 0) {
+        *pRawDataSize = ret;
+        return ZE_RESULT_SUCCESS;
+    }
+
+    *pRawDataSize = 0;
+    return ZE_RESULT_ERROR_UNKNOWN;
+}
+
+uint32_t MetricIpSamplingLinuxImp::getRequiredBufferSize(const uint32_t maxReportCount) {
+
+    uint32_t requiredBufferSize = getUnitReportSize() * maxReportCount;
+    const auto hwInfo = device.getNEODevice()->getHardwareInfo();
+    return std::min(requiredBufferSize, maxDssBufferSize * hwInfo.gtSystemInfo.MaxDualSubSlicesSupported);
+}
+
+uint32_t MetricIpSamplingLinuxImp::getUnitReportSize() {
+    return unitReportSize;
+}
+
+bool MetricIpSamplingLinuxImp::isNReportsAvailable() {
+    struct pollfd pollParams;
+    memset(&pollParams, 0, sizeof(pollParams));
+
+    DEBUG_BREAK_IF(stream == -1);
+
+    pollParams.fd = stream;
+    pollParams.revents = 0;
+    pollParams.events = POLLIN;
+
+    int32_t pollResult = NEO::SysCalls::poll(&pollParams, 1, 0u);
+    PRINT_DEBUG_STRING(NEO::DebugManager.flags.PrintDebugMessages.get() && (pollResult < 0), stderr, "poll() failed errno = %d | pollResult = %d \n",
+                       errno, pollResult);
+
+    if (pollResult > 0) {
+        return true;
+    }
+    return false;
+}
+
+bool MetricIpSamplingLinuxImp::isDependencyAvailable() {
+
+    auto hwInfo = device.getNEODevice()->getHardwareInfo();
+    auto isSupportedDevice = false;
+
+    if (hwInfo.platform.eProductFamily == IGFX_PVC) {
+        if (hwInfo.platform.usDeviceID == NEO::XE_HPC_CORE::pvcXtDeviceIds[0] ||
+            hwInfo.platform.usDeviceID == NEO::XE_HPC_CORE::pvcXtDeviceIds[1] ||
+            hwInfo.platform.usDeviceID == NEO::XE_HPC_CORE::pvcXtDeviceIds[2] ||
+            hwInfo.platform.usDeviceID == NEO::XE_HPC_CORE::pvcXtDeviceIds[3] ||
+            hwInfo.platform.usDeviceID == NEO::XE_HPC_CORE::pvcXtDeviceIds[4]) {
+            isSupportedDevice = true;
+        }
+    }
+
+    if (!isSupportedDevice) {
+        return false;
+    }
+
+    uint32_t notifyEveryNReports = 1u;
+    uint32_t samplingPeriod = 100;
+
+    ze_result_t status = startMeasurement(notifyEveryNReports, samplingPeriod);
+    if (stream != -1) {
+        stopMeasurement();
+    }
+    return status == ZE_RESULT_SUCCESS ? true : false;
+}
+
+std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {
+    return std::make_unique<MetricIpSamplingLinuxImp>(device);
+}
+
+} // namespace L0

level_zero/tools/source/metrics/os_metric_ip_sampling.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include <level_zero/zet_api.h>
+
+#include <memory>
+
+namespace L0 {
+
+struct Device;
+
+class MetricIpSamplingOsInterface {
+  public:
+    virtual ~MetricIpSamplingOsInterface() = default;
+    virtual ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) = 0;
+    virtual ze_result_t stopMeasurement() = 0;
+    virtual ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) = 0;
+    virtual uint32_t getRequiredBufferSize(const uint32_t maxReportCount) = 0;
+    virtual uint32_t getUnitReportSize() = 0;
+    virtual bool isNReportsAvailable() = 0;
+    virtual bool isDependencyAvailable() = 0;
+    static std::unique_ptr<MetricIpSamplingOsInterface> create(Device &device);
+};
+
+} // namespace L0

level_zero/tools/source/metrics/windows/CMakeLists.txt

@@ -8,6 +8,7 @@ set(L0_SRCS_TOOLS_WINDOWS
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_oa_query_imp_windows.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_oa_enumeration_imp_windows.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_metric_ip_sampling_imp_windows.cpp
 )
 
 if(WIN32)

level_zero/tools/source/metrics/windows/os_metric_ip_sampling_imp_windows.cpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/device/device.h"
+#include "level_zero/tools/source/metrics/os_metric_ip_sampling.h"
+
+namespace L0 {
+
+class MetricIpSamplingWindowsImp : public MetricIpSamplingOsInterface {
+  public:
+    MetricIpSamplingWindowsImp() {}
+    ze_result_t startMeasurement(uint32_t &notifyEveryNReports, uint32_t &samplingPeriodNs) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    ze_result_t stopMeasurement() override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    ze_result_t readData(uint8_t *pRawData, size_t *pRawDataSize) override {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+    uint32_t getRequiredBufferSize(const uint32_t maxReportCount) override {
+        return 0u;
+    }
+    uint32_t getUnitReportSize() override {
+        return 0u;
+    }
+    bool isNReportsAvailable() override {
+        return false;
+    }
+    bool isDependencyAvailable() override {
+        return false;
+    }
+};
+
+std::unique_ptr<MetricIpSamplingOsInterface> MetricIpSamplingOsInterface::create(Device &device) {
+    return std::make_unique<MetricIpSamplingWindowsImp>();
+}
+
+} // namespace L0

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

@@ -4,8 +4,25 @@
 # SPDX-License-Identifier: MIT
 #
 
+set(L0_TOOLS_METRICS_LINUX_TESTS_LINUX
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_query_pool_linux.cpp
+)
+
+if(NEO_ENABLE_i915_PRELIM_DETECTION)
+  list(APPEND L0_TOOLS_METRICS_LINUX_TESTS_LINUX
+       ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_linux_prelim.cpp
+  )
+endif()
+
+if("${BRANCH_TYPE}" STREQUAL "")
+  list(APPEND L0_TOOLS_METRICS_LINUX_TESTS_LINUX
+       ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_ip_sampling_linux_upstream.cpp
+  )
+endif()
+
 if(UNIX)
   target_sources(${TARGET_NAME} PRIVATE
-                 ${CMAKE_CURRENT_SOURCE_DIR}/test_metric_oa_query_pool_linux.cpp
+                 ${L0_TOOLS_METRICS_LINUX_TESTS_LINUX}
   )
 endif()