fix: Synchronize power property retrievals

bellekal · Compute-Runtime-Automation · commit 5b9e1e394940 · 2024-03-08T14:12:21.000+01:00
Related-To: NEO-10525 Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com> Source: a023b40
diff --git a/level_zero/sysman/source/api/power/linux/sysman_os_power_imp.cpp b/level_zero/sysman/source/api/power/linux/sysman_os_power_imp.cpp
@@ -42,6 +42,10 @@ class LinuxPowerImp::PowerLimitRestorer : NEO::NonCopyableOrMovableClass {
     uint64_t powerLimitValue = 0;
 };
 
+std::unique_lock<std::mutex> LinuxPowerImp::obtainMutex() {
+    return std::unique_lock<std::mutex>(this->powerLimitMutex);
+}
+
 ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
     pProperties->onSubdevice = isSubdevice;
     pProperties->subdeviceId = subdeviceId;
@@ -60,6 +64,7 @@ ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
         return result;
     }
 
+    auto lock = this->obtainMutex();
     auto powerLimitRestorer = L0::Sysman::LinuxPowerImp::PowerLimitRestorer(pSysfsAccess, sustainedPowerLimit);
     if (powerLimitRestorer != ZE_RESULT_SUCCESS) {
         NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(powerLimitRestorer));
diff --git a/level_zero/sysman/source/api/power/linux/sysman_os_power_imp.h b/level_zero/sysman/source/api/power/linux/sysman_os_power_imp.h
@@ -11,6 +11,7 @@
 #include "level_zero/sysman/source/api/power/sysman_os_power.h"
 
 #include <memory>
+#include <mutex>
 #include <string>
 
 namespace L0 {
@@ -44,12 +45,14 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
     SysFsAccessInterface *pSysfsAccess = nullptr;
     SysmanKmdInterface *pSysmanKmdInterface = nullptr;
     SysmanProductHelper *pSysmanProductHelper = nullptr;
+    virtual std::unique_lock<std::mutex> obtainMutex();
 
   private:
     std::string intelGraphicsHwmonDir = {};
     std::string criticalPowerLimit = {};
     std::string sustainedPowerLimit = {};
     std::string sustainedPowerLimitInterval = {};
+    std::mutex powerLimitMutex{};
     bool canControl = false;
     bool isSubdevice = false;
     uint32_t subdeviceId = 0;
diff --git a/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp b/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp
@@ -105,6 +105,31 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerProper
     }
 }
 
+TEST_F(SysmanDevicePowerFixtureI915, GivenValidMockMutexPowerImpWhenGettingPowerPropertiesThenMutexLockCounterMatchesNumberOfGetCalls) {
+    class MockMutexPowerImp : public L0::Sysman::LinuxPowerImp {
+      public:
+        using L0::Sysman::LinuxPowerImp::pSysfsAccess;
+        MockMutexPowerImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId) {}
+        uint32_t mutexLockCounter = 0;
+        std::unique_lock<std::mutex> obtainMutex() override {
+            mutexLockCounter++;
+            std::unique_lock<std::mutex> mutexLock = L0::Sysman::LinuxPowerImp::obtainMutex();
+            EXPECT_TRUE(mutexLock.owns_lock());
+            return mutexLock;
+        }
+    };
+
+    std::unique_ptr<MockMutexPowerImp> pLinuxPowerImp(new MockMutexPowerImp(pOsSysman, false, 0));
+    pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
+
+    zes_power_properties_t properties{};
+    uint32_t testReadCount = 0;
+    for (uint32_t i = 0; i < testReadCount; i++) {
+        EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxPowerImp->getProperties(&properties));
+    }
+    EXPECT_EQ(pLinuxPowerImp->mutexLockCounter, testReadCount);
+}
+
 TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
     auto handles = getPowerHandles(powerHandleComponentCount);
 
diff --git a/level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.cpp b/level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -45,6 +45,10 @@ class LinuxPowerImp::PowerLimitRestorer : NEO::NonCopyableOrMovableClass {
     uint64_t powerLimitValue = 0;
 };
 
