intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create Sysman Frequency API handles based on available subdevice/device

Browse Source 
Change-Id: I2049515150004551c3f61647d20f1df7b375f587
Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>
This commit is contained in:
Jitendra Sharma
2020-09-10 10:54:55 +05:30
committed by sys_ocldev
parent d0a6b8aece
commit e904a1f0b4
13 changed files with 430 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/device/device_imp.cpp
View File

@@ -621,7 +621,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, uint3
device->getSourceLevelDebugger()
->notifyNewDevice(osInterface ? osInterface->getDeviceHandle() : 0);
}
if (static_cast<DriverHandleImp *>(driverHandle)->enableSysman) {
if (static_cast<DriverHandleImp *>(driverHandle)->enableSysman && !device->isSubdevice) {
device->setSysmanHandle(L0::SysmanDeviceHandleContext::init(device->toHandle()));
}

14
level_zero/tools/source/sysman/frequency/frequency.cpp
View File

@@ -10,6 +10,7 @@
#include "shared/source/helpers/basic_math.h"
#include "level_zero/tools/source/sysman/frequency/frequency_imp.h"
#include "level_zero/tools/source/sysman/frequency/os_frequency.h"
namespace L0 {
@@ -19,9 +20,18 @@ FrequencyHandleContext::~FrequencyHandleContext() {
}
}
ze_result_t FrequencyHandleContext::init() {
Frequency *pFrequency = new FrequencyImp(pOsSysman);
void FrequencyHandleContext::createHandle(ze_device_handle_t deviceHandle, uint16_t frequencyDomain) {
Frequency *pFrequency = new FrequencyImp(pOsSysman, deviceHandle, frequencyDomain);
handleList.push_back(pFrequency);
}
ze_result_t FrequencyHandleContext::init(std::vector<ze_device_handle_t> deviceHandles) {
for (auto deviceHandle : deviceHandles) {
auto totalDomains = OsFrequency::getHardwareBlockCount(deviceHandle);
for (uint16_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {
createHandle(deviceHandle, frequencyDomain);
}
}
return ZE_RESULT_SUCCESS;
}

8
level_zero/tools/source/sysman/frequency/frequency.h
View File

@@ -6,6 +6,7 @@
*/
#pragma once
#include "level_zero/core/source/device/device.h"
#include <level_zero/zes_api.h>
#include <vector>
@@ -39,12 +40,15 @@ struct FrequencyHandleContext {
FrequencyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
~FrequencyHandleContext();
ze_result_t init();
ze_result_t init(std::vector<ze_device_handle_t> deviceHandles);
ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency);
OsSysman *pOsSysman;
OsSysman *pOsSysman = nullptr;
std::vector<Frequency *> handleList = {};
private:
void createHandle(ze_device_handle_t deviceHandle, uint16_t frequencyDomain);
};
} // namespace L0

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

@@ -15,7 +15,6 @@
namespace L0 {
const double FrequencyImp::step = 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode)
const bool FrequencyImp::canControl = true; // canControl is true on i915 (GEN9 Hardcode)
ze_result_t FrequencyImp::frequencyGetProperties(zes_freq_properties_t *pProperties) {
*pProperties = zesFrequencyProperties;
@@ -36,11 +35,7 @@ ze_result_t FrequencyImp::frequencyGetAvailableClocks(uint32_t *pCount, double *
}
ze_result_t FrequencyImp::frequencyGetRange(zes_freq_range_t *pLimits) {
ze_result_t result = pOsFrequency->getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->getMin(pLimits->min);
return pOsFrequency->osFrequencyGetRange(pLimits);
}
ze_result_t FrequencyImp::frequencySetRange(const zes_freq_range_t *pLimits) {
@@ -58,77 +53,21 @@ ze_result_t FrequencyImp::frequencySetRange(const zes_freq_range_t *pLimits) {
if (newMin > newMax || !newMinValid || !newMaxValid) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
double currentMax;
pOsFrequency->getMax(currentMax);
if (newMin > currentMax) {
// set the max first
ze_result_t result = pOsFrequency->setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->setMin(newMin);
}
// set the min first
ze_result_t result = pOsFrequency->setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return pOsFrequency->setMax(newMax);
return pOsFrequency->osFrequencySetRange(pLimits);
}
ze_result_t FrequencyImp::frequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
result = pOsFrequency->getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = pOsFrequency->getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
pState->stype = ZES_STRUCTURE_TYPE_FREQ_STATE;
pState->pNext = nullptr;
pState->currentVoltage = -1.0;
pState->throttleReasons = 0u;
return result;
return pOsFrequency->osFrequencyGetState(pState);
}
ze_result_t FrequencyImp::frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return pOsFrequency->osFrequencyGetThrottleTime(pThrottleTime);
}
void FrequencyImp::init() {
zesFrequencyProperties.stype = ZES_STRUCTURE_TYPE_FREQ_PROPERTIES;
zesFrequencyProperties.pNext = nullptr;
zesFrequencyProperties.type = ZES_FREQ_DOMAIN_GPU;
zesFrequencyProperties.onSubdevice = false;
zesFrequencyProperties.subdeviceId = 0;
zesFrequencyProperties.canControl = canControl;
ze_result_t result3 = pOsFrequency->getMinVal(zesFrequencyProperties.min);
ze_result_t result4 = pOsFrequency->getMaxVal(zesFrequencyProperties.max);
// If can't figure out the valid range, then can't control it.
if (ZE_RESULT_SUCCESS != result3 || ZE_RESULT_SUCCESS != result4) {
zesFrequencyProperties.canControl = false;
zesFrequencyProperties.min = 0.0;
zesFrequencyProperties.max = 0.0;
}
zesFrequencyProperties.isThrottleEventSupported = false;
zesFrequencyProperties.type = static_cast<zes_freq_domain_t>(frequencyDomain);
pOsFrequency->osFrequencyGetProperties(zesFrequencyProperties);
double freqRange = zesFrequencyProperties.max - zesFrequencyProperties.min;
numClocks = static_cast<uint32_t>(round(freqRange / step)) + 1;
pClocks = new double[numClocks];
@@ -137,8 +76,10 @@ void FrequencyImp::init() {
}
}
FrequencyImp::FrequencyImp(OsSysman *pOsSysman) {
pOsFrequency = OsFrequency::create(pOsSysman);
FrequencyImp::FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, uint16_t frequencyDomain) : deviceHandle(handle), frequencyDomain(frequencyDomain) {
ze_device_properties_t deviceProperties = {};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
pOsFrequency = OsFrequency::create(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, deviceProperties.subdeviceId);
UNRECOVERABLE_IF(nullptr == pOsFrequency);
init();

5
level_zero/tools/source/sysman/frequency/frequency_imp.h
View File

@@ -25,18 +25,19 @@ class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
FrequencyImp() = default;
FrequencyImp(OsSysman *pOsSysman);
FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, uint16_t frequencyDomain);
~FrequencyImp() override;
OsFrequency *pOsFrequency = nullptr;
void init();
private:
static const double step;
static const bool canControl;
zes_freq_properties_t zesFrequencyProperties = {};
double *pClocks = nullptr;
uint32_t numClocks = 0;
ze_device_handle_t deviceHandle = nullptr;
uint16_t frequencyDomain = 0;
};
} // namespace L0

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

