From b9b34659c8817393dd8ce35bf37c167c23cefcff Mon Sep 17 00:00:00 2001 From: Mraghuwa Date: Thu, 14 May 2020 23:11:33 +0530 Subject: [PATCH] Redesign ULT by mocking sysfs and implementing for frequency Change-Id: I5979132fc775fe227ed83f4d49f932f4ce2800cc --- .../source/sysman/frequency/frequency_imp.cpp | 2 +- .../sysman/frequency/linux/CMakeLists.txt | 1 + .../frequency/linux/os_frequency_imp.cpp | 60 +----- .../sysman/frequency/linux/os_frequency_imp.h | 49 +++++ .../tools/source/sysman/linux/fs_access.h | 4 +- .../sources/sysman/frequency/CMakeLists.txt | 6 +- .../sysman/frequency/linux/CMakeLists.txt | 14 ++ .../frequency/linux/mock_sysfs_frequency.h | 121 ++++++++++++ .../{ => linux}/test_sysman_frequency.cpp | 183 +++++++----------- .../sources/sysman/frequency/mock_frequency.h | 47 ----- 10 files changed, 269 insertions(+), 218 deletions(-) create mode 100644 level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/CMakeLists.txt create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h rename level_zero/tools/test/unit_tests/sources/sysman/frequency/{ => linux}/test_sysman_frequency.cpp (62%) delete mode 100644 level_zero/tools/test/unit_tests/sources/sysman/frequency/mock_frequency.h diff --git a/level_zero/tools/source/sysman/frequency/frequency_imp.cpp b/level_zero/tools/source/sysman/frequency/frequency_imp.cpp index c7dc653090..e0a2daeee1 100644 --- a/level_zero/tools/source/sysman/frequency/frequency_imp.cpp +++ b/level_zero/tools/source/sysman/frequency/frequency_imp.cpp @@ -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); diff --git a/level_zero/tools/source/sysman/frequency/linux/CMakeLists.txt b/level_zero/tools/source/sysman/frequency/linux/CMakeLists.txt index 8483cabff2..c82cbf2e68 100644 --- a/level_zero/tools/source/sysman/frequency/linux/CMakeLists.txt +++ b/level_zero/tools/source/sysman/frequency/linux/CMakeLists.txt @@ -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) diff --git a/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp b/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp index fa7d3a04f5..fbd259ca71 100644 --- a/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp +++ b/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.cpp @@ -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) { diff --git a/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h b/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h new file mode 100644 index 0000000000..15ab95f109 --- /dev/null +++ b/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h @@ -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 diff --git a/level_zero/tools/source/sysman/linux/fs_access.h b/level_zero/tools/source/sysman/linux/fs_access.h index 9e2b64419a..704e69bac7 100644 --- a/level_zero/tools/source/sysman/linux/fs_access.h +++ b/level_zero/tools/source/sysman/linux/fs_access.h @@ -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 &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 &list); ze_result_t readSymLink(const std::string path, std::string &buf); diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/frequency/CMakeLists.txt index 733f53931c..292a5dd53a 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/frequency/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/sysman/frequency/CMakeLists.txt @@ -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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/CMakeLists.txt new file mode 100644 index 0000000000..71269a28bc --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/CMakeLists.txt @@ -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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h new file mode 100644 index 0000000000..c54a3c1c56 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency.h @@ -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 : 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() = default; +}; + +class PublicLinuxFrequencyImp : public L0::LinuxFrequencyImp { + public: + using LinuxFrequencyImp::pSysfsAccess; +}; + +} // namespace ult +} // namespace L0 + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/test_sysman_frequency.cpp b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_sysman_frequency.cpp similarity index 62% rename from level_zero/tools/test/unit_tests/sources/sysman/frequency/test_sysman_frequency.cpp rename to level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_sysman_frequency.cpp index c640b1ac5a..0d825fc291 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/frequency/test_sysman_frequency.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_sysman_frequency.cpp @@ -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 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((maxFreq - minFreq) / step) + 1; class SysmanFrequencyFixture : public DeviceFixture, public ::testing::Test { protected: - SysmanImp *sysmanImp; + std::unique_ptr sysmanImp; zet_sysman_handle_t hSysman; zet_sysman_freq_handle_t hSysmanFrequency; + Mock *pSysfsAccess = nullptr; - Mock *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((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>; + sysmanImp = std::make_unique(device->toHandle()); + pSysfsAccess = new NiceMock>; + linuxFrequencyImp.pSysfsAccess = pSysfsAccess; + pOsFrequency = static_cast(&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::getVal)); + ON_CALL(*pSysfsAccess, write(_, _)) + .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock::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); diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/mock_frequency.h b/level_zero/tools/test/unit_tests/sources/sysman/frequency/mock_frequency.h deleted file mode 100644 index b8219a61c9..0000000000 --- a/level_zero/tools/test/unit_tests/sources/sysman/frequency/mock_frequency.h +++ /dev/null @@ -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 : public OsFrequency { - - Mock() = 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