Implement sysman power set/get limit APIs

Change-Id: I35232902cf96d20594adbd128064c362cf154711
Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>

level_zero/tools/source/sysman/power/linux/CMakeLists.txt

@@ -4,10 +4,19 @@
 # SPDX-License-Identifier: MIT
 #
 
-set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
-    ${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.h
-)
+if(SUPPORT_DG1)
+  set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/dg1/os_power_imp.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/dg1/os_power_imp.h
+  )
+else()
+  set(L0_SRCS_TOOLS_SYSMAN_POWER_LINUX
+      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/os_power_imp.h
+  )
+endif()
 
 if(UNIX)
   target_sources(${L0_STATIC_LIB_NAME}

level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.cpp

@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.h"
+
+#include "level_zero/tools/source/sysman/sysman_const.h"
+
+#include "sysman/linux/os_sysman_imp.h"
+
+namespace L0 {
+
+const std::string LinuxPowerImp::hwmonDir("device/hwmon");
+const std::string LinuxPowerImp::i915("i915");
+const std::string LinuxPowerImp::sustainedPowerLimitEnabled("power1_max_enable");
+const std::string LinuxPowerImp::sustainedPowerLimit("power1_max");
+const std::string LinuxPowerImp::sustainedPowerLimitInterval("power1_max_interval");
+const std::string LinuxPowerImp::burstPowerLimitEnabled("power1_cap_enable");
+const std::string LinuxPowerImp::burstPowerLimit("power1_cap");
+const std::string LinuxPowerImp::energyCounterNode("energy1_input");
+
+void powerGetTimestamp(uint64_t &timestamp) {
+    std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
+    timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
+}
+
+ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
+    pProperties->onSubdevice = false;
+    pProperties->subdeviceId = 0;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
+    auto result = pSysfsAccess->read(i915HwmonDir + "/" + energyCounterNode, pEnergy->energy);
+    if (ZE_RESULT_SUCCESS != result) {
+        return getErrorCode(result);
+    }
+    powerGetTimestamp(pEnergy->timestamp);
+    return result;
+}
+
+ze_result_t LinuxPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) {
+    ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
+    uint64_t val = 0;
+    if (pSustained != nullptr) {
+        result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitEnabled, val);
+        if (ZE_RESULT_SUCCESS != result) {
+            return getErrorCode(result);
+        }
+        pSustained->enabled = static_cast<ze_bool_t>(val);
+
+        if (pSustained->enabled) {
+            val = 0;
+            result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimit, val);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+            val /= milliFactor; // Convert microWatts to milliwatts
+            pSustained->power = static_cast<int32_t>(val);
+
+            val = 0;
+            result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitInterval, val);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+            pSustained->interval = static_cast<int32_t>(val);
+        }
+    }
+    if (pBurst != nullptr) {
+        result = pSysfsAccess->read(i915HwmonDir + "/" + burstPowerLimitEnabled, val);
+        if (ZE_RESULT_SUCCESS != result) {
+            return getErrorCode(result);
+        }
+        pBurst->enabled = static_cast<ze_bool_t>(val);
+
+        if (pBurst->enabled) {
+            result = pSysfsAccess->read(i915HwmonDir + "/" + burstPowerLimit, val);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+            val /= milliFactor; // Convert microWatts to milliwatts
+            pBurst->power = static_cast<int32_t>(val);
+        }
+    }
+    if (pPeak != nullptr) {
+        pPeak->powerAC = -1;
+        pPeak->powerDC = -1;
+        result = ZE_RESULT_SUCCESS;
+    }
+    return result;
+}
+
+ze_result_t LinuxPowerImp::setLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) {
+    ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
+    int32_t val = 0;
+    if (pSustained != nullptr) {
+        uint64_t isSustainedPowerLimitEnabled = 0;
+        result = pSysfsAccess->read(i915HwmonDir + "/" + sustainedPowerLimitEnabled, isSustainedPowerLimitEnabled);
+        if (ZE_RESULT_SUCCESS != result) {
+            return getErrorCode(result);
+        }
+
+        if (isSustainedPowerLimitEnabled) {
+            val = static_cast<uint32_t>(pSustained->power) * milliFactor; // Convert milliWatts to microwatts
+            result = pSysfsAccess->write(i915HwmonDir + "/" + sustainedPowerLimit, val);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+
+            result = pSysfsAccess->write(i915HwmonDir + "/" + sustainedPowerLimitInterval, pSustained->interval);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+        }
+    }
+    if (pBurst != nullptr) {
+        result = pSysfsAccess->write(i915HwmonDir + "/" + burstPowerLimitEnabled, static_cast<int>(pBurst->enabled));
+        if (ZE_RESULT_SUCCESS != result) {
+            return getErrorCode(result);
+        }
+
+        if (pBurst->enabled) {
+            val = static_cast<uint32_t>(pBurst->power) * milliFactor; // Convert milliWatts to microwatts
+            result = pSysfsAccess->write(i915HwmonDir + "/" + burstPowerLimit, val);
+            if (ZE_RESULT_SUCCESS != result) {
+                return getErrorCode(result);
+            }
+        }
+    }
+
+    return result;
+}
+
+ze_result_t LinuxPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxPowerImp::setEnergyThreshold(double threshold) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool LinuxPowerImp::isPowerModuleSupported() {
+    std::vector<std::string> listOfAllHwmonDirs = {};
+    if (ZE_RESULT_SUCCESS != pSysfsAccess->scanDirEntries(hwmonDir, listOfAllHwmonDirs)) {
+        return false;
+    }
+    for (const auto &tempHwmonDirEntry : listOfAllHwmonDirs) {
+        const std::string i915NameFile = hwmonDir + "/" + tempHwmonDirEntry + "/" + "name";
+        std::string name;
+        if (ZE_RESULT_SUCCESS != pSysfsAccess->read(i915NameFile, name)) {
+            continue;
+        }
+        if (name == i915) {
+            i915HwmonDir = hwmonDir + "/" + tempHwmonDirEntry;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
+}
+
+OsPower *OsPower::create(OsSysman *pOsSysman) {
+    LinuxPowerImp *pLinuxPowerImp = new LinuxPowerImp(pOsSysman);
+    return static_cast<OsPower *>(pLinuxPowerImp);
+}
+
+} // namespace L0

level_zero/tools/source/sysman/power/linux/dg1/os_power_imp.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/tools/source/sysman/power/os_power.h"
+
+#include <string>
+
+namespace L0 {
+
+class SysfsAccess;
+class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t getProperties(zes_power_properties_t *pProperties) override;
+    ze_result_t getEnergyCounter(zes_power_energy_counter_t *pEnergy) override;
+    ze_result_t getLimits(zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak) override;
+    ze_result_t setLimits(const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak) override;
+    ze_result_t getEnergyThreshold(zes_energy_threshold_t *pThreshold) override;
+    ze_result_t setEnergyThreshold(double threshold) override;
+
+    bool isPowerModuleSupported() override;
+    LinuxPowerImp(OsSysman *pOsSysman);
+    LinuxPowerImp() = default;
+    ~LinuxPowerImp() override = default;
+
+  protected:
+    SysfsAccess *pSysfsAccess = nullptr;
+
+  private:
+    std::string i915HwmonDir;
+    static const std::string hwmonDir;
+    static const std::string i915;
+    static const std::string sustainedPowerLimitEnabled;
+    static const std::string sustainedPowerLimit;
+    static const std::string sustainedPowerLimitInterval;
+    static const std::string burstPowerLimitEnabled;
+    static const std::string burstPowerLimit;
+    static const std::string energyCounterNode;
+
+    ze_result_t getErrorCode(ze_result_t result) {
+        if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
+            result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        }
+        return result;
+    }
+};
+} // namespace L0

level_zero/tools/source/sysman/sysman_const.h

@@ -41,3 +41,4 @@ constexpr uint64_t minTimeoutInMicroSeconds = 1000u;
 constexpr uint16_t milliSecsToMicroSecs = 1000;
 constexpr uint64_t numSocTemperatureEntries = 7;
 constexpr uint32_t numCoreTemperatureEntries = 4;
+constexpr uint32_t milliFactor = 1000u;