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

refactor(sysman): Modify zesPowerGetLimitsExt() to return user requested limits

Browse Source 
Related-To: NEO-16717

Signed-off-by: Anvesh Bakwad <anvesh.bakwad@intel.com>
This commit is contained in:
Anvesh Bakwad
2025-11-23 12:48:41 +00:00
committed by Compute-Runtime-Automation
parent 32a99b0667
commit 40c0a281ab
4 changed files with 288 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
level_zero/sysman/source/api/power/linux/sysman_os_power_imp.cpp
View File

@@ -178,16 +178,22 @@ ze_result_t LinuxPowerImp::setEnergyThreshold(double threshold) {
}
ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pLimitExt) {
ze_result_t result = ZE_RESULT_SUCCESS;
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if ((*pCount == 0) || (powerLimitCount < *pCount)) {
*pCount = powerLimitCount;
}
if (isSubdevice || pLimitExt == nullptr) {
if (isSubdevice) {
*pCount = 0;
return result;
}
result = ZE_RESULT_SUCCESS;
if (*pCount == 0) {
*pCount = powerLimitCount;
return result;
}
uint32_t numOfLimitsToReturn = std::min(*pCount, powerLimitCount);
bool sustainedLimitReadSuccess = true;
bool sustainedLimitIntervalReadSuccess = true;
bool burstLimitReadSuccess = true;
@@ -195,7 +201,7 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
uint64_t powerLimit = 0;
int32_t interval = 0;
uint8_t count = 0;
uint32_t limitIndex = 0;
if (sustainedPowerLimitFileExists) {
result = pSysfsAccess->read(sustainedPowerLimitFile, powerLimit);
@@ -217,18 +223,18 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
}
pSysmanKmdInterface->convertSysfsValueUnit(SysfsValueUnit::milli, pSysmanKmdInterface->getNativeUnit(SysfsName::sysfsNamePackageSustainedPowerLimit), powerLimit, powerLimit);
pLimitExt[count].limit = static_cast<int32_t>(powerLimit);
pLimitExt[count].enabledStateLocked = true;
pLimitExt[count].intervalValueLocked = false;
pLimitExt[count].limitValueLocked = false;
pLimitExt[count].source = ZES_POWER_SOURCE_ANY;
pLimitExt[count].level = ZES_POWER_LEVEL_SUSTAINED;
pLimitExt[count].limitUnit = ZES_LIMIT_UNIT_POWER;
pLimitExt[count].interval = sustainedLimitIntervalReadSuccess ? interval : -1;
count++;
pLimitExt[limitIndex].limit = static_cast<int32_t>(powerLimit);
pLimitExt[limitIndex].enabledStateLocked = true;
pLimitExt[limitIndex].intervalValueLocked = false;
pLimitExt[limitIndex].limitValueLocked = false;
pLimitExt[limitIndex].source = ZES_POWER_SOURCE_ANY;
pLimitExt[limitIndex].level = ZES_POWER_LEVEL_SUSTAINED;
pLimitExt[limitIndex].limitUnit = ZES_LIMIT_UNIT_POWER;
pLimitExt[limitIndex].interval = sustainedLimitIntervalReadSuccess ? interval : -1;
limitIndex++;
}
if (burstPowerLimitFileExists) {
if (burstPowerLimitFileExists && (limitIndex < numOfLimitsToReturn)) {
powerLimit = 0;
result = pSysfsAccess->read(burstPowerLimitFile, powerLimit);
if (result != ZE_RESULT_SUCCESS) {
@@ -250,18 +256,18 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
}
pSysmanKmdInterface->convertSysfsValueUnit(SysfsValueUnit::milli, pSysmanKmdInterface->getNativeUnit(SysfsName::sysfsNamePackageSustainedPowerLimit), powerLimit, powerLimit);
pLimitExt[count].limit = static_cast<int32_t>(powerLimit);
pLimitExt[count].enabledStateLocked = true;
pLimitExt[count].intervalValueLocked = false;
pLimitExt[count].limitValueLocked = false;
pLimitExt[count].source = ZES_POWER_SOURCE_ANY;
pLimitExt[count].level = ZES_POWER_LEVEL_BURST;
pLimitExt[count].limitUnit = ZES_LIMIT_UNIT_POWER;
pLimitExt[count].interval = burstLimitIntervalReadSuccess ? interval : -1;
count++;
pLimitExt[limitIndex].limit = static_cast<int32_t>(powerLimit);
pLimitExt[limitIndex].enabledStateLocked = true;
pLimitExt[limitIndex].intervalValueLocked = false;
pLimitExt[limitIndex].limitValueLocked = false;
pLimitExt[limitIndex].source = ZES_POWER_SOURCE_ANY;
pLimitExt[limitIndex].level = ZES_POWER_LEVEL_BURST;
pLimitExt[limitIndex].limitUnit = ZES_LIMIT_UNIT_POWER;
pLimitExt[limitIndex].interval = burstLimitIntervalReadSuccess ? interval : -1;
limitIndex++;
}
if (criticalPowerLimitFileExists) {
if (criticalPowerLimitFileExists && (limitIndex < numOfLimitsToReturn)) {
powerLimit = 0;
result = pSysfsAccess->read(criticalPowerLimitFile, powerLimit);
if (result != ZE_RESULT_SUCCESS) {
@@ -269,16 +275,18 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
return getErrorCode(result);
}
pLimitExt[count].enabledStateLocked = true;
pLimitExt[count].intervalValueLocked = true;
pLimitExt[count].limitValueLocked = false;
pLimitExt[count].source = ZES_POWER_SOURCE_ANY;
pLimitExt[count].level = ZES_POWER_LEVEL_PEAK;
pLimitExt[count].interval = 0;
pLimitExt[count].limit = pSysmanProductHelper->getPowerLimitValue(powerLimit);
pLimitExt[count].limitUnit = pSysmanProductHelper->getPowerLimitUnit();
pLimitExt[limitIndex].enabledStateLocked = true;
pLimitExt[limitIndex].intervalValueLocked = true;
pLimitExt[limitIndex].limitValueLocked = false;
pLimitExt[limitIndex].source = ZES_POWER_SOURCE_ANY;
pLimitExt[limitIndex].level = ZES_POWER_LEVEL_PEAK;
pLimitExt[limitIndex].interval = 0;
pLimitExt[limitIndex].limit = pSysmanProductHelper->getPowerLimitValue(powerLimit);
pLimitExt[limitIndex].limitUnit = pSysmanProductHelper->getPowerLimitUnit();
limitIndex++;
}
*pCount = limitIndex;
return ZE_RESULT_SUCCESS;
}

8
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp
View File

@@ -187,8 +187,14 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenReadingToSysNodesFailsWhe
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, nullptr));
}
EXPECT_EQ(count, 0u);
}
}

