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

refactor: Abstract frequency set requests based on Hw 

Related-To: NEO-10101

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran 2024-01-19 06:52:38 +00:00 committed by Compute-Runtime-Automation
parent 76de854a69
commit cfba0e0861
12 changed files with 117 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2023 Intel Corporation * Copyright (C) 2020-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -72,6 +72,10 @@ ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimi
double newMin = round(pLimits->min); double newMin = round(pLimits->min);
double newMax = round(pLimits->max); double newMax = round(pLimits->max);
if (!pSysmanProductHelper->isFrequencySetRangeSupported()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
if (pSysmanKmdInterface->isDefaultFrequencyAvailable()) { if (pSysmanKmdInterface->isDefaultFrequencyAvailable()) {
if (newMax == -1 && newMin == -1) { if (newMax == -1 && newMin == -1) {
double maxDefault = 0, minDefault = 0; double maxDefault = 0, minDefault = 0;
@ -117,6 +121,7 @@ ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimi
} }
return setMax(newMax); return setMax(newMax);
} }
bool LinuxFrequencyImp::getThrottleReasonStatus(void) { bool LinuxFrequencyImp::getThrottleReasonStatus(void) {
uint32_t val = 0; uint32_t val = 0;
auto result = pSysfsAccess->read(throttleReasonStatusFile, val); auto result = pSysfsAccess->read(throttleReasonStatusFile, val);

3
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -45,6 +45,7 @@ class SysmanProductHelper {
// Frequency // Frequency
virtual void getFrequencyStepSize(double *pStepSize) = 0; virtual void getFrequencyStepSize(double *pStepSize) = 0;
virtual bool isFrequencySetRangeSupported() = 0;
// Memory // Memory
virtual ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) = 0; virtual ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) = 0;

3
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -24,6 +24,7 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// Frequency // Frequency
void getFrequencyStepSize(double *pStepSize) override; void getFrequencyStepSize(double *pStepSize) override;
bool isFrequencySetRangeSupported() override;
// Memory // Memory
ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) override; ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) override;

7
level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -107,6 +107,11 @@ bool SysmanProductHelperHw<gfxProduct>::isMemoryMaxTemperatureSupported() {
return false; return false;
} }
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isFrequencySetRangeSupported() {
return true;
}
template <PRODUCT_FAMILY gfxProduct> template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) { ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
auto isValidTemperature = [](auto temperature) { auto isValidTemperature = [](auto temperature) {

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

@ -1,5 +1,5 @@
# #
# Copyright (C) 2020-2023 Intel Corporation # Copyright (C) 2020-2024 Intel Corporation
# #
# SPDX-License-Identifier: MIT # SPDX-License-Identifier: MIT
# #
@ -19,3 +19,4 @@ if(UNIX)
) )
endif() endif()
add_subdirectories()

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -11,6 +11,7 @@
#include "shared/test/common/test_macros/mock_method_macros.h" #include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h" #include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h" #include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h" #include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
@ -212,6 +213,14 @@ struct MockProductHelperFreq : NEO::ProductHelperHw<IGFX_UNKNOWN> {
return isMediaFreqDomainPresent; return isMediaFreqDomainPresent;
} }
}; };
struct MockSysmanProductHelperFreq : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperFreq() = default;
bool isFrequencySetRangeSupported() override {
return false;
}
};
class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp { class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
public: public:
PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {} PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}

10
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysman_frequency.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2023 Intel Corporation * Copyright (C) 2020-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -12,6 +12,7 @@
#include "shared/test/common/test_macros/mock_method_macros.h" #include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h" #include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h" #include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -358,6 +359,13 @@ struct MockProductHelperFreq : NEO::ProductHelperHw<IGFX_UNKNOWN> {
} }
}; };
struct MockSysmanProductHelperFreq : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperFreq() = default;
bool isFrequencySetRangeSupported() override {
return false;
}
};
class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp { class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
public: public:
PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {} PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2023 Intel Corporation * Copyright (C) 2020-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -260,7 +260,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
} }
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true; ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
@ -277,7 +277,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequen
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true; ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
@ -294,7 +294,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequen
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
const double startingMin = 900.0; const double startingMin = 900.0;
@ -314,7 +314,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
} }
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
const double negativeMin = -1; const double negativeMin = -1;
@ -331,7 +331,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCal
} }
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
const double startingMax = 600.0; const double startingMax = 600.0;
@ -351,7 +351,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
} }
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError, IsXeHpOrXeHpcOrXeHpgCore) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true; ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
@ -364,6 +364,24 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequ
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenFrequencySetRangeNotSupportedWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeFails) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperFreq>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
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_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) { TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
@ -431,7 +449,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
} }
} }
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) { HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
pSysfsAccess->isLegacy = true; pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false; pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) { for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {

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

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -57,7 +57,6 @@ class SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
delete handle; delete handle;
} }
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear(); pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
} }
void TearDown() override { void TearDown() override {
@ -226,7 +225,7 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFr
} }
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) { HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true; ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
@ -244,7 +243,7 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequ
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) { HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true; ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
@ -262,7 +261,7 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequ
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) { HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
@ -297,7 +296,7 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAnd
} }
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect) { HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect, IsXeHpOrXeHpcOrXeHpgCore) {
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto &handle : handles) { for (auto &handle : handles) {
const double negativeMin = -1; const double negativeMin = -1;
@ -313,7 +312,7 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAnd
} }
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) { HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) { for (auto handle : handles) {
@ -346,6 +345,25 @@ TEST_F(SysmanDeviceFrequencyFixtureXe, GivenInvalidFrequencyLimitsWhenCallingFre
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits)); EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, pFrequencyImp->frequencySetRange(&limits));
} }
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenFrequencySetRangeNotSupportedWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeFails) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperFreq>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) { TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get(); auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto handles = getFreqHandles(handleComponentCount); auto handles = getFreqHandles(handleComponentCount);

12
level_zero/sysman/test/unit_tests/sources/linux/mocks/CMakeLists.txt Normal file
View File

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

11
level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.cpp Normal file
View File

@ -0,0 +1,11 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl"
template class L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN>;

7
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_frequency_tests.cpp
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2023 Intel Corporation * Copyright (C) 2023-2024 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@ -30,6 +30,11 @@ HWTEST2_F(SysmanProductHelperFrequencyTest, GivenFrequencyModuleWhenGettingStepS
EXPECT_EQ((50.0 / 3), stepSize); EXPECT_EQ((50.0 / 3), stepSize);
} }
HWTEST2_F(SysmanProductHelperFrequencyTest, GivenFrequencyModuleWhenQueryingFrequencySetRangeSupportedThenVerifySetRangeIsSupported, IsXeHpOrXeHpcOrXeHpgCore) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_EQ(true, pSysmanProductHelper->isFrequencySetRangeSupported());
}
TEST_F(SysmanProductHelperFrequencyTest, GivenSysmanProductHelperInstanceWhenGettingCurrentVoltageThenVerifyCurrentVoltageIsNegative) { TEST_F(SysmanProductHelperFrequencyTest, GivenSysmanProductHelperInstanceWhenGettingCurrentVoltageThenVerifyCurrentVoltageIsNegative) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<PublicFsAccess> pFsAccess = std::make_unique<PublicFsAccess>(); std::unique_ptr<PublicFsAccess> pFsAccess = std::make_unique<PublicFsAccess>();