@@ -6,7 +6,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}${BRANCH_DIR_SUFFIX}/os_frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.h
)

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

@@ -11,14 +11,90 @@
namespace L0 {
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");
const std::string LinuxFrequencyImp::tdpFreqFile("gt_boost_freq_mhz");
const std::string LinuxFrequencyImp::actualFreqFile("gt_act_freq_mhz");
const std::string LinuxFrequencyImp::efficientFreqFile("gt_RP1_freq_mhz");
const std::string LinuxFrequencyImp::maxValFreqFile("gt_RP0_freq_mhz");
const std::string LinuxFrequencyImp::minValFreqFile("gt_RPn_freq_mhz");
const bool LinuxFrequencyImp::canControl = true; // canControl is true on i915 (GEN9 Hardcode)
ze_result_t LinuxFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
properties.pNext = nullptr;
properties.canControl = canControl;
ze_result_t result1 = getMinVal(properties.min);
ze_result_t result2 = getMaxVal(properties.max);
// If can't figure out the valid range, then can't control it.
if (ZE_RESULT_SUCCESS != result1 || ZE_RESULT_SUCCESS != result2) {
properties.canControl = false;
properties.min = 0.0;
properties.max = 0.0;
}
properties.isThrottleEventSupported = false;
properties.onSubdevice = isSubdevice;
properties.subdeviceId = subdeviceId;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
ze_result_t result = getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return getMin(pLimits->min);
}
ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
double currentMax = 0.0;
ze_result_t result = getMax(currentMax);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
if (newMin > currentMax) {
// set the max first
ze_result_t result = setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return setMin(newMin);
}
// set the min first
result = setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
return setMax(newMax);
}
ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
result = getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
result = getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
pState->pNext = nullptr;
pState->currentVoltage = -1.0;
pState->throttleReasons = 0u;
return result;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getMin(double &min) {
double intval;
@@ -154,20 +230,30 @@ ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getThrottleReasons(uint32_t &throttleReasons) {
throttleReasons = 0u;
return ZE_RESULT_SUCCESS;
void LinuxFrequencyImp::init() {
minFreqFile = "gt_min_freq_mhz";
maxFreqFile = "gt_max_freq_mhz";
requestFreqFile = "gt_cur_freq_mhz";
tdpFreqFile = "gt_boost_freq_mhz";
actualFreqFile = "gt_act_freq_mhz";
efficientFreqFile = "gt_RP1_freq_mhz";
maxValFreqFile = "gt_RP0_freq_mhz";
minValFreqFile = "gt_RPn_freq_mhz";
}
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman) {
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
init();
}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman) {
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman);
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId);
return static_cast<OsFrequency *>(pLinuxFrequencyImp);
}
uint16_t OsFrequency::getHardwareBlockCount(ze_device_handle_t handle) {
return 1; // hardcode for now to support only ZES_FREQ_DOMAIN_GPU
}
} // namespace L0

