intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(sysman): ULTs for Frequency w.r.t Xe driver

Browse Source 
Related-To: NEO-8815

Signed-off-by: Bari, Pratik <pratik.bari@intel.com>
This commit is contained in:
Bari, Pratik
2023-12-18 22:07:38 +05:30
committed by Compute-Runtime-Automation
parent cb448c6c35
commit 13a451712c
6 changed files with 1044 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -13,6 +13,8 @@
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
#include "igfxfmid.h"
#include <cmath>
namespace L0 {
@@ -41,7 +43,13 @@ ze_result_t LinuxFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &p
}
double LinuxFrequencyImp::osFrequencyGetStepSize() {
return 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode);
double stepSize;
if (productFamily >= IGFX_XE_HP_SDV) {
stepSize = 50.0;
} else {
stepSize = 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode)
}
return stepSize;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
@@ -428,6 +436,7 @@ LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice,
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
productFamily = pLinuxSysmanImp->getProductFamily();
init();
}

1
level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h
View File

@@ -76,6 +76,7 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
bool isSubdevice = false;
uint32_t subdeviceId = 0;
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
PRODUCT_FAMILY productFamily;
void init();
};

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

@@ -17,6 +17,8 @@ else()
list(APPEND L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency.h
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency_xe.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency_xe.h
)
endif()

224
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_xe.h Normal file
View File

