intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added support for Frequency APIs

Browse Source 
- Added support for the Frequency APIs in the new sysman design.
- Added ULTs for the Frequency APIs in the new sysman design.

Related-To: LOCI-4096

Signed-off-by: Bari, Pratik <pratik.bari@intel.com>
This commit is contained in:
Bari, Pratik
2023-03-13 08:43:44 +00:00
committed by Compute-Runtime-Automation
parent 9a056318a4
commit 593bd13d4d
27 changed files with 4247 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/api/sysman/zes_handles_struct.h
View File

@@ -23,3 +23,6 @@ struct _zes_pwr_handle_t {
struct _zes_engine_handle_t {
virtual ~_zes_engine_handle_t() = default;
};
struct _zes_freq_handle_t {
virtual ~_zes_freq_handle_t() = default;
};

108
level_zero/api/sysman/zes_sysman_api_entrypoints.h
View File

@@ -252,112 +252,184 @@ ze_result_t zesDeviceEnumFrequencyDomains(
zes_device_handle_t hDevice,
uint32_t *pCount,
zes_freq_handle_t *phFrequency) {
return L0::SysmanDevice::frequencyGet(hDevice, pCount, phFrequency);
if (L0::sysmanInitFromCore) {
return L0::SysmanDevice::frequencyGet(hDevice, pCount, phFrequency);
} else {
return L0::Sysman::SysmanDevice::frequencyGet(hDevice, pCount, phFrequency);
}
}
ze_result_t zesFrequencyGetProperties(
zes_freq_handle_t hFrequency,
zes_freq_properties_t *pProperties) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyGetProperties(pProperties);
}
}
ze_result_t zesFrequencyGetAvailableClocks(
zes_freq_handle_t hFrequency,
uint32_t *pCount,
double *phFrequency) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetAvailableClocks(pCount, phFrequency);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetAvailableClocks(pCount, phFrequency);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyGetAvailableClocks(pCount, phFrequency);
}
}
ze_result_t zesFrequencyGetRange(
zes_freq_handle_t hFrequency,
zes_freq_range_t *pLimits) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyGetRange(pLimits);
}
}
ze_result_t zesFrequencySetRange(
zes_freq_handle_t hFrequency,
const zes_freq_range_t *pLimits) {
return L0::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencySetRange(pLimits);
}
}
ze_result_t zesFrequencyGetState(
zes_freq_handle_t hFrequency,
zes_freq_state_t *pState) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyGetState(pState);
}
}
ze_result_t zesFrequencyGetThrottleTime(
zes_freq_handle_t hFrequency,
zes_freq_throttle_time_t *pThrottleTime) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetThrottleTime(pThrottleTime);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyGetThrottleTime(pThrottleTime);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyGetThrottleTime(pThrottleTime);
}
}
ze_result_t zesFrequencyOcGetFrequencyTarget(
zes_freq_handle_t hFrequency,
double *pCurrentOcFrequency) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetFrequencyTarget(pCurrentOcFrequency);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetFrequencyTarget(pCurrentOcFrequency);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGetFrequencyTarget(pCurrentOcFrequency);
}
}
ze_result_t zesFrequencyOcSetFrequencyTarget(
zes_freq_handle_t hFrequency,
double currentOcFrequency) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetFrequencyTarget(currentOcFrequency);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetFrequencyTarget(currentOcFrequency);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcSetFrequencyTarget(currentOcFrequency);
}
}
ze_result_t zesFrequencyOcGetVoltageTarget(
zes_freq_handle_t hFrequency,
double *pCurrentVoltageTarget,
double *pCurrentVoltageOffset) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGetVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
}
}
ze_result_t zesFrequencyOcSetVoltageTarget(
zes_freq_handle_t hFrequency,
double currentVoltageTarget,
double currentVoltageOffset) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetVoltageTarget(currentVoltageTarget, currentVoltageOffset);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetVoltageTarget(currentVoltageTarget, currentVoltageOffset);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcSetVoltageTarget(currentVoltageTarget, currentVoltageOffset);
}
}
ze_result_t zesFrequencyOcSetMode(
zes_freq_handle_t hFrequency,
zes_oc_mode_t currentOcMode) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetMode(currentOcMode);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetMode(currentOcMode);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcSetMode(currentOcMode);
}
}
ze_result_t zesFrequencyOcGetMode(
zes_freq_handle_t hFrequency,
zes_oc_mode_t *pCurrentOcMode) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetMode(pCurrentOcMode);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetMode(pCurrentOcMode);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGetMode(pCurrentOcMode);
}
}
ze_result_t zesFrequencyOcGetCapabilities(
zes_freq_handle_t hFrequency,
zes_oc_capabilities_t *pOcCapabilities) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetCapabilities(pOcCapabilities);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetCapabilities(pOcCapabilities);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGetCapabilities(pOcCapabilities);
}
}
ze_result_t zesFrequencyOcGetIccMax(
zes_freq_handle_t hFrequency,
double *pOcIccMax) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetIccMax(pOcIccMax);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGetIccMax(pOcIccMax);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGetIccMax(pOcIccMax);
}
}
ze_result_t zesFrequencyOcSetIccMax(
zes_freq_handle_t hFrequency,
double ocIccMax) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetIccMax(ocIccMax);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetIccMax(ocIccMax);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcSetIccMax(ocIccMax);
}
}
ze_result_t zesFrequencyOcGetTjMax(
zes_freq_handle_t hFrequency,
double *pOcTjMax) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGeTjMax(pOcTjMax);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcGeTjMax(pOcTjMax);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcGeTjMax(pOcTjMax);
}
}
ze_result_t zesFrequencyOcSetTjMax(
zes_freq_handle_t hFrequency,
double ocTjMax) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetTjMax(ocTjMax);
if (L0::sysmanInitFromCore) {
return L0::Frequency::fromHandle(hFrequency)->frequencyOcSetTjMax(ocTjMax);
} else {
return L0::Sysman::Frequency::fromHandle(hFrequency)->frequencyOcSetTjMax(ocTjMax);
}
}
ze_result_t zesDeviceEnumEngineGroups(

28
level_zero/sysman/source/frequency/CMakeLists.txt Normal file
View File

@@ -0,0 +1,28 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_SRCS_SYSMAN_FREQUENCY
${CMAKE_CURRENT_SOURCE_DIR}/frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/frequency.h
${CMAKE_CURRENT_SOURCE_DIR}/frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/frequency_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency.h
)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${L0_SRCS_SYSMAN_FREQUENCY}
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
if(UNIX)
add_subdirectory(linux)
else()
add_subdirectory(windows)
endif()
# Make our source files visible to parent
set_property(GLOBAL PROPERTY L0_SRCS_SYSMAN_FREQUENCY ${L0_SRCS_SYSMAN_FREQUENCY})

69
level_zero/sysman/source/frequency/frequency.cpp Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/frequency/frequency.h"
#include "shared/source/helpers/basic_math.h"
#include "level_zero/sysman/source/frequency/frequency_imp.h"
#include "level_zero/sysman/source/frequency/os_frequency.h"
#include "level_zero/sysman/source/os_sysman.h"
namespace L0 {
namespace Sysman {
FrequencyHandleContext::~FrequencyHandleContext() {
for (Frequency *pFrequency : handleList) {
delete pFrequency;
}
}
void FrequencyHandleContext::createHandle(ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomain) {
Frequency *pFrequency = new FrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomain);
handleList.push_back(pFrequency);
}
ze_result_t FrequencyHandleContext::init(uint32_t subDeviceCount) {
auto totalDomains = OsFrequency::getNumberOfFreqDomainsSupported(pOsSysman);
UNRECOVERABLE_IF(totalDomains > 2);
if (subDeviceCount == 0) {
for (uint32_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {
createHandle(false, 0, static_cast<zes_freq_domain_t>(frequencyDomain));
}
}
else {
for (uint32_t subDeviceId = 0; subDeviceId < subDeviceCount; subDeviceId++) {
for (uint32_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {
createHandle(true, subDeviceId, static_cast<zes_freq_domain_t>(frequencyDomain));
}
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyHandleContext::frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) {
std::call_once(initFrequencyOnce, [this]() {
this->init(pOsSysman->getSubDeviceCount());
});
uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
uint32_t numToCopy = std::min(*pCount, handleListSize);
if (0 == *pCount || *pCount > handleListSize) {
*pCount = handleListSize;
}
if (nullptr != phFrequency) {
for (uint32_t i = 0; i < numToCopy; i++) {
phFrequency[i] = handleList[i]->toZesFreqHandle();
}
}
return ZE_RESULT_SUCCESS;
}
} // namespace Sysman
} // namespace L0

69
level_zero/sysman/source/frequency/frequency.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/api/sysman/zes_handles_struct.h"
#include <level_zero/zes_api.h>
#include <mutex>
#include <vector>
namespace L0 {
namespace Sysman {
constexpr double unsupportedProperty = -1.0;
struct OsSysman;
class Frequency : _zes_freq_handle_t {
public:
~Frequency() override {}
virtual ze_result_t frequencyGetProperties(zes_freq_properties_t *pProperties) = 0;
virtual ze_result_t frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) = 0;
virtual ze_result_t frequencyGetRange(zes_freq_range_t *pLimits) = 0;
virtual ze_result_t frequencySetRange(const zes_freq_range_t *pLimits) = 0;
virtual ze_result_t frequencyGetState(zes_freq_state_t *pState) = 0;
virtual ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) = 0;
// Overclocking
virtual ze_result_t frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) = 0;
virtual ze_result_t frequencyOcGetFrequencyTarget(double *pCurrentOcfrequency) = 0;
virtual ze_result_t frequencyOcSetFrequencyTarget(double currentOcfrequency) = 0;
virtual ze_result_t frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) = 0;
virtual ze_result_t frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) = 0;
virtual ze_result_t frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) = 0;
virtual ze_result_t frequencyOcSetMode(zes_oc_mode_t currentOcMode) = 0;
virtual ze_result_t frequencyOcGetIccMax(double *pOcIccMax) = 0;
virtual ze_result_t frequencyOcSetIccMax(double ocIccMax) = 0;
virtual ze_result_t frequencyOcGeTjMax(double *pOcTjMax) = 0;
virtual ze_result_t frequencyOcSetTjMax(double ocTjMax) = 0;
static Frequency *fromHandle(zes_freq_handle_t handle) {
return static_cast<Frequency *>(handle);
}
inline zes_freq_handle_t toZesFreqHandle() { return this; }
};
struct FrequencyHandleContext {
FrequencyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
~FrequencyHandleContext();
ze_result_t init(uint32_t subDeviceCount);
ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency);
OsSysman *pOsSysman = nullptr;
std::vector<Frequency *> handleList = {};
private:
void createHandle(ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomain);
std::once_flag initFrequencyOnce;
};
} // namespace Sysman
} // namespace L0