84
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp
View File

@@ -346,18 +346,20 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandlesWhenCallingSetAndG
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
uint32_t limitCount = 0;
if (properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, 0u);
continue;
}
const int32_t testLimit = 300000;
const int32_t testInterval = 10;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
limitCount++;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
@@ -403,10 +405,6 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandlesWhenCallingSetAndG
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
limitCount++;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
@@ -599,26 +597,19 @@ HWTEST2_F(SysmanProductHelperPowerMultiDeviceTest, GivenValidPowerHandlesWhenCal
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, &limits));
EXPECT_EQ(limitCount, 0u);
}
limitCount++;
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(limitCount, mockLimitCount);
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &limitCount, &limits));
EXPECT_EQ(limitCount, 0u);
}
std::vector<zes_power_limit_ext_desc_t> allLimits(limitCount);
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(limitCount, mockLimitCount);
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(limitCount, 0u);
}
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
@@ -650,10 +641,63 @@ HWTEST2_F(SysmanProductHelperPowerMultiDeviceTest, GivenValidPowerHandlesWhenCal
}
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(limitCount, 0u);
}
}
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountThenOnlyRequestedNumberOfLimitsAreReturned, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
// First get total available limits
uint32_t totalLimitCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &totalLimitCount, nullptr));
EXPECT_EQ(totalLimitCount, mockLimitCount);
// Request only 1 limit when multiple are available
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
// Request only 2 limits when 3 are available
requestedCount = 2;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 2u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_PEAK);
}
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithCountGreaterThanAvailableThenAllAvailableLimitsAreReturned, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
// Request more limits than available
uint32_t requestedCount = 10;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
if (properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 0u);
continue;
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &requestedCount, limits.data()));
EXPECT_EQ(requestedCount, mockLimitCount);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_PEAK);
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

