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

Redesign ULT by mocking sysfs and implementing for frequency 

Change-Id: I5979132fc775fe227ed83f4d49f932f4ce2800cc
This commit is contained in:
Mraghuwa 2020-05-14 23:11:33 +05:30 committed by sys_ocldev
parent 8f70ba916a
commit b9b34659c8
10 changed files with 269 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/tools/source/sysman/frequency/frequency_imp.cpp
View File

@ -58,7 +58,7 @@ ze_result_t FrequencyImp::frequencySetRange(const zet_freq_range_t *pLimits) {
}
}
if (newMin > newMax || !newMinValid || !newMaxValid) {
return ZE_RESULT_ERROR_UNKNOWN;
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
double currentMax;
pOsFrequency->getMax(currentMax);

1
level_zero/tools/source/sysman/frequency/linux/CMakeLists.txt
View File

@ -7,6 +7,7 @@
set(L0_SRCS_TOOLS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.h
)
if(UNIX)

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

@ -5,52 +5,10 @@
*
*/
#include "shared/source/os_interface/linux/drm_neo.h"
#include "shared/source/os_interface/linux/os_interface.h"
#include "level_zero/core/source/device/device.h"
#include "sysman/frequency/frequency_imp.h"
#include "sysman/frequency/os_frequency.h"
#include "sysman/linux/fs_access.h"
#include "sysman/linux/os_sysman_imp.h"
#include "level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h"
namespace L0 {
class LinuxFrequencyImp : public OsFrequency {
public:
ze_result_t getMin(double &min) override;
ze_result_t setMin(double min) override;
ze_result_t getMax(double &max) override;
ze_result_t setMax(double max) override;
ze_result_t getRequest(double &request) override;
ze_result_t getTdp(double &tdp) override;
ze_result_t getActual(double &actual) override;
ze_result_t getEfficient(double &efficient) override;
ze_result_t getMaxVal(double &maxVal) override;
ze_result_t getMinVal(double &minVal) override;
ze_result_t getThrottleReasons(uint32_t &throttleReasons) override;
LinuxFrequencyImp(OsSysman *pOsSysman);
~LinuxFrequencyImp() override = default;
// Don't allow copies of the LinuxFrequencyImp object
LinuxFrequencyImp(const LinuxFrequencyImp &obj) = delete;
LinuxFrequencyImp &operator=(const LinuxFrequencyImp &obj) = delete;
private:
SysfsAccess *pSysfsAccess;
static const std::string minFreqFile;
static const std::string maxFreqFile;
static const std::string requestFreqFile;
static const std::string tdpFreqFile;
static const std::string actualFreqFile;
static const std::string efficientFreqFile;
static const std::string maxValFreqFile;
static const std::string minValFreqFile;
};
const std::string LinuxFrequencyImp::minFreqFile("gt_min_freq_mhz");
const std::string LinuxFrequencyImp::maxFreqFile("gt_max_freq_mhz");
const std::string LinuxFrequencyImp::requestFreqFile("gt_cur_freq_mhz");
@ -61,7 +19,7 @@ const std::string LinuxFrequencyImp::maxValFreqFile("gt_RP0_freq_mhz");
const std::string LinuxFrequencyImp::minValFreqFile("gt_RPn_freq_mhz");
ze_result_t LinuxFrequencyImp::getMin(double &min) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(minFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -80,7 +38,7 @@ ze_result_t LinuxFrequencyImp::setMin(double min) {
}
ze_result_t LinuxFrequencyImp::getMax(double &max) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(maxFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -99,7 +57,7 @@ ze_result_t LinuxFrequencyImp::setMax(double max) {
}
ze_result_t LinuxFrequencyImp::getRequest(double &request) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(requestFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -110,7 +68,7 @@ ze_result_t LinuxFrequencyImp::getRequest(double &request) {
}
ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(tdpFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -121,7 +79,7 @@ ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
}
ze_result_t LinuxFrequencyImp::getActual(double &actual) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(actualFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -132,7 +90,7 @@ ze_result_t LinuxFrequencyImp::getActual(double &actual) {
}
ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(efficientFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -143,7 +101,7 @@ ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
}
ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(maxValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
@ -154,7 +112,7 @@ ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
}
ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
int intval;
double intval;
ze_result_t result = pSysfsAccess->read(minValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {

49
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "sysman/frequency/frequency_imp.h"
#include "sysman/frequency/os_frequency.h"
#include "sysman/linux/fs_access.h"
#include "sysman/linux/os_sysman_imp.h"
namespace L0 {
class LinuxFrequencyImp : public NEO::NonCopyableClass, public OsFrequency {
public:
ze_result_t getMin(double &min) override;
ze_result_t setMin(double min) override;
ze_result_t getMax(double &max) override;
ze_result_t setMax(double max) override;
ze_result_t getRequest(double &request) override;
ze_result_t getTdp(double &tdp) override;
ze_result_t getActual(double &actual) override;
ze_result_t getEfficient(double &efficient) override;
ze_result_t getMaxVal(double &maxVal) override;
ze_result_t getMinVal(double &minVal) override;
ze_result_t getThrottleReasons(uint32_t &throttleReasons) override;
LinuxFrequencyImp() = default;
LinuxFrequencyImp(OsSysman *pOsSysman);
~LinuxFrequencyImp() override = default;
protected:
SysfsAccess *pSysfsAccess = nullptr;
private:
static const std::string minFreqFile;
static const std::string maxFreqFile;
static const std::string requestFreqFile;
static const std::string tdpFreqFile;
static const std::string actualFreqFile;
static const std::string efficientFreqFile;
static const std::string maxValFreqFile;
static const std::string minValFreqFile;
};
} // namespace L0

4
level_zero/tools/source/sysman/linux/fs_access.h
View File

@ -82,13 +82,13 @@ class SysfsAccess : private FsAccess {
MOCKABLE_VIRTUAL ze_result_t read(const std::string file, std::string &val);
MOCKABLE_VIRTUAL ze_result_t read(const std::string file, int &val);
MOCKABLE_VIRTUAL ze_result_t read(const std::string file, uint64_t &val);
ze_result_t read(const std::string file, double &val);
MOCKABLE_VIRTUAL ze_result_t read(const std::string file, double &val);
ze_result_t read(const std::string file, std::vector<std::string> &val);
ze_result_t write(const std::string file, const std::string val);
MOCKABLE_VIRTUAL ze_result_t write(const std::string file, const int val);
MOCKABLE_VIRTUAL ze_result_t write(const std::string file, const uint64_t val);
ze_result_t write(const std::string file, const double val);
MOCKABLE_VIRTUAL ze_result_t write(const std::string file, const double val);
MOCKABLE_VIRTUAL ze_result_t scanDirEntries(const std::string path, std::vector<std::string> &list);
ze_result_t readSymLink(const std::string path, std::string &buf);

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

@ -5,7 +5,7 @@
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_frequency.h
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
add_subdirectories()

14
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
#
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency.h
)
endif()

121
level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/core/test/unit_tests/mock.h"
#include "level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h"
#include "sysman/frequency/frequency_imp.h"
#include "sysman/frequency/os_frequency.h"
#include "sysman/linux/fs_access.h"
#include "sysman/sysman.h"
#include "sysman/sysman_imp.h"
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
using ::testing::_;
namespace L0 {
namespace ult {
const std::string minFreqFile("gt_min_freq_mhz");
const std::string maxFreqFile("gt_max_freq_mhz");
const std::string requestFreqFile("gt_cur_freq_mhz");
const std::string tdpFreqFile("gt_boost_freq_mhz");
const std::string actualFreqFile("gt_act_freq_mhz");
const std::string efficientFreqFile("gt_RP1_freq_mhz");
const std::string maxValFreqFile("gt_RP0_freq_mhz");
const std::string minValFreqFile("gt_RPn_freq_mhz");
class FrequencySysfsAccess : public SysfsAccess {};
template <>
struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
double mockMin = 0;
double mockMax = 0;
double mockRequest = 0;
double mockTdp = 0;
double mockActual = 0;
double mockEfficient = 0;
double mockMaxVal = 0;
double mockMinVal = 0;
MOCK_METHOD2(read, ze_result_t(const std::string file, double &val));
MOCK_METHOD2(write, ze_result_t(const std::string file, const double val));
ze_result_t getVal(const std::string file, double &val) {
if (file.compare(minFreqFile) == 0) {
val = mockMin;
}
if (file.compare(maxFreqFile) == 0) {
val = mockMax;
}
if (file.compare(requestFreqFile) == 0) {
val = mockRequest;
}
if (file.compare(tdpFreqFile) == 0) {
val = mockTdp;
}
if (file.compare(actualFreqFile) == 0) {
val = mockActual;
}
if (file.compare(efficientFreqFile) == 0) {
val = mockEfficient;
}
if (file.compare(maxValFreqFile) == 0) {
val = mockMaxVal;
}
if (file.compare(minValFreqFile) == 0) {
val = mockMinVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setVal(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
mockMin = val;
}
if (file.compare(maxFreqFile) == 0) {
mockMax = 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;
}
Mock<FrequencySysfsAccess>() = default;
};
class PublicLinuxFrequencyImp : public L0::LinuxFrequencyImp {
public:
using LinuxFrequencyImp::pSysfsAccess;
};
} // namespace ult
} // namespace L0
#if defined(__clang__)
#pragma clang diagnostic pop
#endif

183
level_zero/tools/test/unit_tests/sources/sysman/frequency/test_sysman_frequency.cpp → level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_sysman_frequency.cpp
View File

@ -6,39 +6,47 @@
*/
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "mock_frequency.h"
#include "mock_sysfs_frequency.h"
#include <cmath>
using ::testing::_;
using ::testing::DoAll;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::NiceMock;
using ::testing::Return;
namespace L0 {
namespace ult {
ACTION_P(SetFloat, value) {
arg0 = value;
}
constexpr double minFreq = 300.0;
constexpr double maxFreq = 1100.0;
constexpr double step = 100.0 / 6;
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 numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
class SysmanFrequencyFixture : public DeviceFixture, public ::testing::Test {
protected:
SysmanImp *sysmanImp;
std::unique_ptr<SysmanImp> sysmanImp;
zet_sysman_handle_t hSysman;
zet_sysman_freq_handle_t hSysmanFrequency;
Mock<FrequencySysfsAccess> *pSysfsAccess = nullptr;
Mock<OsFrequency> *pOsFrequency;
FrequencyImp *pFrequencyImp;
const float minFreq = 300.0;
const float maxFreq = 1100.0;
const double step = 100.0 / 6;
const uint32_t numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
OsFrequency *pOsFrequency = nullptr;
FrequencyImp *pFrequencyImp = nullptr;
PublicLinuxFrequencyImp linuxFrequencyImp;
double clockValue(const double calculatedClock) {
// i915 specific. frequency step is a fraction
@ -51,54 +59,36 @@ class SysmanFrequencyFixture : public DeviceFixture, public ::testing::Test {
void SetUp() override {
DeviceFixture::SetUp();
sysmanImp = new SysmanImp(device->toHandle());
pOsFrequency = new NiceMock<Mock<OsFrequency>>;
sysmanImp = std::make_unique<SysmanImp>(device->toHandle());
pSysfsAccess = new NiceMock<Mock<FrequencySysfsAccess>>;
linuxFrequencyImp.pSysfsAccess = pSysfsAccess;
pOsFrequency = static_cast<OsFrequency *>(&linuxFrequencyImp);
pFrequencyImp = new FrequencyImp();
pFrequencyImp->pOsFrequency = pOsFrequency;
ON_CALL(*pOsFrequency, getMin(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getMax(_))
.WillByDefault(DoAll(
SetFloat(maxFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getRequest(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getTdp(_))
.WillByDefault(DoAll(
SetFloat(maxFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getActual(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getEfficient(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getMaxVal(_))
.WillByDefault(DoAll(
SetFloat(maxFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getMinVal(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
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);
ON_CALL(*pSysfsAccess, read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<FrequencySysfsAccess>::getVal));
ON_CALL(*pSysfsAccess, write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess, &Mock<FrequencySysfsAccess>::setVal));
pFrequencyImp->init();
sysmanImp->pFrequencyHandleContext->handle_list.push_back(pFrequencyImp);
hSysman = sysmanImp->toHandle();
hSysmanFrequency = pFrequencyImp->toHandle();
}
void TearDown() override {
if (sysmanImp != nullptr) {
delete sysmanImp;
sysmanImp = nullptr;
pFrequencyImp->pOsFrequency = nullptr;
if (pSysfsAccess != nullptr) {
delete pSysfsAccess;
pSysfsAccess = nullptr;
}
DeviceFixture::TearDown();
}
@ -178,67 +168,51 @@ TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFreq
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencySetRangeThenVerifyzetSysmanFrequencySetRangeTest1CallSucceeds) {
const float startingMin = 900.0;
const float newMax = 600.0;
const double startingMin = 900.0;
const double newMax = 600.0;
zet_freq_range_t limits;
ON_CALL(*pOsFrequency, getMin(_))
.WillByDefault(DoAll(
SetFloat(startingMin),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getMax(_))
.WillByDefault(DoAll(
SetFloat(maxFreq),
Return(ZE_RESULT_SUCCESS)));
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
InSequence s;
EXPECT_CALL(*pOsFrequency, setMin(minFreq))
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*pOsFrequency, setMax(newMax))
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
limits.min = minFreq;
limits.max = newMax;
ze_result_t result = zetSysmanFrequencySetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = zetSysmanFrequencyGetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_DOUBLE_EQ(minFreq, limits.min);
EXPECT_DOUBLE_EQ(newMax, limits.max);
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencySetRangeThenVerifyzetSysmanFrequencySetRangeTest2CallSucceeds) {
const float startingMax = 600.0;
const float newMin = 900.0;
const double startingMax = 600.0;
const double newMin = 900.0;
zet_freq_range_t limits;
ON_CALL(*pOsFrequency, getMin(_))
.WillByDefault(DoAll(
SetFloat(minFreq),
Return(ZE_RESULT_SUCCESS)));
ON_CALL(*pOsFrequency, getMax(_))
.WillByDefault(DoAll(
SetFloat(startingMax),
Return(ZE_RESULT_SUCCESS)));
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
InSequence s;
EXPECT_CALL(*pOsFrequency, setMax(maxFreq))
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
EXPECT_CALL(*pOsFrequency, setMin(newMin))
.Times(1)
.WillOnce(Return(ZE_RESULT_SUCCESS));
limits.min = newMin;
limits.max = maxFreq;
ze_result_t result = zetSysmanFrequencySetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
result = zetSysmanFrequencyGetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_DOUBLE_EQ(newMin, limits.min);
EXPECT_DOUBLE_EQ(maxFreq, limits.max);
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencySetRangeThenVerifyzetSysmanFrequencySetRangeTest3CallSucceeds) {
@ -249,7 +223,7 @@ TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFreq
limits.max = clockValue(maxFreq + step);
ze_result_t result = zetSysmanFrequencySetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencySetRangeThenVerifyzetSysmanFrequencySetRangeTest4CallSucceeds) {
@ -260,7 +234,7 @@ TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFreq
limits.max = maxFreq;
ze_result_t result = zetSysmanFrequencySetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencySetRangeThenVerifyzetSysmanFrequencySetRangeTest5CallSucceeds) {
@ -271,40 +245,21 @@ TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFreq
limits.max = maxFreq;
ze_result_t result = zetSysmanFrequencySetRange(hSysmanFrequency, &limits);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
}
TEST_F(SysmanFrequencyFixture, GivenValidFrequencyHandleWhenCallingzetSysmanFrequencyGetStateThenVerifyzetSysmanFrequencyGetStateTestCallSucceeds) {
const float testRequestValue = 450.0;
const float testTdpValue = 1200.0;
const float testEfficientValue = 400.0;
const float testActualValue = 550.0;
const double testRequestValue = 450.0;
const double testTdpValue = 1200.0;
const double testEfficientValue = 400.0;
const double testActualValue = 550.0;
zet_freq_state_t state;
EXPECT_CALL(*pOsFrequency, getRequest(_))
.Times(1)
.WillOnce(DoAll(
SetFloat(testRequestValue),
Return(ZE_RESULT_SUCCESS)));
EXPECT_CALL(*pOsFrequency, getTdp(_))
.Times(1)
.WillOnce(DoAll(
SetFloat(testTdpValue),
Return(ZE_RESULT_SUCCESS)));
EXPECT_CALL(*pOsFrequency, getEfficient(_))
.Times(1)
.WillOnce(DoAll(
SetFloat(testEfficientValue),
Return(ZE_RESULT_SUCCESS)));
EXPECT_CALL(*pOsFrequency, getActual(_))
.Times(1)
.WillOnce(DoAll(
SetFloat(testActualValue),
Return(ZE_RESULT_SUCCESS)));
EXPECT_CALL(*pOsFrequency, getThrottleReasons(_))
.Times(1)
.WillOnce(Return(ZE_RESULT_ERROR_UNKNOWN));
pSysfsAccess->setVal(requestFreqFile, testRequestValue);
pSysfsAccess->setVal(tdpFreqFile, testTdpValue);
pSysfsAccess->setVal(actualFreqFile, testActualValue);
pSysfsAccess->setVal(efficientFreqFile, testEfficientValue);
ze_result_t result = zetSysmanFrequencyGetState(hSysmanFrequency, &state);

47
level_zero/tools/test/unit_tests/sources/sysman/frequency/mock_frequency.h
View File

@ -1,47 +0,0 @@
/*
* Copyright (C) 2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/core/test/unit_tests/mock.h"
#include "sysman/frequency/frequency_imp.h"
#include "sysman/frequency/os_frequency.h"
#include "sysman/sysman.h"
#include "sysman/sysman_imp.h"
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
namespace L0 {
namespace ult {
template <>
struct Mock<OsFrequency> : public OsFrequency {
Mock<OsFrequency>() = default;
MOCK_METHOD1(getMin, ze_result_t(double &min));
MOCK_METHOD1(setMin, ze_result_t(double min));
MOCK_METHOD1(getMax, ze_result_t(double &max));
MOCK_METHOD1(setMax, ze_result_t(double max));
MOCK_METHOD1(getRequest, ze_result_t(double &request));
MOCK_METHOD1(getTdp, ze_result_t(double &tdp));
MOCK_METHOD1(getActual, ze_result_t(double &actual));
MOCK_METHOD1(getEfficient, ze_result_t(double &efficient));
MOCK_METHOD1(getMaxVal, ze_result_t(double &maxVal));
MOCK_METHOD1(getMinVal, ze_result_t(double &minVal));
MOCK_METHOD1(getThrottleReasons, ze_result_t(uint32_t &throttleReasons));
};
} // namespace ult
} // namespace L0
#if defined(__clang__)
#pragma clang diagnostic pop
#endif