Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update throttle reason status sysfs names 

Related-To: LOCI-1843

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran 2022-04-06 19:00:32 +00:00 committed by Compute-Runtime-Automation
parent 0441295e21
commit f7e04b32aa
5 changed files with 394 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp
View File

@ -73,6 +73,16 @@ 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);
if (ZE_RESULT_SUCCESS == result) {
return (val == 0 ? false : true);
} else {
return false;
}
}
ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
@ -99,6 +109,26 @@ ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
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;
}
@ -295,6 +325,11 @@ void LinuxFrequencyImp::init() {
efficientFreqFile = baseDir + "rps_RP1_freq_mhz";
maxValFreqFile = baseDir + "rps_RP0_freq_mhz";
minValFreqFile = baseDir + "rps_RPn_freq_mhz";
throttleReasonStatusFile = baseDir + "throttle_reason_status";
throttleReasonPL1File = baseDir + "throttle_reason_pl1";
throttleReasonPL2File = baseDir + "throttle_reason_pl2";
throttleReasonPL4File = baseDir + "throttle_reason_pl4";
throttleReasonThermalFile = baseDir + "throttle_reason_thermal";
} else {
minFreqFile = "gt_min_freq_mhz";
maxFreqFile = "gt_max_freq_mhz";
@ -304,6 +339,11 @@ void LinuxFrequencyImp::init() {
efficientFreqFile = "gt_RP1_freq_mhz";
maxValFreqFile = "gt_RP0_freq_mhz";
minValFreqFile = "gt_RPn_freq_mhz";
throttleReasonStatusFile = "gt_throttle_reason_status";
throttleReasonPL1File = "gt_throttle_reason_status_pl1";
throttleReasonPL2File = "gt_throttle_reason_status_pl2";
throttleReasonPL4File = "gt_throttle_reason_status_pl4";
throttleReasonThermalFile = "gt_throttle_reason_status_thermal";
}
}

8
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -49,6 +49,7 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
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;
@ -59,6 +60,11 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
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;

10
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp_prelim.cpp
View File

@ -345,11 +345,11 @@ void LinuxFrequencyImp::init() {
efficientFreqFile = baseDir + "rps_RP1_freq_mhz";
maxValFreqFile = baseDir + "rps_RP0_freq_mhz";
minValFreqFile = baseDir + "rps_RPn_freq_mhz";
throttleReasonStatusFile = "throttle_reason_status";
throttleReasonPL1File = "throttle_reason_pl1";
throttleReasonPL2File = "throttle_reason_pl2";
throttleReasonPL4File = "throttle_reason_pl4";
throttleReasonThermalFile = "throttle_reason_thermal";
throttleReasonStatusFile = baseDir + "throttle_reason_status";
throttleReasonPL1File = baseDir + "throttle_reason_pl1";
throttleReasonPL2File = baseDir + "throttle_reason_pl2";
throttleReasonPL4File = baseDir + "throttle_reason_pl4";
throttleReasonThermalFile = baseDir + "throttle_reason_thermal";
} else {
minFreqFile = "gt_min_freq_mhz";
maxFreqFile = "gt_max_freq_mhz";

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

@ -19,6 +19,11 @@ 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");
@ -28,6 +33,11 @@ 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");
class FrequencySysfsAccess : public SysfsAccess {};
@ -41,6 +51,16 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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 mockReadVal32Result = ZE_RESULT_SUCCESS;
bool mockReadPL1Error = false;
bool mockReadPL2Error = false;
bool mockReadPL4Error = false;
bool mockReadThermalError = false;
MOCK_METHOD(ze_result_t, read, (const std::string file, double &val), (override));
MOCK_METHOD(ze_result_t, write, (const std::string file, const double val), (override));
@ -174,6 +194,46 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
return ZE_RESULT_SUCCESS;
}
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;
@ -286,6 +346,49 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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 getValU32Error(const std::string file, uint32_t &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadVal32Result != ZE_RESULT_SUCCESS) {
return mockReadVal32Result;
}
return getValU32(file, val);
}
Mock() = default;
~Mock() override = default;
};

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

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -15,7 +15,10 @@
extern bool sysmanUltsEnable;
using ::testing::DoDefault;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::Return;
namespace L0 {
namespace ult {
@ -54,7 +57,7 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getVal));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setVal));
@ -203,14 +206,14 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhe
TEST_F(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_range_t limit = {};
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
EXPECT_EQ(-1, limit.max);
EXPECT_EQ(-1, limit.min);
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorUnknown));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
EXPECT_EQ(-1, limit.max);
EXPECT_EQ(-1, limit.min);
@ -313,8 +316,10 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
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);
@ -331,7 +336,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValLegacy));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValLegacy));
@ -350,24 +355,233 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
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 |
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);
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(setAllThrottleReasons, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_LE(state.currentVoltage, 0);
}
}
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, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
auto handles = get_freq_handles(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 = get_freq_handles(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 = get_freq_handles(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 = get_freq_handles(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 = get_freq_handles(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, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
pSysfsAccess->mockReadThermalError = true;
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->mockReadPL4Error = true;
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, 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;
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, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeWithLegacyPathThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValLegacy));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValLegacy));
@ -394,42 +608,42 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU);
zes_freq_state_t state = {};
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.actual);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.actual);
@ -444,11 +658,11 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenThrottleTimeStructPointerWhenCallingfr
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double min = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMin(min));
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMin(min));
}
@ -456,11 +670,11 @@ TEST_F(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidati
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double val = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMinVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMinVal(val));
}
@ -468,11 +682,11 @@ TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValid
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
double val = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMaxVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMaxVal(val));
}
@ -480,7 +694,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValid
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
@ -489,7 +703,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValid
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
@ -514,7 +728,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
// value, the new Max must be set before the new Min
limits.min = newMin;
limits.max = maxFreq;
ON_CALL(*pSysfsAccess.get(), read(_, _))
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}