48
level_zero/tools/source/sysman/frequency/linux/os_frequency_imp.h
View File

@@ -16,33 +16,41 @@ namespace L0 {
class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
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;
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) override;
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
LinuxFrequencyImp() = default;
LinuxFrequencyImp(OsSysman *pOsSysman);
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
~LinuxFrequencyImp() override = default;
protected:
SysfsAccess *pSysfsAccess = nullptr;
ze_result_t getMin(double &min);
ze_result_t setMin(double min);
ze_result_t getMax(double &max);
ze_result_t setMax(double max);
ze_result_t getRequest(double &request);
ze_result_t getTdp(double &tdp);
ze_result_t getActual(double &actual);
ze_result_t getEfficient(double &efficient);
ze_result_t getMaxVal(double &maxVal);
ze_result_t getMinVal(double &minVal);
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;
std::string minFreqFile;
std::string maxFreqFile;
std::string requestFreqFile;
std::string tdpFreqFile;
std::string actualFreqFile;
std::string efficientFreqFile;
std::string maxValFreqFile;
std::string minValFreqFile;
static const bool canControl;
bool isSubdevice = false;
uint32_t subdeviceId = 0;
void init();
};
} // namespace L0

19
level_zero/tools/source/sysman/frequency/os_frequency.h
View File

@@ -13,19 +13,14 @@ namespace L0 {
class OsFrequency {
public:
virtual ze_result_t getMin(double &min) = 0;
virtual ze_result_t setMin(double min) = 0;
virtual ze_result_t getMax(double &max) = 0;
virtual ze_result_t setMax(double max) = 0;
virtual ze_result_t getRequest(double &request) = 0;
virtual ze_result_t getTdp(double &tdp) = 0;
virtual ze_result_t getActual(double &actual) = 0;
virtual ze_result_t getEfficient(double &efficient) = 0;
virtual ze_result_t getMaxVal(double &maxVal) = 0;
virtual ze_result_t getMinVal(double &minVal) = 0;
virtual ze_result_t getThrottleReasons(uint32_t &throttleReasons) = 0;
virtual ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) = 0;
virtual ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) = 0;
virtual ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) = 0;
virtual ze_result_t osFrequencyGetState(zes_freq_state_t *pState) = 0;
virtual ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) = 0;
static OsFrequency *create(OsSysman *pOsSysman);
static OsFrequency *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
static uint16_t getHardwareBlockCount(ze_device_handle_t handle);
virtual ~OsFrequency() {}
};

56
level_zero/tools/source/sysman/frequency/windows/os_frequency_imp.cpp
View File