174
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests_xe.cpp
View File

@@ -699,6 +699,180 @@ HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleForPowerDomainAnd
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountThenOnlyRequestedNumberOfLimitsAreReturned, IsBMG) {
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Request only 1 limit when 3 are available
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
// Request only 2 limits when 3 are available
requestedCount = 2;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 2u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_BURST);
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithCountGreaterThanAvailableThenAllAvailableLimitsAreReturned, IsBMG) {
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Request more limits than available
uint32_t requestedCount = 10;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, bmgPowerLimitSupportedCount);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_BURST);
EXPECT_EQ(limits[2].level, ZES_POWER_LEVEL_PEAK);
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountAndOnlySustainedAvailableThenOnlyRequestedNumberOfLimitsAreReturned, IsBMG) {
pSysfsAccess->isCardBurstPowerLimitFilePresent = false;
pSysfsAccess->isPackageBurstPowerLimitFilePresent = false;
pSysfsAccess->isCardCriticalPowerLimitFilePresent = false;
pSysfsAccess->isPackageCriticalPowerLimitFilePresent = false;
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Get total available limits (only sustained)
uint32_t totalLimitCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&totalLimitCount, nullptr));
EXPECT_EQ(totalLimitCount, 1u);
// Request 1 limit
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
// Request more than available
requestedCount = 5;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountAndOnlyBurstAvailableThenOnlyRequestedNumberOfLimitsAreReturned, IsBMG) {
pSysfsAccess->isCardSustainedPowerLimitFilePresent = false;
pSysfsAccess->isPackageSustainedPowerLimitFilePresent = false;
pSysfsAccess->isCardCriticalPowerLimitFilePresent = false;
pSysfsAccess->isPackageCriticalPowerLimitFilePresent = false;
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Get total available limits (only burst)
uint32_t totalLimitCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&totalLimitCount, nullptr));
EXPECT_EQ(totalLimitCount, 1u);
// Request 1 limit
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_BURST);
// Request more than available
requestedCount = 5;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_BURST);
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountAndOnlyPeakAvailableThenOnlyRequestedNumberOfLimitsAreReturned, IsBMG) {
pSysfsAccess->isCardSustainedPowerLimitFilePresent = false;
pSysfsAccess->isPackageSustainedPowerLimitFilePresent = false;
pSysfsAccess->isCardBurstPowerLimitFilePresent = false;
pSysfsAccess->isPackageBurstPowerLimitFilePresent = false;
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Get total available limits (only peak)
uint32_t totalLimitCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&totalLimitCount, nullptr));
// Request 1 limit
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_PEAK);
// Request more than available
requestedCount = 5;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_PEAK);
}
}
HWTEST2_F(SysmanXeProductHelperPowerTest, GivenValidPowerHandleWhenCallingGetPowerLimitsExtWithLimitedCountAndSustainedAndBurstAvailableThenOnlyRequestedNumberOfLimitsAreReturned, IsBMG) {
pSysfsAccess->isCardCriticalPowerLimitFilePresent = false;
pSysfsAccess->isPackageCriticalPowerLimitFilePresent = false;
std::vector<zes_power_domain_t> powerDomains = {ZES_POWER_DOMAIN_CARD, ZES_POWER_DOMAIN_PACKAGE};
for (auto powerDomain : powerDomains) {
auto pPowerImp = std::make_unique<XePublicLinuxPowerImp>(pOsSysman, false, 0, powerDomain);
// Get total available limits (sustained and burst)
uint32_t totalLimitCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&totalLimitCount, nullptr));
EXPECT_EQ(totalLimitCount, 2u);
// Request 1 limit
uint32_t requestedCount = 1;
std::vector<zes_power_limit_ext_desc_t> limits(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 1u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
// Request 2 limits
requestedCount = 2;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 2u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_BURST);
// Request more than available
requestedCount = 5;
limits.resize(requestedCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, pPowerImp->getLimitsExt(&requestedCount, limits.data()));
EXPECT_EQ(requestedCount, 2u);
EXPECT_EQ(limits[0].level, ZES_POWER_LEVEL_SUSTAINED);
EXPECT_EQ(limits[1].level, ZES_POWER_LEVEL_BURST);
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0