feature(sysman): Added support for Performance APIs

Added support for the Performance APIs in the new sysman design.
Added ULTs for the Performance APIs in the new sysman design.
In the black box test for performance, the API to compute the number
of sub devices has been changed in order to get the sub device count
regardless of the sysman initialization using zeInit or zesInit.

Related-To: LOCI-4294

Signed-off-by: Bari, Pratik <[email protected]>

Author: pratikbariintel

level_zero/api/sysman/zes_handles_struct.h

@@ -50,4 +50,7 @@ struct _zes_standby_handle_t {
 
 struct _zes_temp_handle_t {
     virtual ~_zes_temp_handle_t() = default;
-};
+};
+struct _zes_perf_handle_t {
+    virtual ~_zes_perf_handle_t() = default;
+};

level_zero/api/sysman/zes_sysman_api_entrypoints.h

@@ -954,25 +954,41 @@ ze_result_t zesDeviceEnumPerformanceFactorDomains(
     zes_device_handle_t hDevice,
     uint32_t *pCount,
     zes_perf_handle_t *phPerf) {
-    return L0::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    if (L0::sysmanInitFromCore) {
+        return L0::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    } else {
+        return L0::Sysman::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    }
 }
 
 ze_result_t zesPerformanceFactorGetProperties(
     zes_perf_handle_t hPerf,
     zes_perf_properties_t *pProperties) {
-    return L0::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    }
 }
 
 ze_result_t zesPerformanceFactorGetConfig(
     zes_perf_handle_t hPerf,
     double *pFactor) {
-    return L0::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    }
 }
 
 ze_result_t zesPerformanceFactorSetConfig(
     zes_perf_handle_t hPerf,
     double factor) {
-    return L0::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    }
 }
 
 ze_result_t zesDeviceEccAvailable(

level_zero/sysman/source/performance/CMakeLists.txt

@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${L0_STATIC_LIB_NAME}
+               PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance_imp.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance_imp.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/os_performance.h
+)
+
+add_subdirectories()

level_zero/sysman/source/performance/linux/CMakeLists.txt

@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  )
+
+  if(NEO_ENABLE_i915_PRELIM_DETECTION)
+    target_sources(${L0_STATIC_LIB_NAME}
+                   PRIVATE
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp_prelim.cpp
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp_prelim.h
+    )
+  else()
+    target_sources(${L0_STATIC_LIB_NAME}
+                   PRIVATE
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.cpp
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.h
+    )
+  endif()
+endif()

level_zero/sysman/source/performance/linux/os_performance_imp.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/linux/os_performance_imp.h"
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetProperties(zes_perf_properties_t &pProperties) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetConfig(double *pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceSetConfig(double pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool LinuxPerformanceImp::isPerformanceSupported(void) {
+    return false;
+}
+
+OsPerformance *OsPerformance::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain) {
+    LinuxPerformanceImp *pLinuxPerformanceImp = new LinuxPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain);
+    return static_cast<OsPerformance *>(pLinuxPerformanceImp);
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/linux/os_performance_imp.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/linux/os_sysman_imp.h"
+#include "level_zero/sysman/source/performance/os_performance.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+class LinuxPerformanceImp : public OsPerformance, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t osPerformanceGetProperties(zes_perf_properties_t &pProperties) override;
+    ze_result_t osPerformanceGetConfig(double *pFactor) override;
+    ze_result_t osPerformanceSetConfig(double pFactor) override;
+
+    bool isPerformanceSupported(void) override;
+
+    LinuxPerformanceImp() = delete;
+    LinuxPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                        zes_engine_type_flag_t domain) {}
+    ~LinuxPerformanceImp() override = default;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/linux/os_performance_imp_prelim.cpp

