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

refactor(sysman): Remove Pmt tile aggregator from Sysman Modules 

- The PMT tile aggregator used by the frequency and power modules has
been replaced with the wrapper functions which calls the functions from
the Pmt Util class.
- The earlier Pmt Tile aggregator implementation has been removed from
the PMT specific files.

Related-To: NEO-12147

Signed-off-by: Pratik Bari <pratik.bari@intel.com>
This commit is contained in:
Pratik Bari 2024-08-14 13:33:49 +00:00 committed by Compute-Runtime-Automation
parent d963318cad
commit 8ea7751381
23 changed files with 330 additions and 1127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,7 +12,6 @@
#include "shared/source/helpers/hw_info.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
@ -402,7 +401,7 @@ ze_result_t LinuxFrequencyImp::getMinVal(double &minVal) {
}
void LinuxFrequencyImp::getCurrentVoltage(double &voltage) {
pSysmanProductHelper->getCurrentVoltage(pPmt, voltage);
voltage = -1.0;
}
void LinuxFrequencyImp::init() {
@ -447,7 +446,6 @@ LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice,
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
init();
}

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

@ -18,7 +18,6 @@ namespace Sysman {
class SysmanKmdInterface;
class SysmanProductHelper;
class SysFsAccessInterface;
class PlatformMonitoringTech;
class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
public:
@ -81,7 +80,6 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
uint32_t subdeviceId = 0;
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
SysmanProductHelper *pSysmanProductHelper = nullptr;
PlatformMonitoringTech *pPmt = nullptr;
void init();
};

34
level_zero/sysman/source/api/power/linux/sysman_os_power_imp.cpp
View File

@ -10,7 +10,6 @@
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
@ -85,13 +84,30 @@ ze_result_t LinuxPowerImp::getPropertiesExt(zes_power_ext_properties_t *pExtPope
}
ze_result_t LinuxPowerImp::getPmtEnergyCounter(zes_power_energy_counter_t *pEnergy) {
std::string telemDir = "";
std::string guid = "";
uint64_t telemOffset = 0;
if (!pLinuxSysmanImp->getTelemData(subdeviceId, telemDir, guid, telemOffset)) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
std::map<std::string, uint64_t> keyOffsetMap;
if (!PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guid, keyOffsetMap)) {
return ZE_RESULT_ERROR_UNKNOWN;
}
const std::string key("PACKAGE_ENERGY");
uint64_t energy = 0;
constexpr uint64_t fixedPointToJoule = 1048576;
ze_result_t result = pPmt->readValue(key, energy);
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemDir, key, telemOffset, energy)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
// PMT will return energy counter in Q20 format(fixed point representation) where first 20 bits(from LSB) represent decimal part and remaining integral part which is converted into joule by division with 1048576(2^20) and then converted into microjoules
pEnergy->energy = (energy / fixedPointToJoule) * convertJouleToMicroJoule;
return result;
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy) {
@ -99,14 +115,10 @@ ze_result_t LinuxPowerImp::getEnergyCounter(zes_power_energy_counter_t *pEnergy)
std::string energyCounterNode = intelGraphicsHwmonDir + "/" + pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEnergyCounterNode, subdeviceId, false);
ze_result_t result = pSysfsAccess->read(energyCounterNode, pEnergy->energy);
if (result != ZE_RESULT_SUCCESS) {
if (pPmt != nullptr) {
if (isTelemetrySupportAvailable) {
return getPmtEnergyCounter(pEnergy);
}
}
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s/%s and returning error:0x%x \n", __FUNCTION__, intelGraphicsHwmonDir.c_str(), energyCounterNode.c_str(), getErrorCode(result));
return getErrorCode(result);
}
return result;
}
@ -315,14 +327,14 @@ bool LinuxPowerImp::isPowerModuleSupported() {
}
if (hwmonDirExists == false) {
return (pPmt != nullptr);
isTelemetrySupportAvailable = PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subdeviceId);
return isTelemetrySupportAvailable;
}
return true;
}
LinuxPowerImp::LinuxPowerImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), powerDomain(powerDomain) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
pSysfsAccess = pSysmanKmdInterface->getSysFsAccess();
pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();

5
level_zero/sysman/source/api/power/linux/sysman_os_power_imp.h
View File

