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

refactor: Remove unnecessary prelim files for frequency

Browse Source 
Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2023-12-15 12:51:34 +00:00
committed by Compute-Runtime-Automation
parent 3f1d3d42ad
commit d953b3e8c5
12 changed files with 201 additions and 1975 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
level_zero/sysman/source/api/frequency/linux/CMakeLists.txt
View File

@@ -6,20 +6,10 @@
set(L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp_prelim.h
)
else()
list(APPEND L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_frequency_imp.h
)
endif()
if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE

72
level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.cpp
View File

@@ -8,6 +8,8 @@
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/device/device.h"
#include "shared/source/helpers/hw_info.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
@@ -19,7 +21,6 @@
namespace L0 {
namespace Sysman {
const bool LinuxFrequencyImp::canControl = true; // canControl is true on i915 (GEN9 Hardcode)
ze_result_t LinuxFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
@@ -118,7 +119,6 @@ ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimi
}
return setMax(newMax);
}
bool LinuxFrequencyImp::getThrottleReasonStatus(void) {
uint32_t val = 0;
auto result = pSysfsAccess->read(throttleReasonStatusFile, val);
@@ -237,9 +237,8 @@ ze_result_t LinuxFrequencyImp::setOcTjMax(double ocTjMax) {
}
ze_result_t LinuxFrequencyImp::getMin(double &min) {
double intval;
ze_result_t result = pSysfsAccess->read(minFreqFile, intval);
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(minFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -248,7 +247,7 @@ ze_result_t LinuxFrequencyImp::getMin(double &min) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
min = intval;
min = freqVal;
return ZE_RESULT_SUCCESS;
}
@@ -266,9 +265,8 @@ ze_result_t LinuxFrequencyImp::setMin(double min) {
}
ze_result_t LinuxFrequencyImp::getMax(double &max) {
double intval;
ze_result_t result = pSysfsAccess->read(maxFreqFile, intval);
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(maxFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -277,7 +275,7 @@ ze_result_t LinuxFrequencyImp::getMax(double &max) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
max = intval;
max = freqVal;
return ZE_RESULT_SUCCESS;
}
@@ -300,9 +298,9 @@ ze_result_t LinuxFrequencyImp::setMax(double max) {
}
ze_result_t LinuxFrequencyImp::getRequest(double &request) {
double intval;
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(requestFreqFile, intval);
ze_result_t result = pSysfsAccess->read(requestFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -311,7 +309,7 @@ ze_result_t LinuxFrequencyImp::getRequest(double &request) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, requestFreqFile.c_str(), result);
return result;
}
request = intval;
request = freqVal;
return ZE_RESULT_SUCCESS;
}
@@ -333,14 +331,13 @@ ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
} else {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return result;
}
ze_result_t LinuxFrequencyImp::getActual(double &actual) {
double intval;
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(actualFreqFile, intval);
ze_result_t result = pSysfsAccess->read(actualFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -349,14 +346,14 @@ ze_result_t LinuxFrequencyImp::getActual(double &actual) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, actualFreqFile.c_str(), result);
return result;
}
actual = intval;
actual = freqVal;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
double intval;
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(efficientFreqFile, intval);
ze_result_t result = pSysfsAccess->read(efficientFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -365,14 +362,14 @@ ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, efficientFreqFile.c_str(), result);
return result;
}
efficient = intval;
efficient = freqVal;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
double intval;
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(maxValFreqFile, intval);
ze_result_t result = pSysfsAccess->read(maxValFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -381,14 +378,14 @@ ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxValFreqFile.c_str(), result);
return result;
}
maxVal = intval;
maxVal = freqVal;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
double intval;
double freqVal = 0;
ze_result_t result = pSysfsAccess->read(minValFreqFile, intval);
ze_result_t result = pSysfsAccess->read(minValFreqFile, freqVal);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -397,13 +394,18 @@ ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minValFreqFile.c_str(), result);
return result;
}
minVal = intval;
minVal = freqVal;
return ZE_RESULT_SUCCESS;
}
void LinuxFrequencyImp::init() {
const std::string baseDir = pSysmanKmdInterface->getBasePath(subdeviceId);
bool baseDirectoryExists = pSysfsAccess->directoryExists(baseDir);
bool baseDirectoryExists = false;
if (pSysfsAccess->directoryExists(baseDir)) {
baseDirectoryExists = true;
}
minFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinFrequency, subdeviceId, baseDirectoryExists);
maxFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxFrequency, subdeviceId, baseDirectoryExists);
@@ -434,9 +436,9 @@ void LinuxFrequencyImp::init() {
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
productFamily = pLinuxSysmanImp->getProductFamily();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
init();
}
@@ -446,7 +448,19 @@ OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uin
}
std::vector<zes_freq_domain_t> OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
std::vector<zes_freq_domain_t> freqDomains = {ZES_FREQ_DOMAIN_GPU};
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto &productHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper<NEO::ProductHelper>();
auto releaseHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getReleaseHelper();
std::vector<zes_freq_domain_t> freqDomains = {};
uint32_t mediaFreqTileIndex;
if (productHelper.getMediaFrequencyTileIndex(releaseHelper, mediaFreqTileIndex) == true) {
auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
const std::string baseDir = "gt/gt" + std::to_string(mediaFreqTileIndex) + "/";
if (pSysfsAccess->directoryExists(baseDir)) {
freqDomains.push_back(ZES_FREQ_DOMAIN_MEDIA);
}
}
freqDomains.push_back(ZES_FREQ_DOMAIN_GPU);
return freqDomains;
}

3
level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h
View File