@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/linux/os_performance_imp_prelim.h"
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/device/device.h"
+#include "shared/source/helpers/hw_info.h"
+
+#include "level_zero/sysman/source/sysman_const.h"
+
+#include <cmath>
+
+namespace L0 {
+namespace Sysman {
+
+const std::string LinuxPerformanceImp::sysPwrBalance("sys_pwr_balance");
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetProperties(zes_perf_properties_t &pProperties) {
+    pProperties.onSubdevice = isSubdevice;
+    pProperties.subdeviceId = subdeviceId;
+    pProperties.engines = domain;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::getBaseScaleFactor() {
+    auto result = pSysfsAccess->read(baseScale, baseScaleReading);
+    if (ZE_RESULT_SUCCESS != result) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, baseScale.c_str(), getErrorCode(result));
+        return getErrorCode(result);
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::getMediaScaleFactor() {
+    auto result = pSysfsAccess->read(mediaScale, mediaScaleReading);
+    if (ZE_RESULT_SUCCESS != result) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, mediaScale.c_str(), getErrorCode(result));
+        return getErrorCode(result);
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetConfig(double *pFactor) {
+    ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    double baseFactorReading = 0;
+    double mediaFactorReading = 0;
+    double sysPwrBalanceReading = 0;
+    double multiplier = 0;
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        result = pSysfsAccess->read(sysPwrBalance, sysPwrBalanceReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, sysPwrBalance.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        if (sysPwrBalanceReading >= 0 && sysPwrBalanceReading <= 16.0) {
+            *pFactor = 50.0 + std::round((16.0 - sysPwrBalanceReading) * 50.0 / 16.0);
+        } else if (sysPwrBalanceReading > 16.0 && sysPwrBalanceReading <= 63.0) {
+            *pFactor = std::round((63.0 - sysPwrBalanceReading) * 50.0 / (63.0 - 16.0));
+        } else {
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        result = pSysfsAccess->read(mediaFreqFactor, mediaFactorReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, mediaFreqFactor.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        multiplier = (mediaFactorReading * mediaScaleReading); // Value retrieved from media_freq_factor file is in U(fixed point decimal) format convert it into decimal by multiplication with scale factor
+        if (multiplier == 1) {
+            *pFactor = maxPerformanceFactor;
+        } else if (multiplier == 0.5) {
+            *pFactor = halfOfMaxPerformanceFactor;
+        } else if (multiplier == 0) {
+            *pFactor = minPerformanceFactor;
+        } else {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): multiplier for MEDIA is not matching with given presets and returning UNKNOWN ERROR \n", __FUNCTION__);
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        result = pSysfsAccess->read(baseFreqFactor, baseFactorReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, baseFreqFactor.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        multiplier = (baseFactorReading * baseScaleReading); // Value retrieved from base_freq_factor file is in U(fixed point decimal) format convert it into decimal by multiplication with scale factor
+        if (multiplier >= 0.5 && multiplier <= 1) {
+            *pFactor = (1 - multiplier) * 100 + 50;
+        } else if (multiplier > 1 && multiplier <= 2) {
+            *pFactor = (2 - multiplier) * 50;
+        } else {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): multiplier for COMPUTE is not matching with given presets and returning UNKNOWN ERROR\n", __FUNCTION__);
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    default:
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        break;
+    }
+    return result;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceSetConfig(double pFactor) {
+    double multiplier = 0;
+    ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    if (pFactor < minPerformanceFactor || pFactor > maxPerformanceFactor) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        if (pFactor <= halfOfMaxPerformanceFactor) {
+            multiplier = 63.0 - std::round(pFactor * (47.0) / 50.0); // multiplier = 63 - ROUND(pFactor * (63.0 - 16.0) / 50.0)
+        } else {
+            multiplier = 16.0 - std::round((pFactor - 50.0) * 16.0 / 50.0);
+        }
+        result = pSysfsAccess->write(sysPwrBalance, multiplier);
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        if (productFamily == IGFX_PVC) {
+            if (pFactor > halfOfMaxPerformanceFactor) {
+                multiplier = 1;
+            } else {
+                multiplier = 0.5;
+            }
+        } else {
+            if (pFactor > halfOfMaxPerformanceFactor) {
+                multiplier = 1;
+            } else if (pFactor > minPerformanceFactor) {
+                multiplier = 0.5;
+            } else {
+                multiplier = 0; // dynamic control mode is not supported on PVC
+            }
+        }
+        multiplier = multiplier / mediaScaleReading; // Divide by scale factor and then round off to convert from decimal to U format
+        multiplier = std::round(multiplier);
+        result = pSysfsAccess->write(mediaFreqFactor, multiplier);
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        if (pFactor < halfOfMaxPerformanceFactor) {
+            multiplier = 2 - (pFactor / 50.0);
+        } else {
+            multiplier = 1 - ((pFactor - 50) / 100.0);
+        }
+        multiplier = multiplier / baseScaleReading; // Divide by scale factor and then round off to convert from decimal to U format
+        multiplier = std::round(multiplier);
+        result = pSysfsAccess->write(baseFreqFactor, multiplier);
+        break;
+    default:
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        break;
+    }
+
+    return result;
+}
+
+bool LinuxPerformanceImp::isPerformanceSupported(void) {
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        if (pSysfsAccess->canRead(sysPwrBalance) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_OTHER returns false \n", __FUNCTION__);
+            return false;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        if (pSysfsAccess->canRead(mediaFreqFactor) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_MEDIA returns false \n", __FUNCTION__);
+            return false;
+        }
+        if (getMediaScaleFactor() != ZE_RESULT_SUCCESS) {
+            return false;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        if (pSysfsAccess->canRead(baseFreqFactor) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_COMPUTE returns false \n", __FUNCTION__);
+            return false;
+        }
+        if (getBaseScaleFactor() != ZE_RESULT_SUCCESS) {
+            return false;
+        }
+        break;
+    default:
+        return false;
+        break;
+    }
+    return true;
+}
+
+void LinuxPerformanceImp::init() {
+    const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
+    baseFreqFactor = baseDir + "base_freq_factor";
+    mediaFreqFactor = baseDir + "media_freq_factor";
+    baseScale = baseDir + "base_freq_factor.scale";
+    mediaScale = baseDir + "media_freq_factor.scale";
+}
+
+LinuxPerformanceImp::LinuxPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                                         zes_engine_type_flag_t domain) : domain(domain), subdeviceId(subdeviceId), isSubdevice(onSubdevice) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
+    productFamily = pLinuxSysmanImp->getProductFamily();
+    init();
+}
+
+OsPerformance *OsPerformance::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain) {
+    LinuxPerformanceImp *pLinuxPerformanceImp = new LinuxPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain);
+    return static_cast<OsPerformance *>(pLinuxPerformanceImp);
+}
+
+} // namespace Sysman
+} // namespace L0