@ -17,10 +17,10 @@
namespace L0 {
namespace Sysman {
class PlatformMonitoringTech;
class SysFsAccessInterface;
class SysmanKmdInterface;
class SysmanProductHelper;
class LinuxSysmanImp;
class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getProperties(zes_power_properties_t *pProperties) override;
@ -41,10 +41,11 @@ class LinuxPowerImp : public OsPower, NEO::NonCopyableOrMovableClass {
~LinuxPowerImp() override = default;
protected:
PlatformMonitoringTech *pPmt = nullptr;
LinuxSysmanImp *pLinuxSysmanImp = nullptr;
SysFsAccessInterface *pSysfsAccess = nullptr;
SysmanKmdInterface *pSysmanKmdInterface = nullptr;
SysmanProductHelper *pSysmanProductHelper = nullptr;
bool isTelemetrySupportAvailable = false;
private:
std::string intelGraphicsHwmonDir = {};

3
level_zero/sysman/source/shared/linux/pmt/CMakeLists.txt
View File

@ -1,5 +1,5 @@
#
# Copyright (C) 2023 Intel Corporation
# Copyright (C) 2023-2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@ -8,7 +8,6 @@ if(UNIX)
target_sources(${L0_STATIC_LIB_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_pmt_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_pmt.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_pmt.h
)

225
level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp
View File

@ -5,203 +5,30 @@
*
*/
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/linux/file_descriptor.h"
#include "shared/source/os_interface/linux/pmt_util.h"
#include "level_zero/sysman/source/device/sysman_device_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
#include <algorithm>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
namespace L0 {
namespace Sysman {
const std::string PlatformMonitoringTech::baseTelemSysFS("/sys/class/intel_pmt");
const std::string PlatformMonitoringTech::telem("telem");
uint32_t PlatformMonitoringTech::rootDeviceTelemNodeIndex = 0;
ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &value) {
auto offset = keyOffsetMap.find(key);
if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
static const std::string baseTelemSysfs("/sys/class/intel_pmt");
ze_result_t res = ZE_RESULT_SUCCESS;
if (this->preadFunction(fd, &value, sizeof(uint32_t), baseOffset + offset->second) != sizeof(uint32_t)) {
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
return res;
}
ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint64_t &value) {
auto offset = keyOffsetMap.find(key);
if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
ze_result_t res = ZE_RESULT_SUCCESS;
if (this->preadFunction(fd, &value, sizeof(uint64_t), baseOffset + offset->second) != sizeof(uint64_t)) {
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
return res;
}
bool compareTelemNodes(std::string &telemNode1, std::string &telemNode2) {
std::string telem = "telem";
auto indexString1 = telemNode1.substr(telem.size(), telemNode1.size());
auto indexForTelemNode1 = stoi(indexString1);
auto indexString2 = telemNode2.substr(telem.size(), telemNode2.size());
auto indexForTelemNode2 = stoi(indexString2);
return indexForTelemNode1 < indexForTelemNode2;
}
// Check if Telemetry node(say /sys/class/intel_pmt/telem1) and gpuUpstreamPortPath share same PCI Root port
static bool isValidTelemNode(FsAccessInterface *pFsAccess, const std::string &gpuUpstreamPortPath, const std::string sysfsTelemNode) {
std::string realPathOfTelemNode;
auto result = pFsAccess->getRealPath(sysfsTelemNode, realPathOfTelemNode);
if (result != ZE_RESULT_SUCCESS) {
bool PlatformMonitoringTech::getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &keyOffsetMap) {
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
if (pGuidToKeyOffsetMap == nullptr) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get the pGuidToKeyOffsetMap \n", __FUNCTION__);
return false;
}
// Example: If
// gpuUpstreamPortPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
// realPathOfTelemNode = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
// As gpuUpstreamPortPath is a substring of realPathOfTelemNode , hence both sysfs telemNode and GPU device share same PCI Root.
// the PMT is part of the OOBMSM sitting on a switch port 0000:8b:02.0 attached to the upstream port/ Also known as CardBus
// Hence this telem node entry is valid for GPU device.
return (realPathOfTelemNode.compare(0, gpuUpstreamPortPath.size(), gpuUpstreamPortPath) == 0);
}
ze_result_t PlatformMonitoringTech::enumerateRootTelemIndex(FsAccessInterface *pFsAccess, std::string &gpuUpstreamPortPath) {
std::vector<std::string> listOfTelemNodes;
auto result = pFsAccess->listDirectory(baseTelemSysFS, listOfTelemNodes);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
// listOfTelemNodes vector could contain non "telem" entries which are not interested to us.
// Lets refactor listOfTelemNodes vector as below
for (auto iterator = listOfTelemNodes.begin(); iterator != listOfTelemNodes.end(); iterator++) {
if (iterator->compare(0, telem.size(), telem) != 0) {
listOfTelemNodes.erase(iterator--); // Remove entry if its suffix is not "telem"
}
}
// Exmaple: For below directory
// # /sys/class/intel_pmt$ ls
// telem1 telem2 telem3
// Then listOfTelemNodes would contain telem1, telem2, telem3
std::sort(listOfTelemNodes.begin(), listOfTelemNodes.end(), compareTelemNodes); // sort listOfTelemNodes, to arange telem nodes in ascending order
for (const auto &telemNode : listOfTelemNodes) {
if (isValidTelemNode(pFsAccess, gpuUpstreamPortPath, baseTelemSysFS + "/" + telemNode)) {
auto indexString = telemNode.substr(telem.size(), telemNode.size());
rootDeviceTelemNodeIndex = stoi(indexString); // if telemNode is telemN, then rootDeviceTelemNodeIndex = N
return ZE_RESULT_SUCCESS;
}
}
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
ze_result_t PlatformMonitoringTech::init(LinuxSysmanImp *pLinuxSysmanImp, const std::string &gpuUpstreamPortPath) {
std::string telemNode = telem + std::to_string(rootDeviceTelemNodeIndex);
// For XE_HP_SDV and PVC single tile devices, telemetry info is retrieved from
// tile's telem node rather from root device telem node.
auto productFamily = pLinuxSysmanImp->getSysmanDeviceImp()->getProductFamily();
if ((isSubdevice) || (productFamily == IGFX_PVC)) {
uint32_t telemNodeIndex = 0;
// If rootDeviceTelemNode is telem1, then rootDeviceTelemNodeIndex = 1
// And thus for subdevice0 --> telem node will be telem2,
// for subdevice1 --> telem node will be telem3 etc
telemNodeIndex = rootDeviceTelemNodeIndex + subdeviceId + 1;
telemNode = telem + std::to_string(telemNodeIndex);
}
std::string baseTelemSysFSNode = baseTelemSysFS + "/" + telemNode;
auto pFsAccess = &pLinuxSysmanImp->getFsAccess();
if (!isValidTelemNode(pFsAccess, gpuUpstreamPortPath, baseTelemSysFSNode)) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
telemetryDeviceEntry = baseTelemSysFSNode + "/" + telem;
if (!pFsAccess->fileExists(telemetryDeviceEntry)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Telemetry support not available. No file %s\n", telemetryDeviceEntry.c_str());
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
std::string guid = "";
std::string guidPath = baseTelemSysFSNode + std::string("/guid");
ze_result_t result = pFsAccess->read(guidPath, guid);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Telemetry sysfs entry not available %s\n", guidPath.c_str());
return result;
}
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
result = PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guid, keyOffsetMap);
if (ZE_RESULT_SUCCESS != result) {
// We didnt have any entry for this guid in guidToKeyOffsetMap
return result;
}
std::string offsetPath = baseTelemSysFSNode + std::string("/offset");
result = pFsAccess->read(offsetPath, baseOffset);
if (ZE_RESULT_SUCCESS != result) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Telemetry sysfs entry not available %s\n", offsetPath.c_str());
return result;
}
return ZE_RESULT_SUCCESS;
}
PlatformMonitoringTech::PlatformMonitoringTech(FsAccessInterface *pFsAccess, ze_bool_t onSubdevice,
uint32_t subdeviceId) : subdeviceId(subdeviceId), isSubdevice(onSubdevice) {
}
void PlatformMonitoringTech::doInitPmtObject(LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject) {
if (pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPath) == ZE_RESULT_SUCCESS) {
mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stdout,
"Pmt object: 0x%llX initialization for subdeviceId %d successful\n", pPmt, static_cast<int>(subdeviceId));
return;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr,
"Pmt initialization for subdeviceId %d failed\n", static_cast<int>(subdeviceId));
delete pPmt; // We are here as pPmt->init failed and thus this pPmt object is not useful. Let's delete that.
}
void PlatformMonitoringTech::create(LinuxSysmanImp *pLinuxSysmanImp, std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject) {
if (ZE_RESULT_SUCCESS == PlatformMonitoringTech::enumerateRootTelemIndex(&pLinuxSysmanImp->getFsAccess(), gpuUpstreamPortPath)) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new PlatformMonitoringTech(&pLinuxSysmanImp->getFsAccess(), onSubdevice, subdeviceId);
UNRECOVERABLE_IF(nullptr == pPmt);
PlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPath, mapOfSubDeviceIdToPmtObject);
subdeviceId++;
} while (subdeviceId < subDeviceCount);
auto keyOffsetMapEntry = pGuidToKeyOffsetMap->find(guid);
if (keyOffsetMapEntry == pGuidToKeyOffsetMap->end()) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to find keyOffset in keyOffsetMap \n", __FUNCTION__);
return false;
}
keyOffsetMap = keyOffsetMapEntry->second;
return true;
}
bool PlatformMonitoringTech::getTelemOffsetAndTelemDir(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &telemOffset, std::string &telemDir) {
@ -233,15 +60,19 @@ bool PlatformMonitoringTech::getTelemOffsetForContainer(SysmanProductHelper *pSy
}
std::map<std::string, uint64_t> keyOffsetMap;
if (ZE_RESULT_SUCCESS == PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guidString.data(), keyOffsetMap)) {
auto keyOffset = keyOffsetMap.find(key.c_str());
if (keyOffset != keyOffsetMap.end()) {
telemOffset = keyOffset->second;
return true;
}
if (!PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guidString.data(), keyOffsetMap)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get KeyOffsetMap for Guid : %s\n", __FUNCTION__, guidString.data());
return false;
}
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to find keyOffset in keyOffsetMap \n", __FUNCTION__);
return false;
auto keyOffset = keyOffsetMap.find(key.c_str());
if (keyOffset == keyOffsetMap.end()) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to find keyOffset in keyOffsetMap \n", __FUNCTION__);
return false;
}
telemOffset = keyOffset->second;
return true;
}
bool PlatformMonitoringTech::readValue(const std::map<std::string, uint64_t> keyOffsetMap, const std::string &telemDir, const std::string &key, const uint64_t &telemOffset, uint32_t &value) {
@ -281,8 +112,8 @@ bool PlatformMonitoringTech::readValue(const std::map<std::string, uint64_t> key
bool PlatformMonitoringTech::getTelemDataForTileAggregator(const std::map<uint32_t, std::string> telemNodesInPciPath, uint32_t subdeviceId, std::string &telemDir, std::string &guid, uint64_t &telemOffset) {
uint32_t rootDeviceTelemIndex = telemNodesInPciPath.begin()->first;
std::string telemNode = telem + std::to_string(rootDeviceTelemIndex + subdeviceId + 1);
telemDir = baseTelemSysFS + "/" + telemNode;
const std::string telemNode = "telem" + std::to_string(rootDeviceTelemIndex + subdeviceId + 1);
telemDir = baseTelemSysfs + "/" + telemNode;
if (!NEO::PmtUtil::readOffset(telemDir, telemOffset)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read offset from %s\n", __FUNCTION__, telemDir.c_str());
return false;
@ -328,8 +159,7 @@ bool PlatformMonitoringTech::isTelemetrySupportAvailable(LinuxSysmanImp *pLinuxS
std::map<std::string, uint64_t> keyOffsetMap;
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
auto result = PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guid, keyOffsetMap);
if (ZE_RESULT_SUCCESS != result) {
if (!PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guid, keyOffsetMap)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to get KeyOffsetMap for Guid : %s\n", __FUNCTION__, guid.c_str());
return false;
}
@ -344,8 +174,5 @@ bool PlatformMonitoringTech::isTelemetrySupportAvailable(LinuxSysmanImp *pLinuxS
return true;
}
PlatformMonitoringTech::~PlatformMonitoringTech() {
}
} // namespace Sysman
} // namespace L0

30
level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h
View File

@ -11,10 +11,7 @@
#include "level_zero/zes_api.h"
#include <fcntl.h>
#include <map>
#include <sys/stat.h>
#include <sys/types.h>
namespace L0 {
namespace Sysman {
@ -30,16 +27,7 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
uint64_t offset;
};
PlatformMonitoringTech() = default;
PlatformMonitoringTech(FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId);
virtual ~PlatformMonitoringTech();
virtual ze_result_t readValue(const std::string key, uint32_t &value);
virtual ze_result_t readValue(const std::string key, uint64_t &value);
static ze_result_t enumerateRootTelemIndex(FsAccessInterface *pFsAccess, std::string &gpuUpstreamPortPath);
static void create(LinuxSysmanImp *pLinuxSysmanImp, std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject);
static ze_result_t getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &keyOffsetMap);
static bool getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &keyOffsetMap);
static bool getTelemOffsetAndTelemDir(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &telemOffset, std::string &telemDir);
static bool getTelemData(const std::map<uint32_t, std::string> telemNodesInPciPath, std::string &telemDir, std::string &guid, uint64_t &telemOffset);
static bool getTelemDataForTileAggregator(const std::map<uint32_t, std::string> telemNodesInPciPath, uint32_t subDeviceId, std::string &telemDir, std::string &guid, uint64_t &telemOffset);
@ -47,22 +35,6 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
static bool readValue(const std::map<std::string, uint64_t> keyOffsetMap, const std::string &telemDir, const std::string &key, const uint64_t &telemOffset, uint32_t &value);
static bool readValue(const std::map<std::string, uint64_t> keyOffsetMap, const std::string &telemDir, const std::string &key, const uint64_t &telemOffset, uint64_t &value);
static bool isTelemetrySupportAvailable(LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId);
protected:
static uint32_t rootDeviceTelemNodeIndex;
std::string telemetryDeviceEntry{};
std::map<std::string, uint64_t> keyOffsetMap;
ze_result_t init(LinuxSysmanImp *pLinuxSysmanImp, const std::string &gpuUpstreamPortPath);
static void doInitPmtObject(LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject);
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private:
static const std::string baseTelemSysFS;
static const std::string telem;
uint64_t baseOffset = 0;
uint32_t subdeviceId = 0;
ze_bool_t isSubdevice = 0;
};
} // namespace Sysman

