Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add Prelim ULTs for frequency

Browse Source 
Remove gmock usage from frequency ULTs.

Related-To: LOCI-3214

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2022-08-04 15:14:26 +00:00
committed by Compute-Runtime-Automation
parent d1fb4011bd
commit fb0d2b0acd
5 changed files with 1271 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,12 +6,15 @@
set(L0_TESTS_TOOLS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}mock_sysfs_frequency.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION AND("${BRANCH_TYPE}" STREQUAL ""))
list(REMOVE_ITEM L0_TESTS_TOOLS_SYSMAN_FREQUENCY_LINUX
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_TOOLS_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_TOOLS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency.h
)

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

@ -59,143 +59,24 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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 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;
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));
MOCK_METHOD(bool, directoryExists, (const std::string path), (override));
bool mockDirectoryExistsSuccess(const std::string path) {
return true;
}
bool mockDirectoryExistsFailure(const std::string path) {
return false;
}
ze_result_t getMaxValReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(maxValFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMaxValReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(maxValFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMinValReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(minValFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMinValReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(minValFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValReturnErrorNotAvailable(const std::string file, double &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValActualReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(actualFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValEfficientReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(efficientFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValTdpReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(tdpFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValRequestReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(requestFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMinReturnErrorNotAvailable(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMaxReturnErrorNotAvailable(const std::string file, const double val) {
if (file.compare(maxFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValReturnErrorUnknown(const std::string file, double &val) {
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t getValActualReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(actualFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValEfficientReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(efficientFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValTdpReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(tdpFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValRequestReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(requestFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMinReturnErrorUnknown(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMaxReturnErrorUnknown(const std::string file, const double val) {
if (file.compare(maxFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
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) {
@ -291,39 +172,69 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
return ZE_RESULT_SUCCESS;
}
ze_result_t getVal(const std::string file, double &val) {
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;
}
if (file.compare(maxFreqFile) == 0) {
} else if (file.compare(maxFreqFile) == 0) {
if (mockReadMaxResult != ZE_RESULT_SUCCESS) {
return mockReadMaxResult;
}
val = mockMax;
}
if (file.compare(requestFreqFile) == 0) {
} else if (file.compare(requestFreqFile) == 0) {
if (mockReadRequestResult != ZE_RESULT_SUCCESS) {
return mockReadRequestResult;
}
val = mockRequest;
}
if (file.compare(tdpFreqFile) == 0) {
} else if (file.compare(tdpFreqFile) == 0) {
if (mockReadTdpResult != ZE_RESULT_SUCCESS) {
return mockReadTdpResult;
}
val = mockTdp;
}
if (file.compare(actualFreqFile) == 0) {
} else if (file.compare(actualFreqFile) == 0) {
if (mockReadActualResult != ZE_RESULT_SUCCESS) {
return mockReadActualResult;
}
val = mockActual;
}
if (file.compare(efficientFreqFile) == 0) {
} else if (file.compare(efficientFreqFile) == 0) {
if (mockReadEfficientResult != ZE_RESULT_SUCCESS) {
return mockReadEfficientResult;
}
val = mockEfficient;
}
if (file.compare(maxValFreqFile) == 0) {
} else if (file.compare(maxValFreqFile) == 0) {
if (mockReadMaxValResult != ZE_RESULT_SUCCESS) {
return mockReadMaxValResult;
}
val = mockMaxVal;
}
if (file.compare(minValFreqFile) == 0) {
} else if (file.compare(minValFreqFile) == 0) {
if (mockReadMinValResult != ZE_RESULT_SUCCESS) {
return mockReadMinValResult;
}
val = mockMinVal;
} 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) {
@ -382,10 +293,6 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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;
@ -393,6 +300,13 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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);
}
Mock() = default;
~Mock() override = default;
};

355
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency_prelim.h Normal file
View File

@ -0,0 +1,355 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/tools/source/sysman/frequency/linux/os_frequency_imp_prelim.h"
namespace L0 {
namespace ult {
const std::string minFreqFile("gt/gt0/rps_min_freq_mhz");
const std::string minDefaultFreqFile("gt/gt0/.defaults/rps_min_freq_mhz");
const std::string maxFreqFile("gt/gt0/rps_max_freq_mhz");
const std::string boostFreqFile("gt/gt0/rps_boost_freq_mhz");
const std::string maxDefaultFreqFile("gt/gt0/.defaults/rps_max_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");
class FrequencySysfsAccess : public SysfsAccess {};
template <>
struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
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 mockReadUnsignedIntResult = 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 mockReadMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadPL1Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadPL2Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadPL4Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadThermalResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMinResult = ZE_RESULT_SUCCESS;
ze_bool_t isLegacy = false;
ADDMETHOD_NOBASE(directoryExists, bool, true, (const std::string path));
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) {
val = mockDefaultMin;
} else if (file.compare(maxDefaultFreqFile) == 0) {
val = mockDefaultMax;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadUnsignedIntResult != ZE_RESULT_SUCCESS) {
return mockReadUnsignedIntResult;
}
if (isLegacy) {
return getValU32Legacy(file, val);
}
if (file.compare(throttleReasonStatusFile) == 0) {
val = throttleVal;
}
if (file.compare(throttleReasonPL1File) == 0) {
if (mockReadPL1Result != ZE_RESULT_SUCCESS) {
return mockReadPL1Result;
}
val = throttleReasonPL1Val;
}
if (file.compare(throttleReasonPL2File) == 0) {
if (mockReadPL2Result != ZE_RESULT_SUCCESS) {
return mockReadPL2Result;
}
val = throttleReasonPL2Val;
}
if (file.compare(throttleReasonPL4File) == 0) {
if (mockReadPL4Result != ZE_RESULT_SUCCESS) {
return mockReadPL4Result;
}
val = throttleReasonPL4Val;
}
if (file.compare(throttleReasonThermalFile) == 0) {
if (mockReadThermalResult != ZE_RESULT_SUCCESS) {
return mockReadThermalResult;
}
val = throttleReasonThermalVal;
}
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 getValU32Legacy(const std::string file, uint32_t &val) {
if (file.compare(throttleReasonStatusFileLegacy) == 0) {
val = throttleVal;
}
if (file.compare(throttleReasonPL1FileLegacy) == 0) {
val = throttleReasonPL1Val;
}
if (file.compare(throttleReasonPL2FileLegacy) == 0) {
val = throttleReasonPL2Val;
}
if (file.compare(throttleReasonPL4FileLegacy) == 0) {
val = throttleReasonPL4Val;
}
if (file.compare(throttleReasonThermalFileLegacy) == 0) {
val = throttleReasonThermalVal;
}
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 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 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 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 write(const std::string file, double val) override {
if (isLegacy) {
return setValLegacy(file, val);
}
return setVal(file, val);
}
Mock() = default;
~Mock() override = default;
};
class PublicLinuxFrequencyImp : public L0::LinuxFrequencyImp {
public:
PublicLinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}
using LinuxFrequencyImp::getMaxVal;
using LinuxFrequencyImp::getMin;
using LinuxFrequencyImp::getMinVal;
using LinuxFrequencyImp::pSysfsAccess;
};
} // namespace ult
} // namespace L0

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

@ -57,12 +57,6 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
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));
ON_CALL(*pSysfsAccess.get(), directoryExists(_))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::mockDirectoryExistsSuccess));
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
@ -206,14 +200,12 @@ 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(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
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);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetRange(&limit));
EXPECT_EQ(-1, limit.max);
EXPECT_EQ(-1, limit.min);
@ -236,12 +228,10 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequen
// Verify that Max must be within range.
limits.min = minFreq;
limits.max = 600.0;
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMinReturnErrorNotAvailable));
pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMinReturnErrorUnknown));
pSysfsAccess->mockWriteMinResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
@ -252,12 +242,10 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequen
// Verify that Max must be within range.
limits.min = 900.0;
limits.max = maxFreq;
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorUnknown));
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
@ -338,12 +326,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
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));
ON_CALL(*pSysfsAccess.get(), directoryExists(_))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::mockDirectoryExistsFailure));
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
@ -583,12 +567,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
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));
ON_CALL(*pSysfsAccess.get(), directoryExists(_))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::mockDirectoryExistsFailure));
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
@ -612,43 +592,38 @@ 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(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorNotAvailable));
pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorUnknown));
pSysfsAccess->mockReadRequestResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.request);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorNotAvailable));
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);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorUnknown));
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorNotAvailable));
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);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorUnknown));
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorNotAvailable));
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);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorUnknown));
pSysfsAccess->mockReadActualResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.actual);
}
@ -662,44 +637,37 @@ 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(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
pSysfsAccess->mockReadDoubleValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMin(min));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorUnknown));
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;
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMinVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorUnknown));
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;
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMaxVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorUnknown));
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);
ON_CALL(*pSysfsAccess.get(), read(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
@ -707,8 +675,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(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
@ -732,8 +699,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(_, Matcher<double &>(_)))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
pSysfsAccess->mockReadMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
@ -750,8 +716,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(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}

814
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency_prelim.cpp Normal file
View File

@ -0,0 +1,814 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "igfxfmid.h"
#include "mock_sysfs_frequency_prelim.h"
#include <cmath>
extern bool sysmanUltsEnable;
using ::testing::DoDefault;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::Return;
namespace L0 {
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;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
std::vector<ze_device_handle_t> deviceHandles;
std::unique_ptr<Mock<FrequencySysfsAccess>> pSysfsAccess;
SysfsAccess *pSysfsAccessOld = nullptr;
uint32_t numClocks = 0;
double step = 0;
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
auto productFamily = device->getNEODevice()->getHardwareInfo().platform.eProductFamily;
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;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<NiceMock<Mock<FrequencySysfsAccess>>>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
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();
uint32_t subDeviceCount = 0;
// We received a device handle. Check for subdevices in this device
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
if (subDeviceCount == 0) {
deviceHandles.resize(1, device->toHandle());
} else {
deviceHandles.resize(subDeviceCount, nullptr);
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
}
getFreqHandles(0);
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
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, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
auto pFrequencyHandleContextTest = std::make_unique<FrequencyHandleContext>(pOsSysman);
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman, device->toHandle(), ZES_FREQ_DOMAIN_GPU));
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman, device->toHandle(), 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_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
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 pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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 pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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 pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest4ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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(deviceHandles);
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(deviceHandles);
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 pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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 pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 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, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidSchedPropertiesRetrieved) {
zes_freq_properties_t properties = {};
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(device)->getProperties(&deviceProperties);
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
EXPECT_EQ(properties.subdeviceId, deviceProperties.subdeviceId);
EXPECT_EQ(properties.onSubdevice, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE);
delete pLinuxFrequencyImp;
}
} // namespace ult
} // namespace L0