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

refactor: Merge prelim and non-prelim implementations for power

Browse Source 
Abstract power set request support based on hw.

Related-To: NEO-10804

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2024-02-15 07:02:37 +00:00
committed by Compute-Runtime-Automation
parent 0f817d1db4
commit 075fae19fd
15 changed files with 786 additions and 2231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
level_zero/sysman/source/api/power/linux/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2023 Intel Corporation
# Copyright (C) 2023-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -8,20 +8,7 @@ if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp_prelim.h
)
else()
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_power_imp.h
)
endif()
endif()

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

@@ -221,7 +221,7 @@ ze_result_t LinuxPowerImp::getLimits(zes_power_sustained_limit_t *pSustained, ze
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_UNSUPPORTED_FEATURE;
if (!isSubdevice) {
if ((!isSubdevice) && (pSysmanProductHelper->isPowerSetLimitSupported())) {
uint64_t val = 0;
if (pSustained != nullptr) {
@@ -312,7 +312,7 @@ ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_de
ze_result_t LinuxPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) {
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if (!isSubdevice) {
if ((!isSubdevice) && (pSysmanProductHelper->isPowerSetLimitSupported())) {
uint64_t val = 0;
for (uint32_t i = 0; i < *pCount; i++) {
if (pSustained[i].level == ZES_POWER_LEVEL_SUSTAINED) {

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

@@ -1,410 +0,0 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/api/power/linux/sysman_os_power_imp_prelim.h"
#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"
#include "level_zero/sysman/source/sysman_const.h"
namespace L0 {
namespace Sysman {
class LinuxPowerImp::PowerLimitRestorer : NEO::NonCopyableOrMovableClass {
public:
PowerLimitRestorer(L0::Sysman::SysFsAccessInterface *pSysfsAccess, std::string powerLimit) : pSysfsAccess(pSysfsAccess), powerLimit(powerLimit) {
result = pSysfsAccess->read(powerLimit, powerLimitValue);
}
~PowerLimitRestorer() {
if (result == ZE_RESULT_SUCCESS) {
result = pSysfsAccess->write(powerLimit, powerLimitValue);
DEBUG_BREAK_IF(result != ZE_RESULT_SUCCESS);
}
}
operator ze_result_t() const {
return result;
}
protected:
ze_result_t result = ZE_RESULT_ERROR_UNINITIALIZED;
SysFsAccessInterface *pSysfsAccess = nullptr;
std::string powerLimit = {};
uint64_t powerLimitValue = 0;
};
ze_result_t LinuxPowerImp::getProperties(zes_power_properties_t *pProperties) {
pProperties->onSubdevice = isSubdevice;
pProperties->subdeviceId = subdeviceId;
pProperties->canControl = canControl;
pProperties->isEnergyThresholdSupported = false;
pProperties->defaultLimit = -1;
pProperties->minLimit = -1;
pProperties->maxLimit = -1;
if (isSubdevice) {
return ZE_RESULT_SUCCESS;
}
auto result = getDefaultLimit(pProperties->defaultLimit);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
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));
return getErrorCode(powerLimitRestorer);
}
result = getMinLimit(pProperties->minLimit);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
return getMaxLimit(pProperties->maxLimit);
}
ze_result_t LinuxPowerImp::getMinLimit(int32_t &minLimit) {
// Fw clamps to minimum value if power limit requested to set is less than min limit, Set to 100 micro watt to get min limit
uint64_t powerLimit = 100;
auto result = pSysfsAccess->write(sustainedPowerLimit, powerLimit);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to write %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
result = pSysfsAccess->read(sustainedPowerLimit, powerLimit);
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);
}
// Values are retrieved from KMD in micro watts, Conversion to milli is required.
minLimit = static_cast<int32_t>(powerLimit / milliFactor);
return result;
}
ze_result_t LinuxPowerImp::getMaxLimit(int32_t &maxLimit) {
// Fw clamps to maximum value if power limit requested to set is greater than max limit, Set to max value to get max limit
uint64_t powerLimit = std::numeric_limits<int32_t>::max();
auto result = pSysfsAccess->write(sustainedPowerLimit, powerLimit);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to write %s and returning error:0x%x \n", __FUNCTION__, sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
result = pSysfsAccess->read(sustainedPowerLimit, powerLimit);
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);
}
// Values are retrieved from KMD in micro watts, Conversion to milli is required.
maxLimit = static_cast<int32_t>(powerLimit / milliFactor);
return result;
}
ze_result_t LinuxPowerImp::getDefaultLimit(int32_t &defaultLimit) {
uint64_t powerLimit = 0;
std::string defaultPowerLimit = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameDefaultPowerLimit, subdeviceId, false);
auto result = pSysfsAccess->read(defaultPowerLimit, powerLimit);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), defaultPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
// Values are retrieved from KMD in micro watts, Conversion to milli is required.
defaultLimit = static_cast<int32_t>(powerLimit / milliFactor);
return result;
}
ze_result_t LinuxPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) {
pExtPoperties->domain = isSubdevice ? ZES_POWER_DOMAIN_PACKAGE : ZES_POWER_DOMAIN_CARD;
if (pExtPoperties->defaultLimit) {
if (!isSubdevice) {
uint32_t val = 0;
std::string defaultPowerLimit = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameDefaultPowerLimit, subdeviceId, false);
ze_result_t result = pSysfsAccess->read(defaultPowerLimit, val);
if (result == ZE_RESULT_SUCCESS) {
pExtPoperties->defaultLimit->limit = static_cast<int32_t>(val / milliFactor); // need to convert from microwatt to milliwatt
} else {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), defaultPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
} else {
pExtPoperties->defaultLimit->limit = -1;
}
pExtPoperties->defaultLimit->limitUnit = ZES_LIMIT_UNIT_POWER;
pExtPoperties->defaultLimit->enabledStateLocked = true;
pExtPoperties->defaultLimit->intervalValueLocked = true;
pExtPoperties->defaultLimit->limitValueLocked = true;
pExtPoperties->defaultLimit->source = ZES_POWER_SOURCE_ANY;
pExtPoperties->defaultLimit->level = ZES_POWER_LEVEL_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPowerImp::getPmtEnergyCounter(zes_power_energy_counter_t *pEnergy) {
const std::string key("PACKAGE_ENERGY");
uint64_t energy = 0;
constexpr uint64_t fixedPointToJoule = 1048576;
ze_result_t result = pPmt->readValue(key, energy);
// PMT will return energy counter in Q20 format(fixed point representation) where first 20 bits(from LSB) represent decimal part and remaining integral part which is converted into joule by division with 1048576(2^20) and then converted into microjoules
pEnergy->energy = (energy / fixedPointToJoule) * convertJouleToMicroJoule;
return result;
}
ze_result_t LinuxPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
pEnergy->timestamp = SysmanDevice::getSysmanTimestamp();
std::string energyCounterNode = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEnergyCounterNode, subdeviceId, false);
ze_result_t result = pSysfsAccess->read(energyCounterNode, pEnergy->energy);
if (result != ZE_RESULT_SUCCESS) {
if (pPmt != nullptr) {
return getPmtEnergyCounter(pEnergy);
}
}
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), energyCounterNode.c_str(), getErrorCode(result));
return getErrorCode(result);
}
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_UNSUPPORTED_FEATURE;
if (!isSubdevice) {
uint64_t val = 0;
if (pSustained != nullptr) {
val = 0;
result = pSysfsAccess->read(sustainedPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
val /= milliFactor; // Convert microwatts to milliwatts
pSustained->power = static_cast<int32_t>(val);
pSustained->enabled = true;
pSustained->interval = -1;
}
if (pBurst != nullptr) {
pBurst->power = -1;
pBurst->enabled = false;
}
if (pPeak != nullptr) {
result = pSysfsAccess->read(criticalPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), criticalPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
val /= milliFactor; // Convert microwatts to milliwatts
pPeak->powerAC = static_cast<int32_t>(val);
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_UNSUPPORTED_FEATURE;
if (!isSubdevice) {
int32_t val = 0;
if (pSustained != nullptr) {
val = static_cast<uint32_t>(pSustained->power) * milliFactor; // Convert milliwatts to microwatts
result = pSysfsAccess->write(sustainedPowerLimit, 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(), sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
}
if (pPeak != nullptr) {
val = static_cast<uint32_t>(pPeak->powerAC) * milliFactor; // Convert milliwatts to microwatts
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));
return getErrorCode(result);
}
}
result = ZE_RESULT_SUCCESS;
}
return result;
}
ze_result_t LinuxPowerImp::getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) {
ze_result_t result = ZE_RESULT_SUCCESS;
if ((*pCount == 0) || (powerLimitCount < *pCount)) {
*pCount = powerLimitCount;
}
if (pSustained != nullptr) {
uint64_t val = 0;
uint8_t count = 0;
if (count < *pCount) {
result = pSysfsAccess->read(sustainedPowerLimit, val);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
int32_t interval = 0;
result = pSysfsAccess->read(sustainedPowerLimitInterval, interval);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), sustainedPowerLimitInterval.c_str(), getErrorCode(result));
return getErrorCode(result);
}
val /= milliFactor; // Convert microwatts to milliwatts
pSustained[count].limit = static_cast<int32_t>(val);
pSustained[count].enabledStateLocked = true;
pSustained[count].intervalValueLocked = false;
pSustained[count].limitValueLocked = false;
pSustained[count].source = ZES_POWER_SOURCE_ANY;
pSustained[count].level = ZES_POWER_LEVEL_SUSTAINED;
pSustained[count].limitUnit = ZES_LIMIT_UNIT_POWER;
pSustained[count].interval = interval;
count++;
}
if (count < *pCount) {
result = pSysfsAccess->read(criticalPowerLimit, val);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), criticalPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
pSustained[count].enabledStateLocked = true;
pSustained[count].intervalValueLocked = true;
pSustained[count].limitValueLocked = false;
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
pSustained[count].limit = pSysmanProductHelper->getPowerLimitValue(val);
pSustained[count].limitUnit = pSysmanProductHelper->getPowerLimitUnit();
}
}
return result;
}
ze_result_t LinuxPowerImp::setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) {
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if (!isSubdevice) {
uint64_t val = 0;
for (uint32_t i = 0; i < *pCount; i++) {
if (pSustained[i].level == ZES_POWER_LEVEL_SUSTAINED) {
val = static_cast<uint64_t>(pSustained[i].limit) * milliFactor; // Convert milliwatts to microwatts
result = pSysfsAccess->write(sustainedPowerLimit, 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(), sustainedPowerLimit.c_str(), getErrorCode(result));
return getErrorCode(result);
}
result = pSysfsAccess->write(sustainedPowerLimitInterval, pSustained[i].interval);
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(), sustainedPowerLimitInterval.c_str(), getErrorCode(result));
return getErrorCode(result);
}
} else if (pSustained[i].level == ZES_POWER_LEVEL_PEAK) {
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));
return getErrorCode(result);
}
} else {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
result = ZE_RESULT_SUCCESS;
}
return result;
}
ze_result_t LinuxPowerImp::getEnergyThreshold(zes_energy_threshold_t *pThreshold) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxPowerImp::setEnergyThreshold(double threshold) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
// The top-level hwmon(hwmon1 in example) contains all the power related information and device level
// energy counters. The other hwmon directories contain per tile energy counters.
// ex:- device/hwmon/hwmon1/energy1_input name = "i915" (Top level hwmon)
// device/hwmon/hwmon2/energy1_input name = "i915_gt0" (Tile 0)
// device/hwmon/hwmon3/energy1_input name = "i915_gt1" (Tile 1)
bool LinuxPowerImp::isIntelGraphicsHwmonDir(const std::string &name) {
std::string intelGraphicsHwmonName = pSysmanKmdInterface->getHwmonName(subdeviceId, isSubdevice);
if (name == intelGraphicsHwmonName) {
return true;
}
return false;
}
bool LinuxPowerImp::isPowerModuleSupported() {
std::vector<std::string> listOfAllHwmonDirs = {};
bool hwmonDirExists = false;
const std::string hwmonDir("device/hwmon");
if (ZE_RESULT_SUCCESS != pSysfsAccess->scanDirEntries(hwmonDir, listOfAllHwmonDirs)) {
hwmonDirExists = false;
}
for (const auto &tempHwmonDirEntry : listOfAllHwmonDirs) {
const std::string hwmonNameFile = hwmonDir + "/" + tempHwmonDirEntry + "/" + "name";
std::string name;
if (ZE_RESULT_SUCCESS != pSysfsAccess->read(hwmonNameFile, name)) {
continue;
}
if (isIntelGraphicsHwmonDir(name)) {
intelGraphicsHwmonDir = hwmonDir + "/" + tempHwmonDirEntry;
hwmonDirExists = true;
canControl = isSubdevice ? false : true;
}
}
if (!isSubdevice) {
uint64_t val = 0;
sustainedPowerLimit = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameSustainedPowerLimit, subdeviceId, false);
criticalPowerLimit = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameCriticalPowerLimit, subdeviceId, false);
sustainedPowerLimitInterval = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameSustainedPowerLimitInterval, subdeviceId, false);
if (ZE_RESULT_SUCCESS == pSysfsAccess->read(sustainedPowerLimit, val)) {
powerLimitCount++;
}
if (ZE_RESULT_SUCCESS == pSysfsAccess->read(criticalPowerLimit, val)) {
powerLimitCount++;
}
}
if (hwmonDirExists == false) {
return (pPmt != nullptr);
}
return true;
}
LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
productFamily = pLinuxSysmanImp->getProductFamily();
pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
}
OsPower *OsPower::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
LinuxPowerImp *pLinuxPowerImp = new LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId);
return static_cast<OsPower *>(pLinuxPowerImp);
}
} // namespace Sysman
} // namespace L0

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

