intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-30 01:35:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(sysman): enable product helper for power module

Browse Source 
Related-To: NEO-8734

Signed-off-by: Kulkarni, Ashwin Kumar <ashwin.kumar.kulkarni@intel.com>
This commit is contained in:
Kulkarni, Ashwin Kumar
2023-12-22 05:20:54 +00:00
committed by Compute-Runtime-Automation
parent 4fa6368c01
commit 50fe037aeb
8 changed files with 108 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
level_zero/sysman/source/api/power/linux/sysman_os_power_imp_prelim.cpp
View File

@@ -10,6 +10,7 @@
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
@@ -285,14 +286,8 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
pSustained[count].source = ZES_POWER_SOURCE_ANY;
pSustained[count].level = ZES_POWER_LEVEL_PEAK;
pSustained[count].interval = 0; // Hardcode to 100 micro seconds i.e 0.1 milli seconds
if (productFamily == IGFX_PVC) {
pSustained[count].limit = static_cast<int32_t>(val);
pSustained[count].limitUnit = ZES_LIMIT_UNIT_CURRENT;
} else {
val /= milliFactor; // Convert microwatts to milliwatts
pSustained[count].limit = static_cast<int32_t>(val);
pSustained[count].limitUnit = ZES_LIMIT_UNIT_POWER;
}
pSustained[count].limit = pSysmanProductHelper->getPowerLimitValue(val);
pSustained[count].limitUnit = pSysmanProductHelper->getPowerLimitUnit();
}
}
return result;
@@ -317,11 +312,7 @@ ze_result_t LinuxPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
return getErrorCode(result);
}
} else if (pSustained[i].level == ZES_POWER_LEVEL_PEAK) {
if (productFamily == IGFX_PVC) {
val = pSustained[i].limit;
} else {
val = static_cast<uint64_t>(pSustained[i].limit) * milliFactor; // Convert milliwatts to microwatts
}
val = pSysmanProductHelper->setPowerLimitValue(pSustained[i].limit);
result = pSysfsAccess->write(criticalPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->write() failed to write into %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), criticalPowerLimit.c_str(), getErrorCode(result));
@@ -407,6 +398,7 @@ LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
productFamily = pLinuxSysmanImp->getProductFamily();
pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
}
OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {

3
level_zero/sysman/source/api/power/linux/sysman_os_power_imp_prelim.h
View File

@@ -20,7 +20,7 @@ namespace Sysman {
class SysmanKmdInterface;
class SysFsAccessInterface;
class SysmanProductHelper;
class PlatformMonitoringTech;
class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
public:
@@ -56,6 +56,7 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
uint32_t subdeviceId = 0;
uint32_t powerLimitCount = 0;
PRODUCT_FAMILY productFamily{};
SysmanProductHelper *pSysmanProductHelper = nullptr;
class PowerLimitRestorer;
ze_result_t getErrorCode(ze_result_t result) {

5
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h
View File

@@ -62,6 +62,11 @@ class SysmanProductHelper {
// Voltage
virtual void getCurrentVoltage(PlatformMonitoringTech *pPmt, double &voltage) = 0;
// power
virtual int32_t getPowerLimitValue(uint64_t value) = 0;
virtual uint64_t setPowerLimitValue(int32_t value) = 0;
virtual zes_limit_unit_t getPowerLimitUnit() = 0;
virtual ~SysmanProductHelper() = default;
protected:

5
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h
View File

@@ -48,6 +48,11 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// Voltage
void getCurrentVoltage(PlatformMonitoringTech *pPmt, double &voltage) override;
// power
int32_t getPowerLimitValue(uint64_t value) override;
uint64_t setPowerLimitValue(int32_t value) override;
zes_limit_unit_t getPowerLimitUnit() override;
~SysmanProductHelperHw() override = default;
protected:

17
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
View File

@@ -131,5 +131,22 @@ void SysmanProductHelperHw<gfxProduct>::getCurrentVoltage(PlatformMonitoringTech
voltage = -1.0;
}
template <PRODUCT_FAMILY gfxProduct>
int32_t SysmanProductHelperHw<gfxProduct>::getPowerLimitValue(uint64_t value) {
uint64_t val = value / milliFactor;
return static_cast<int32_t>(val);
}
template <PRODUCT_FAMILY gfxProduct>
uint64_t SysmanProductHelperHw<gfxProduct>::setPowerLimitValue(int32_t value) {
uint64_t val = static_cast<uint64_t>(value) * milliFactor;
return val;
}
template <PRODUCT_FAMILY gfxProduct>
zes_limit_unit_t SysmanProductHelperHw<gfxProduct>::getPowerLimitUnit() {
return ZES_LIMIT_UNIT_POWER;
}
} // namespace Sysman
} // namespace L0

15
level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp
View File

@@ -94,6 +94,21 @@ bool SysmanProductHelperHw<gfxProduct>::isRepairStatusSupported() {
return true;
}
template <>
int32_t SysmanProductHelperHw<gfxProduct>::getPowerLimitValue(uint64_t value) {
return static_cast<int32_t>(value);
}
template <>
uint64_t SysmanProductHelperHw<gfxProduct>::setPowerLimitValue(int32_t value) {
return static_cast<uint64_t>(value);
}
template <>
zes_limit_unit_t SysmanProductHelperHw<gfxProduct>::getPowerLimitUnit() {
return ZES_LIMIT_UNIT_CURRENT;
}
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

1
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt
View File

@@ -13,6 +13,7 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_globalops_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_frequency_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_ras_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_power_tests.cpp
)
endif()

58
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
namespace L0 {
namespace Sysman {
namespace ult {
using SysmanProductHelperPowerTest = SysmanDeviceFixture;
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingGetPowerLimitValueThenCorrectValueIsReturned, IsPVC) {
uint64_t testValue = 3000;
int32_t expectedValue = 3000;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedValue, pSysmanProductHelper->getPowerLimitValue(testValue));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingGetPowerLimitValueThenCorrectValueIsReturned, IsNotPVC) {
uint64_t testValue = 3000;
int32_t expectedValue = 3;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedValue, pSysmanProductHelper->getPowerLimitValue(testValue));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingSetPowerLimitValueThenCorrectValueIsReturned, IsPVC) {
int32_t testValue = 3000;
uint64_t expectedValue = 3000;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedValue, pSysmanProductHelper->setPowerLimitValue(testValue));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingSetPowerLimitValueThenCorrectValueIsReturned, IsNotPVC) {
int32_t testValue = 3;
uint64_t expectedValue = 3000;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedValue, pSysmanProductHelper->setPowerLimitValue(testValue));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingGetPowerLimitUnitThenCorrectPowerLimitUnitIsReturned, IsPVC) {
zes_limit_unit_t expectedPowerUnit = ZES_LIMIT_UNIT_CURRENT;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedPowerUnit, pSysmanProductHelper->getPowerLimitUnit());
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingGetPowerLimitUnitThenCorrectPowerLimitUnitIsReturned, IsNotPVC) {
zes_limit_unit_t expectedPowerUnit = ZES_LIMIT_UNIT_POWER;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(expectedPowerUnit, pSysmanProductHelper->getPowerLimitUnit());
}
} // namespace ult
} // namespace Sysman
} // namespace L0