+std::unique_lock<std::mutex> LinuxPowerImp::obtainMutex() {
+    return std::unique_lock<std::mutex>(this->powerLimitMutex);
+}
+
 ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
     pProperties->onSubdevice = isSubdevice;
     pProperties->subdeviceId = subdeviceId;
@@ -64,7 +68,8 @@ ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
     }
 
     std::string sustainedLimit = i915HwmonDir + "/" + sustainedPowerLimit;
-    auto powerLimitRestorer = L0::LinuxPowerImp::PowerLimitRestorer(pSysfsAccess, sustainedLimit);
+    auto lock = this->obtainMutex();
+    auto powerLimitRestorer = L0::LinuxPowerImp::PowerLimitRestorer(pSysfsAccess, sustainedLimit); // 600
     if (powerLimitRestorer != ZE_RESULT_SUCCESS) {
         NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(powerLimitRestorer));
         return getErrorCode(powerLimitRestorer);
@@ -88,7 +93,7 @@ ze_result_t LinuxPowerImp::getMinLimit(int32_t &minLimit) {
         return getErrorCode(result);
     }
 
-    result = pSysfsAccess->read(sustainedLimit, powerLimit);
+    result = pSysfsAccess->read(sustainedLimit, powerLimit); // 300
     if (ZE_RESULT_SUCCESS != result) {
         NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(result));
         return getErrorCode(result);
@@ -109,7 +114,7 @@ ze_result_t LinuxPowerImp::getMaxLimit(int32_t &maxLimit) {
         return getErrorCode(result);
     }
 
-    result = pSysfsAccess->read(sustainedLimit, powerLimit);
+    result = pSysfsAccess->read(sustainedLimit, powerLimit); // 600
     if (ZE_RESULT_SUCCESS != result) {
         NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(result));
         return getErrorCode(result);
diff --git a/level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.h b/level_zero/tools/source/sysman/power/linux/os_power_imp_prelim.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -42,10 +42,12 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
   protected:
     PlatformMonitoringTech *pPmt = nullptr;
     SysfsAccess *pSysfsAccess = nullptr;
+    virtual std::unique_lock<std::mutex> obtainMutex();
 
   private:
     std::string i915HwmonDir;
     std::string criticalPowerLimit;
+    std::mutex powerLimitMutex{};
     static const std::string hwmonDir;
     static const std::string i915;
     static const std::string sustainedPowerLimit;
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_prelim.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2023 Intel Corporation
+ * Copyright (C) 2020-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -121,6 +121,31 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerProperties
     }
 }
 
+TEST_F(SysmanDevicePowerFixture, GivenValidMockMutexPowerImpWhenGettingPowerPropertiesThenMutexLockCounterMatchesNumberOfGetCalls) {
+    class MockMutexPowerImp : public L0::LinuxPowerImp {
+      public:
+        using L0::LinuxPowerImp::pSysfsAccess;
+        MockMutexPowerImp(L0::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId) {}
+        uint32_t mutexLockCounter = 0;
+        std::unique_lock<std::mutex> obtainMutex() override {
+            mutexLockCounter++;
+            std::unique_lock<std::mutex> mutexLock = L0::LinuxPowerImp::obtainMutex();
+            EXPECT_TRUE(mutexLock.owns_lock());
+            return mutexLock;
+        }
+    };
+
+    std::unique_ptr<MockMutexPowerImp> pLinuxPowerImp(new MockMutexPowerImp(pOsSysman, false, 0));
+    pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
+
+    uint32_t testReadCount = 0;
+    zes_power_properties_t properties{};
+    for (uint32_t i = 0; i < testReadCount; i++) {
+        EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxPowerImp->getProperties(&properties));
+    }
+    EXPECT_EQ(pLinuxPowerImp->mutexLockCounter, testReadCount);
+}
+
 TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
     auto handles = getPowerHandles(powerHandleComponentCount);
 