132
level_zero/sysman/source/frequency/frequency_imp.cpp Normal file
View File

@@ -0,0 +1,132 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/frequency/frequency_imp.h"
#include "shared/source/helpers/debug_helpers.h"
#include "level_zero/sysman/source/sysman_device_imp.h"
#include <algorithm>
#include <cmath>
namespace L0 {
namespace Sysman {
ze_result_t FrequencyImp::frequencyGetProperties(zes_freq_properties_t *pProperties) {
*pProperties = zesFrequencyProperties;
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) {
uint32_t numToCopy = std::min(*pCount, numClocks);
if (0 == *pCount || *pCount > numClocks) {
*pCount = numClocks;
}
if (nullptr != phFrequency) {
for (uint32_t i = 0; i < numToCopy; i++) {
phFrequency[i] = pClocks[i];
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t FrequencyImp::frequencyGetRange(zes_freq_range_t *pLimits) {
return pOsFrequency->osFrequencyGetRange(pLimits);
}
ze_result_t FrequencyImp::frequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
// No need to check if the frequency is inside the clocks array:
// 1. GuC will cap this, GuC has an internal range. Hw too rounds to the next step, no need to do that check.
// 2. For Overclocking, Oc frequency will be higher than the zesFrequencyProperties.max frequency, so it would be outside
// the clocks array too. Pcode at the end will decide the granted frequency, no need for the check.
if (newMin > newMax) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
return pOsFrequency->osFrequencySetRange(pLimits);
}
ze_result_t FrequencyImp::frequencyGetState(zes_freq_state_t *pState) {
return pOsFrequency->osFrequencyGetState(pState);
}
ze_result_t FrequencyImp::frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return pOsFrequency->osFrequencyGetThrottleTime(pThrottleTime);
}
ze_result_t FrequencyImp::frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return pOsFrequency->getOcCapabilities(pOcCapabilities);
}
ze_result_t FrequencyImp::frequencyOcGetFrequencyTarget(double *pCurrentOcFrequency) {
return pOsFrequency->getOcFrequencyTarget(pCurrentOcFrequency);
}
ze_result_t FrequencyImp::frequencyOcSetFrequencyTarget(double currentOcFrequency) {
return pOsFrequency->setOcFrequencyTarget(currentOcFrequency);
}
ze_result_t FrequencyImp::frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return pOsFrequency->getOcVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
}
ze_result_t FrequencyImp::frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return pOsFrequency->setOcVoltageTarget(currentVoltageTarget, currentVoltageOffset);
}
ze_result_t FrequencyImp::frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) {
return pOsFrequency->getOcMode(pCurrentOcMode);
}
ze_result_t FrequencyImp::frequencyOcSetMode(zes_oc_mode_t currentOcMode) {
return pOsFrequency->setOcMode(currentOcMode);
}
ze_result_t FrequencyImp::frequencyOcGetIccMax(double *pOcIccMax) {
return pOsFrequency->getOcIccMax(pOcIccMax);
}
ze_result_t FrequencyImp::frequencyOcSetIccMax(double ocIccMax) {
return pOsFrequency->setOcIccMax(ocIccMax);
}
ze_result_t FrequencyImp::frequencyOcGeTjMax(double *pOcTjMax) {
return pOsFrequency->getOcTjMax(pOcTjMax);
}
ze_result_t FrequencyImp::frequencyOcSetTjMax(double ocTjMax) {
return pOsFrequency->setOcTjMax(ocTjMax);
}
void FrequencyImp::init() {
pOsFrequency->osFrequencyGetProperties(zesFrequencyProperties);
double step = pOsFrequency->osFrequencyGetStepSize();
double freqRange = zesFrequencyProperties.max - zesFrequencyProperties.min;
numClocks = static_cast<uint32_t>(round(freqRange / step)) + 1;
pClocks = new double[numClocks];
for (unsigned int i = 0; i < numClocks; i++) {
pClocks[i] = round(zesFrequencyProperties.min + (step * i));
}
}
FrequencyImp::FrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
pOsFrequency = OsFrequency::create(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
UNRECOVERABLE_IF(nullptr == pOsFrequency);
init();
}
FrequencyImp::~FrequencyImp() {
delete pOsFrequency;
delete[] pClocks;
}
} // namespace Sysman
} // namespace L0

54
level_zero/sysman/source/frequency/frequency_imp.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/sysman/source/frequency/frequency.h"
#include "level_zero/sysman/source/frequency/os_frequency.h"
#include <level_zero/zes_api.h>
namespace L0 {
namespace Sysman {
class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t frequencyGetProperties(zes_freq_properties_t *pProperties) override;
ze_result_t frequencyGetAvailableClocks(uint32_t *pCount, double *phFrequency) override;
ze_result_t frequencyGetRange(zes_freq_range_t *pLimits) override;
ze_result_t frequencySetRange(const zes_freq_range_t *pLimits) override;
ze_result_t frequencyGetState(zes_freq_state_t *pState) override;
ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
// Overclocking
ze_result_t frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
ze_result_t frequencyOcGetFrequencyTarget(double *pCurrentOcFrequency) override;
ze_result_t frequencyOcSetFrequencyTarget(double currentOcFrequency) override;
ze_result_t frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
ze_result_t frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
ze_result_t frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) override;
ze_result_t frequencyOcSetMode(zes_oc_mode_t currentOcMode) override;
ze_result_t frequencyOcGetIccMax(double *pOcIccMax) override;
ze_result_t frequencyOcSetIccMax(double ocIccMax) override;
ze_result_t frequencyOcGeTjMax(double *pOcTjMax) override;
ze_result_t frequencyOcSetTjMax(double ocTjMax) override;
FrequencyImp() = default;
FrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber);
~FrequencyImp() override;
OsFrequency *pOsFrequency = nullptr;
void init();
private:
zes_freq_properties_t zesFrequencyProperties = {};
double *pClocks = nullptr;
uint32_t numClocks = 0;
};
} // namespace Sysman
} // namespace L0

31
level_zero/sysman/source/frequency/linux/CMakeLists.txt Normal file
View File

@@ -0,0 +1,31 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp_prelim.h
)
else()
list(APPEND L0_SRCS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.h
)
endif()
if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${L0_SRCS_SYSMAN_FREQUENCY_LINUX}
)
endif()
# Make our source files visible to parent
set_property(GLOBAL PROPERTY L0_SRCS_SYSMAN_FREQUENCY_LINUX ${L0_SRCS_SYSMAN_FREQUENCY_LINUX})

432
level_zero/sysman/source/frequency/linux/os_frequency_imp.cpp Normal file
View File