@@ -1,74 +0,0 @@
/*
* 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/api/power/sysman_os_power.h"
#include "igfxfmid.h"
#include <memory>
#include <string>
namespace L0 {
namespace Sysman {
class SysmanKmdInterface;
class SysFsAccessInterface;
class SysmanProductHelper;
class PlatformMonitoringTech;
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;
ze_result_t getLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t setLimitsExt(uint32_t *pCount, zes_power_limit_ext_desc_t *pSustained) override;
ze_result_t getPropertiesExt(zes_power_ext_properties_t *pExtPoperties) override;
bool isPowerModuleSupported() override;
bool isIntelGraphicsHwmonDir(const std::string &name);
ze_result_t getPmtEnergyCounter(zes_power_energy_counter_t *pEnergy);
LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
LinuxPowerImp() = default;
~LinuxPowerImp() override = default;
protected:
PlatformMonitoringTech *pPmt = nullptr;
SysFsAccessInterface *pSysfsAccess = nullptr;
SysmanKmdInterface *pSysmanKmdInterface = nullptr;
private:
std::string intelGraphicsHwmonDir = {};
std::string criticalPowerLimit = {};
std::string sustainedPowerLimit = {};
std::string sustainedPowerLimitInterval = {};
bool canControl = false;
bool isSubdevice = false;
uint32_t subdeviceId = 0;
uint32_t powerLimitCount = 0;
PRODUCT_FAMILY productFamily{};
SysmanProductHelper *pSysmanProductHelper = nullptr;
class PowerLimitRestorer;
ze_result_t getErrorCode(ze_result_t result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return result;
}
ze_result_t getMinLimit(int32_t &minLimit);
ze_result_t getMaxLimit(int32_t &maxLimit);
ze_result_t getDefaultLimit(int32_t &defaultLimit);
};
} // namespace Sysman
} // namespace L0

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

@@ -77,6 +77,7 @@ class SysmanProductHelper {
virtual int32_t getPowerLimitValue(uint64_t value) = 0;
virtual uint64_t setPowerLimitValue(int32_t value) = 0;
virtual zes_limit_unit_t getPowerLimitUnit() = 0;
virtual bool isPowerSetLimitSupported() = 0;
// Diagnostics
virtual bool isDiagnosticsSupported() = 0;

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

@@ -54,6 +54,7 @@ class SysmanProductHelperHw : public SysmanProductHelper {
int32_t getPowerLimitValue(uint64_t value) override;
uint64_t setPowerLimitValue(int32_t value) override;
zes_limit_unit_t getPowerLimitUnit() override;
bool isPowerSetLimitSupported() override;
// Diagnostics
bool isDiagnosticsSupported() override;

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

@@ -219,6 +219,11 @@ zes_limit_unit_t SysmanProductHelperHw<gfxProduct>::getPowerLimitUnit() {
return ZES_LIMIT_UNIT_POWER;
}
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isPowerSetLimitSupported() {
return true;
}
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isDiagnosticsSupported() {
return false;

20
level_zero/sysman/test/unit_tests/sources/power/linux/CMakeLists.txt
View File

@@ -1,28 +1,16 @@
#
# Copyright (C) 2020-2023 Intel Corporation
# Copyright (C) 2020-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_TESTS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_power.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power_helper_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_power_prelim.h
)
else()
list(APPEND L0_TESTS_SYSMAN_POWER_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_power_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_power.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE

11
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power.h
View File

@@ -55,6 +55,7 @@ struct MockPowerSysfsAccessInterface : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadPeakResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadIntResult = ZE_RESULT_SUCCESS;
ze_result_t mockWritePeakLimitResult = ZE_RESULT_SUCCESS;
ze_result_t mockscanDirEntriesResult = ZE_RESULT_SUCCESS;
@@ -187,6 +188,14 @@ struct MockPowerSysfsAccessInterface : public L0::Sysman::SysFsAccessInterface {
return getValUnsignedInt(file, val);
}
ze_result_t write(const std::string file, const int val) override {
if (mockWriteResult != ZE_RESULT_SUCCESS) {
return mockWriteResult;
}
return setVal(file, val);
}
ze_result_t write(const std::string file, const uint64_t val) override {
ze_result_t result = ZE_RESULT_SUCCESS;
if (!mockWriteUnsignedResult.empty()) {
@@ -291,7 +300,7 @@ struct MockPowerFsAccess : public L0::Sysman::FsAccessInterface {
class PublicLinuxPowerImp : public L0::Sysman::LinuxPowerImp {
public:
PublicLinuxPowerImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId) {}
PublicLinuxPowerImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId) {}
using L0::Sysman::LinuxPowerImp::pPmt;
using L0::Sysman::LinuxPowerImp::pSysfsAccess;
};

406
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power_prelim.h
View File

@@ -1,406 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/string.h"
#include "level_zero/sysman/source/api/power/linux/sysman_os_power_imp_prelim.h"
#include "level_zero/sysman/source/api/power/sysman_power_imp.h"
#include "level_zero/sysman/source/device/sysman_device_imp.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/sysman_const.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
namespace L0 {
namespace Sysman {
namespace ult {
constexpr uint64_t setEnergyCounter = (83456u * 1048576u);
constexpr uint64_t offset = 0x400;
constexpr uint32_t mockLimitCount = 2u;
const std::string deviceName("device");
const std::string baseTelemSysFS("/sys/class/intel_pmt");
const std::string hwmonDir("device/hwmon");
const std::string i915HwmonDir("device/hwmon/hwmon2");
const std::string nonI915HwmonDir("device/hwmon/hwmon1");
const std::string i915HwmonDirTile0("device/hwmon/hwmon3");
const std::string i915HwmonDirTile1("device/hwmon/hwmon4");
const std::vector<std::string> listOfMockedHwmonDirs = {"hwmon0", "hwmon1", "hwmon2", "hwmon3", "hwmon4"};
const std::string sustainedPowerLimit("power1_max");
const std::string sustainedPowerLimitInterval("power1_max_interval");
const std::string criticalPowerLimit1("curr1_crit");
const std::string criticalPowerLimit2("power1_crit");
const std::string energyCounterNode("energy1_input");
const std::string defaultPowerLimit("power1_rated_max");
constexpr uint64_t expectedEnergyCounter = 123456785u;
constexpr uint64_t expectedEnergyCounterTile0 = 123456785u;
constexpr uint64_t expectedEnergyCounterTile1 = 128955785u;
constexpr uint32_t mockDefaultPowerLimitVal = 300000000;
constexpr uint64_t mockMinPowerLimitVal = 300000000;
constexpr uint64_t mockMaxPowerLimitVal = 600000000;
const std::map<std::string, uint64_t> deviceKeyOffsetMapPower = {
{"PACKAGE_ENERGY", 0x400},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}};
struct MockPowerSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadPeakResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadIntResult = ZE_RESULT_SUCCESS;
ze_result_t mockWritePeakLimitResult = ZE_RESULT_SUCCESS;
ze_result_t mockscanDirEntriesResult = ZE_RESULT_SUCCESS;
std::vector<ze_result_t> mockReadValUnsignedLongResult{};
std::vector<ze_result_t> mockWriteUnsignedResult{};
ze_result_t getValString(const std::string file, std::string &val) {
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;
if (file.compare(i915HwmonDir + "/" + "name") == 0) {
val = "i915";
result = ZE_RESULT_SUCCESS;
} else if (file.compare(nonI915HwmonDir + "/" + "name") == 0) {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
} else if (file.compare(i915HwmonDirTile1 + "/" + "name") == 0) {
val = "i915_gt1";
result = ZE_RESULT_SUCCESS;
} else if (file.compare(i915HwmonDirTile0 + "/" + "name") == 0) {
val = "i915_gt0";
result = ZE_RESULT_SUCCESS;
} else {
val = "garbageI915";
result = ZE_RESULT_SUCCESS;
}
return result;
}
uint64_t sustainedPowerLimitVal = 0;
uint64_t criticalPowerLimitVal = 0;
int32_t sustainedPowerLimitIntervalVal = 0;
ze_result_t getValUnsignedLongHelper(const std::string file, uint64_t &val);
ze_result_t getValUnsignedLong(const std::string file, uint64_t &val) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
val = sustainedPowerLimitVal;
} else if ((file.compare(i915HwmonDir + "/" + criticalPowerLimit1) == 0) || (file.compare(i915HwmonDir + "/" + criticalPowerLimit2) == 0)) {
if (mockReadPeakResult != ZE_RESULT_SUCCESS) {
return mockReadPeakResult;
}
val = criticalPowerLimitVal;
} else if (file.compare(i915HwmonDirTile0 + "/" + energyCounterNode) == 0) {
val = expectedEnergyCounterTile0;
} else if (file.compare(i915HwmonDirTile1 + "/" + energyCounterNode) == 0) {
val = expectedEnergyCounterTile1;
} else if (file.compare(i915HwmonDir + "/" + energyCounterNode) == 0) {
val = expectedEnergyCounter;
} else if (file.compare(i915HwmonDir + "/" + defaultPowerLimit) == 0) {
val = mockDefaultPowerLimitVal;
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t getValUnsignedInt(const std::string file, uint32_t &val) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (file.compare(i915HwmonDir + "/" + defaultPowerLimit) == 0) {
val = mockDefaultPowerLimitVal;
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t setVal(const std::string file, const int val) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
sustainedPowerLimitVal = static_cast<uint64_t>(val);
} else if ((file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0)) {
sustainedPowerLimitIntervalVal = val;
} else if ((file.compare(i915HwmonDir + "/" + criticalPowerLimit1) == 0) || (file.compare(i915HwmonDir + "/" + criticalPowerLimit2) == 0)) {
if (mockWritePeakLimitResult != ZE_RESULT_SUCCESS) {
return mockWritePeakLimitResult;
}
criticalPowerLimitVal = static_cast<uint64_t>(val);
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t getscanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) {
if (file.compare(hwmonDir) == 0) {
listOfEntries = listOfMockedHwmonDirs;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t read(const std::string file, uint64_t &val) override {
ze_result_t result = ZE_RESULT_SUCCESS;
if (!mockReadValUnsignedLongResult.empty()) {
result = mockReadValUnsignedLongResult.front();
mockReadValUnsignedLongResult.erase(mockReadValUnsignedLongResult.begin());
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
return getValUnsignedLong(file, val);
}
ze_result_t read(const std::string file, int32_t &val) override {
if (mockReadIntResult != ZE_RESULT_SUCCESS) {
return mockReadIntResult;
}
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimitInterval) == 0) {
val = sustainedPowerLimitIntervalVal;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t read(const std::string file, std::string &val) override {
if (mockReadResult != ZE_RESULT_SUCCESS) {
return mockReadResult;
}
return getValString(file, val);
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadResult != ZE_RESULT_SUCCESS) {
return mockReadResult;
}
return getValUnsignedInt(file, val);
}
ze_result_t write(const std::string file, const int val) override {
if (mockWriteResult != ZE_RESULT_SUCCESS) {
return mockWriteResult;
}
return setVal(file, val);
}
ze_result_t write(const std::string file, const uint64_t val) override {
ze_result_t result = ZE_RESULT_SUCCESS;
if (!mockWriteUnsignedResult.empty()) {
result = mockWriteUnsignedResult.front();
mockWriteUnsignedResult.erase(mockWriteUnsignedResult.begin());
if (result != ZE_RESULT_SUCCESS) {
return result;
}
}
if (file.compare(i915HwmonDir + "/" + sustainedPowerLimit) == 0) {
if (val < mockMinPowerLimitVal) {
sustainedPowerLimitVal = mockMinPowerLimitVal;
} else if (val > mockMaxPowerLimitVal) {
sustainedPowerLimitVal = mockMaxPowerLimitVal;
} else {
sustainedPowerLimitVal = val;
}
} else if ((file.compare(i915HwmonDir + "/" + criticalPowerLimit1) == 0) || (file.compare(i915HwmonDir + "/" + criticalPowerLimit2) == 0)) {
if (mockWritePeakLimitResult != ZE_RESULT_SUCCESS) {
return mockWritePeakLimitResult;
}
criticalPowerLimitVal = val;
} else {
result = ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
ze_result_t scanDirEntries(const std::string file, std::vector<std::string> &listOfEntries) override {
if (mockscanDirEntriesResult != ZE_RESULT_SUCCESS) {
return mockscanDirEntriesResult;
}
return getscanDirEntries(file, listOfEntries);
}
MockPowerSysfsAccess() = default;
};
struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
MockPowerPmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
~MockPowerPmt() override {
rootDeviceTelemNodeIndex = 0;
}
void mockedInit(L0::Sysman::FsAccessInterface *pFsAccess) {
std::string gpuUpstreamPortPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
if (ZE_RESULT_SUCCESS != L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, gpuUpstreamPortPath)) {
return;
}
telemetryDeviceEntry = "/sys/class/intel_pmt/telem2/telem";
}
};
struct MockPowerFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (directory.compare(baseTelemSysFS) == 0) {
listOfTelemNodes.push_back("telem1");
listOfTelemNodes.push_back("telem2");
listOfTelemNodes.push_back("telem3");
listOfTelemNodes.push_back("telem4");
listOfTelemNodes.push_back("telem5");
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getRealPath(const std::string path, std::string &buf) override {
if (path.compare("/sys/class/intel_pmt/telem1") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
} else if (path.compare("/sys/class/intel_pmt/telem2") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem2";
} else if (path.compare("/sys/class/intel_pmt/telem3") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem3";
} else if (path.compare("/sys/class/intel_pmt/telem4") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem4";
} else if (path.compare("/sys/class/intel_pmt/telem5") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem5";
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
MockPowerFsAccess() = default;
};
class PublicLinuxPowerImp : public L0::Sysman::LinuxPowerImp {
public:
PublicLinuxPowerImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId) {}
using L0::Sysman::LinuxPowerImp::pPmt;
using L0::Sysman::LinuxPowerImp::pSysfsAccess;
};
class SysmanDevicePowerFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<PublicLinuxPowerImp> pPublicLinuxPowerImp;
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> pmtMapOriginal;
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pFsAccess = std::make_unique<MockPowerFsAccess>();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockPowerSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pmtMapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockPowerPmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pPmt->keyOffsetMap = deviceKeyOffsetMapPower;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
getPowerHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->releasePmtObject();
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = pmtMapOriginal;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanDeviceFixture::TearDown();
}
std::vector<zes_pwr_handle_t> getPowerHandles(uint32_t count) {
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
class SysmanDevicePowerMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<PublicLinuxPowerImp> pPublicLinuxPowerImp;
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOriginal;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
device = pSysmanDevice;
pFsAccess = std::make_unique<MockPowerFsAccess>();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockPowerSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
mapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockPowerPmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pPmt->keyOffsetMap = deviceKeyOffsetMapPower;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
}
void TearDown() override {
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.second) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = mapOriginal;
SysmanMultiDeviceFixture::TearDown();
}
std::vector<zes_pwr_handle_t> getPowerHandles(uint32_t count) {
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
} // namespace ult
} // namespace Sysman
} // namespace L0

441
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp
View File

@@ -67,12 +67,33 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenUninitializedPowerHandlesAndWhenGettin
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenScanDiectoriesFailAndPmtIsNullWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.second) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesWhenhwmonInterfaceExistsThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
@@ -84,6 +105,58 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerProper
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, defaultLimit.source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, defaultLimit.limitUnit);
EXPECT_EQ(defaultLimit.limit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWithNoStypeForExtPropertiesWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
@@ -139,6 +212,59 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerProper
EXPECT_EQ(properties.maxLimit, -1);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteForMinLimitFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.minLimit, -1);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteForMaxLimitFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.maxLimit, -1);
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteToOriginalLimitFailsThenVerifySustainedLimitIsMaximum, IsPVC) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxPowerImp->getProperties(&properties));
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = mockLimitCount;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
EXPECT_EQ(allLimits[i].limit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
}
}
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyCounterFailedWhenHwmonInterfaceExistThenValidErrorCodeReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
@@ -158,7 +284,27 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergy
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved) {
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumPowerHandleSucceeds) {
VariableBackup<L0::Sysman::SysFsAccessInterface *> sysfsBackup(&pLinuxSysmanImp->pSysfsAccess);
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
EXPECT_EQ(count, powerHandleComponentCount);
for (auto handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pLinuxSysmanImp->reInitSysmanDeviceResources();
count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
EXPECT_EQ(count, powerHandleComponentCount);
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
@@ -187,6 +333,120 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenSetPowerLimitsWhenGettingPowerLimitsWh
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesAndExtPropertiesThenApiCallReturnsFailure) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
}
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
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++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
}
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
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++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForSustainedPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
@@ -203,6 +463,176 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerLimitNodeReturnEr
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToSustainedLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToSustainedLimitIntervalSysNodeFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndReadingToSustainedLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
count = mockLimitCount;
pSysfsAccess->mockReadIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, 0u);
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndReadingToPeakLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockReadPeakResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingBurstPowerLimitThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_limit_ext_desc_t allLimits{};
uint32_t count = 1;
allLimits.level = ZES_POWER_LEVEL_BURST;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, &allLimits));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenCallingGetPowerLimitsExtThenProperValuesAreReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_limit_ext_desc_t allLimits{};
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, mockLimitCount);
count = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, &allLimits));
EXPECT_EQ(count, 1u);
EXPECT_EQ(false, allLimits.limitValueLocked);
EXPECT_EQ(true, allLimits.enabledStateLocked);
EXPECT_EQ(false, allLimits.intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits.source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits.limitUnit);
EXPECT_EQ(ZES_POWER_LEVEL_SUSTAINED, allLimits.level);
}
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenReadingPeakPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForPeakPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_peak_limit_t peakSet = {};
zes_power_peak_limit_t peakGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerNodeReturnErrorWhenGetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
@@ -225,7 +655,7 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenReadingpeakPowerNodeReturnErrorWhenGet
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned) {
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
zes_power_sustained_limit_t sustainedSet = {};
@@ -279,7 +709,7 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerIntervalNodeRetur
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned) {
HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
@@ -382,7 +812,8 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerProper
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
zes_power_properties_t properties;
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);

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

@@ -24,6 +24,7 @@ TEST_F(SysmanDevicePowerFixtureHelper, GivenValidPowerHandleWhenGettingPowerEner
}
}
constexpr uint32_t powerHandleComponentCountMultiDevice = 3u;
using SysmanDevicePowerMultiDeviceFixtureHelper = SysmanDevicePowerMultiDeviceFixture;
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidDeviceHandlesAndHwmonInterfaceExistThenSuccessIsReturned) {
@@ -38,11 +39,102 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidDeviceHandlesAndHwmo
} while (++subdeviceId < subDeviceCount);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenInvalidComponentCountWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCountMultiDevice);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCountMultiDevice);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerPointerWhenGettingCardPowerDomainWhenhwmonInterfaceExistsAndThenCallSucceeds) {
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_SUCCESS);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
} else {
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(defaultLimit.level, ZES_POWER_LEVEL_UNKNOWN);
EXPECT_EQ(defaultLimit.source, ZES_POWER_SOURCE_ANY);
EXPECT_EQ(defaultLimit.limitUnit, ZES_LIMIT_UNIT_POWER);
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
EXPECT_EQ(defaultLimit.limit, -1);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_EQ(defaultLimit.limit, static_cast<int32_t>(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleAndExtPropertiesWithNullDescWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
properties.pNext = &extProperties;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
EXPECT_EQ(properties.defaultLimit, -1);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndPmtIsNullForSubDeviceZeroWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
@@ -63,6 +155,232 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndPmt
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.first == 0) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, 0u);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerEnergyCounterThenValidPowerReadingsRetrieved) {
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));
zes_power_energy_counter_t energyCounter = {};
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
if (properties.subdeviceId == 0) {
EXPECT_EQ(energyCounter.energy, expectedEnergyCounterTile0);
} else if (properties.subdeviceId == 1) {
EXPECT_EQ(energyCounter.energy, expectedEnergyCounterTile1);
}
}
}
HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) {
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));
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
sustainedSet.power = 300000;
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
zes_power_burst_limit_t burstGet = {};
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
EXPECT_EQ(burstGet.enabled, false);
EXPECT_EQ(burstGet.power, -1);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
}
zes_power_peak_limit_t peakSet = {};
zes_power_peak_limit_t peakGet = {};
peakSet.powerAC = 300000;
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
EXPECT_EQ(peakGet.powerAC, peakSet.powerAC);
EXPECT_EQ(peakGet.powerDC, -1);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
}
}
}
HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
const int32_t testLimit = 300000;
const int32_t testInterval = 10;
zes_power_properties_t properties = {};
zes_power_limit_ext_desc_t limits = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
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, &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(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()));
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, 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);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
}
}
}
HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
const int32_t testLimit = 300000;
const int32_t testInterval = 10;
zes_power_properties_t properties = {};
zes_power_limit_ext_desc_t limits = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
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, &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(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()));
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, 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);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
}
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

374
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper_prelim.cpp
View File

@@ -1,374 +0,0 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power_prelim.h"
namespace L0 {
namespace Sysman {
namespace ult {
constexpr uint32_t powerHandleComponentCountMultiDevice = 3u;
class SysmanDevicePowerMultiDeviceFixtureHelper : public SysmanDevicePowerMultiDeviceFixture {
protected:
void SetUp() override {
SysmanDevicePowerMultiDeviceFixture::SetUp();
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
}
void TearDown() override {
SysmanDevicePowerMultiDeviceFixture::TearDown();
}
};
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenInvalidComponentCountWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCountMultiDevice);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCountMultiDevice);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerPointerWhenGettingCardPowerDomainWhenhwmonInterfaceExistsAndThenCallSucceds) {
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_SUCCESS);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
zes_power_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(properties.defaultLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
} else {
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(defaultLimit.level, ZES_POWER_LEVEL_UNKNOWN);
EXPECT_EQ(defaultLimit.source, ZES_POWER_SOURCE_ANY);
EXPECT_EQ(defaultLimit.limitUnit, ZES_LIMIT_UNIT_POWER);
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
EXPECT_EQ(defaultLimit.limit, -1);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_EQ(defaultLimit.limit, static_cast<int32_t>(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleAndExtPropertiesWithNullDescWhenGettingPowerPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
properties.pNext = &extProperties;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
if (properties.onSubdevice) {
EXPECT_FALSE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_PACKAGE);
EXPECT_EQ(properties.maxLimit, -1);
EXPECT_EQ(properties.minLimit, -1);
EXPECT_EQ(properties.defaultLimit, -1);
} else {
EXPECT_TRUE(properties.canControl);
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDiectoriesFailAndPmtIsNullForSubDeviceZeroWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.first == 0) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.first == 0) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, 0u);
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGettingPowerEnergyCounterThenValidPowerReadingsRetrieved) {
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));
zes_power_energy_counter_t energyCounter = {};
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
if (properties.subdeviceId == 0) {
EXPECT_EQ(energyCounter.energy, expectedEnergyCounterTile0);
} else if (properties.subdeviceId == 1) {
EXPECT_EQ(energyCounter.energy, expectedEnergyCounterTile1);
}
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved) {
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));
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
sustainedSet.power = 300000;
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
zes_power_burst_limit_t burstGet = {};
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
EXPECT_EQ(burstGet.enabled, false);
EXPECT_EQ(burstGet.power, -1);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
}
zes_power_peak_limit_t peakSet = {};
zes_power_peak_limit_t peakGet = {};
peakSet.powerAC = 300000;
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
EXPECT_EQ(peakGet.powerAC, peakSet.powerAC);
EXPECT_EQ(peakGet.powerDC, -1);
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
}
}
}
HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
const int32_t testLimit = 300000;
const int32_t testInterval = 10;
zes_power_properties_t properties = {};
zes_power_limit_ext_desc_t limits = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
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, &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(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()));
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, 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);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
}
}
}
HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCountMultiDevice);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
const int32_t testLimit = 300000;
const int32_t testInterval = 10;
zes_power_properties_t properties = {};
zes_power_limit_ext_desc_t limits = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
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, &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(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()));
} else {
EXPECT_EQ(ZE_RESULT_SUCCESS, 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);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
if (!properties.onSubdevice) {
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
} else {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
}
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

926
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_prelim.cpp
View File

@@ -1,926 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power_prelim.h"
namespace L0 {
namespace Sysman {
namespace ult {
constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u;
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter;
return count;
}
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenInvalidComponentCountWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidPowerHandlesIsReturned) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerPointerWhenGettingCardPowerDomainWhenhwmonInterfaceExistsAndThenCallSucceds) {
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_SUCCESS);
}
TEST_F(SysmanDevicePowerFixture, GivenInvalidPowerPointerWhenGettingCardPowerDomainAndThenReturnsFailure) {
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), nullptr), ZE_RESULT_ERROR_INVALID_NULL_POINTER);
}
TEST_F(SysmanDevicePowerFixture, GivenUninitializedPowerHandlesAndWhenGettingCardPowerDomainThenReurnsFailure) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixture, GivenScanDiectoriesFailAndPmtIsNullWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.second) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesWhenhwmonInterfaceExistsThenCallSucceeds) {
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));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
EXPECT_EQ(extProperties.domain, ZES_POWER_DOMAIN_CARD);
EXPECT_TRUE(defaultLimit.limitValueLocked);
EXPECT_TRUE(defaultLimit.enabledStateLocked);
EXPECT_TRUE(defaultLimit.intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, defaultLimit.source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, defaultLimit.limitUnit);
EXPECT_EQ(defaultLimit.limit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWithNoStypeForExtPropertiesWhenGettingPowerPropertiesAndExtPropertiesThenCallSucceeds) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
properties.pNext = &extProperties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
EXPECT_EQ(properties.canControl, true);
EXPECT_EQ(properties.isEnergyThresholdSupported, false);
EXPECT_EQ(properties.defaultLimit, (int32_t)(mockDefaultPowerLimitVal / milliFactor));
EXPECT_EQ(properties.maxLimit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
EXPECT_EQ(properties.minLimit, (int32_t)(mockMinPowerLimitVal / milliFactor));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.defaultLimit, -1);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndSustainedLimitReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.minLimit, -1);
EXPECT_EQ(properties.maxLimit, -1);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndMinLimitReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.minLimit, -1);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndMaxLimitReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.maxLimit, -1);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteForMinLimitFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.minLimit, -1);
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteForMaxLimitFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.maxLimit, -1);
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsWriteToOriginalLimitFailsThenVerifySustainedLimitIsMaximum, IsPVC) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess.get();
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_SUCCESS);
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxPowerImp->getProperties(&properties));
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = mockLimitCount;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
EXPECT_EQ(allLimits[i].limit, (int32_t)(mockMaxPowerLimitVal / milliFactor));
}
}
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterFailedWhenHwmonInterfaceExistThenValidErrorCodeReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter = {};
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumPowerHandleSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
EXPECT_EQ(count, powerHandleComponentCount);
for (auto handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pLinuxSysmanImp->reInitSysmanDeviceResources();
count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(device->toHandle(), &count, NULL));
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
sustainedSet.enabled = 1;
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
zes_power_burst_limit_t burstGet = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr));
EXPECT_EQ(burstGet.enabled, false);
EXPECT_EQ(burstGet.power, -1);
zes_power_peak_limit_t peakSet = {};
zes_power_peak_limit_t peakGet = {};
peakSet.powerAC = 300000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
EXPECT_EQ(peakGet.powerAC, peakSet.powerAC);
EXPECT_EQ(peakGet.powerDC, -1);
}
}
TEST_F(SysmanDevicePowerFixture, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesAndExtPropertiesThenApiCallReturnsFailure) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_properties_t properties = {};
zes_power_ext_properties_t extProperties = {};
zes_power_limit_ext_desc_t defaultLimit = {};
extProperties.defaultLimit = &defaultLimit;
extProperties.stype = ZES_STRUCTURE_TYPE_POWER_EXT_PROPERTIES;
properties.pNext = &extProperties;
pSysfsAccess->mockReadResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetProperties(handle, &properties));
}
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
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++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
}
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t limitCount = 0;
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++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_FALSE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
allLimits[i].interval = testInterval;
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_FALSE(allLimits[i].limitValueLocked);
EXPECT_TRUE(allLimits[i].enabledStateLocked);
EXPECT_TRUE(allLimits[i].intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit);
allLimits[i].limit = testLimit;
}
}
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data()));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data()));
for (uint32_t i = 0; i < limitCount; i++) {
if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) {
EXPECT_EQ(testInterval, allLimits[i].interval);
} else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) {
EXPECT_EQ(0, allLimits[i].interval);
}
EXPECT_EQ(testLimit, allLimits[i].limit);
}
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingSustainedPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForSustainedPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndWritingToSustainedLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndWritingToSustainedLimitIntervalSysNodeFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndReadingToSustainedLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_SUCCESS);
count = mockLimitCount;
pSysfsAccess->mockReadIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, 0u);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndReadingToPeakLimitSysNodesFailsWhenCallingGetPowerLimitsExtThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockReadPeakResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenSettingBurstPowerLimitThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_limit_ext_desc_t allLimits{};
uint32_t count = 1;
allLimits.level = ZES_POWER_LEVEL_BURST;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, &allLimits));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenCallingGetPowerLimitsExtThenProperValuesAreReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_limit_ext_desc_t allLimits{};
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, nullptr));
EXPECT_EQ(count, mockLimitCount);
count = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, &allLimits));
EXPECT_EQ(count, 1u);
EXPECT_EQ(false, allLimits.limitValueLocked);
EXPECT_EQ(true, allLimits.enabledStateLocked);
EXPECT_EQ(false, allLimits.intervalValueLocked);
EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits.source);
EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits.limitUnit);
EXPECT_EQ(ZES_POWER_LEVEL_SUSTAINED, allLimits.level);
}
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsPVC) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
HWTEST2_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsDG1) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
uint32_t count = mockLimitCount;
std::vector<zes_power_limit_ext_desc_t> allLimits(mockLimitCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data()));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data()));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingPeakPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForPeakPowerLimitEnabledThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_peak_limit_t peakSet = {};
zes_power_peak_limit_t peakGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingSustainedPowerNodeReturnErrorWhenGetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustainedGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr));
}
}
TEST_F(SysmanDevicePowerFixture, GivenReadingpeakPowerNodeReturnErrorWhenGetPowerLimitsForpeakPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_peak_limit_t peakGet = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet));
}
}
TEST_F(SysmanDevicePowerFixture, GivenwritingSustainedPowerNodeReturnErrorWhenSetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_power_sustained_limit_t sustainedSet = {};
sustainedSet.enabled = 1;
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixture, GivenwritingSustainedPowerIntervalNodeReturnErrorWhenSetPowerLimitsForSustainedPowerIntervalWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_power_sustained_limit_t sustainedSet = {};
sustainedSet.enabled = 1;
sustainedSet.interval = 10;
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
pSysfsAccess->mockWriteResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
zes_power_sustained_limit_t sustainedSet = {};
sustainedSet.enabled = 0;
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
zes_power_sustained_limit_t sustainedSet = {};
zes_power_sustained_limit_t sustainedGet = {};
sustainedSet.enabled = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
sustainedSet.power = 300000;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], &sustainedGet, nullptr, nullptr));
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
}
TEST_F(SysmanDevicePowerFixture, GivenScanDirectoriesFailAndPmtIsNotNullPointerThenPowerModuleIsSupported) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
PublicLinuxPowerImp *pPowerImp = new PublicLinuxPowerImp(pOsSysman, onSubdevice, subdeviceId);
EXPECT_TRUE(pPowerImp->isPowerModuleSupported());
delete pPowerImp;
}
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenInvalidComponentCountWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixture, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidPowerHandlesIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
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));
EXPECT_FALSE(properties.onSubdevice);
EXPECT_EQ(properties.subdeviceId, 0u);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterThenValidPowerReadingsRetrieved) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
auto handles = getPowerHandles(powerHandleComponentCount);
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter;
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterWhenEnergyHwmonFileReturnsErrorAndPmtFailsThenFailureIsReturned) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
}
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
do {
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, nullptr);
} while (++subdeviceId < subDeviceCount);
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetEnergyCounter(handle, &energyCounter));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_energy_threshold_t threshold;
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetEnergyThreshold(handle, &threshold));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenSettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
double threshold = 0;
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetEnergyThreshold(handle, threshold));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerLimitsThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustained, &burst, &peak));
}
}
TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenSettingPowerLimitsThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustained, &burst, &peak));
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterWhenEnergyHwmonFailsThenValidPowerReadingsRetrievedFromPmt) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
auto handles = getPowerHandles(powerHandleComponentCount);
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter;
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

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

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -53,6 +53,11 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCalling
EXPECT_EQ(expectedPowerUnit, pSysmanProductHelper->getPowerLimitUnit());
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingIsPowerSetLimitSupportedThenVerifySetRequestIsSupported, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_TRUE(pSysmanProductHelper->isPowerSetLimitSupported());
}
} // namespace ult
} // namespace Sysman
} // namespace L0