@@ -11,6 +11,7 @@
#include "level_zero/sysman/source/api/frequency/sysman_frequency_imp.h"
#include "level_zero/sysman/source/api/frequency/sysman_os_frequency.h"
#include "igfxfmid.h"
namespace L0 {
namespace Sysman {
@@ -58,9 +59,9 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
private:
std::string minFreqFile;
std::string maxFreqFile;
std::string boostFreqFile;
std::string minDefaultFreqFile;
std::string maxDefaultFreqFile;
std::string boostFreqFile;
std::string requestFreqFile;
std::string tdpFreqFile;
std::string actualFreqFile;

443
level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp_prelim.cpp
View File

@@ -1,443 +0,0 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp_prelim.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/device/device.h"
#include "shared/source/helpers/hw_info.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 <cmath>
namespace L0 {
namespace Sysman {
const bool LinuxFrequencyImp::canControl = true; // canControl is true on i915 (GEN9 Hardcode)
ze_result_t LinuxFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
properties.pNext = nullptr;
properties.canControl = canControl;
properties.type = frequencyDomainNumber;
ze_result_t result1 = getMinVal(properties.min);
ze_result_t result2 = getMaxVal(properties.max);
// If can't figure out the valid range, then can't control it.
if (ZE_RESULT_SUCCESS != result1 || ZE_RESULT_SUCCESS != result2) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMinVal returned: 0x%x, getMaxVal returned: 0x%x> <setting min = 0.0, max = 0.0>\n", __func__, result1, result2);
properties.canControl = false;
properties.min = 0.0;
properties.max = 0.0;
}
properties.isThrottleEventSupported = false;
properties.onSubdevice = isSubdevice;
properties.subdeviceId = subdeviceId;
return ZE_RESULT_SUCCESS;
}
double LinuxFrequencyImp::osFrequencyGetStepSize() {
double stepSize;
if (productFamily >= IGFX_XE_HP_SDV) {
stepSize = 50.0;
} else {
stepSize = 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode)
}
return stepSize;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
ze_result_t result = getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x setting max = -1>\n", __func__, result);
pLimits->max = -1;
}
result = getMin(pLimits->min);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMin returned 0x%x setting min = -1>\n", __func__, result);
pLimits->min = -1;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
if (newMax == -1 && newMin == -1) {
double maxDefault = 0, minDefault = 0;
ze_result_t result1, result2, result;
result1 = pSysfsAccess->read(maxDefaultFreqFile, maxDefault);
result2 = pSysfsAccess->read(minDefaultFreqFile, minDefault);
if (result1 == ZE_RESULT_SUCCESS && result2 == ZE_RESULT_SUCCESS) {
result = setMax(maxDefault);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(maxDefault) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(minDefault);
}
}
double currentMax = 0.0;
ze_result_t result = getMax(currentMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x>\n", __func__, result);
return result;
}
if (newMin > currentMax) {
// set the max first
ze_result_t result = setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(newMax) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(newMin);
}
// set the min first
result = setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMin returned 0x%x>\n", __func__, result);
return result;
}
return setMax(newMax);
}
bool LinuxFrequencyImp::getThrottleReasonStatus(void) {
uint32_t val = 0;
auto result = pSysfsAccess->read(throttleReasonStatusFile, val);
if (ZE_RESULT_SUCCESS == result) {
return (val == 0 ? false : true);
} else {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, throttleReasonStatusFile.c_str(), result);
return false;
}
}
ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
result = getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getRequest returned 0x%x>\n", __func__, result);
pState->request = -1;
}
result = getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getTdp returned 0x%x>\n", __func__, result);
pState->tdp = -1;
}
result = getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getEfficient returned 0x%x>\n", __func__, result);
pState->efficient = -1;
}
result = getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getActual returned 0x%x>\n", __func__, result);
pState->actual = -1;
}
pState->pNext = nullptr;
pState->currentVoltage = -1.0;
pState->throttleReasons = 0u;
if (getThrottleReasonStatus()) {
uint32_t val = 0;
ze_result_t result;
result = pSysfsAccess->read(throttleReasonPL1File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL2File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL4File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT;
}
result = pSysfsAccess->read(throttleReasonThermalFile, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcIccMax(double *pOcIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcIccMax(double ocIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcTjMax(double *pOcTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcTjMax(double ocTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getMin(double &min) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(minFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
min = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMin(double min) {
ze_result_t result = pSysfsAccess->write(minFreqFile, min);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMax(double &max) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(maxFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
max = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMax(double max) {
ze_result_t result = pSysfsAccess->write(maxFreqFile, max);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
return pSysfsAccess->write(boostFreqFile, max);
}
ze_result_t LinuxFrequencyImp::getRequest(double &request) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(requestFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, requestFreqFile.c_str(), result);
return result;
}
request = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(tdpFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, tdpFreqFile.c_str(), result);
return result;
}
tdp = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getActual(double &actual) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(actualFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, actualFreqFile.c_str(), result);
return result;
}
actual = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(efficientFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, efficientFreqFile.c_str(), result);
return result;
}
efficient = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(maxValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxValFreqFile.c_str(), result);
return result;
}
maxVal = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(minValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minValFreqFile.c_str(), result);
return result;
}
minVal = intval;
return ZE_RESULT_SUCCESS;
}
void LinuxFrequencyImp::init() {
const std::string baseDir = pSysmanKmdInterface->getBasePath(subdeviceId);
bool baseDirectoryExists = false;
if (pSysfsAccess->directoryExists(baseDir)) {
baseDirectoryExists = true;
}
minFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinFrequency, subdeviceId, baseDirectoryExists);
minDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinDefaultFrequency, subdeviceId, baseDirectoryExists);
maxFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxFrequency, subdeviceId, baseDirectoryExists);
maxDefaultFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxDefaultFrequency, subdeviceId, baseDirectoryExists);
boostFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameBoostFrequency, subdeviceId, baseDirectoryExists);
requestFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameCurrentFrequency, subdeviceId, baseDirectoryExists);
tdpFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameTdpFrequency, subdeviceId, baseDirectoryExists);
actualFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameActualFrequency, subdeviceId, baseDirectoryExists);
efficientFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEfficientFrequency, subdeviceId, baseDirectoryExists);
maxValFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxValueFrequency, subdeviceId, baseDirectoryExists);
minValFreqFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMinValueFrequency, subdeviceId, baseDirectoryExists);
throttleReasonStatusFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonStatus, subdeviceId, baseDirectoryExists);
throttleReasonPL1File = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL1, subdeviceId, baseDirectoryExists);
throttleReasonPL2File = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL2, subdeviceId, baseDirectoryExists);
throttleReasonPL4File = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonPL4, subdeviceId, baseDirectoryExists);
throttleReasonThermalFile = pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameThrottleReasonThermal, subdeviceId, baseDirectoryExists);
}
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
productFamily = pLinuxSysmanImp->getProductFamily();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
init();
}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
return static_cast<OsFrequency *>(pLinuxFrequencyImp);
}
std::vector<zes_freq_domain_t> OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
auto &productHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper<NEO::ProductHelper>();
auto releaseHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getReleaseHelper();
std::vector<zes_freq_domain_t> freqDomains = {};
uint32_t mediaFreqTileIndex;
if (productHelper.getMediaFrequencyTileIndex(releaseHelper, mediaFreqTileIndex) == true) {
auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
const std::string baseDir = "gt/gt" + std::to_string(mediaFreqTileIndex) + "/";
if (pSysfsAccess->directoryExists(baseDir)) {
freqDomains.push_back(ZES_FREQ_DOMAIN_MEDIA);
}
}
freqDomains.push_back(ZES_FREQ_DOMAIN_GPU);
return freqDomains;
}
} // namespace Sysman
} // namespace L0