@@ -0,0 +1,432 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/frequency/linux/os_frequency_imp.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/linux/os_sysman_imp.h"
#include <cmath>
namespace L0 {
namespace Sysman {
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;
properties.type = frequencyDomainNumber;
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) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMinVal returned: 0x%x, getMaxVal returned: 0x%x> <setting min = 0.0, max = 0.0>\n", __func__, result1, 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;
}
double LinuxFrequencyImp::osFrequencyGetStepSize() {
return 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode);
}
ze_result_t LinuxFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
ze_result_t result = getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x setting max = -1>\n", __func__, result);
pLimits->max = -1;
}
result = getMin(pLimits->min);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMin returned 0x%x setting min = -1>\n", __func__, result);
pLimits->min = -1;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
if (newMax == -1 && newMin == -1) {
double maxDefault = 0, minDefault = 0;
ze_result_t result1, result2, result;
result1 = pSysfsAccess->read(maxDefaultFreqFile, maxDefault);
result2 = pSysfsAccess->read(minDefaultFreqFile, minDefault);
if (result1 == ZE_RESULT_SUCCESS && result2 == ZE_RESULT_SUCCESS) {
result = setMax(maxDefault);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(maxDefault) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(minDefault);
}
}
double currentMax = 0.0;
ze_result_t result = getMax(currentMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x>\n", __func__, result);
return result;
}
if (newMin > currentMax) {
// set the max first
ze_result_t result = setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(newMax) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(newMin);
}
// set the min first
result = setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMin returned 0x%x>\n", __func__, result);
return result;
}
return setMax(newMax);
}
bool LinuxFrequencyImp::getThrottleReasonStatus(void) {
uint32_t val = 0;
auto result = pSysfsAccess->read(throttleReasonStatusFile, val);
if (ZE_RESULT_SUCCESS == result) {
return (val == 0 ? false : true);
} else {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, throttleReasonStatusFile.c_str(), result);
return false;
}
}
ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
result = getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getRequest returned 0x%x>\n", __func__, result);
pState->request = -1;
}
result = getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getTdp returned 0x%x>\n", __func__, result);
pState->tdp = -1;
}
result = getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getEfficient returned 0x%x>\n", __func__, result);
pState->efficient = -1;
}
result = getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getActual returned 0x%x>\n", __func__, result);
pState->actual = -1;
}
pState->pNext = nullptr;
pState->currentVoltage = -1.0;
pState->throttleReasons = 0u;
if (getThrottleReasonStatus()) {
uint32_t val = 0;
ze_result_t result;
result = pSysfsAccess->read(throttleReasonPL1File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL2File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL4File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT;
}
result = pSysfsAccess->read(throttleReasonThermalFile, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcIccMax(double *pOcIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcIccMax(double ocIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcTjMax(double *pOcTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcTjMax(double ocTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getMin(double &min) {
double intval;
ze_result_t result = pSysfsAccess->read(minFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
min = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMin(double min) {
ze_result_t result = pSysfsAccess->write(minFreqFile, min);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMax(double &max) {
double intval;
ze_result_t result = pSysfsAccess->read(maxFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
max = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMax(double max) {
ze_result_t result = pSysfsAccess->write(maxFreqFile, max);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
return pSysfsAccess->write(boostFreqFile, max);
}
ze_result_t LinuxFrequencyImp::getRequest(double &request) {
double intval;
ze_result_t result = pSysfsAccess->read(requestFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, requestFreqFile.c_str(), result);
return result;
}
request = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
double intval;
ze_result_t result = pSysfsAccess->read(tdpFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, tdpFreqFile.c_str(), result);
return result;
}
tdp = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getActual(double &actual) {
double intval;
ze_result_t result = pSysfsAccess->read(actualFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, actualFreqFile.c_str(), result);
return result;
}
actual = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
double intval;
ze_result_t result = pSysfsAccess->read(efficientFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, efficientFreqFile.c_str(), result);
return result;
}
efficient = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
double intval;
ze_result_t result = pSysfsAccess->read(maxValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxValFreqFile.c_str(), result);
return result;
}
maxVal = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
double intval;
ze_result_t result = pSysfsAccess->read(minValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minValFreqFile.c_str(), result);
return result;
}
minVal = intval;
return ZE_RESULT_SUCCESS;
}
void LinuxFrequencyImp::init() {
const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
if (pSysfsAccess->directoryExists(baseDir)) {
minFreqFile = baseDir + "rps_min_freq_mhz";
maxFreqFile = baseDir + "rps_max_freq_mhz";
minDefaultFreqFile = baseDir + ".defaults/rps_min_freq_mhz";
maxDefaultFreqFile = baseDir + ".defaults/rps_max_freq_mhz";
boostFreqFile = baseDir + "rps_boost_freq_mhz";
requestFreqFile = baseDir + "punit_req_freq_mhz";
tdpFreqFile = baseDir + "rapl_PL1_freq_mhz";
actualFreqFile = baseDir + "rps_act_freq_mhz";
efficientFreqFile = baseDir + "rps_RP1_freq_mhz";
maxValFreqFile = baseDir + "rps_RP0_freq_mhz";
minValFreqFile = baseDir + "rps_RPn_freq_mhz";
throttleReasonStatusFile = baseDir + "throttle_reason_status";
throttleReasonPL1File = baseDir + "throttle_reason_pl1";
throttleReasonPL2File = baseDir + "throttle_reason_pl2";
throttleReasonPL4File = baseDir + "throttle_reason_pl4";
throttleReasonThermalFile = baseDir + "throttle_reason_thermal";
} else {
minFreqFile = "gt_min_freq_mhz";
maxFreqFile = "gt_max_freq_mhz";
boostFreqFile = "gt_boost_freq_mhz";
requestFreqFile = "gt_cur_freq_mhz";
tdpFreqFile = "rapl_PL1_freq_mhz";
actualFreqFile = "gt_act_freq_mhz";
efficientFreqFile = "gt_RP1_freq_mhz";
maxValFreqFile = "gt_RP0_freq_mhz";
minValFreqFile = "gt_RPn_freq_mhz";
throttleReasonStatusFile = "gt_throttle_reason_status";
throttleReasonPL1File = "gt_throttle_reason_status_pl1";
throttleReasonPL2File = "gt_throttle_reason_status_pl2";
throttleReasonPL4File = "gt_throttle_reason_status_pl4";
throttleReasonThermalFile = "gt_throttle_reason_status_thermal";
}
}
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
init();
}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
return static_cast<OsFrequency *>(pLinuxFrequencyImp);
}
uint16_t OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
return 1; // hardcode for now to support only ZES_FREQ_DOMAIN_GPU
}
} // namespace Sysman
} // namespace L0

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

@@ -0,0 +1,80 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/sysman/source/frequency/frequency_imp.h"
#include "level_zero/sysman/source/frequency/os_frequency.h"
#include "level_zero/sysman/source/linux/fs_access.h"
namespace L0 {
namespace Sysman {
class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
double osFrequencyGetStepSize() 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 getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
ze_result_t getOcIccMax(double *pOcIccMax) override;
ze_result_t setOcIccMax(double ocIccMax) override;
ze_result_t getOcTjMax(double *pOcTjMax) override;
ze_result_t setOcTjMax(double ocTjMax) override;
LinuxFrequencyImp() = default;
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber);
~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);
bool getThrottleReasonStatus(void);
private:
std::string minFreqFile;
std::string maxFreqFile;
std::string minDefaultFreqFile;
std::string maxDefaultFreqFile;
std::string boostFreqFile;
std::string requestFreqFile;
std::string tdpFreqFile;
std::string actualFreqFile;
std::string efficientFreqFile;
std::string maxValFreqFile;
std::string minValFreqFile;
std::string throttleReasonStatusFile;
std::string throttleReasonPL1File;
std::string throttleReasonPL2File;
std::string throttleReasonPL4File;
std::string throttleReasonThermalFile;
static const bool canControl;
bool isSubdevice = false;
uint32_t subdeviceId = 0;
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
void init();
};
} // namespace Sysman
} // namespace L0

437
level_zero/sysman/source/frequency/linux/os_frequency_imp_prelim.cpp Normal file
View File