31
level_zero/sysman/source/shared/linux/pmt/sysman_pmt_helper.cpp
View File

@ -1,31 +0,0 @@
/*
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
namespace L0 {
namespace Sysman {
ze_result_t PlatformMonitoringTech::getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &keyOffsetMap) {
ze_result_t retVal = ZE_RESULT_ERROR_UNKNOWN;
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
if (pGuidToKeyOffsetMap == nullptr) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto keyOffsetMapEntry = pGuidToKeyOffsetMap->find(guid);
if (keyOffsetMapEntry == pGuidToKeyOffsetMap->end()) {
// We didnt have any entry for this guid in guidToKeyOffsetMap
retVal = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return retVal;
}
keyOffsetMap = keyOffsetMapEntry->second;
return ZE_RESULT_SUCCESS;
}
} // namespace Sysman
} // namespace L0

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

@ -73,9 +73,6 @@ class SysmanProductHelper {
// Global Operations
virtual bool isRepairStatusSupported() = 0;
// Voltage
virtual void getCurrentVoltage(PlatformMonitoringTech *pPmt, double &voltage) = 0;
// power
virtual int32_t getPowerLimitValue(uint64_t value) = 0;
virtual uint64_t setPowerLimitValue(int32_t value) = 0;

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

@ -48,9 +48,6 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// global ops
bool isRepairStatusSupported() override;
// Voltage
void getCurrentVoltage(PlatformMonitoringTech *pPmt, double &voltage) override;
// power
int32_t getPowerLimitValue(uint64_t value) override;
uint64_t setPowerLimitValue(int32_t value) override;

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

@ -244,11 +244,6 @@ bool SysmanProductHelperHw<gfxProduct>::isRepairStatusSupported() {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
void SysmanProductHelperHw<gfxProduct>::getCurrentVoltage(PlatformMonitoringTech *pPmt, double &voltage) {
voltage = -1.0;
}
template <PRODUCT_FAMILY gfxProduct>
int32_t SysmanProductHelperHw<gfxProduct>::getPowerLimitValue(uint64_t value) {
uint64_t val = value / milliFactor;

34
level_zero/sysman/source/shared/linux/zes_os_sysman_imp.cpp
View File

@ -61,7 +61,7 @@ ze_result_t LinuxSysmanImp::init() {
osInterface.getDriverModel()->as<NEO::Drm>()->cleanup();
pPmuInterface = PmuInterface::create(this);
return createPmtHandles();
return result;
}
ze_result_t LinuxSysmanImp::getResult(int err) {
@ -90,17 +90,6 @@ NEO::Drm *LinuxSysmanImp::getDrm() {
return osInterface.getDriverModel()->as<NEO::Drm>();
}
ze_result_t LinuxSysmanImp::createPmtHandles() {
std::string gtDevicePCIPath;
auto result = pSysfsAccess->getRealPath("device", gtDevicePCIPath);
if (ZE_RESULT_SUCCESS != result) {
return result;
}
auto gpuUpstreamPortPath = getPciCardBusDirectoryPath(gtDevicePCIPath);
PlatformMonitoringTech::create(this, gpuUpstreamPortPath, mapOfSubDeviceIdToPmtObject);
return result;
}
static std::string modifyPathOnLevel(std::string realPciPath, uint8_t nLevel) {
size_t loc;
// we need to change the absolute path to 'nLevel' levels up
@ -146,24 +135,6 @@ std::string LinuxSysmanImp::getPciCardBusDirectoryPath(std::string realPciPath)
return modifyPathOnLevel(realPciPath, 2);
}
PlatformMonitoringTech *LinuxSysmanImp::getPlatformMonitoringTechAccess(uint32_t subDeviceId) {
auto subDeviceIdToPmtEntry = mapOfSubDeviceIdToPmtObject.find(subDeviceId);
if (subDeviceIdToPmtEntry == mapOfSubDeviceIdToPmtObject.end()) {
return nullptr;
}
return subDeviceIdToPmtEntry->second;
}
void LinuxSysmanImp::releasePmtObject() {
for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject) {
if (subDeviceIdToPmtEntry.second) {
delete subDeviceIdToPmtEntry.second;
subDeviceIdToPmtEntry.second = nullptr;
}
}
mapOfSubDeviceIdToPmtObject.clear();
}
FsAccessInterface &LinuxSysmanImp::getFsAccess() {
UNRECOVERABLE_IF(nullptr == pFsAccess);
return *pFsAccess;
@ -229,7 +200,6 @@ LinuxSysmanImp::~LinuxSysmanImp() {
pPmuInterface = nullptr;
}
releaseFwUtilInterface();
releasePmtObject();
}
void LinuxSysmanImp::getPidFdsForOpenDevice(const ::pid_t pid, std::vector<int> &deviceFds) {
@ -304,14 +274,12 @@ void LinuxSysmanImp::releaseSysmanDeviceResources() {
getSysmanDeviceImp()->pDiagnosticsHandleContext->releaseDiagnosticsHandles();
}
getSysmanDeviceImp()->pFirmwareHandleContext->releaseFwHandles();
releasePmtObject();
if (!diagnosticsReset) {
releaseFwUtilInterface();
}
}
ze_result_t LinuxSysmanImp::reInitSysmanDeviceResources() {
createPmtHandles();
if (!diagnosticsReset) {
if (pFwUtilInterface == nullptr) {
createFwUtilInterface();

4
level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h
View File

@ -54,11 +54,9 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
std::string getPciCardBusDirectoryPath(std::string realPciPath);
uint32_t getMemoryType();
static std::string getPciRootPortDirectoryPath(std::string realPciPath);
PlatformMonitoringTech *getPlatformMonitoringTechAccess(uint32_t subDeviceId);
PRODUCT_FAMILY getProductFamily() const { return pParentSysmanDeviceImp->getProductFamily(); }
SysmanHwDeviceIdDrm::SingleInstance getSysmanHwDeviceIdInstance();
NEO::Drm *getDrm();
void releasePmtObject();
MOCKABLE_VIRTUAL void releaseSysmanDeviceResources();
MOCKABLE_VIRTUAL ze_result_t reInitSysmanDeviceResources();
MOCKABLE_VIRTUAL void getPidFdsForOpenDevice(const ::pid_t, std::vector<int> &);
@ -68,7 +66,6 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
std::string getAddressFromPath(std::string &rootPortPath);
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
decltype(&NEO::SysCalls::pwrite) pwriteFunction = NEO::SysCalls::pwrite;
ze_result_t createPmtHandles();
SysmanDeviceImp *getParentSysmanDeviceImp() { return pParentSysmanDeviceImp; }
std::string &getPciRootPath() { return rootPath; }
std::string &getDeviceName();
@ -88,7 +85,6 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
FsAccessInterface *pFsAccess = nullptr;
ProcFsAccessInterface *pProcfsAccess = nullptr;
SysFsAccessInterface *pSysfsAccess = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
uint32_t subDeviceCount = 0;
FirmwareUtil *pFwUtilInterface = nullptr;
PmuInterface *pPmuInterface = nullptr;

1
level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h
View File

@ -37,7 +37,6 @@ namespace ult {
class PublicLinuxSysmanImp : public L0::Sysman::LinuxSysmanImp {
public:
using LinuxSysmanImp::mapOfSubDeviceIdToPmtObject;
using LinuxSysmanImp::pFsAccess;
using LinuxSysmanImp::pFwUtilInterface;
using LinuxSysmanImp::pPmuInterface;

147
level_zero/sysman/test/unit_tests/sources/linux/pmt/mock_pmt.h
View File

@ -13,152 +13,17 @@ namespace L0 {
namespace Sysman {
namespace ult {
const std::string baseTelemSysFS("/sys/class/intel_pmt");
const std::string telem("telem");
const std::string telemNodeForSubdevice0("telem2");
const std::string telemNodeForSubdevice1("telem3");
std::string gpuUpstreamPortPathInPmt = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
const std::string realPathTelem1 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
const std::string realPathTelem2 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem2";
const std::string realPathTelem3 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem3";
const std::string realPathTelem4 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem4";
const std::string realPathTelem5 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem5";
const std::string invalidRealPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8e:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
const std::string sysfsPathTelem1 = "/sys/class/intel_pmt/telem1";
const std::string sysfsPathTelem2 = "/sys/class/intel_pmt/telem2";
const std::string sysfsPathTelem3 = "/sys/class/intel_pmt/telem3";
const std::string sysfsPathTelem4 = "/sys/class/intel_pmt/telem4";
const std::string sysfsPathTelem5 = "/sys/class/intel_pmt/telem5";
struct MockPmtFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectoryResult = ZE_RESULT_SUCCESS;
ze_result_t getRealPathResult = ZE_RESULT_SUCCESS;
ze_result_t readUnsignedResult = ZE_RESULT_SUCCESS;
ze_result_t readStringResult = ZE_RESULT_SUCCESS;
ze_result_t readFileAvailability = ZE_RESULT_SUCCESS;
ze_bool_t returnTelemNodes = true;
ze_bool_t returnInvalidRealPath = false;
ze_bool_t readInvalidString = false;
MockPmtFsAccess() {
baseTelemSysFSNodeForSubdevice0 = baseTelemSysFS + "/" + telemNodeForSubdevice0;
baseTelemSysFSNodeForSubdevice1 = baseTelemSysFS + "/" + telemNodeForSubdevice1;
telemetryDeviceEntryForSubdevice0 = baseTelemSysFSNodeForSubdevice0 + "/" + telem;
telemetryDeviceEntryForSubdevice1 = baseTelemSysFSNodeForSubdevice1 + "/" + telem;
}
ze_result_t read(const std::string file, std::string &val) override {
if (readStringResult != ZE_RESULT_SUCCESS) {
return readStringResult;
}
if (readInvalidString) {
val = "";
return ZE_RESULT_SUCCESS;
}
std::string guidPathForSubdevice0 = baseTelemSysFSNodeForSubdevice0 + std::string("/guid");
std::string guidPathForSubdevice1 = baseTelemSysFSNodeForSubdevice1 + std::string("/guid");
if ((file.compare(guidPathForSubdevice0) == 0) ||
(file.compare(guidPathForSubdevice1) == 0)) {
val = "0x490e01";
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t read(const std::string file, uint64_t &val) override {
if (readUnsignedResult != ZE_RESULT_SUCCESS) {
return readUnsignedResult;
}
if ((file.compare(baseTelemSysFSNodeForSubdevice0 + std::string("/size")) == 0) ||
(file.compare(baseTelemSysFSNodeForSubdevice1 + std::string("/size")) == 0) ||
(file.compare(baseTelemSysFSNodeForSubdevice0 + std::string("/offset")) == 0) ||
(file.compare(baseTelemSysFSNodeForSubdevice1 + std::string("/offset")) == 0)) {
val = 0;
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
bool fileExists(const std::string file) override {
if (readFileAvailability != ZE_RESULT_SUCCESS) {
return false;
}
if ((file.compare(telemetryDeviceEntryForSubdevice0) == 0) ||
(file.compare(telemetryDeviceEntryForSubdevice1) == 0)) {
return true;
}
return false;
}
ze_result_t getRealPath(const std::string path, std::string &buf) override {
if (getRealPathResult != ZE_RESULT_SUCCESS) {
return getRealPathResult;
}
if (returnInvalidRealPath) {
buf = invalidRealPath;
return ZE_RESULT_SUCCESS;
}
if (path.compare(sysfsPathTelem1) == 0) {
buf = realPathTelem1;
} else if (path.compare(sysfsPathTelem2) == 0) {
buf = realPathTelem2;
} else if (path.compare(sysfsPathTelem3) == 0) {
buf = realPathTelem3;
} else if (path.compare(sysfsPathTelem4) == 0) {
buf = realPathTelem4;
} else if (path.compare(sysfsPathTelem5) == 0) {
buf = realPathTelem5;
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (listDirectoryResult != ZE_RESULT_SUCCESS) {
return listDirectoryResult;
}
if (directory.compare(baseTelemSysFS) == 0) {
listOfTelemNodes.push_back("crashlog2");
listOfTelemNodes.push_back("crashlog1");
if (returnTelemNodes) {
listOfTelemNodes.push_back("telem3");
listOfTelemNodes.push_back("telem2");
listOfTelemNodes.push_back("telem1");
listOfTelemNodes.push_back("telem4");
listOfTelemNodes.push_back("telem5");
}
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
std::string telemetryDeviceEntryForSubdevice0;
std::string telemetryDeviceEntryForSubdevice1;
std::string baseTelemSysFSNodeForSubdevice0;
std::string baseTelemSysFSNodeForSubdevice1;
};
class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
public:
PublicPlatformMonitoringTech(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::doInitPmtObject;
using PlatformMonitoringTech::init;
using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::rootDeviceTelemNodeIndex;
using PlatformMonitoringTech::telemetryDeviceEntry;
};
const std::string telem1OffsetFileName("/sys/class/intel_pmt/telem1/offset");
const std::string telem1GuidFileName("/sys/class/intel_pmt/telem1/guid");
const std::string telem1TelemFileName("/sys/class/intel_pmt/telem1/telem");
const std::string telem2OffsetFileName("/sys/class/intel_pmt/telem2/offset");
const std::string telem2GuidFileName("/sys/class/intel_pmt/telem2/guid");
const std::string telem2TelemFileName("/sys/class/intel_pmt/telem2/telem");
} // namespace ult
} // namespace Sysman

283
level_zero/sysman/test/unit_tests/sources/linux/pmt/test_pmt.cpp
View File

@ -15,33 +15,11 @@ namespace L0 {
namespace Sysman {
namespace ult {
const std::map<std::string, uint64_t> dummyKeyOffsetMap = {
{"DUMMY_KEY", 0x0}};
class ZesPmtFixtureMultiDevice : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<MockPmtFsAccess> pTestFsAccess;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
pTestFsAccess = std::make_unique<MockPmtFsAccess>();
pLinuxSysmanImp->pFsAccess = pTestFsAccess.get();
L0::Sysman::PlatformMonitoringTech::create(pLinuxSysmanImp, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
}
void TearDown() override {
SysmanMultiDeviceFixture::TearDown();
for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
subDeviceIdToPmtEntry.second = nullptr;
}
}
};
static int mockReadLinkMultiTelemetryNodesSuccess(const char *path, char *buf, size_t bufsize) {
std::map<std::string, std::string> fileNameLinkMap = {
{"/sys/class/intel_pmt/telem1", "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1"},
{"/sys/class/intel_pmt/telem2", "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem2"},
{sysfsPathTelem1, realPathTelem1},
{sysfsPathTelem2, realPathTelem2},
};
auto it = fileNameLinkMap.find(std::string(path));
if (it != fileNameLinkMap.end()) {
@ -54,7 +32,7 @@ static int mockReadLinkMultiTelemetryNodesSuccess(const char *path, char *buf, s
static int mockReadLinkSingleTelemetryNodesSuccess(const char *path, char *buf, size_t bufsize) {
std::map<std::string, std::string> fileNameLinkMap = {
{"/sys/class/intel_pmt/telem1", "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1"},
{sysfsPathTelem1, realPathTelem1},
};
auto it = fileNameLinkMap.find(std::string(path));
if (it != fileNameLinkMap.end()) {
@ -68,11 +46,11 @@ static int mockOpenSuccess(const char *pathname, int flags) {
int returnValue = -1;
std::string strPathName(pathname);
if (strPathName == "/sys/class/intel_pmt/telem1/offset" || strPathName == "/sys/class/intel_pmt/telem2/offset") {
if (strPathName == telem1OffsetFileName || strPathName == telem2OffsetFileName) {
returnValue = 4;
} else if (strPathName == "/sys/class/intel_pmt/telem1/guid" || strPathName == "/sys/class/intel_pmt/telem2/guid") {
} else if (strPathName == telem1GuidFileName || strPathName == telem2GuidFileName) {
returnValue = 5;
} else if (strPathName == "/sys/class/intel_pmt/telem1/telem" || strPathName == "/sys/class/intel_pmt/telem2/telem") {
} else if (strPathName == telem1TelemFileName || strPathName == telem2TelemFileName) {
returnValue = 6;
}
return returnValue;
@ -126,246 +104,16 @@ static ssize_t mockReadIncorrectGuid(int fd, void *buf, size_t count, off_t offs
return count;
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenenumerateRootTelemIndexThenCheckForErrorIflistDirectoryFails) {
pTestFsAccess->listDirectoryResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt));
}
using ZesPmtFixture = SysmanDeviceFixture;
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenenumerateRootTelemIndexThenCheckForErrorIfgetRealPathFails) {
pTestFsAccess->getRealPathResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenWhenenumerateRootTelemIndexThenCheckForErrorIfgetRealPathSuccessButNoTelemetryNodeAndGPUDeviceShareRootPciPort) {
pTestFsAccess->returnInvalidRealPath = true;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenTelemDirectoryContainNowTelemEntryWhenenumerateRootTelemIndexThenCheckForError) {
pTestFsAccess->returnTelemNodes = false;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringWhileValidatingTelemNode) {
pTestFsAccess->getRealPathResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 0, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringWhileCheckingTelemetryDeviceEntryAvailability) {
pTestFsAccess->readFileAvailability = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 0, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringGUIDRead) {
pTestFsAccess->readStringResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_NOT_AVAILABLE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorIfGUIDReadValueIsNotSupported) {
pTestFsAccess->readInvalidString = true;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenSomeKeyWhenCallingreadValueWithUint64TypeThenCheckForErrorBranches) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 0, 0);
uint64_t val = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPmt->readValue("SOMETHING", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenSomeKeyWhenCallingreadValueWithUint32TypeThenCheckForErrorBranches) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 0, 0);
uint32_t val = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPmt->readValue("SOMETHING", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringbaseOffsetRead) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
pTestFsAccess->readUnsignedResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_NOT_AVAILABLE);
}
inline static int openMockReturnFailure(const char *pathname, int flags) {
return -1;
}
inline static int openMockReturnSuccess(const char *pathname, int flags) {
NEO::SysCalls::closeFuncCalled = 0;
return 0;
}
ssize_t preadMockPmt(int fd, void *buf, size_t count, off_t offset) {
EXPECT_EQ(0u, NEO::SysCalls::closeFuncCalled);
*reinterpret_cast<uint32_t *>(buf) = 3u;
return count;
}
ssize_t preadMockPmt64(int fd, void *buf, size_t count, off_t offset) {
EXPECT_EQ(0u, NEO::SysCalls::closeFuncCalled);
*reinterpret_cast<uint64_t *>(buf) = 5u;
return count;
}
ssize_t preadMockPmtFailure(int fd, void *buf, size_t count, off_t offset) {
return -1;
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingReadValueWithUint32TypeThenSuccessIsReturned) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPmt->readValue("DUMMY_KEY", val));
EXPECT_EQ(val, 3u);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingReadValueWithUint64TypeThenSuccessIsReturned) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt64);
uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_SUCCESS, pPmt->readValue("DUMMY_KEY", val));
EXPECT_EQ(val, 5u);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->preadFunction = preadMockPmtFailure;
uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->preadFunction = preadMockPmtFailure;
uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenDoingPMTInitThenPMTmapOfSubDeviceIdToPmtObjectWouldContainValidEntries) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new PublicPlatformMonitoringTech(pTestFsAccess.get(), onSubdevice, subdeviceId);
PublicPlatformMonitoringTech::rootDeviceTelemNodeIndex = 1;
UNRECOVERABLE_IF(nullptr == pPmt);
PublicPlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
auto subDeviceIdToPmtEntry = mapOfSubDeviceIdToPmtObject.find(subdeviceId);
EXPECT_EQ(subDeviceIdToPmtEntry->second, pPmt);
delete pPmt;
} while (++subdeviceId < subDeviceCount);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenBaseOffsetReadFailWhenDoingPMTInitThenPMTmapOfSubDeviceIdToPmtObjectWouldBeEmpty) {
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
pTestFsAccess->readUnsignedResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new PublicPlatformMonitoringTech(pTestFsAccess.get(), onSubdevice, subdeviceId);
UNRECOVERABLE_IF(nullptr == pPmt);
PublicPlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
EXPECT_TRUE(mapOfSubDeviceIdToPmtObject.empty());
} while (++subdeviceId < subDeviceCount);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenNoPMTHandleInmapOfSubDeviceIdToPmtObjectWhenCallingreleasePmtObjectThenMapWouldGetEmpty) {
auto mapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, nullptr);
} while (subdeviceId++ < subDeviceCount);
pLinuxSysmanImp->releasePmtObject();
EXPECT_TRUE(pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.empty());
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = mapOriginal;
}
class ZesPmtFixtureNoSubDevice : public SysmanDeviceFixture {
protected:
std::unique_ptr<MockPmtFsAccess> pTestFsAccess;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
void SetUp() override {
SysmanDeviceFixture::SetUp();
pTestFsAccess = std::make_unique<MockPmtFsAccess>();
pLinuxSysmanImp->pFsAccess = pTestFsAccess.get();
L0::Sysman::PlatformMonitoringTech::create(pLinuxSysmanImp, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
subDeviceIdToPmtEntry.second = nullptr;
}
}
};
TEST_F(ZesPmtFixtureNoSubDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringWhileCheckingTelemetryDeviceEntryAvailability) {
pTestFsAccess->readFileAvailability = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 0, 0);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenTelemNodesAreNotAvailableWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
HWTEST2_F(ZesPmtFixture, GivenTelemNodesAreNotAvailableWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
uint32_t subDeviceId = 0;
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenOffsetReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
HWTEST2_F(ZesPmtFixture, GivenOffsetReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkMultiTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadOffsetFail);
@ -376,7 +124,7 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenOffsetReadFailsWhenCallingIsTelemetrySu
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenOffsetReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsDG2) {
HWTEST2_F(ZesPmtFixture, GivenOffsetReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsDG2) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadOffsetFail);
@ -387,7 +135,7 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenOffsetReadFailsWhenCallingIsTelemetrySu
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenGuidReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
HWTEST2_F(ZesPmtFixture, GivenGuidReadFailsWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkMultiTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
@ -399,7 +147,7 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenGuidReadFailsWhenCallingIsTelemetrySupp
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenGuidDoesNotGiveKeyOffsetMapWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
HWTEST2_F(ZesPmtFixture, GivenGuidDoesNotGiveKeyOffsetMapWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkMultiTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadIncorrectGuid);
@ -410,7 +158,7 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenGuidDoesNotGiveKeyOffsetMapWhenCallingI
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenTelemDoesNotExistWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
HWTEST2_F(ZesPmtFixture, GivenTelemDoesNotExistWhenCallingIsTelemetrySupportAvailableThenFalseValueIsReturned, IsPVC) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkMultiTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
@ -428,7 +176,6 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenTelemDoesNotExistWhenCallingIsTelemetry
memcpy(buf, value.data(), count);
return count;
});
pTestFsAccess->readFileAvailability = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
@ -436,7 +183,7 @@ HWTEST2_F(ZesPmtFixtureNoSubDevice, GivenTelemDoesNotExistWhenCallingIsTelemetry
EXPECT_FALSE(PlatformMonitoringTech::isTelemetrySupportAvailable(pLinuxSysmanImp, subDeviceId));
}
TEST_F(ZesPmtFixtureNoSubDevice, GivenKeyDoesNotExistinKeyOffsetMapWhenCallingReadValueForUnsignedIntThenFalseValueIsReturned) {
TEST_F(ZesPmtFixture, GivenKeyDoesNotExistinKeyOffsetMapWhenCallingReadValueForUnsignedIntThenFalseValueIsReturned) {
uint32_t value = 0;
std::string mockTelemDir = sysfsPathTelem1;
uint64_t mockOffset = 0;
@ -445,7 +192,7 @@ TEST_F(ZesPmtFixtureNoSubDevice, GivenKeyDoesNotExistinKeyOffsetMapWhenCallingRe
EXPECT_FALSE(PlatformMonitoringTech::readValue(keyOffsetMap, mockTelemDir, mockKey, mockOffset, value));
}
TEST_F(ZesPmtFixtureNoSubDevice, GivenKeyDoesNotExistinKeyOffsetMapWhenCallingReadValueForUnsignedLongThenFalseValueIsReturned) {
TEST_F(ZesPmtFixture, GivenKeyDoesNotExistinKeyOffsetMapWhenCallingReadValueForUnsignedLongThenFalseValueIsReturned) {
uint64_t value = 0;
std::string mockTelemDir = sysfsPathTelem1;
uint64_t mockOffset = 0;

1
level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory.cpp
View File

@ -76,7 +76,6 @@ class SysmanDeviceMemoryFixtureI915 : public SysmanDeviceMemoryFixture {
}
void TearDown() override {
pLinuxSysmanImp->releasePmtObject();
SysmanDeviceFixture::TearDown();
}
};

124
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power.h
View File

@ -12,7 +12,6 @@
#include "level_zero/sysman/source/api/power/linux/sysman_os_power_imp.h"
#include "level_zero/sysman/source/api/power/sysman_power_imp.h"
#include "level_zero/sysman/source/device/sysman_device_imp.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/sysman_const.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
@ -23,10 +22,8 @@ namespace Sysman {
namespace ult {
constexpr uint64_t setEnergyCounter = (83456u * 1048576u);
constexpr uint64_t offset = 0x400;
constexpr uint64_t mockKeyOffset = 0x420;
constexpr uint32_t mockLimitCount = 2u;
const std::string deviceName("device");
const std::string baseTelemSysFS("/sys/class/intel_pmt");
const std::string hwmonDir("device/hwmon");
const std::string i915HwmonDir("device/hwmon/hwmon2");
const std::string nonI915HwmonDir("device/hwmon/hwmon1");
@ -46,11 +43,11 @@ constexpr uint32_t mockDefaultPowerLimitVal = 600000000;
constexpr uint64_t mockMinPowerLimitVal = 300000000;
constexpr uint64_t mockMaxPowerLimitVal = 600000000;
const std::map<std::string, uint64_t> deviceKeyOffsetMapPower = {
{"PACKAGE_ENERGY", 0x400},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}};
const std::string realPathTelem = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
const std::string sysfsPathTelem = "/sys/class/intel_pmt/telem1";
const std::string telemOffsetFileName("/sys/class/intel_pmt/telem1/offset");
const std::string telemGuidFileName("/sys/class/intel_pmt/telem1/guid");
const std::string telemFileName("/sys/class/intel_pmt/telem1/telem");
struct MockPowerSysfsAccessInterface : public L0::Sysman::SysFsAccessInterface {
@ -238,110 +235,37 @@ struct MockPowerSysfsAccessInterface : public L0::Sysman::SysFsAccessInterface {
MockPowerSysfsAccessInterface() = default;
};
struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
MockPowerPmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
~MockPowerPmt() override {
rootDeviceTelemNodeIndex = 0;
}
void mockedInit(L0::Sysman::FsAccessInterface *pFsAccess) {
std::string gpuUpstreamPortPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
if (ZE_RESULT_SUCCESS != L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, gpuUpstreamPortPath)) {
return;
}
telemetryDeviceEntry = "/sys/class/intel_pmt/telem2/telem";
}
};
struct MockPowerFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (directory.compare(baseTelemSysFS) == 0) {
listOfTelemNodes.push_back("telem1");
listOfTelemNodes.push_back("telem2");
listOfTelemNodes.push_back("telem3");
listOfTelemNodes.push_back("telem4");
listOfTelemNodes.push_back("telem5");
return ZE_RESULT_SUCCESS;
}
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t listDirectoryFailure(const std::string directory, std::vector<std::string> &events) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
ze_result_t getRealPath(const std::string path, std::string &buf) override {
if (path.compare("/sys/class/intel_pmt/telem1") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
} else if (path.compare("/sys/class/intel_pmt/telem2") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:86:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem2";
} else if (path.compare("/sys/class/intel_pmt/telem3") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem3";
} else if (path.compare("/sys/class/intel_pmt/telem4") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem4";
} else if (path.compare("/sys/class/intel_pmt/telem5") == 0) {
buf = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem5";
} else {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t getRealPathFailure(const std::string path, std::string &buf) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
MockPowerFsAccess() = default;
struct MockPowerFsAccessInterface : public L0::Sysman::FsAccessInterface {
MockPowerFsAccessInterface() = default;
};
class PublicLinuxPowerImp : public L0::Sysman::LinuxPowerImp {
public:
PublicLinuxPowerImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_power_domain_t powerDomain) : L0::Sysman::LinuxPowerImp(pOsSysman, onSubdevice, subdeviceId, powerDomain) {}
using L0::Sysman::LinuxPowerImp::pPmt;
using L0::Sysman::LinuxPowerImp::isTelemetrySupportAvailable;
using L0::Sysman::LinuxPowerImp::pSysfsAccess;
};
class SysmanDevicePowerFixtureI915 : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> pmtMapOriginal;
MockSysmanKmdInterfacePrelim *pSysmanKmdInterface = nullptr;
MockPowerSysfsAccessInterface *pSysfsAccess = nullptr;
MockPowerFsAccessInterface *pFsAccess = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDevice;
pFsAccess = std::make_unique<MockPowerFsAccess>();
pSysmanKmdInterface = new MockSysmanKmdInterfacePrelim(pLinuxSysmanImp->getSysmanProductHelper());
pFsAccess = new MockPowerFsAccessInterface();
pSysfsAccess = new MockPowerSysfsAccessInterface();
pSysmanKmdInterface->pFsAccess.reset(pFsAccess);
pSysmanKmdInterface->pSysfsAccess.reset(pSysfsAccess);
pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
pmtMapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockPowerPmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pPmt->keyOffsetMap = deviceKeyOffsetMapPower;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
pLinuxSysmanImp->pFsAccess = pFsAccess;
getPowerHandles(0);
}
void TearDown() override {
pLinuxSysmanImp->releasePmtObject();
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = pmtMapOriginal;
SysmanDeviceFixture::TearDown();
}
@ -369,40 +293,18 @@ class SysmanDevicePowerMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<PublicLinuxPowerImp> pPublicLinuxPowerImp;
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOriginal;
MockSysmanKmdInterfacePrelim *pSysmanKmdInterface = nullptr;
MockPowerSysfsAccessInterface *pSysfsAccess = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
device = pSysmanDevice;
pFsAccess = std::make_unique<MockPowerFsAccess>();
pSysmanKmdInterface = new MockSysmanKmdInterfacePrelim(pLinuxSysmanImp->getSysmanProductHelper());
pSysfsAccess = new MockPowerSysfsAccessInterface();
pSysmanKmdInterface->pSysfsAccess.reset(pSysfsAccess);
pLinuxSysmanImp->pSysmanKmdInterface.reset(pSysmanKmdInterface);
mapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockPowerPmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pPmt->keyOffsetMap = deviceKeyOffsetMapPower;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
}
void TearDown() override {
for (const auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
delete pmtMapElement.second;
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = mapOriginal;
SysmanMultiDeviceFixture::TearDown();
}

258
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp
View File

@ -12,15 +12,8 @@ namespace L0 {
namespace Sysman {
namespace ult {
constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u;
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter;
return count;
}
TEST_F(SysmanDevicePowerFixtureI915, GivenComponentCountZeroWhenEnumeratingPowerDomainsWhenhwmonInterfaceExistsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
@ -68,26 +61,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenUninitializedPowerHandlesAndWhenGettin
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenScanDiectoriesFailAndPmtIsNullWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.second) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesWhenhwmonInterfaceExistsThenCallSucceeds) {
MockSysmanProductHelper *pMockSysmanProductHelper = new MockSysmanProductHelper();
pMockSysmanProductHelper->isPowerSetLimitSupportedResult = true;
@ -208,35 +181,13 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPowerSetLimitSuppor
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesAndSysfsReadFailsThenFailureIsReturned) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->pSysfsAccess = pSysfsAccess;
pLinuxPowerImp->pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(0));
pLinuxPowerImp->isPowerModuleSupported();
EXPECT_TRUE(pLinuxPowerImp->isPowerModuleSupported());
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
zes_power_properties_t properties{};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getProperties(&properties));
EXPECT_EQ(properties.defaultLimit, -1);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyCounterFailedWhenHwmonInterfaceExistThenValidErrorCodeReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter = {};
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndHandleCountZeroWhenCallingReInitThenValidCountIsReturnedAndVerifyzesDeviceEnumPowerHandleSucceeds) {
VariableBackup<L0::Sysman::SysFsAccessInterface *> sysfsBackup(&pLinuxSysmanImp->pSysfsAccess);
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
@ -633,23 +584,6 @@ HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPermissionsThenF
EXPECT_EQ(sustainedGet.power, sustainedSet.power);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerLimitsThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustained, &burst, &peak));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerNodeReturnErrorWhenSetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
ASSERT_NE(nullptr, handles[0]);
@ -684,87 +618,6 @@ HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenWritingToSustai
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr));
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingPowerLimitsThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustained, &burst, &peak));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenScanDirectoriesFailAndPmtIsNotNullPointerThenPowerModuleIsSupported) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
PublicLinuxPowerImp *pPowerImp = new PublicLinuxPowerImp(pOsSysman, onSubdevice, subdeviceId, ZES_POWER_DOMAIN_CARD);
EXPECT_TRUE(pPowerImp->isPowerModuleSupported());
delete pPowerImp;
}
TEST_F(SysmanDevicePowerFixtureI915, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenInvalidComponentCountWhenEnumeratingPowerDomainsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
count = count + 1;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidPowerHandlesIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
@ -783,68 +636,18 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerProper
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyCounterThenValidPowerReadingsRetrieved) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
TEST_F(SysmanDevicePowerFixtureI915, GivenHwMonDoesNotExistAndTelemDataNotAvailableWhenGettingPowerEnergyCounterThenFailureIsReturned) {
auto handles = getPowerHandles(powerHandleComponentCount);
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
for (auto handle : handles) {
zes_power_energy_counter_t energyCounter;
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyCounterWhenEnergyHwmonFileReturnsErrorAndPmtFailsThenFailureIsReturned) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
}
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
do {
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, nullptr);
} while (++subdeviceId < subDeviceCount);
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zesPowerGetEnergyCounter(handle, &energyCounter));
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_energy_threshold_t threshold;
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
@ -853,36 +656,8 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerEnergy
}
}
TEST_F(SysmanDevicePowerFixtureI915, GivenScanDirectoriesFailAndPmtIsNullWhenGettingCardPowerThenReturnsFailure) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.second) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingPowerEnergyThresholdThenUnsupportedFeatureErrorIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
double threshold = 0;
auto handles = getPowerHandles(powerHandleComponentCount);
for (auto handle : handles) {
@ -890,33 +665,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenSettingPowerEnergy
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowerEnergyCounterWhenEnergyHwmonFailsThenValidPowerReadingsRetrievedFromPmt) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
auto handles = getPowerHandles(powerHandleComponentCount);
uint32_t subdeviceId = 0;
do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_energy_counter_t energyCounter;
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
ASSERT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(handle, &energyCounter));
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
}
TEST_F(SysmanDevicePowerFixtureXe, GivenKmdInterfaceWhenGettingSysFsFilenamesForPowerForXeVersionThenProperPathsAreReturned) {
auto pSysmanKmdInterface = std::make_unique<SysmanKmdInterfaceXe>(pLinuxSysmanImp->getSysmanProductHelper());
EXPECT_STREQ("energy1_input", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameEnergyCounterNode, 0, false).c_str());

27
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp
View File

@ -150,7 +150,7 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleAndExtPro
}
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndPmtIsNullForSubDeviceZeroWhenGettingCardPowerThenReturnsFailure) {
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndTelemetrySupportNotAvailableWhenGettingCardPowerThenFailureIsReturned) {
pSysfsAccess->mockscanDirEntriesResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
@ -158,29 +158,30 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndPmt
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.first == 0) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenPowerHandleDomainIsNotCardWhenGettingCardPowerDomainThenErrorIsReturned) {
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCountMultiDevice);
auto handle = pSysmanDeviceImp->pPowerHandleContext->handleList.front();
delete handle;
pSysmanDeviceImp->pPowerHandleContext->handleList.erase(pSysmanDeviceImp->pPowerHandleContext->handleList.begin());
zes_pwr_handle_t phPower = {};
EXPECT_EQ(zesDeviceGetCardPowerDomain(device->toHandle(), &phPower), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenReadingToSysNodesFailsWhenCallingGetPowerLimitsExtThenPowerLimitCountIsZero) {
for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) {
delete handle;
}
pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
for (auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
if (pmtMapElement.first == 0) {
delete pmtMapElement.second;
pmtMapElement.second = nullptr;
}
}
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysfsAccess->mockReadValUnsignedLongResult.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pSysmanDeviceImp->pPowerHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());

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

@ -35,15 +35,6 @@ HWTEST2_F(SysmanProductHelperFrequencyTest, GivenFrequencyModuleWhenQueryingFreq
EXPECT_EQ(true, pSysmanProductHelper->isFrequencySetRangeSupported());
}
TEST_F(SysmanProductHelperFrequencyTest, GivenSysmanProductHelperInstanceWhenGettingCurrentVoltageThenVerifyCurrentVoltageIsNegative) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<PublicFsAccess> pFsAccess = std::make_unique<PublicFsAccess>();
auto pPmt = std::make_unique<PlatformMonitoringTech>(pFsAccess.get(), 1, 0);
double voltage = 0;
pSysmanProductHelper->getCurrentVoltage(pPmt.get(), voltage);
EXPECT_EQ(voltage, -1.0);
}
} // namespace ult
} // namespace Sysman
} // namespace L0

1
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp
View File

@ -42,7 +42,6 @@ class SysmanProductHelperMemoryTest : public SysmanDeviceFixture {
}
void TearDown() override {
pLinuxSysmanImp->releasePmtObject();
SysmanDeviceFixture::TearDown();
}
};

223
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp
View File

@ -7,12 +7,69 @@
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power.h"
namespace L0 {
namespace Sysman {
namespace ult {
using SysmanProductHelperPowerTest = SysmanDeviceFixture;
constexpr uint32_t powerHandleComponentCount = 1u;
static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) {
std::map<std::string, std::string> fileNameLinkMap = {
{sysfsPathTelem, realPathTelem},
};
auto it = fileNameLinkMap.find(std::string(path));
if (it != fileNameLinkMap.end()) {
std::memcpy(buf, it->second.c_str(), it->second.size());
return static_cast<int>(it->second.size());
}
return -1;
}
static ssize_t mockReadSuccess(int fd, void *buf, size_t count, off_t offset) {
std::ostringstream oStream;
uint64_t val = 0;
if (fd == 4) {
memcpy(buf, &val, count);
return count;
} else if (fd == 5) {
oStream << "0x490e01";
} else if (fd == 6) {
if (offset == mockKeyOffset) {
val = setEnergyCounter;
}
memcpy(buf, &val, count);
return count;
} else if (fd == 7) {
return -1;
} else {
oStream << "-1";
}
std::string value = oStream.str();
memcpy(buf, value.data(), count);
return count;
}
static int mockOpenSuccess(const char *pathname, int flags) {
int returnValue = -1;
std::string strPathName(pathname);
if (strPathName == telemOffsetFileName) {
returnValue = 4;
} else if (strPathName == telemGuidFileName) {
returnValue = 5;
} else if (strPathName == telemFileName) {
returnValue = 6;
} else if (strPathName.find(energyCounterNode) != std::string::npos) {
returnValue = 7;
}
return returnValue;
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCallingGetPowerLimitValueThenCorrectValueIsReturned, IsPVC) {
uint64_t testValue = 3000;
int32_t expectedValue = 3000;
@ -78,6 +135,172 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidProductHelperHandleWhenCalling
EXPECT_TRUE(pSysmanProductHelper->isPowerSetLimitSupported());
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenSysfsReadFailsAndTelemDataNotAvailableWhenGettingPowerEnergyCounterThenFailureIsReturned, IsSKL) {
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->isTelemetrySupportAvailable = true;
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPowerImp->getEnergyCounter(&energyCounter));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenSysfsReadFailsAndGuidToKeyOffsetMapPtrIsNullWhenGettingPowerEnergyCounterThenFailureIsReturned, IsSKL) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->isTelemetrySupportAvailable = true;
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pLinuxPowerImp->getEnergyCounter(&energyCounter));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenSysfsReadFailsAndKeyOffsetMapNotAvailableForGuidWhenGettingPowerEnergyCounterThenFailureIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::ostringstream oStream;
uint64_t val = 0;
if (fd == 4) {
memcpy(buf, &val, count);
return count;
} else if (fd == 5) {
oStream << "0xABCDE";
} else if (fd == 7) {
return -1;
} else {
oStream << "-1";
}
std::string value = oStream.str();
memcpy(buf, value.data(), count);
return count;
});
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->isTelemetrySupportAvailable = true;
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pLinuxPowerImp->getEnergyCounter(&energyCounter));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenSysfsReadFailsAndPmtReadValueFailsWhenGettingPowerEnergyCounterThenFailureIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::ostringstream oStream;
uint64_t val = 0;
if (fd == 4) {
memcpy(buf, &val, count);
return count;
} else if (fd == 5) {
oStream << "0x490e01";
} else if (fd == 6) {
if (offset == mockKeyOffset) {
errno = ENOENT;
return -1;
}
} else if (fd == 7) {
return -1;
} else {
oStream << "-1";
}
std::string value = oStream.str();
memcpy(buf, value.data(), count);
return count;
});
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->isTelemetrySupportAvailable = true;
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pLinuxPowerImp->getEnergyCounter(&energyCounter));
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenSysfsReadFailsWhenGettingPowerEnergyCounterThenSuccesIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, false, 0, ZES_POWER_DOMAIN_CARD));
pLinuxPowerImp->isTelemetrySupportAvailable = true;
zes_power_energy_counter_t energyCounter = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxPowerImp->getEnergyCounter(&energyCounter));
uint64_t expectedEnergyCounter = convertJouleToMicroJoule * (setEnergyCounter / 1048576);
EXPECT_EQ(energyCounter.energy, expectedEnergyCounter);
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleAndHwMonDoesNotExistWhenGettingPowerLimitsThenUnsupportedFeatureErrorIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
VariableBackup<bool> allowFakeDevicePathBackup(&NEO::SysCalls::allowFakeDevicePath, true);
uint32_t count = 0;
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustained, &burst, &peak));
}
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenScanDirectoriesFailAndTelemetrySupportAvailableThenPowerModuleIsSupported, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
VariableBackup<bool> allowFakeDevicePathBackup(&NEO::SysCalls::allowFakeDevicePath, true);
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
pSysmanDeviceImp->pPowerHandleContext->init(subDeviceCount);
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
std::unique_ptr<PublicLinuxPowerImp> pLinuxPowerImp(new PublicLinuxPowerImp(pOsSysman, onSubdevice, subdeviceId, ZES_POWER_DOMAIN_CARD));
EXPECT_TRUE(pLinuxPowerImp->isPowerModuleSupported());
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenSettingPowerLimitsThenUnsupportedFeatureErrorIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
VariableBackup<bool> allowFakeDevicePathBackup(&NEO::SysCalls::allowFakeDevicePath, true);
uint32_t count = 0;
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_power_sustained_limit_t sustained;
zes_power_burst_limit_t burst;
zes_power_peak_limit_t peak;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustained, &burst, &peak));
}
}
HWTEST2_F(SysmanProductHelperPowerTest, GivenComponentCountZeroWhenEnumeratingPowerDomainsThenValidPowerHandlesIsReturned, IsDG1) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess);
VariableBackup<bool> allowFakeDevicePathBackup(&NEO::SysCalls::allowFakeDevicePath, true);
uint32_t count = 0;
EXPECT_EQ(zesDeviceEnumPowerDomains(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
EXPECT_EQ(count, powerHandleComponentCount);
std::vector<zes_pwr_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumPowerDomains(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
for (auto handle : handles) {
EXPECT_NE(handle, nullptr);
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0