85
level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp_prelim.h
View File

@@ -1,85 +0,0 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/sysman/source/api/frequency/sysman_frequency_imp.h"
#include "level_zero/sysman/source/api/frequency/sysman_os_frequency.h"
#include "igfxfmid.h"
namespace L0 {
namespace Sysman {
class SysmanKmdInterface;
class SysFsAccessInterface;
class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
double osFrequencyGetStepSize() override;
ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) override;
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
ze_result_t getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
ze_result_t getOcIccMax(double *pOcIccMax) override;
ze_result_t setOcIccMax(double ocIccMax) override;
ze_result_t getOcTjMax(double *pOcTjMax) override;
ze_result_t setOcTjMax(double ocTjMax) override;
LinuxFrequencyImp() = default;
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber);
~LinuxFrequencyImp() override = default;
protected:
SysmanKmdInterface *pSysmanKmdInterface = nullptr;
SysFsAccessInterface *pSysfsAccess = nullptr;
ze_result_t getMin(double &min);
ze_result_t setMin(double min);
ze_result_t getMax(double &max);
ze_result_t setMax(double max);
ze_result_t getRequest(double &request);
ze_result_t getTdp(double &tdp);
ze_result_t getActual(double &actual);
ze_result_t getEfficient(double &efficient);
ze_result_t getMaxVal(double &maxVal);
ze_result_t getMinVal(double &minVal);
bool getThrottleReasonStatus(void);
private:
std::string minFreqFile;
std::string maxFreqFile;
std::string boostFreqFile;
std::string minDefaultFreqFile;
std::string maxDefaultFreqFile;
std::string requestFreqFile;
std::string tdpFreqFile;
std::string actualFreqFile;
std::string efficientFreqFile;
std::string maxValFreqFile;
std::string minValFreqFile;
std::string throttleReasonStatusFile;
std::string throttleReasonPL1File;
std::string throttleReasonPL2File;
std::string throttleReasonPL4File;
std::string throttleReasonThermalFile;
static const bool canControl;
bool isSubdevice = false;
uint32_t subdeviceId = 0;
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
PRODUCT_FAMILY productFamily;
void init();
};
} // namespace Sysman
} // namespace L0

18
level_zero/sysman/test/unit_tests/sources/frequency/linux/CMakeLists.txt
View File