@@ -0,0 +1,437 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/frequency/linux/os_frequency_imp_prelim.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/device/device.h"
#include "shared/source/helpers/hw_info.h"
#include "level_zero/sysman/source/linux/os_sysman_imp.h"
#include <cmath>
namespace L0 {
namespace Sysman {
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;
properties.type = frequencyDomainNumber;
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) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMinVal returned: 0x%x, getMaxVal returned: 0x%x> <setting min = 0.0, max = 0.0>\n", __func__, result1, 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;
}
double LinuxFrequencyImp::osFrequencyGetStepSize() {
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) {
ze_result_t result = getMax(pLimits->max);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x setting max = -1>\n", __func__, result);
pLimits->max = -1;
}
result = getMin(pLimits->min);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMin returned 0x%x setting min = -1>\n", __func__, result);
pLimits->min = -1;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
double newMin = round(pLimits->min);
double newMax = round(pLimits->max);
if (newMax == -1 && newMin == -1) {
double maxDefault = 0, minDefault = 0;
ze_result_t result1, result2, result;
result1 = pSysfsAccess->read(maxDefaultFreqFile, maxDefault);
result2 = pSysfsAccess->read(minDefaultFreqFile, minDefault);
if (result1 == ZE_RESULT_SUCCESS && result2 == ZE_RESULT_SUCCESS) {
result = setMax(maxDefault);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(maxDefault) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(minDefault);
}
}
double currentMax = 0.0;
ze_result_t result = getMax(currentMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getMax returned 0x%x>\n", __func__, result);
return result;
}
if (newMin > currentMax) {
// set the max first
ze_result_t result = setMax(newMax);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMax(newMax) returned 0x%x>\n", __func__, result);
return result;
}
return setMin(newMin);
}
// set the min first
result = setMin(newMin);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <setMin returned 0x%x>\n", __func__, result);
return result;
}
return setMax(newMax);
}
bool LinuxFrequencyImp::getThrottleReasonStatus(void) {
uint32_t val = 0;
auto result = pSysfsAccess->read(throttleReasonStatusFile, val);
if (ZE_RESULT_SUCCESS == result) {
return (val == 0 ? false : true);
} else {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, throttleReasonStatusFile.c_str(), result);
return false;
}
}
ze_result_t LinuxFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
ze_result_t result;
result = getRequest(pState->request);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getRequest returned 0x%x>\n", __func__, result);
pState->request = -1;
}
result = getTdp(pState->tdp);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getTdp returned 0x%x>\n", __func__, result);
pState->tdp = -1;
}
result = getEfficient(pState->efficient);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getEfficient returned 0x%x>\n", __func__, result);
pState->efficient = -1;
}
result = getActual(pState->actual);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <getActual returned 0x%x>\n", __func__, result);
pState->actual = -1;
}
pState->pNext = nullptr;
pState->currentVoltage = -1.0;
pState->throttleReasons = 0u;
if (getThrottleReasonStatus()) {
uint32_t val = 0;
ze_result_t result;
result = pSysfsAccess->read(throttleReasonPL1File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL2File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP;
}
result = pSysfsAccess->read(throttleReasonPL4File, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT;
}
result = pSysfsAccess->read(throttleReasonThermalFile, val);
if (val && (result == ZE_RESULT_SUCCESS)) {
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT;
}
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcIccMax(double *pOcIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcIccMax(double ocIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getOcTjMax(double *pOcTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::setOcTjMax(double ocTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFrequencyImp::getMin(double &min) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(minFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
min = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMin(double min) {
ze_result_t result = pSysfsAccess->write(minFreqFile, min);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, minFreqFile.c_str(), result);
return result;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMax(double &max) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(maxFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
max = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::setMax(double max) {
ze_result_t result = pSysfsAccess->write(maxFreqFile, max);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to write file %s> <result: 0x%x>\n", __func__, maxFreqFile.c_str(), result);
return result;
}
return pSysfsAccess->write(boostFreqFile, max);
}
ze_result_t LinuxFrequencyImp::getRequest(double &request) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(requestFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, requestFreqFile.c_str(), result);
return result;
}
request = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getTdp(double &tdp) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(tdpFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, tdpFreqFile.c_str(), result);
return result;
}
tdp = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getActual(double &actual) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(actualFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, actualFreqFile.c_str(), result);
return result;
}
actual = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getEfficient(double &efficient) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(efficientFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, efficientFreqFile.c_str(), result);
return result;
}
efficient = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMaxVal(double &maxVal) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(maxValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, maxValFreqFile.c_str(), result);
return result;
}
maxVal = intval;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
double intval = 0;
ze_result_t result = pSysfsAccess->read(minValFreqFile, intval);
if (ZE_RESULT_SUCCESS != result) {
if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, minValFreqFile.c_str(), result);
return result;
}
minVal = intval;
return ZE_RESULT_SUCCESS;
}
void LinuxFrequencyImp::init() {
const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
if (pSysfsAccess->directoryExists(baseDir)) {
minFreqFile = baseDir + "rps_min_freq_mhz";
minDefaultFreqFile = baseDir + ".defaults/rps_min_freq_mhz";
maxFreqFile = baseDir + "rps_max_freq_mhz";
boostFreqFile = baseDir + "rps_boost_freq_mhz";
maxDefaultFreqFile = baseDir + ".defaults/rps_max_freq_mhz";
requestFreqFile = baseDir + "punit_req_freq_mhz";
tdpFreqFile = baseDir + "rapl_PL1_freq_mhz";
actualFreqFile = baseDir + "rps_act_freq_mhz";
efficientFreqFile = baseDir + "rps_RP1_freq_mhz";
maxValFreqFile = baseDir + "rps_RP0_freq_mhz";
minValFreqFile = baseDir + "rps_RPn_freq_mhz";
throttleReasonStatusFile = baseDir + "throttle_reason_status";
throttleReasonPL1File = baseDir + "throttle_reason_pl1";
throttleReasonPL2File = baseDir + "throttle_reason_pl2";
throttleReasonPL4File = baseDir + "throttle_reason_pl4";
throttleReasonThermalFile = baseDir + "throttle_reason_thermal";
} else {
minFreqFile = "gt_min_freq_mhz";
maxFreqFile = "gt_max_freq_mhz";
boostFreqFile = "gt_boost_freq_mhz";
requestFreqFile = "gt_cur_freq_mhz";
tdpFreqFile = "rapl_PL1_freq_mhz";
actualFreqFile = "gt_act_freq_mhz";
efficientFreqFile = "gt_RP1_freq_mhz";
maxValFreqFile = "gt_RP0_freq_mhz";
minValFreqFile = "gt_RPn_freq_mhz";
throttleReasonStatusFile = "gt_throttle_reason_status";
throttleReasonPL1File = "gt_throttle_reason_status_pl1";
throttleReasonPL2File = "gt_throttle_reason_status_pl2";
throttleReasonPL4File = "gt_throttle_reason_status_pl4";
throttleReasonThermalFile = "gt_throttle_reason_status_thermal";
}
}
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
productFamily = pLinuxSysmanImp->getProductFamily();
init();
}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
return static_cast<OsFrequency *>(pLinuxFrequencyImp);
}
uint16_t OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
return 1; // hardcode for now to support only ZES_FREQ_DOMAIN_GPU
}
} // namespace Sysman
} // namespace L0

82
level_zero/sysman/source/frequency/linux/os_frequency_imp_prelim.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/sysman/source/frequency/frequency_imp.h"
#include "level_zero/sysman/source/frequency/os_frequency.h"
#include "level_zero/sysman/source/linux/fs_access.h"
#include "igfxfmid.h"
namespace L0 {
namespace Sysman {
class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
double osFrequencyGetStepSize() 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 getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
ze_result_t getOcIccMax(double *pOcIccMax) override;
ze_result_t setOcIccMax(double ocIccMax) override;
ze_result_t getOcTjMax(double *pOcTjMax) override;
ze_result_t setOcTjMax(double ocTjMax) override;
LinuxFrequencyImp() = default;
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber);
~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);
bool getThrottleReasonStatus(void);
private:
std::string minFreqFile;
std::string maxFreqFile;
std::string boostFreqFile;
std::string minDefaultFreqFile;
std::string maxDefaultFreqFile;
std::string requestFreqFile;
std::string tdpFreqFile;
std::string actualFreqFile;
std::string efficientFreqFile;
std::string maxValFreqFile;
std::string minValFreqFile;
std::string throttleReasonStatusFile;
std::string throttleReasonPL1File;
std::string throttleReasonPL2File;
std::string throttleReasonPL4File;
std::string throttleReasonThermalFile;
static const bool canControl;
bool isSubdevice = false;
uint32_t subdeviceId = 0;
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
PRODUCT_FAMILY productFamily;
void init();
};
} // namespace Sysman
} // namespace L0

40
level_zero/sysman/source/frequency/os_frequency.h Normal file
View File

@@ -0,0 +1,40 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/sysman/source/os_sysman.h"
namespace L0 {
namespace Sysman {
class OsFrequency {
public:
virtual ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) = 0;
virtual double osFrequencyGetStepSize() = 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;
virtual ze_result_t getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) = 0;
virtual ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) = 0;
virtual ze_result_t setOcFrequencyTarget(double currentOcFrequency) = 0;
virtual ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) = 0;
virtual ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) = 0;
virtual ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) = 0;
virtual ze_result_t setOcMode(zes_oc_mode_t currentOcMode) = 0;
virtual ze_result_t getOcIccMax(double *pOcIccMax) = 0;
virtual ze_result_t setOcIccMax(double ocIccMax) = 0;
virtual ze_result_t getOcTjMax(double *pOcTjMax) = 0;
virtual ze_result_t setOcTjMax(double ocTjMax) = 0;
static OsFrequency *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type);
static uint16_t getNumberOfFreqDomainsSupported(OsSysman *pOsSysman);
virtual ~OsFrequency() {}
};
} // namespace Sysman
} // namespace L0

20
level_zero/sysman/source/frequency/windows/CMakeLists.txt Normal file
View File