@@ -0,0 +1,224 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#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/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/sysman_kmd_interface.h"
#include "gtest/gtest.h"
namespace L0 {
namespace Sysman {
namespace ult {
const std::string minFreqFile("device/tile0/gt0/freq0/min_freq");
const std::string maxFreqFile("device/tile0/gt0/freq0/max_freq");
const std::string requestFreqFile("device/tile0/gt0/freq0/cur_freq");
const std::string actualFreqFile("device/tile0/gt0/freq0/act_freq");
const std::string efficientFreqFile("device/tile0/gt0/freq0/rpe_freq");
const std::string maxValFreqFile("device/tile0/gt0/freq0/rp0_freq");
const std::string minValFreqFile("device/tile0/gt0/freq0/rpn_freq");
const std::string throttleReasonStatusFile("device/tile0/gt0/freq0/throttle/status");
const std::string throttleReasonPL1File("device/tile0/gt0/freq0/throttle/reason_pl1");
const std::string throttleReasonPL2File("device/tile0/gt0/freq0/throttle/reason_pl2");
const std::string throttleReasonPL4File("device/tile0/gt0/freq0/throttle/reason_pl4");
const std::string throttleReasonThermalFile("device/tile0/gt0/freq0/throttle/reason_thermal");
struct MockXeFrequencySysfsAccess : public L0::Sysman::SysFsAccessInterface {
double mockMin = 0;
double mockMax = 0;
double mockRequest = 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 mockReadRequestResult = 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;
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) {
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 read(const std::string file, double &val) override {
if (mockReadDoubleValResult != ZE_RESULT_SUCCESS) {
return mockReadDoubleValResult;
}
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(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 {
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(requestFreqFile) == 0) {
mockRequest = 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 getValU32(const std::string file, uint32_t &val) {
if (file.compare(throttleReasonStatusFile) == 0) {
val = throttleVal;
}
if (file.compare(throttleReasonPL1File) == 0) {
if (mockReadPL1Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL1Val;
}
if (file.compare(throttleReasonPL2File) == 0) {
if (mockReadPL2Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL2Val;
}
if (file.compare(throttleReasonPL4File) == 0) {
if (mockReadPL4Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL4Val;
}
if (file.compare(throttleReasonThermalFile) == 0) {
if (mockReadThermalError) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonThermalVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadVal32Result != ZE_RESULT_SUCCESS) {
return mockReadVal32Result;
}
return getValU32(file, val);
}
ze_result_t write(const std::string file, double val) override {
return setVal(file, val);
}
MockXeFrequencySysfsAccess() = default;
~MockXeFrequencySysfsAccess() override = default;
};
class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
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) {}
using L0::Sysman::LinuxFrequencyImp::getMaxVal;
using L0::Sysman::LinuxFrequencyImp::getMin;
using L0::Sysman::LinuxFrequencyImp::getMinVal;
using L0::Sysman::LinuxFrequencyImp::pSysfsAccess;
};
class MockSysmanKmdInterfaceXe : public L0::Sysman::SysmanKmdInterfaceXe {
public:
std::unique_ptr<MockXeFrequencySysfsAccess> pSysfsAccess;
MockSysmanKmdInterfaceXe(const PRODUCT_FAMILY productFamily) : SysmanKmdInterfaceXe(productFamily) {}
~MockSysmanKmdInterfaceXe() override = default;
};
} // namespace ult
} // namespace Sysman
} // namespace L0

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

@@ -16,14 +16,12 @@ namespace ult {
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;
constexpr uint32_t handleComponentCount = 1u;
constexpr uint32_t multiHandleComponentCount = 2u;
@@ -32,6 +30,8 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
uint32_t numClocks = 0;
double step = 0;
void SetUp() override {
SysmanDeviceFixture::SetUp();
@@ -48,6 +48,8 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
step = 50;
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
@@ -132,7 +134,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
@@ -142,7 +144,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCa
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsMoreThanNumClocksThenCallSucceeds) {
HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsMoreThanNumClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
@@ -152,7 +154,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCo
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsLessThanNumClocksThenCallSucceeds) {
HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsLessThanNumClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
@@ -161,7 +163,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCo
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
HWTEST2_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
uint32_t count = 0;

799
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_xe.cpp Normal file
View File

@@ -0,0 +1,799 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_xe.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include <cmath>
namespace L0 {
namespace Sysman {
namespace ult {
constexpr double minFreq = 300.0;
constexpr double maxFreq = 1100.0;
constexpr double request = 300.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 SysmanDeviceFrequencyFixtureXe : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
MockSysmanKmdInterfaceXe *pSysmanKmdInterface = nullptr;
uint32_t numClocks = 0;
double step = 0;
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pSysmanKmdInterface = new MockSysmanKmdInterfaceXe(pLinuxSysmanImp->getProductFamily());
pSysmanKmdInterface->pSysfsAccess = std::make_unique<MockXeFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
pSysmanKmdInterface->pSysfsAccess->setVal(minFreqFile, minFreq);
pSysmanKmdInterface->pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysmanKmdInterface->pSysfsAccess->setVal(requestFreqFile, request);
pSysmanKmdInterface->pSysfsAccess->setVal(actualFreqFile, actual);
pSysmanKmdInterface->pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysmanKmdInterface->pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysmanKmdInterface->pSysfsAccess->setVal(minValFreqFile, minVal);
step = 50;
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
}
double clockValue(const double calculatedClock) {
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(SysmanDeviceFrequencyFixtureXe, GivenSysmanKmdInterfaceInstanceWhenCheckingAvailabilityOfFrequencyFilesThenFalseValueIsReturned) {
auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get();
EXPECT_FALSE(pSysmanKmdInterface->isDefaultFrequencyAvailable());
EXPECT_FALSE(pSysmanKmdInterface->isBoostFrequencyAvailable());
EXPECT_FALSE(pSysmanKmdInterface->isTdpFrequencyAvailable());
}
TEST_F(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyHandleContextTest = std::make_unique<L0::Sysman::FrequencyHandleContext>(pOsSysman);
pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU));
pFrequencyHandleContextTest->handleList.push_back(new L0::Sysman::FrequencyImp(pOsSysman, onSubdevice, subdeviceId, 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(SysmanDeviceFrequencyFixtureXe, 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);
}
}
HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
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);
}
}
HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsGen8) {
step = 50 / 3;
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
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);
}
}
HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleAndZeroCountWhenCountIsMoreThanNumClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
uint32_t count = 80;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
EXPECT_EQ(numClocks, count);
}
}
HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleAndZeroCountWhenCountIsLessThanNumClocksThenCallSucceeds, IsPVC) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
uint32_t count = 20;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(handle, &count, nullptr));
}
}
HWTEST2_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds, IsPVC) {
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(SysmanDeviceFrequencyFixtureXe, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
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_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreq, limits.min);
EXPECT_DOUBLE_EQ(newMax, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAndSettingMaxValueFailsThenFailureIsReturned) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect) {
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_DOUBLE_EQ(-1, limits.min);
EXPECT_DOUBLE_EQ(-1, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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);
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest4ReturnsError) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 450.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(actualFreqFile, testActualValue);
pSysfsAccess->setVal(efficientFreqFile, testEfficientValue);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadVal32Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t unsetAllThrottleReasons = 0u;
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, invalidReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(unsetAllThrottleReasons, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonBurstPower) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsCurrentExcursion) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsThermalExcursion) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsInvalidThermalExcursion) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforValidReasons) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadThermalError = true;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptThermal =
(ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonThermalFile, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptThermal, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadPL4Error = true;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL4 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL4File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL4, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadPL1Error = true;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL1 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL2File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL1File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL1, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadPL2Error = true;
zes_freq_state_t state;
uint32_t validReason = 1;
uint32_t invalidReason = 0;
uint32_t setAllThrottleReasonsExceptPL2 =
(ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT |
ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP);
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->setValU32(throttleReasonStatusFile, validReason);
pSysfsAccess->setValU32(throttleReasonPL1File, validReason);
pSysfsAccess->setValU32(throttleReasonPL4File, validReason);
pSysfsAccess->setValU32(throttleReasonThermalFile, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
pSysfsAccess->setValU32(throttleReasonPL2File, invalidReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetState(&state));
EXPECT_EQ(setAllThrottleReasonsExceptPL2, state.throttleReasons);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, 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->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(SysmanDeviceFrequencyFixtureXe, GivenThrottleTimeStructPointerWhenCallingfrequencyGetThrottleTimeThenUnsupportedIsReturned) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pFrequencyImp = std::make_unique<L0::Sysman::FrequencyImp>(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
zes_freq_throttle_time_t throttleTime = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetThrottleTime(&throttleTime));
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, GivengetMinValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfgetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto pSysfsAccess = pSysmanKmdInterface->pSysfsAccess.get();
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->mockWriteMaxResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
TEST_F(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, 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(SysmanDeviceFrequencyFixtureXe, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetTjMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double tjMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetTjMax(handle, tjMax));
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0