@@ -6,22 +6,12 @@
set(L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysman_frequency.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency_xe.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency_xe.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency_prelim.h
)
else()
list(APPEND L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency_xe.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency_xe.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE

345
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency.h
View File

@@ -1,345 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "gtest/gtest.h"
namespace L0 {
namespace Sysman {
namespace ult {
const std::string minFreqFile("gt/gt0/rps_min_freq_mhz");
const std::string maxFreqFile("gt/gt0/rps_max_freq_mhz");
const std::string minDefaultFreqFile("gt/gt0/.defaults/rps_min_freq_mhz");
const std::string maxDefaultFreqFile("gt/gt0/.defaults/rps_max_freq_mhz");
const std::string boostFreqFile("gt/gt0/rps_boost_freq_mhz");
const std::string requestFreqFile("gt/gt0/punit_req_freq_mhz");
const std::string tdpFreqFile("gt/gt0/rapl_PL1_freq_mhz");
const std::string actualFreqFile("gt/gt0/rps_act_freq_mhz");
const std::string efficientFreqFile("gt/gt0/rps_RP1_freq_mhz");
const std::string maxValFreqFile("gt/gt0/rps_RP0_freq_mhz");
const std::string minValFreqFile("gt/gt0/rps_RPn_freq_mhz");
const std::string throttleReasonStatusFile("gt/gt0/throttle_reason_status");
const std::string throttleReasonPL1File("gt/gt0/throttle_reason_pl1");
const std::string throttleReasonPL2File("gt/gt0/throttle_reason_pl2");
const std::string throttleReasonPL4File("gt/gt0/throttle_reason_pl4");
const std::string throttleReasonThermalFile("gt/gt0/throttle_reason_thermal");
const std::string minFreqFileLegacy("gt_min_freq_mhz");
const std::string maxFreqFileLegacy("gt_max_freq_mhz");
const std::string boostFreqFileLegacy("gt_boost_freq_mhz");
const std::string requestFreqFileLegacy("gt_cur_freq_mhz");
const std::string tdpFreqFileLegacy("rapl_PL1_freq_mhz");
const std::string actualFreqFileLegacy("gt_act_freq_mhz");
const std::string efficientFreqFileLegacy("gt_RP1_freq_mhz");
const std::string maxValFreqFileLegacy("gt_RP0_freq_mhz");
const std::string minValFreqFileLegacy("gt_RPn_freq_mhz");
const std::string throttleReasonStatusFileLegacy("gt_throttle_reason_status");
const std::string throttleReasonPL1FileLegacy("gt_throttle_reason_status_pl1");
const std::string throttleReasonPL2FileLegacy("gt_throttle_reason_status_pl2");
const std::string throttleReasonPL4FileLegacy("gt_throttle_reason_status_pl4");
const std::string throttleReasonThermalFileLegacy("gt_throttle_reason_status_thermal");
struct MockFrequencySysfsAccess : public L0::Sysman::SysFsAccessInterface {
double mockMin = 0;
double mockMax = 0;
double mockBoost = 0;
double mockRequest = 0;
double mockDefaultMin = 1;
double mockDefaultMax = 1000;
double mockTdp = 0;
double mockActual = 0;
double mockEfficient = 0;
double mockMaxVal = 0;
double mockMinVal = 0;
uint32_t throttleVal = 0;
uint32_t throttleReasonPL1Val = 0;
uint32_t throttleReasonPL2Val = 0;
uint32_t throttleReasonPL4Val = 0;
uint32_t throttleReasonThermalVal = 0;
ze_result_t mockReadDoubleValResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadRequestResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadTdpResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadEfficientResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadActualResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadMinValResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadMaxValResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadDefaultMinResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadDefaultMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadVal32Result = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMinResult = ZE_RESULT_SUCCESS;
bool mockReadPL1Error = false;
bool mockReadPL2Error = false;
bool mockReadPL4Error = false;
bool mockReadThermalError = false;
bool isLegacy = false;
ADDMETHOD_NOBASE(directoryExists, bool, true, (const std::string path));
ze_result_t setValU32(const std::string file, uint32_t val) {
if (file.compare(throttleReasonStatusFile) == 0) {
throttleVal = val;
}
if (file.compare(throttleReasonPL1File) == 0) {
throttleReasonPL1Val = val;
}
if (file.compare(throttleReasonPL2File) == 0) {
throttleReasonPL2Val = val;
}
if (file.compare(throttleReasonPL4File) == 0) {
throttleReasonPL4Val = val;
}
if (file.compare(throttleReasonThermalFile) == 0) {
throttleReasonThermalVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValU32Legacy(const std::string file, uint32_t val) {
if (file.compare(throttleReasonStatusFileLegacy) == 0) {
throttleVal = val;
}
if (file.compare(throttleReasonPL1FileLegacy) == 0) {
throttleReasonPL1Val = val;
}
if (file.compare(throttleReasonPL2FileLegacy) == 0) {
throttleReasonPL2Val = val;
}
if (file.compare(throttleReasonPL4FileLegacy) == 0) {
throttleReasonPL4Val = val;
}
if (file.compare(throttleReasonThermalFileLegacy) == 0) {
throttleReasonThermalVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValLegacy(const std::string file, double &val) {
if (file.compare(minFreqFileLegacy) == 0) {
val = mockMin;
}
if (file.compare(maxFreqFileLegacy) == 0) {
val = mockMax;
}
if (file.compare(requestFreqFileLegacy) == 0) {
val = mockRequest;
}
if (file.compare(tdpFreqFileLegacy) == 0) {
val = mockTdp;
}
if (file.compare(actualFreqFileLegacy) == 0) {
val = mockActual;
}
if (file.compare(efficientFreqFileLegacy) == 0) {
val = mockEfficient;
}
if (file.compare(maxValFreqFileLegacy) == 0) {
val = mockMaxVal;
}
if (file.compare(minValFreqFileLegacy) == 0) {
val = mockMinVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValLegacy(const std::string file, const double val) {
if (file.compare(minFreqFileLegacy) == 0) {
mockMin = val;
} else if (file.compare(maxFreqFileLegacy) == 0) {
mockMax = val;
} else if (file.compare(boostFreqFileLegacy) == 0) {
mockBoost = val;
} else if (file.compare(requestFreqFileLegacy) == 0) {
mockRequest = val;
} else if (file.compare(tdpFreqFileLegacy) == 0) {
mockTdp = val;
} else if (file.compare(actualFreqFileLegacy) == 0) {
mockActual = val;
} else if (file.compare(efficientFreqFileLegacy) == 0) {
mockEfficient = val;
} else if (file.compare(maxValFreqFileLegacy) == 0) {
mockMaxVal = val;
} else if (file.compare(minValFreqFileLegacy) == 0) {
mockMinVal = val;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, double &val) override {
if (mockReadDoubleValResult != ZE_RESULT_SUCCESS) {
return mockReadDoubleValResult;
}
if (isLegacy) {
return getValLegacy(file, val);
}
if (file.compare(minFreqFile) == 0) {
val = mockMin;
} else if (file.compare(maxFreqFile) == 0) {
if (mockReadMaxResult != ZE_RESULT_SUCCESS) {
return mockReadMaxResult;
}
val = mockMax;
} else if (file.compare(requestFreqFile) == 0) {
if (mockReadRequestResult != ZE_RESULT_SUCCESS) {
return mockReadRequestResult;
}
val = mockRequest;
} else if (file.compare(tdpFreqFile) == 0) {
if (mockReadTdpResult != ZE_RESULT_SUCCESS) {
return mockReadTdpResult;
}
val = mockTdp;
} else if (file.compare(actualFreqFile) == 0) {
if (mockReadActualResult != ZE_RESULT_SUCCESS) {
return mockReadActualResult;
}
val = mockActual;
} else if (file.compare(efficientFreqFile) == 0) {
if (mockReadEfficientResult != ZE_RESULT_SUCCESS) {
return mockReadEfficientResult;
}
val = mockEfficient;
} else if (file.compare(maxValFreqFile) == 0) {
if (mockReadMaxValResult != ZE_RESULT_SUCCESS) {
return mockReadMaxValResult;
}
val = mockMaxVal;
} else if (file.compare(minValFreqFile) == 0) {
if (mockReadMinValResult != ZE_RESULT_SUCCESS) {
return mockReadMinValResult;
}
val = mockMinVal;
} else if (file.compare(minDefaultFreqFile) == 0) {
if (mockReadDefaultMinResult != ZE_RESULT_SUCCESS) {
return mockReadDefaultMinResult;
}
val = mockDefaultMin;
} else if (file.compare(maxDefaultFreqFile) == 0) {
if (mockReadDefaultMaxResult != ZE_RESULT_SUCCESS) {
return mockReadDefaultMaxResult;
}
val = mockDefaultMax;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setVal(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
if (mockWriteMinResult != ZE_RESULT_SUCCESS) {
return mockWriteMinResult;
}
mockMin = val;
}
if (file.compare(maxFreqFile) == 0) {
if (mockWriteMaxResult != ZE_RESULT_SUCCESS) {
return mockWriteMaxResult;
}
mockMax = val;
}
if (file.compare(boostFreqFile) == 0) {
mockBoost = val;
}
if (file.compare(requestFreqFile) == 0) {
mockRequest = val;
}
if (file.compare(tdpFreqFile) == 0) {
mockTdp = val;
}
if (file.compare(actualFreqFile) == 0) {
mockActual = val;
}
if (file.compare(efficientFreqFile) == 0) {
mockEfficient = val;
}
if (file.compare(maxValFreqFile) == 0) {
mockMaxVal = val;
}
if (file.compare(minValFreqFile) == 0) {
mockMinVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValU32(const std::string file, uint32_t &val) {
if ((file.compare(throttleReasonStatusFile) == 0) || (file.compare(throttleReasonStatusFileLegacy) == 0)) {
val = throttleVal;
}
if ((file.compare(throttleReasonPL1File) == 0) || (file.compare(throttleReasonPL1FileLegacy) == 0)) {
if (mockReadPL1Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL1Val;
}
if ((file.compare(throttleReasonPL2File) == 0) || (file.compare(throttleReasonPL2FileLegacy) == 0)) {
if (mockReadPL2Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL2Val;
}
if ((file.compare(throttleReasonPL4File) == 0) || (file.compare(throttleReasonPL4FileLegacy) == 0)) {
if (mockReadPL4Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL4Val;
}
if ((file.compare(throttleReasonThermalFile) == 0) || (file.compare(throttleReasonThermalFileLegacy) == 0)) {
if (mockReadThermalError) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonThermalVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadVal32Result != ZE_RESULT_SUCCESS) {
return mockReadVal32Result;
}
return getValU32(file, val);
}
ze_result_t write(const std::string file, double val) override {
if (isLegacy) {
return setValLegacy(file, val);
}
return setVal(file, val);
}
MockFrequencySysfsAccess() = default;
~MockFrequencySysfsAccess() override = default;
};
class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
public:
PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}
using L0::Sysman::LinuxFrequencyImp::getMaxVal;
using L0::Sysman::LinuxFrequencyImp::getMin;
using L0::Sysman::LinuxFrequencyImp::getMinVal;
using L0::Sysman::LinuxFrequencyImp::pSysfsAccess;
};
} // namespace ult
} // namespace Sysman
} // namespace L0

9
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_xe.h
View File

@@ -7,6 +7,7 @@
#pragma once
#include "shared/source/os_interface/product_helper_hw.h"
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
@@ -203,6 +204,14 @@ struct MockXeFrequencySysfsAccess : public L0::Sysman::SysFsAccessInterface {
~MockXeFrequencySysfsAccess() override = default;
};
struct MockProductHelperFreq : NEO::ProductHelperHw<IGFX_UNKNOWN> {
MockProductHelperFreq() = default;
bool isMediaFreqDomainPresent = false;
bool getMediaFrequencyTileIndex(const NEO::ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override {
tileIndex = 1;
return isMediaFreqDomainPresent;
}
};
class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
public:
PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}

2
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h → level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysman_frequency.h
View File

@@ -11,7 +11,7 @@
#include "shared/source/release_helper/release_helper.h"
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp_prelim.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "gtest/gtest.h"

257
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency.cpp
View File

@@ -5,7 +5,8 @@
*
*/
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysman_frequency.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include <cmath>
@@ -24,12 +25,14 @@ constexpr double maxVal = 1100.0;
constexpr double minVal = 300.0;
constexpr uint32_t handleComponentCount = 1u;
constexpr uint32_t multiHandleComponentCount = 2u;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
std::unique_ptr<ProductHelper> pProductHelperOld;
uint32_t numClocks = 0;
double step = 0;
@@ -39,7 +42,9 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pProductHelper = std::make_unique<MockProductHelperFreq>();
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
pSysfsAccess->setVal(minFreqFile, minFreq);
pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysfsAccess->setVal(requestFreqFile, request);
@@ -56,11 +61,12 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
SysmanDeviceFixture::TearDown();
}
@@ -105,6 +111,51 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnume
EXPECT_EQ(handle, static_cast<zes_freq_handle_t>(0UL));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) {
auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
mockProductHelper->isMediaFreqDomainPresent = true;
std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, productHelper);
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, 2U);
uint32_t testCount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
EXPECT_EQ(count, testCount);
auto handles = getFreqHandles(count);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
std::swap(rootDeviceEnvironment.productHelper, productHelper);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaDomainIsAbsentThenNonZeroCountIsReturnedAndCallSucceds) {
pSysfsAccess->directoryExistsResult = false;
auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
mockProductHelper->isMediaFreqDomainPresent = true;
std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, productHelper);
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, 1U);
uint32_t testCount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
EXPECT_EQ(count, testCount);
auto handles = getFreqHandles(count);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
std::swap(rootDeviceEnvironment.productHelper, productHelper);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
@@ -126,7 +177,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(nullptr, properties.pNext);
EXPECT_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
EXPECT_GE(properties.type, ZES_FREQ_DOMAIN_GPU);
EXPECT_LE(properties.type, ZES_FREQ_DOMAIN_MEDIA);
EXPECT_FALSE(properties.onSubdevice);
EXPECT_DOUBLE_EQ(maxFreq, properties.max);
EXPECT_DOUBLE_EQ(minFreq, properties.min);
@@ -262,9 +314,9 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
auto handles = getFreqHandles(handleComponentCount);
for (auto &handle : handles) {
for (auto handle : handles) {
const double negativeMin = -1;
const double negativeMax = -1;
zes_freq_range_t limits;
@@ -273,43 +325,12 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeSetWhenGetRangeIsCalledTh
limits.max = negativeMax;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_EQ(pSysfsAccess->mockDefaultMin, limits.min);
EXPECT_EQ(pSysfsAccess->mockDefaultMax, limits.max);
EXPECT_EQ(1, limits.min);
EXPECT_EQ(1000, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndSettingMaxValueFailsThenFailureIsReturned) {
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getFreqHandles(handleComponentCount);
for (auto &handle : handles) {
const double negativeMin = -1;
const double negativeMax = -1;
zes_freq_range_t limits;
limits.min = negativeMin;
limits.max = negativeMax;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect) {
pSysfsAccess->mockReadDefaultMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto handles = getFreqHandles(handleComponentCount);
for (auto &handle : handles) {
const double negativeMin = -1;
const double negativeMax = -1;
zes_freq_range_t limits;
limits.min = negativeMin;
limits.max = negativeMax;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(-1, limits.min);
EXPECT_DOUBLE_EQ(-1, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
@@ -330,7 +351,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest4ReturnsError) {
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
@@ -352,7 +373,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
const double testActualValue = 550.0;
const uint32_t invalidReason = 0;
zes_freq_state_t state;
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setVal(requestFreqFile, testRequestValue);
pSysfsAccess->setVal(tdpFreqFile, testTdpValue);
@@ -384,7 +404,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
const double testTdpValue = 1100.0;
const double testEfficientValue = 300.0;
const double testActualValue = 550.0;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t setAllThrottleReasons = (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
@@ -400,6 +419,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
pSysfsAccess->setValU32Legacy(throttleReasonPL2FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL4FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonThermalFileLegacy, validReason);
zes_freq_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
@@ -411,21 +431,27 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
pSysfsAccess->mockReadVal32Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t unsetAllThrottleReasons = 0u;
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(unsetAllThrottleReasons, state.throttleReasons);
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
double minFreqLegacy = 400.0;
double maxFreqLegacy = 1200.0;
pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
@@ -514,8 +540,25 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
pSysfsAccess->mockReadUnsignedIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t unsetAllThrottleReasons = 0u;
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(unsetAllThrottleReasons, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
pSysfsAccess->mockReadThermalError = true;
pSysfsAccess->mockReadThermalResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
@@ -539,7 +582,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
pSysfsAccess->mockReadPL4Error = true;
pSysfsAccess->mockReadPL4Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
@@ -562,32 +605,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
pSysfsAccess->mockReadPL1Error = true;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL1 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL1File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
pSysfsAccess->mockReadPL2Error = true;
pSysfsAccess->mockReadPL2Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
@@ -610,27 +629,28 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
double minFreqLegacy = 400.0;
double maxFreqLegacy = 1200.0;
pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
pSysfsAccess->mockReadPL1Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL1 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL1File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
@@ -737,23 +757,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenOnSubdeviceSetWhenValidatingAnyFrequen
EXPECT_EQ(1, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfgetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double startingMax = 600.0;
const double newMin = 900.0;
zes_freq_range_t limits;
pSysfsAccess->setVal(maxFreqFile, startingMax);
// If the new Min value is greater than the old Max
// value, the new Max must be set before the new Min
limits.min = newMin;
limits.max = maxFreq;
pSysfsAccess->mockReadMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
@@ -766,7 +769,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
// value, the new Max must be set before the new Min
limits.min = newMin;
limits.max = maxFreq;
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
pSysfsAccess->mockReadMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
@@ -877,6 +880,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
@@ -884,6 +888,9 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pProductHelper = std::make_unique<MockProductHelperFreq>();
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
@@ -894,6 +901,8 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
SysmanMultiDeviceFixture::TearDown();
}

920
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_prelim.cpp
View File

@@ -1,920 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include <cmath>
namespace L0 {
namespace Sysman {
namespace ult {
constexpr double minFreq = 300.0;
constexpr double maxFreq = 1100.0;
constexpr double request = 300.0;
constexpr double tdp = 1100.0;
constexpr double actual = 300.0;
constexpr double efficient = 300.0;
constexpr double maxVal = 1100.0;
constexpr double minVal = 300.0;
constexpr uint32_t handleComponentCount = 1u;
constexpr uint32_t multiHandleComponentCount = 2u;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
std::unique_ptr<ProductHelper> pProductHelperOld;
uint32_t numClocks = 0;
double step = 0;
PRODUCT_FAMILY productFamily{};
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pProductHelper = std::make_unique<MockProductHelperFreq>();
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
productFamily = pLinuxSysmanImp->getProductFamily();
if (productFamily >= IGFX_XE_HP_SDV) {
step = 50.0;
} else {
step = 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode)
}
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
pSysfsAccess->setVal(minFreqFile, minFreq);
pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysfsAccess->setVal(requestFreqFile, request);
pSysfsAccess->setVal(tdpFreqFile, tdp);
pSysfsAccess->setVal(actualFreqFile, actual);
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
SysmanDeviceFixture::TearDown();
}
double clockValue(const double calculatedClock) {
// i915 specific. frequency step is a fraction
// However, the i915 represents all clock
// rates as integer values. So clocks are
// rounded to the nearest integer.
uint32_t actualClock = static_cast<uint32_t>(calculatedClock + 0.5);
return static_cast<double>(actualClock);
}
std::vector<zes_freq_handle_t> getFreqHandles(uint32_t count) {
std::vector<zes_freq_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesThenNonZeroCountIsReturnedAndCallSucceds) {
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, handleComponentCount);
uint32_t testCount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
EXPECT_EQ(count, testCount);
auto handles = getFreqHandles(count);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnumeratingFrequencyHandlesThenNonZeroCountAndNoHandlesAreReturnedAndCallSucceds) {
uint32_t count = 0U;
zes_freq_handle_t handle = static_cast<zes_freq_handle_t>(0UL);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, &handle));
EXPECT_EQ(count, handleComponentCount);
EXPECT_EQ(handle, static_cast<zes_freq_handle_t>(0UL));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) {
auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
mockProductHelper->isMediaFreqDomainPresent = true;
std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, productHelper);
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, 2U);
uint32_t testCount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
EXPECT_EQ(count, testCount);
auto handles = getFreqHandles(count);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
std::swap(rootDeviceEnvironment.productHelper, productHelper);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaDomainIsAbsentThenNonZeroCountIsReturnedAndCallSucceds) {
pSysfsAccess->directoryExistsResult = false;
auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
mockProductHelper->isMediaFreqDomainPresent = true;
std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, productHelper);
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, 1U);
uint32_t testCount = count + 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
EXPECT_EQ(count, testCount);
auto handles = getFreqHandles(count);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
std::swap(rootDeviceEnvironment.productHelper, productHelper);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyHandleContextTest = std::make_unique<L0::Sysman::FrequencyHandleContext>(pOsSysman);
pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU));
pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU));
uint32_t count = 1;
std::vector<zes_freq_handle_t> phFrequency(count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyHandleContextTest->frequencyGet(&count, phFrequency.data()));
EXPECT_EQ(count, 1u);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(nullptr, properties.pNext);
EXPECT_GE(properties.type, ZES_FREQ_DOMAIN_GPU);
EXPECT_LE(properties.type, ZES_FREQ_DOMAIN_MEDIA);
EXPECT_FALSE(properties.onSubdevice);
EXPECT_DOUBLE_EQ(maxFreq, properties.max);
EXPECT_DOUBLE_EQ(minFreq, properties.min);
EXPECT_TRUE(properties.canControl);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
EXPECT_EQ(numClocks, count);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
EXPECT_EQ(numClocks, count);
double *clocks = new double[count];
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, clocks));
EXPECT_EQ(numClocks, count);
for (uint32_t i = 0; i < count; i++) {
EXPECT_DOUBLE_EQ(clockValue(minFreq + (step * i)), clocks[i]);
}
delete[] clocks;
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limit = {};
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
EXPECT_EQ(-1, limit.max);
EXPECT_EQ(-1, limit.min);
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
EXPECT_EQ(-1, limit.max);
EXPECT_EQ(-1, limit.min);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreq, limits.min);
EXPECT_DOUBLE_EQ(maxFreq, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits = {};
// Verify that Max must be within range.
limits.min = minFreq;
limits.max = 600.0;
pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits = {};
// Verify that Max must be within range.
limits.min = 900.0;
limits.max = maxFreq;
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double startingMin = 900.0;
const double newMax = 600.0;
zes_freq_range_t limits;
pSysfsAccess->setVal(minFreqFile, startingMin);
// If the new Max value is less than the old Min
// value, the new Min must be set before the new Max
limits.min = minFreq;
limits.max = newMax;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreq, limits.min);
EXPECT_DOUBLE_EQ(newMax, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double negativeMin = -1;
const double negativeMax = -1;
zes_freq_range_t limits;
limits.min = negativeMin;
limits.max = negativeMax;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_EQ(1, limits.min);
EXPECT_EQ(1000, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double startingMax = 600.0;
const double newMin = 900.0;
zes_freq_range_t limits;
pSysfsAccess->setVal(maxFreqFile, startingMax);
// If the new Min value is greater than the old Max
// value, the new Max must be set before the new Min
limits.min = newMin;
limits.max = maxFreq;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(newMin, limits.min);
EXPECT_DOUBLE_EQ(maxFreq, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limits;
// Verify that Max must be greater than min range.
limits.min = clockValue(maxFreq + step);
limits.max = minFreq;
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 450.0;
const double testTdpValue = 1200.0;
const double testEfficientValue = 400.0;
const double testActualValue = 550.0;
const uint32_t invalidReason = 0;
zes_freq_state_t state;
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setVal(requestFreqFile, testRequestValue);
pSysfsAccess->setVal(tdpFreqFile, testTdpValue);
pSysfsAccess->setVal(actualFreqFile, testActualValue);
pSysfsAccess->setVal(efficientFreqFile, testEfficientValue);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
EXPECT_DOUBLE_EQ(testActualValue, state.actual);
EXPECT_EQ(0u, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_LE(state.currentVoltage, 0);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 400.0;
const double testTdpValue = 1100.0;
const double testEfficientValue = 300.0;
const double testActualValue = 550.0;
uint32_t validReason = 1;
uint32_t setAllThrottleReasons = (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
pSysfsAccess->setValLegacy(requestFreqFileLegacy, testRequestValue);
pSysfsAccess->setValLegacy(tdpFreqFileLegacy, testTdpValue);
pSysfsAccess->setValLegacy(actualFreqFileLegacy, testActualValue);
pSysfsAccess->setValLegacy(efficientFreqFileLegacy, testEfficientValue);
pSysfsAccess->setValU32Legacy(throttleReasonStatusFileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL1FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL2FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL4FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonThermalFileLegacy, validReason);
zes_freq_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
EXPECT_DOUBLE_EQ(testActualValue, state.actual);
EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_LE(state.currentVoltage, 0);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
double minFreqLegacy = 400.0;
double maxFreqLegacy = 1200.0;
pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state;
uint32_t validReason = 1;
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP), state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonBurstPower) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state;
uint32_t validReason = 1;
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP), state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsCurrentExcursion) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state;
uint32_t validReason = 1;
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT), state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsThermalExcursion) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state;
uint32_t validReason = 1;
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT), state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsInvalidThermalExcursion) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_EQ((ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT), state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforValidReasons) {
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t setAllThrottleReasons = (ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
pSysfsAccess->mockReadUnsignedIntResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t unsetAllThrottleReasons = 0u;
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(unsetAllThrottleReasons, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
pSysfsAccess->mockReadThermalResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptThermal =
(ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonThermalFile, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
pSysfsAccess->mockReadPL4Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL4 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL4File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
pSysfsAccess->mockReadPL2Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL2 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL2File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
pSysfsAccess->mockReadPL1Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL1 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL1File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_state_t state = {};
pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
pSysfsAccess->mockReadRequestResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadActualResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.actual);
pSysfsAccess->mockReadActualResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.actual);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenThrottleTimeStructPointerWhenCallingfrequencyGetThrottleTimeThenUnsupportedIsReturned) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_throttle_time_t throttleTime = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetThrottleTime(&throttleTime));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double min = 0;
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMin(min));
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMin(min));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double val = 0;
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMinVal(val));
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMinVal(val));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double val = 0;
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMaxVal(val));
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMaxVal(val));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenOnSubdeviceSetWhenValidatingAnyFrequencyAPIThenSuccessIsReturned) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 1, 0, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(1, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double startingMax = 600.0;
const double newMin = 900.0;
zes_freq_range_t limits;
pSysfsAccess->setVal(maxFreqFile, startingMax);
// If the new Min value is greater than the old Max
// value, the new Max must be set before the new Min
limits.min = newMin;
limits.max = maxFreq;
pSysfsAccess->mockReadMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetFrequencyTargetThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double freqTarget = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetFrequencyTarget(handle, &freqTarget));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetFrequencyTargetThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double freqTarget = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetFrequencyTarget(handle, freqTarget));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetVoltageTargetThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double voltTarget = 0.0, voltOffset = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetVoltageTarget(handle, &voltTarget, &voltOffset));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetVoltageTargetThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double voltTarget = 0.0, voltOffset = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetVoltageTarget(handle, voltTarget, voltOffset));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetModeThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_oc_mode_t mode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetMode(handle, mode));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetModeThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_oc_mode_t mode = ZES_OC_MODE_OFF;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetMode(handle, &mode));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetCapabilitiesThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
zes_oc_capabilities_t caps = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetCapabilities(handle, &caps));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetIccMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double iccMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetIccMax(handle, &iccMax));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetIccMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double iccMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetIccMax(handle, iccMax));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcGetTjMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double tjMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcGetTjMax(handle, &tjMax));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetTjMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double tjMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetTjMax(handle, tjMax));
}
}
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidFreqPropertiesRetrieved) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
zes_freq_properties_t properties = {};
L0::Sysman::LinuxFrequencyImp *pLinuxFrequencyImp = new L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
EXPECT_EQ(properties.subdeviceId, subdeviceId);
EXPECT_EQ(properties.onSubdevice, onSubdevice);
delete pLinuxFrequencyImp;
}
class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pProductHelper = std::make_unique<MockProductHelperFreq>();
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
SysmanMultiDeviceFixture::TearDown();
}
std::vector<zes_freq_handle_t> getFreqHandles(uint32_t count) {
std::vector<zes_freq_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumFrequencyDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
TEST_F(FreqMultiDeviceFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, multiHandleComponentCount);
auto handles = getFreqHandles(multiHandleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(nullptr, properties.pNext);
EXPECT_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
EXPECT_TRUE(properties.onSubdevice);
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0

8
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_xe.cpp
View File

@@ -27,6 +27,8 @@ class SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
MockSysmanKmdInterfaceXe *pSysmanKmdInterface = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
std::unique_ptr<ProductHelper> pProductHelperOld;
uint32_t numClocks = 0;
double step = 0;
@@ -39,6 +41,9 @@ class SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
pLinuxSysmanImp->pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
pProductHelper = std::make_unique<MockProductHelperFreq>();
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
pSysmanKmdInterface->pSysfsAccess->setVal(minFreqFile, minFreq);
pSysmanKmdInterface->pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysmanKmdInterface->pSysfsAccess->setVal(requestFreqFile, request);
@@ -48,7 +53,6 @@ class SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
pSysmanKmdInterface->pSysfsAccess->setVal(minValFreqFile, minVal);
step = 50;
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
@@ -57,6 +61,8 @@ class SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
}
void TearDown() override {
auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
SysmanDeviceFixture::TearDown();
}