@@ -0,0 +1,20 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_SRCS_SYSMAN_FREQUENCY_WINDOWS
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.cpp
)
if(WIN32)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${L0_SRCS_SYSMAN_FREQUENCY_WINDOWS}
)
endif()
# Make our source files visible to parent
set_property(GLOBAL PROPERTY L0_SRCS_SYSMAN_FREQUENCY_WINDOWS ${L0_SRCS_SYSMAN_FREQUENCY_WINDOWS})

95
level_zero/sysman/source/frequency/windows/os_frequency_imp.cpp Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/frequency/windows/os_frequency_imp.h"
#include "level_zero/sysman/source/frequency/frequency.h"
#include "level_zero/sysman/source/sysman_const.h"
namespace L0 {
namespace Sysman {
ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
double WddmFrequencyImp::osFrequencyGetStepSize() {
return 0.0;
}
ze_result_t WddmFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcIccMax(double *pOcIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setOcIccMax(double ocIccMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::getOcTjMax(double *pOcTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFrequencyImp::setOcTjMax(double ocTjMax) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
WddmFrequencyImp::WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {}
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
return nullptr;
}
uint16_t OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
return static_cast<uint16_t>(0);
}
} // namespace Sysman
} // namespace L0

45
level_zero/sysman/source/frequency/windows/os_frequency_imp.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/non_copyable_or_moveable.h"
#include "level_zero/sysman/source/frequency/os_frequency.h"
#include "level_zero/sysman/source/windows/os_sysman_imp.h"
namespace L0 {
namespace Sysman {
class KmdSysManager;
class WddmFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
public:
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
double osFrequencyGetStepSize() 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 getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
ze_result_t getOcIccMax(double *pOcIccMax) override;
ze_result_t setOcIccMax(double ocIccMax) override;
ze_result_t getOcTjMax(double *pOcTjMax) override;
ze_result_t setOcTjMax(double ocTjMax) override;
WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type);
WddmFrequencyImp() = default;
~WddmFrequencyImp() override = default;
};
} // namespace Sysman
} // namespace L0

11
level_zero/sysman/source/sysman_device.cpp
View File

@@ -37,17 +37,11 @@ ze_result_t SysmanDevice::memoryGet(zes_device_handle_t hDevice, uint32_t *pCoun
ze_result_t SysmanDevice::powerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_pwr_handle_t *phPower) {
auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice);
if (pSysmanDevice == nullptr) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
return pSysmanDevice->powerGet(pCount, phPower);
}
ze_result_t SysmanDevice::powerGetCardDomain(zes_device_handle_t hDevice, zes_pwr_handle_t *phPower) {
auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice);
if (pSysmanDevice == nullptr) {
return ZE_RESULT_ERROR_UNINITIALIZED;
}
return pSysmanDevice->powerGetCardDomain(phPower);
}
@@ -56,5 +50,10 @@ ze_result_t SysmanDevice::engineGet(zes_device_handle_t hDevice, uint32_t *pCoun
return pSysmanDevice->engineGet(pCount, phEngine);
}
ze_result_t SysmanDevice::frequencyGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_freq_handle_t *phFrequency) {
auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice);
return pSysmanDevice->frequencyGet(pCount, phFrequency);
}
} // namespace Sysman
} // namespace L0

14
level_zero/sysman/source/sysman_device.h
View File

@@ -11,6 +11,7 @@
#include "level_zero/core/source/device/device.h"
#include "level_zero/sysman/source/engine/engine.h"
#include "level_zero/sysman/source/fabric_port/fabric_port.h"
#include "level_zero/sysman/source/frequency/frequency.h"
#include "level_zero/sysman/source/memory/memory.h"
#include "level_zero/sysman/source/power/power.h"
#include <level_zero/ze_api.h>
@@ -20,19 +21,16 @@ namespace L0 {
namespace Sysman {
struct SysmanDevice : _ze_device_handle_t {
static ze_result_t powerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_pwr_handle_t *phPower);
static ze_result_t powerGetCardDomain(zes_device_handle_t hDevice, zes_pwr_handle_t *phPower);
virtual ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) = 0;
virtual ze_result_t powerGetCardDomain(zes_pwr_handle_t *phPower) = 0;
static SysmanDevice *fromHandle(zes_device_handle_t handle) { return static_cast<SysmanDevice *>(handle); }
inline zes_device_handle_t toHandle() { return this; }
virtual ~SysmanDevice() = default;
static SysmanDevice *create(NEO::ExecutionEnvironment &executionEnvironment, const uint32_t rootDeviceIndex);
virtual const NEO::HardwareInfo &getHardwareInfo() const = 0;
static ze_result_t powerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_pwr_handle_t *phPower);
virtual ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) = 0;
static ze_result_t powerGetCardDomain(zes_device_handle_t hDevice, zes_pwr_handle_t *phPower);
virtual ze_result_t powerGetCardDomain(zes_pwr_handle_t *phPower) = 0;
static ze_result_t fabricPortGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_fabric_port_handle_t *phPort);
virtual ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) = 0;
static ze_result_t memoryGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_mem_handle_t *phMemory);
@@ -40,6 +38,8 @@ struct SysmanDevice : _ze_device_handle_t {
static ze_result_t engineGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_engine_handle_t *phEngine);
virtual ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) = 0;
static ze_result_t frequencyGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_freq_handle_t *phFrequency);
virtual ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) = 0;
};
} // namespace Sysman

6
level_zero/sysman/source/sysman_device_imp.cpp
View File

@@ -25,6 +25,7 @@ SysmanDeviceImp::SysmanDeviceImp(NEO::ExecutionEnvironment *executionEnvironment
pMemoryHandleContext = new MemoryHandleContext(pOsSysman);
pPowerHandleContext = new PowerHandleContext(pOsSysman);
pEngineHandleContext = new EngineHandleContext(pOsSysman);
pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
}
SysmanDeviceImp::~SysmanDeviceImp() {
@@ -33,6 +34,7 @@ SysmanDeviceImp::~SysmanDeviceImp() {
freeResource(pEngineHandleContext);
freeResource(pFabricPortHandleContext);
freeResource(pMemoryHandleContext);
freeResource(pFrequencyHandleContext);
freeResource(pOsSysman);
}
@@ -64,5 +66,9 @@ ze_result_t SysmanDeviceImp::engineGet(uint32_t *pCount, zes_engine_handle_t *ph
return pEngineHandleContext->engineGet(pCount, phEngine);
}
ze_result_t SysmanDeviceImp::frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) {
return pFrequencyHandleContext->frequencyGet(pCount, phFrequency);
}
} // namespace Sysman
} // namespace L0

3
level_zero/sysman/source/sysman_device_imp.h
View File

@@ -49,6 +49,9 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override;
ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) override;
FrequencyHandleContext *pFrequencyHandleContext = nullptr;
ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override;
private:
NEO::ExecutionEnvironment *executionEnvironment = nullptr;
const uint32_t rootDeviceIndex;

11
level_zero/sysman/test/unit_tests/sources/frequency/CMakeLists.txt Normal file
View File

@@ -0,0 +1,11 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
add_subdirectories()

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

@@ -0,0 +1,29 @@
#
# Copyright (C) 2020-2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency_prelim.h
)
else()
list(APPEND L0_TESTS_SYSMAN_FREQUENCY_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_frequency.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_frequency.h
)
endif()
if(UNIX)
target_sources(${TARGET_NAME}
PRIVATE
${L0_TESTS_SYSMAN_FREQUENCY_LINUX}
)
endif()

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