@@ -11,66 +11,40 @@ namespace L0 {
class WddmFrequencyImp : 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;
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) override;
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
};
ze_result_t WddmFrequencyImp::getMin(double &min) {
ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setMin(double min) {
ze_result_t WddmFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getMax(double &max) {
ze_result_t WddmFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setMax(double max) {
ze_result_t WddmFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getRequest(double &request) {
ze_result_t WddmFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getTdp(double &tdp) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getActual(double &actual) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getEfficient(double &efficient) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getMaxVal(double &maxVal) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getMinVal(double &minVal) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getThrottleReasons(uint32_t &throttleReasons) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman) {
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
WddmFrequencyImp *pWddmFrequencyImp = new WddmFrequencyImp();
return static_cast<OsFrequency *>(pWddmFrequencyImp);
}
uint16_t OsFrequency::getHardwareBlockCount(ze_device_handle_t handle) {
return 1;
}
} // namespace L0

13
level_zero/tools/source/sysman/sysman_imp.cpp
View File

@@ -54,12 +54,23 @@ SysmanDeviceImp::~SysmanDeviceImp() {
}
void SysmanDeviceImp::init() {
uint32_t subDeviceCount = 0;
std::vector<ze_device_handle_t> deviceHandles;
// We received a device handle. Check for subdevices in this device
Device::fromHandle(hCoreDevice)->getSubDevices(&subDeviceCount, nullptr);
if (subDeviceCount == 0) {
deviceHandles.resize(1, hCoreDevice);
} else {
deviceHandles.resize(subDeviceCount, nullptr);
Device::fromHandle(hCoreDevice)->getSubDevices(&subDeviceCount, deviceHandles.data());
}
pOsSysman->init();
if (pPowerHandleContext) {
pPowerHandleContext->init();
}
if (pFrequencyHandleContext) {
pFrequencyHandleContext->init();
pFrequencyHandleContext->init(deviceHandles);
}
if (pFabricPortHandleContext) {
pFabricPortHandleContext->init();

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

@@ -36,38 +36,126 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
MOCK_METHOD(ze_result_t, read, (const std::string file, double &val), (override));
MOCK_METHOD(ze_result_t, write, (const std::string file, const double val), (override));
ze_result_t getValReturnError(const std::string file, double &val) {
ze_result_t getMaxValReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(maxValFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMaxValReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(maxValFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMinValReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(minValFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getMinValReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(minValFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValReturnErrorNotAvailable(const std::string file, double &val) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getValActualReturnError(const std::string file, double &val) {
ze_result_t getValActualReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(actualFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValEfficientReturnError(const std::string file, double &val) {
ze_result_t getValEfficientReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(efficientFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValTdpReturnError(const std::string file, double &val) {
ze_result_t getValTdpReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(tdpFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValRequestReturnError(const std::string file, double &val) {
ze_result_t getValRequestReturnErrorNotAvailable(const std::string file, double &val) {
if (file.compare(requestFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMinReturnErrorNotAvailable(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMaxReturnErrorNotAvailable(const std::string file, const double val) {
if (file.compare(maxFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValReturnErrorUnknown(const std::string file, double &val) {
return ZE_RESULT_ERROR_UNKNOWN;
}
ze_result_t getValActualReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(actualFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValEfficientReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(efficientFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValTdpReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(tdpFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValRequestReturnErrorUnknown(const std::string file, double &val) {
if (file.compare(requestFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMinReturnErrorUnknown(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMaxReturnErrorUnknown(const std::string file, const double val) {
if (file.compare(maxFreqFile) == 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getVal(const std::string file, double &val) {
if (file.compare(minFreqFile) == 0) {
val = mockMin;
@@ -96,20 +184,6 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMinReturnError(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValMaxReturnError(const std::string file, const double val) {
if (file.compare(maxFreqFile) == 0) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setVal(const std::string file, const double val) {
if (file.compare(minFreqFile) == 0) {
mockMin = val;
@@ -144,6 +218,10 @@ struct Mock<FrequencySysfsAccess> : public FrequencySysfsAccess {
class PublicLinuxFrequencyImp : public L0::LinuxFrequencyImp {
public:
PublicLinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId) {}
using LinuxFrequencyImp::getMaxVal;
using LinuxFrequencyImp::getMin;
using LinuxFrequencyImp::getMinVal;
using LinuxFrequencyImp::pSysfsAccess;
};

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

@@ -59,7 +59,17 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init();
uint32_t subDeviceCount = 0;
std::vector<ze_device_handle_t> deviceHandles;
// We received a device handle. Check for subdevices in this device
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
if (subDeviceCount == 0) {
deviceHandles.resize(1, device->toHandle());
} else {
deviceHandles.resize(subDeviceCount, nullptr);
Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
}
pSysmanDeviceImp->pFrequencyHandleContext->init(deviceHandles);
}
void TearDown() override {
@@ -110,8 +120,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnume
TEST_F(SysmanDeviceFrequencyFixture, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
auto pFrequencyHandleContextTest = std::make_unique<FrequencyHandleContext>(pOsSysman);
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman));
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman));
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman, device->toHandle(), 0));
pFrequencyHandleContextTest->handleList.push_back(new FrequencyImp(pOsSysman, device->toHandle(), 0));
uint32_t count = 1;
std::vector<zes_freq_handle_t> phFrequency(count, nullptr);
@@ -125,7 +135,6 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
EXPECT_NE(handle, nullptr);
zes_freq_properties_t properties;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
EXPECT_EQ(ZES_STRUCTURE_TYPE_FREQ_PROPERTIES, properties.stype);
EXPECT_EQ(nullptr, properties.pNext);
EXPECT_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
EXPECT_FALSE(properties.onSubdevice);
@@ -164,11 +173,15 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhe
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxFailsThenFrequencyGetRangeCallShouldFail) {
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnError));
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limit = {};
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetRange(&limit));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencyGetRange(&limit));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetRangeThenVerifyzesFrequencyGetRangeTestCallSucceeds) {
@@ -182,27 +195,35 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits = {};
// Verify that Max must be within range.
limits.min = minFreq;
limits.max = 600.0;
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMinReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMinReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMinReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits = {};
// Verify that Max must be within range.
limits.min = 900.0;
limits.max = maxFreq;
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencySetRange(&limits));
ON_CALL(*pSysfsAccess.get(), write(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencySetRange(&limits));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
@@ -244,7 +265,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest1ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits;
// Verify that Max must be within range.
@@ -254,7 +275,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequ
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest2ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits;
// Verify that Min must be within range.
@@ -264,7 +285,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequ
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest3ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits;
// Verify that values must be multiples of step.
@@ -274,7 +295,7 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequ
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTest4ReturnsError) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_range_t limits;
// Verify that Max must be greater than min range.
@@ -303,36 +324,130 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
EXPECT_DOUBLE_EQ(testActualValue, state.actual);
EXPECT_EQ(0u, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_EQ(ZES_STRUCTURE_TYPE_FREQ_STATE, state.stype);
EXPECT_LE(state.currentVoltage, 0);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateForFailuresThenAPIExitsGracefully) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_state_t state = {};
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValRequestReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValTdpReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnError));
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValEfficientReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetState(&state));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValActualReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFrequencyImp->frequencyGetState(&state));
}
TEST_F(SysmanDeviceFrequencyFixture, GivenThrottleTimeStructPointerWhenCallingfrequencyGetThrottleTimeThenUnsupportedIsReturned) {
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman);
auto pFrequencyImp = std::make_unique<FrequencyImp>(pOsSysman, device->toHandle(), 0);
zes_freq_throttle_time_t throttleTime = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFrequencyImp->frequencyGetThrottleTime(&throttleTime));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0);
double min = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMin(min));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMin(min));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0);
double val = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMinVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMinVal(val));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0);
double val = 0;
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, linuxFrequencyImp.getMaxVal(val));
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorUnknown));
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, linuxFrequencyImp.getMaxVal(val));
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0);
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMaxValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0);
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::getMinValReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(0, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenOnSubdeviceSetWhenValidatingAnyFrequencyAPIThenSuccessIsReturned) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 1, 0);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(1, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
auto handles = get_freq_handles(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;
ON_CALL(*pSysfsAccess.get(), read(_, _))
.WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock<FrequencySysfsAccess>::setValMaxReturnErrorNotAvailable));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencySetRange(handle, &limits));
}
}
} // namespace ult
} // namespace L0