@@ -0,0 +1,341 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/frequency/linux/os_frequency_imp.h"
#include "gtest/gtest.h"
namespace L0 {
namespace ult {
const std::string minFreqFile("gt/gt0/rps_min_freq_mhz");
const std::string maxFreqFile("gt/gt0/rps_max_freq_mhz");
const std::string minDefaultFreqFile("gt/gt0/.defaults/rps_min_freq_mhz");
const std::string maxDefaultFreqFile("gt/gt0/.defaults/rps_max_freq_mhz");
const std::string boostFreqFile("gt/gt0/rps_boost_freq_mhz");
const std::string requestFreqFile("gt/gt0/punit_req_freq_mhz");
const std::string tdpFreqFile("gt/gt0/rapl_PL1_freq_mhz");
const std::string actualFreqFile("gt/gt0/rps_act_freq_mhz");
const std::string efficientFreqFile("gt/gt0/rps_RP1_freq_mhz");
const std::string maxValFreqFile("gt/gt0/rps_RP0_freq_mhz");
const std::string minValFreqFile("gt/gt0/rps_RPn_freq_mhz");
const std::string throttleReasonStatusFile("gt/gt0/throttle_reason_status");
const std::string throttleReasonPL1File("gt/gt0/throttle_reason_pl1");
const std::string throttleReasonPL2File("gt/gt0/throttle_reason_pl2");
const std::string throttleReasonPL4File("gt/gt0/throttle_reason_pl4");
const std::string throttleReasonThermalFile("gt/gt0/throttle_reason_thermal");
const std::string minFreqFileLegacy("gt_min_freq_mhz");
const std::string maxFreqFileLegacy("gt_max_freq_mhz");
const std::string boostFreqFileLegacy("gt_boost_freq_mhz");
const std::string requestFreqFileLegacy("gt_cur_freq_mhz");
const std::string tdpFreqFileLegacy("rapl_PL1_freq_mhz");
const std::string actualFreqFileLegacy("gt_act_freq_mhz");
const std::string efficientFreqFileLegacy("gt_RP1_freq_mhz");
const std::string maxValFreqFileLegacy("gt_RP0_freq_mhz");
const std::string minValFreqFileLegacy("gt_RPn_freq_mhz");
const std::string throttleReasonStatusFileLegacy("gt_throttle_reason_status");
const std::string throttleReasonPL1FileLegacy("gt_throttle_reason_status_pl1");
const std::string throttleReasonPL2FileLegacy("gt_throttle_reason_status_pl2");
const std::string throttleReasonPL4FileLegacy("gt_throttle_reason_status_pl4");
const std::string throttleReasonThermalFileLegacy("gt_throttle_reason_status_thermal");
struct MockFrequencySysfsAccess : public L0::Sysman::SysfsAccess {
double mockMin = 0;
double mockMax = 0;
double mockBoost = 0;
double mockRequest = 0;
double mockDefaultMin = 1;
double mockDefaultMax = 1000;
double mockTdp = 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 mockReadTdpResult = 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 mockReadDefaultMinResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadDefaultMaxResult = 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;
bool isLegacy = 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 setValU32Legacy(const std::string file, uint32_t val) {
if (file.compare(throttleReasonStatusFileLegacy) == 0) {
throttleVal = val;
}
if (file.compare(throttleReasonPL1FileLegacy) == 0) {
throttleReasonPL1Val = val;
}
if (file.compare(throttleReasonPL2FileLegacy) == 0) {
throttleReasonPL2Val = val;
}
if (file.compare(throttleReasonPL4FileLegacy) == 0) {
throttleReasonPL4Val = val;
}
if (file.compare(throttleReasonThermalFileLegacy) == 0) {
throttleReasonThermalVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValLegacy(const std::string file, double &val) {
if (file.compare(minFreqFileLegacy) == 0) {
val = mockMin;
}
if (file.compare(maxFreqFileLegacy) == 0) {
val = mockMax;
}
if (file.compare(requestFreqFileLegacy) == 0) {
val = mockRequest;
}
if (file.compare(tdpFreqFileLegacy) == 0) {
val = mockTdp;
}
if (file.compare(actualFreqFileLegacy) == 0) {
val = mockActual;
}
if (file.compare(efficientFreqFileLegacy) == 0) {
val = mockEfficient;
}
if (file.compare(maxValFreqFileLegacy) == 0) {
val = mockMaxVal;
}
if (file.compare(minValFreqFileLegacy) == 0) {
val = mockMinVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValLegacy(const std::string file, const double val) {
if (file.compare(minFreqFileLegacy) == 0) {
mockMin = val;
} else if (file.compare(maxFreqFileLegacy) == 0) {
mockMax = val;
} else if (file.compare(boostFreqFileLegacy) == 0) {
mockBoost = val;
} else if (file.compare(requestFreqFileLegacy) == 0) {
mockRequest = val;
} else if (file.compare(tdpFreqFileLegacy) == 0) {
mockTdp = val;
} else if (file.compare(actualFreqFileLegacy) == 0) {
mockActual = val;
} else if (file.compare(efficientFreqFileLegacy) == 0) {
mockEfficient = val;
} else if (file.compare(maxValFreqFileLegacy) == 0) {
mockMaxVal = val;
} else if (file.compare(minValFreqFileLegacy) == 0) {
mockMinVal = val;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, double &val) override {
if (mockReadDoubleValResult != ZE_RESULT_SUCCESS) {
return mockReadDoubleValResult;
}
if (isLegacy) {
return getValLegacy(file, val);
}
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(tdpFreqFile) == 0) {
if (mockReadTdpResult != ZE_RESULT_SUCCESS) {
return mockReadTdpResult;
}
val = mockTdp;
} 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 if (file.compare(minDefaultFreqFile) == 0) {
if (mockReadDefaultMinResult != ZE_RESULT_SUCCESS) {
return mockReadDefaultMinResult;
}
val = mockDefaultMin;
} else if (file.compare(maxDefaultFreqFile) == 0) {
if (mockReadDefaultMaxResult != ZE_RESULT_SUCCESS) {
return mockReadDefaultMaxResult;
}
val = mockDefaultMax;
} 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(boostFreqFile) == 0) {
mockBoost = val;
}
if (file.compare(requestFreqFile) == 0) {
mockRequest = val;
}
if (file.compare(tdpFreqFile) == 0) {
mockTdp = val;
}
if (file.compare(actualFreqFile) == 0) {
mockActual = val;
}
if (file.compare(efficientFreqFile) == 0) {
mockEfficient = val;
}
if (file.compare(maxValFreqFile) == 0) {
mockMaxVal = val;
}
if (file.compare(minValFreqFile) == 0) {
mockMinVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValU32(const std::string file, uint32_t &val) {
if ((file.compare(throttleReasonStatusFile) == 0) || (file.compare(throttleReasonStatusFileLegacy) == 0)) {
val = throttleVal;
}
if ((file.compare(throttleReasonPL1File) == 0) || (file.compare(throttleReasonPL1FileLegacy) == 0)) {
if (mockReadPL1Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL1Val;
}
if ((file.compare(throttleReasonPL2File) == 0) || (file.compare(throttleReasonPL2FileLegacy) == 0)) {
if (mockReadPL2Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL2Val;
}
if ((file.compare(throttleReasonPL4File) == 0) || (file.compare(throttleReasonPL4FileLegacy) == 0)) {
if (mockReadPL4Error) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
val = throttleReasonPL4Val;
}
if ((file.compare(throttleReasonThermalFile) == 0) || (file.compare(throttleReasonThermalFileLegacy) == 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 {
if (isLegacy) {
return setValLegacy(file, val);
}
return setVal(file, val);
}
MockFrequencySysfsAccess() = default;
~MockFrequencySysfsAccess() 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;
};
} // namespace ult
} // namespace L0

357
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h Normal file
View File

@@ -0,0 +1,357 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/frequency/linux/os_frequency_imp_prelim.h"
#include "gtest/gtest.h"
#include "igfxfmid.h"
namespace L0 {
namespace ult {
const std::string minFreqFile("gt/gt0/rps_min_freq_mhz");
const std::string minDefaultFreqFile("gt/gt0/.defaults/rps_min_freq_mhz");
const std::string maxFreqFile("gt/gt0/rps_max_freq_mhz");
const std::string boostFreqFile("gt/gt0/rps_boost_freq_mhz");
const std::string maxDefaultFreqFile("gt/gt0/.defaults/rps_max_freq_mhz");
const std::string requestFreqFile("gt/gt0/punit_req_freq_mhz");
const std::string tdpFreqFile("gt/gt0/rapl_PL1_freq_mhz");
const std::string actualFreqFile("gt/gt0/rps_act_freq_mhz");
const std::string efficientFreqFile("gt/gt0/rps_RP1_freq_mhz");
const std::string maxValFreqFile("gt/gt0/rps_RP0_freq_mhz");
const std::string minValFreqFile("gt/gt0/rps_RPn_freq_mhz");
const std::string throttleReasonStatusFile("gt/gt0/throttle_reason_status");
const std::string throttleReasonPL1File("gt/gt0/throttle_reason_pl1");
const std::string throttleReasonPL2File("gt/gt0/throttle_reason_pl2");
const std::string throttleReasonPL4File("gt/gt0/throttle_reason_pl4");
const std::string throttleReasonThermalFile("gt/gt0/throttle_reason_thermal");
const std::string minFreqFileLegacy("gt_min_freq_mhz");
const std::string maxFreqFileLegacy("gt_max_freq_mhz");
const std::string boostFreqFileLegacy("gt_boost_freq_mhz");
const std::string requestFreqFileLegacy("gt_cur_freq_mhz");
const std::string tdpFreqFileLegacy("rapl_PL1_freq_mhz");
const std::string actualFreqFileLegacy("gt_act_freq_mhz");
const std::string efficientFreqFileLegacy("gt_RP1_freq_mhz");
const std::string maxValFreqFileLegacy("gt_RP0_freq_mhz");
const std::string minValFreqFileLegacy("gt_RPn_freq_mhz");
const std::string throttleReasonStatusFileLegacy("gt_throttle_reason_status");
const std::string throttleReasonPL1FileLegacy("gt_throttle_reason_status_pl1");
const std::string throttleReasonPL2FileLegacy("gt_throttle_reason_status_pl2");
const std::string throttleReasonPL4FileLegacy("gt_throttle_reason_status_pl4");
const std::string throttleReasonThermalFileLegacy("gt_throttle_reason_status_thermal");
struct MockFrequencySysfsAccess : public L0::Sysman::SysfsAccess {
double mockMin = 0;
double mockMax = 0;
double mockBoost = 0;
double mockRequest = 0;
double mockDefaultMin = 1;
double mockDefaultMax = 1000;
double mockTdp = 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 mockReadUnsignedIntResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadRequestResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadTdpResult = 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 mockReadPL1Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadPL2Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadPL4Result = ZE_RESULT_SUCCESS;
ze_result_t mockReadThermalResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMaxResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteMinResult = ZE_RESULT_SUCCESS;
ze_bool_t isLegacy = false;
ADDMETHOD_NOBASE(directoryExists, bool, true, (const std::string path));
ze_result_t read(const std::string file, double &val) override {
if (mockReadDoubleValResult != ZE_RESULT_SUCCESS) {
return mockReadDoubleValResult;
}
if (isLegacy) {
return getValLegacy(file, val);
}
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(tdpFreqFile) == 0) {
if (mockReadTdpResult != ZE_RESULT_SUCCESS) {
return mockReadTdpResult;
}
val = mockTdp;
} 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 if (file.compare(minDefaultFreqFile) == 0) {
val = mockDefaultMin;
} else if (file.compare(maxDefaultFreqFile) == 0) {
val = mockDefaultMax;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t read(const std::string file, uint32_t &val) override {
if (mockReadUnsignedIntResult != ZE_RESULT_SUCCESS) {
return mockReadUnsignedIntResult;
}
if (isLegacy) {
return getValU32Legacy(file, val);
}
if (file.compare(throttleReasonStatusFile) == 0) {
val = throttleVal;
}
if (file.compare(throttleReasonPL1File) == 0) {
if (mockReadPL1Result != ZE_RESULT_SUCCESS) {
return mockReadPL1Result;
}
val = throttleReasonPL1Val;
}
if (file.compare(throttleReasonPL2File) == 0) {
if (mockReadPL2Result != ZE_RESULT_SUCCESS) {
return mockReadPL2Result;
}
val = throttleReasonPL2Val;
}
if (file.compare(throttleReasonPL4File) == 0) {
if (mockReadPL4Result != ZE_RESULT_SUCCESS) {
return mockReadPL4Result;
}
val = throttleReasonPL4Val;
}
if (file.compare(throttleReasonThermalFile) == 0) {
if (mockReadThermalResult != ZE_RESULT_SUCCESS) {
return mockReadThermalResult;
}
val = throttleReasonThermalVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValLegacy(const std::string file, double &val) {
if (file.compare(minFreqFileLegacy) == 0) {
val = mockMin;
}
if (file.compare(maxFreqFileLegacy) == 0) {
val = mockMax;
}
if (file.compare(requestFreqFileLegacy) == 0) {
val = mockRequest;
}
if (file.compare(tdpFreqFileLegacy) == 0) {
val = mockTdp;
}
if (file.compare(actualFreqFileLegacy) == 0) {
val = mockActual;
}
if (file.compare(efficientFreqFileLegacy) == 0) {
val = mockEfficient;
}
if (file.compare(maxValFreqFileLegacy) == 0) {
val = mockMaxVal;
}
if (file.compare(minValFreqFileLegacy) == 0) {
val = mockMinVal;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getValU32Legacy(const std::string file, uint32_t &val) {
if (file.compare(throttleReasonStatusFileLegacy) == 0) {
val = throttleVal;
}
if (file.compare(throttleReasonPL1FileLegacy) == 0) {
val = throttleReasonPL1Val;
}
if (file.compare(throttleReasonPL2FileLegacy) == 0) {
val = throttleReasonPL2Val;
}
if (file.compare(throttleReasonPL4FileLegacy) == 0) {
val = throttleReasonPL4Val;
}
if (file.compare(throttleReasonThermalFileLegacy) == 0) {
val = throttleReasonThermalVal;
}
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(boostFreqFile) == 0) {
mockBoost = val;
}
if (file.compare(requestFreqFile) == 0) {
mockRequest = val;
}
if (file.compare(tdpFreqFile) == 0) {
mockTdp = val;
}
if (file.compare(actualFreqFile) == 0) {
mockActual = val;
}
if (file.compare(efficientFreqFile) == 0) {
mockEfficient = val;
}
if (file.compare(maxValFreqFile) == 0) {
mockMaxVal = val;
}
if (file.compare(minValFreqFile) == 0) {
mockMinVal = val;
}
return ZE_RESULT_SUCCESS;
}
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 setValLegacy(const std::string file, const double val) {
if (file.compare(minFreqFileLegacy) == 0) {
mockMin = val;
} else if (file.compare(maxFreqFileLegacy) == 0) {
mockMax = val;
} else if (file.compare(boostFreqFileLegacy) == 0) {
mockBoost = val;
} else if (file.compare(requestFreqFileLegacy) == 0) {
mockRequest = val;
} else if (file.compare(tdpFreqFileLegacy) == 0) {
mockTdp = val;
} else if (file.compare(actualFreqFileLegacy) == 0) {
mockActual = val;
} else if (file.compare(efficientFreqFileLegacy) == 0) {
mockEfficient = val;
} else if (file.compare(maxValFreqFileLegacy) == 0) {
mockMaxVal = val;
} else if (file.compare(minValFreqFileLegacy) == 0) {
mockMinVal = val;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t setValU32Legacy(const std::string file, uint32_t val) {
if (file.compare(throttleReasonStatusFileLegacy) == 0) {
throttleVal = val;
}
if (file.compare(throttleReasonPL1FileLegacy) == 0) {
throttleReasonPL1Val = val;
}
if (file.compare(throttleReasonPL2FileLegacy) == 0) {
throttleReasonPL2Val = val;
}
if (file.compare(throttleReasonPL4FileLegacy) == 0) {
throttleReasonPL4Val = val;
}
if (file.compare(throttleReasonThermalFileLegacy) == 0) {
throttleReasonThermalVal = val;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t write(const std::string file, double val) override {
if (isLegacy) {
return setValLegacy(file, val);
}
return setVal(file, val);
}
MockFrequencySysfsAccess() = default;
~MockFrequencySysfsAccess() 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;
};
} // namespace ult
} // namespace L0

920
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency.cpp Normal file
View File

@@ -0,0 +1,920 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include <cmath>
namespace L0 {
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;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
pSysfsAccess->setVal(minFreqFile, minFreq);
pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysfsAccess->setVal(requestFreqFile, request);
pSysfsAccess->setVal(tdpFreqFile, tdp);
pSysfsAccess->setVal(actualFreqFile, actual);
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanDeviceFixture::TearDown();
}
double clockValue(const double calculatedClock) {
// i915 specific. frequency step is a fraction
// However, the i915 represents all clock
// rates as integer values. So clocks are
// rounded to the nearest integer.
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
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);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsMoreThanNumClocksThenCallSucceeds) {
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);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCountIsLessThanNumClocksThenCallSucceeds) {
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));
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
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(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
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);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
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_EQ(pSysfsAccess->mockDefaultMin, limits.min);
EXPECT_EQ(pSysfsAccess->mockDefaultMax, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndSettingMaxValueFailsThenFailureIsReturned) {
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(SysmanDeviceFrequencyFixture, GivenNegativeRangeWhenSetRangeIsCalledAndGettingDefaultMaxValueFailsThenNoFreqRangeIsInEffect) {
pSysfsAccess->mockReadDefaultMaxResult = 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_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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
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);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 450.0;
const double testTdpValue = 1200.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(tdpFreqFile, testTdpValue);
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(testTdpValue, state.tdp);
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 400.0;
const double testTdpValue = 1100.0;
const double testEfficientValue = 300.0;
const double testActualValue = 550.0;
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);
pSysfsAccess->setValLegacy(requestFreqFileLegacy, testRequestValue);
pSysfsAccess->setValLegacy(tdpFreqFileLegacy, testTdpValue);
pSysfsAccess->setValLegacy(actualFreqFileLegacy, testActualValue);
pSysfsAccess->setValLegacy(efficientFreqFileLegacy, testEfficientValue);
pSysfsAccess->setValU32Legacy(throttleReasonStatusFileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL1FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL2FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL4FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonThermalFileLegacy, validReason);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
EXPECT_DOUBLE_EQ(testActualValue, state.actual);
EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_LE(state.currentVoltage, 0);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonBurstPower) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsCurrentExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsThermalExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsInvalidThermalExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforValidReasons) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
double minFreqLegacy = 400.0;
double maxFreqLegacy = 1200.0;
pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
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->mockReadRequestResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(1, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfgetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetTjMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double tjMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetTjMax(handle, tjMax));
}
}
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidFreqPropertiesRetrieved) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
zes_freq_properties_t properties = {};
L0::Sysman::LinuxFrequencyImp *pLinuxFrequencyImp = new L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
EXPECT_EQ(properties.subdeviceId, subdeviceId);
EXPECT_EQ(properties.onSubdevice, onSubdevice);
delete pLinuxFrequencyImp;
}
class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanMultiDeviceFixture::TearDown();
}
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(FreqMultiDeviceFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, multiHandleComponentCount);
auto handles = getFreqHandles(multiHandleComponentCount);
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_TRUE(properties.onSubdevice);
}
}
} // namespace ult
} // namespace L0

859
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_prelim.cpp Normal file
View File

@@ -0,0 +1,859 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include <cmath>
namespace L0 {
namespace ult {
constexpr double minFreq = 300.0;
constexpr double maxFreq = 1100.0;
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 handleComponentCount = 1u;
constexpr uint32_t multiHandleComponentCount = 2u;
class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
uint32_t numClocks = 0;
double step = 0;
PRODUCT_FAMILY productFamily{};
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
productFamily = pLinuxSysmanImp->getProductFamily();
if (productFamily >= IGFX_XE_HP_SDV) {
step = 50.0;
} else {
step = 50.0 / 3; // Step of 16.6666667 Mhz (GEN9 Hardcode)
}
numClocks = static_cast<uint32_t>((maxFreq - minFreq) / step) + 1;
pSysfsAccess->setVal(minFreqFile, minFreq);
pSysfsAccess->setVal(maxFreqFile, maxFreq);
pSysfsAccess->setVal(requestFreqFile, request);
pSysfsAccess->setVal(tdpFreqFile, tdp);
pSysfsAccess->setVal(actualFreqFile, actual);
pSysfsAccess->setVal(efficientFreqFile, efficient);
pSysfsAccess->setVal(maxValFreqFile, maxVal);
pSysfsAccess->setVal(minValFreqFile, minVal);
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanDeviceFixture::TearDown();
}
double clockValue(const double calculatedClock) {
// i915 specific. frequency step is a fraction
// However, the i915 represents all clock
// rates as integer values. So clocks are
// rounded to the nearest integer.
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndZeroCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
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);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleAndCorrectCountWhenCallingzesFrequencyGetAvailableClocksThenCallSucceeds) {
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(SysmanDeviceFrequencyFixture, GivenValidateFrequencyGetRangeWhengetMaxAndgetMinFailsThenFrequencyGetRangeCallReturnsNegativeValuesForRange) {
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures1ThenAPIExitsGracefully) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyLimitsWhenCallingFrequencySetRangeForFailures2ThenAPIExitsGracefully) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest1CallSucceeds) {
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);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenNegativeUnityRangeSetWhenGetRangeIsCalledThenReturnsValueFromDefaultPath) {
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_EQ(1, limits.min);
EXPECT_EQ(1000, limits.max);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeThenVerifyzesFrequencySetRangeTest2CallSucceeds) {
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);
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenInvalidFrequencyLimitsWhenCallingFrequencySetRangeThenVerifyFrequencySetRangeTestReturnsError) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyGetStateTestCallSucceeds) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 450.0;
const double testTdpValue = 1200.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(tdpFreqFile, testTdpValue);
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(testTdpValue, state.tdp);
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateWithLegacyPathThenVerifyzesFrequencyGetStateTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
const double testRequestValue = 400.0;
const double testTdpValue = 1100.0;
const double testEfficientValue = 300.0;
const double testActualValue = 550.0;
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);
pSysfsAccess->setValLegacy(requestFreqFileLegacy, testRequestValue);
pSysfsAccess->setValLegacy(tdpFreqFileLegacy, testTdpValue);
pSysfsAccess->setValLegacy(actualFreqFileLegacy, testActualValue);
pSysfsAccess->setValLegacy(efficientFreqFileLegacy, testEfficientValue);
pSysfsAccess->setValU32Legacy(throttleReasonStatusFileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL1FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL2FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonPL4FileLegacy, validReason);
pSysfsAccess->setValU32Legacy(throttleReasonThermalFileLegacy, validReason);
zes_freq_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(handle, &state));
EXPECT_DOUBLE_EQ(testRequestValue, state.request);
EXPECT_DOUBLE_EQ(testTdpValue, state.tdp);
EXPECT_DOUBLE_EQ(testEfficientValue, state.efficient);
EXPECT_DOUBLE_EQ(testActualValue, state.actual);
EXPECT_EQ(setAllThrottleReasons, state.throttleReasons);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_LE(state.currentVoltage, 0);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeWithLegacyPathThenVerifyzesFrequencySetRangeTestCallSucceeds) {
pSysfsAccess->isLegacy = true;
pSysfsAccess->directoryExistsResult = false;
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
pSysmanDeviceImp->pFrequencyHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getFreqHandles(handleComponentCount);
double minFreqLegacy = 400.0;
double maxFreqLegacy = 1200.0;
pSysfsAccess->setValLegacy(minFreqFileLegacy, minFreqLegacy);
pSysfsAccess->setValLegacy(maxFreqFileLegacy, maxFreqLegacy);
for (auto handle : handles) {
zes_freq_range_t limits;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(handle, &limits));
EXPECT_DOUBLE_EQ(minFreqLegacy, limits.min);
EXPECT_DOUBLE_EQ(maxFreqLegacy, limits.max);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(handle, &limits));
EXPECT_DOUBLE_EQ(pSysfsAccess->mockBoost, limits.max);
}
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonAveragePower) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonBurstPower) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsCurrentExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsThermalExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsInvalidThermalExcursion) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforValidReasons) {
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforInvalidReasons) {
pSysfsAccess->mockReadUnsignedIntResult = 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingTHermalStatusFile) {
pSysfsAccess->mockReadThermalResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL4StatusFile) {
pSysfsAccess->mockReadPL4Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL2StatusFile) {
pSysfsAccess->mockReadPL2Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetStateThenVerifyzesFrequencyThrottleReasonsStatusforMissingPL1StatusFile) {
pSysfsAccess->mockReadPL1Result = ZE_RESULT_ERROR_NOT_AVAILABLE;
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(SysmanDeviceFrequencyFixture, GivenValidStatePointerWhenValidatingfrequencyGetStateWhenOneOfTheFrequencyStateThenNegativeValueIsReturned) {
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->mockReadRequestResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.tdp);
pSysfsAccess->mockReadTdpResult = ZE_RESULT_SUCCESS;
pSysfsAccess->mockReadEfficientResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFrequencyImp->frequencyGetState(&state));
EXPECT_EQ(-1, state.efficient);
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivengetMinFunctionReturnsErrorWhenValidatinggetMinFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMinValFunctionReturnsErrorWhenValidatinggetMinValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatinggetMaxValFailuresThenAPIReturnsErrorAccordingly) {
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
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(SysmanDeviceFrequencyFixture, GivengetMaxValFunctionReturnsErrorWhenValidatingosFrequencyGetPropertiesThenAPIBehavesAsExpected) {
zes_freq_properties_t properties = {};
PublicLinuxFrequencyImp linuxFrequencyImp(pOsSysman, 0, 0, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMaxValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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, ZES_FREQ_DOMAIN_GPU);
pSysfsAccess->mockReadMinValResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
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, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, linuxFrequencyImp.osFrequencyGetProperties(properties));
EXPECT_EQ(1, properties.canControl);
}
TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencySetRangeAndIfsetMaxFailsThenVerifyzesFrequencySetRangeTestCallFail) {
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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, 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(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyOcSetTjMaxThenVerifyTestCallFail) {
auto handles = getFreqHandles(handleComponentCount);
for (auto handle : handles) {
double tjMax = 0.0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFrequencyOcSetTjMax(handle, tjMax));
}
}
TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingFrequencyPropertiesThenValidFreqPropertiesRetrieved) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
zes_freq_properties_t properties = {};
L0::Sysman::LinuxFrequencyImp *pLinuxFrequencyImp = new L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, ZES_FREQ_DOMAIN_GPU);
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxFrequencyImp->osFrequencyGetProperties(properties));
EXPECT_EQ(properties.subdeviceId, subdeviceId);
EXPECT_EQ(properties.onSubdevice, onSubdevice);
delete pLinuxFrequencyImp;
}
class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
device = pSysmanDevice;
pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
// delete handles created in initial SysmanDeviceHandleContext::init() call
for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
getFreqHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
SysmanMultiDeviceFixture::TearDown();
}
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(FreqMultiDeviceFixture, GivenValidFrequencyHandleWhenCallingzesFrequencyGetPropertiesThenSuccessIsReturned) {
uint32_t count = 0U;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
EXPECT_EQ(count, multiHandleComponentCount);
auto handles = getFreqHandles(multiHandleComponentCount);
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_TRUE(properties.onSubdevice);
}
}
} // namespace ult
} // namespace L0

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

@@ -1,21 +1,17 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/api/sysman/zes_handles_struct.h"
#include "level_zero/core/source/device/device.h"
#include <level_zero/zes_api.h>
#include <mutex>
#include <vector>
struct _zes_freq_handle_t {
virtual ~_zes_freq_handle_t() = default;
};
namespace L0 {
constexpr double unsupportedProperty = -1.0;