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

fix: use FileDescriptor class to handle open/close file descriptor in PCI/PMT 

Related-To: NEO-9038
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2023-10-10 08:13:48 +00:00 committed by Compute-Runtime-Automation
parent e3260de8ca
commit a7e86f40bf
25 changed files with 79 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.cpp
View File

@ -8,6 +8,7 @@
#include "level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.h" #include "level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/linux/file_descriptor.h"
#include "shared/source/utilities/directory.h" #include "shared/source/utilities/directory.h"
#include "level_zero/sysman/source/api/pci/sysman_pci_imp.h" #include "level_zero/sysman/source/api/pci/sysman_pci_imp.h"
@ -293,8 +294,7 @@ bool LinuxPciImp::getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &
return false; return false;
} }
int fd = -1; auto fd = NEO::FileDescriptor(pciPath.c_str(), O_RDONLY);
fd = this->openFunction(pciPath.c_str(), O_RDONLY);
if (fd < 0) { if (fd < 0) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() Config File Open Failed \n", __FUNCTION__); NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() Config File Open Failed \n", __FUNCTION__);
return false; return false;
@ -303,10 +303,6 @@ bool LinuxPciImp::getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() Config Mem Read Failed \n", __FUNCTION__); NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() Config Mem Read Failed \n", __FUNCTION__);
return false; return false;
} }
if (this->closeFunction(fd) < 0) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() Config file close Failed \n", __FUNCTION__);
return false;
}
return true; return true;
} }

2
level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.h
View File

@ -40,8 +40,6 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
L0::Sysman::SysfsAccess *pSysfsAccess = nullptr; L0::Sysman::SysfsAccess *pSysfsAccess = nullptr;
L0::Sysman::LinuxSysmanImp *pLinuxSysmanImp = nullptr; L0::Sysman::LinuxSysmanImp *pLinuxSysmanImp = nullptr;
bool getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &configMem); bool getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &configMem);
decltype(&NEO::SysCalls::open) openFunction = NEO::SysCalls::open;
decltype(&NEO::SysCalls::close) closeFunction = NEO::SysCalls::close;
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread; decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private: private:

15
level_zero/sysman/source/linux/pmt/sysman_pmt.cpp
View File

@ -8,6 +8,7 @@
#include "level_zero/sysman/source/linux/pmt/sysman_pmt.h" #include "level_zero/sysman/source/linux/pmt/sysman_pmt.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/os_interface/linux/file_descriptor.h"
#include "level_zero/sysman/source/linux/zes_os_sysman_imp.h" #include "level_zero/sysman/source/linux/zes_os_sysman_imp.h"
#include "level_zero/sysman/source/sysman_device_imp.h" #include "level_zero/sysman/source/sysman_device_imp.h"
@ -32,7 +33,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &v
if (offset == keyOffsetMap.end()) { if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
int fd = this->openFunction(telemetryDeviceEntry.c_str(), O_RDONLY); auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) { if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
@ -41,11 +42,6 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &v
if (this->preadFunction(fd, &value, sizeof(uint32_t), baseOffset + offset->second) != sizeof(uint32_t)) { if (this->preadFunction(fd, &value, sizeof(uint32_t), baseOffset + offset->second) != sizeof(uint32_t)) {
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
if (this->closeFunction(fd) < 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return res; return res;
} }
@ -54,7 +50,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint64_t &v
if (offset == keyOffsetMap.end()) { if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
int fd = this->openFunction(telemetryDeviceEntry.c_str(), O_RDONLY); auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) { if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
@ -63,11 +59,6 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint64_t &v
if (this->preadFunction(fd, &value, sizeof(uint64_t), baseOffset + offset->second) != sizeof(uint64_t)) { if (this->preadFunction(fd, &value, sizeof(uint64_t), baseOffset + offset->second) != sizeof(uint64_t)) {
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
if (this->closeFunction(fd) < 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return res; return res;
} }

2
level_zero/sysman/source/linux/pmt/sysman_pmt.h
View File

@ -44,8 +44,6 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
ze_result_t init(FsAccess *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily); ze_result_t init(FsAccess *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily);
static void doInitPmtObject(FsAccess *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath, static void doInitPmtObject(FsAccess *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily); std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily);
decltype(&NEO::SysCalls::open) openFunction = NEO::SysCalls::open;
decltype(&NEO::SysCalls::close) closeFunction = NEO::SysCalls::close;
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread; decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private: private:

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

@ -146,11 +146,9 @@ struct MockPmtFsAccess : public L0::Sysman::FsAccess {
class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
public: public:
PublicPlatformMonitoringTech(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} PublicPlatformMonitoringTech(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::closeFunction;
using PlatformMonitoringTech::doInitPmtObject; using PlatformMonitoringTech::doInitPmtObject;
using PlatformMonitoringTech::init; using PlatformMonitoringTech::init;
using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::openFunction;
using PlatformMonitoringTech::preadFunction; using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::rootDeviceTelemNodeIndex; using PlatformMonitoringTech::rootDeviceTelemNodeIndex;
using PlatformMonitoringTech::telemetryDeviceEntry; using PlatformMonitoringTech::telemetryDeviceEntry;

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

@ -13,8 +13,6 @@ namespace L0 {
namespace Sysman { namespace Sysman {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
const std::map<std::string, uint64_t> dummyKeyOffsetMap = { const std::map<std::string, uint64_t> dummyKeyOffsetMap = {
{"DUMMY_KEY", 0x0}}; {"DUMMY_KEY", 0x0}};
@ -104,32 +102,24 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesTh
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE); EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE);
} }
inline static int openMock(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int openMockReturnFailure(const char *pathname, int flags) { inline static int openMockReturnFailure(const char *pathname, int flags) {
return -1; return -1;
} }
inline static int closeMock(int fd) { inline static int openMockReturnSuccess(const char *pathname, int flags) {
if (fd == fakeFileDescriptor) { NEO::SysCalls::closeFuncCalled = 0;
return 0; return 0;
}
return -1;
}
inline static int closeMockReturnFailure(int fd) {
return -1;
} }
ssize_t preadMockPmt(int fd, void *buf, size_t count, off_t offset) { 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; return count;
} }
@ -139,52 +129,49 @@ ssize_t preadMockPmtFailure(int fd, void *buf, size_t count, off_t offset) {
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndOpenSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val)); EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
} }
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndCloseSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingReadValueWithUint32TypeThenSuccessIsReturned) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnSuccess);
pPmt->openFunction = openMock; VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
pPmt->preadFunction = preadMockPmt;
pPmt->closeFunction = closeMockReturnFailure;
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); 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) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
uint64_t val = 0; uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val)); EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
} }
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndCloseSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmt;
pPmt->closeFunction = closeMockReturnFailure;
uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndPreadSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmtFailure; pPmt->preadFunction = preadMockPmtFailure;
pPmt->closeFunction = closeMock;
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
@ -194,9 +181,7 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint3
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndPreadSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmtFailure; pPmt->preadFunction = preadMockPmtFailure;
pPmt->closeFunction = closeMock;
uint64_t val = 0; uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;

2
level_zero/sysman/test/unit_tests/sources/pci/linux/mock_sysfs_pci.h
View File

@ -95,8 +95,6 @@ struct MockPciSysfsAccess : public L0::Sysman::SysfsAccess {
class PublicLinuxPciImp : public L0::Sysman::LinuxPciImp { class PublicLinuxPciImp : public L0::Sysman::LinuxPciImp {
public: public:
PublicLinuxPciImp(L0::Sysman::OsSysman *pOsSysman) : L0::Sysman::LinuxPciImp(pOsSysman) {} PublicLinuxPciImp(L0::Sysman::OsSysman *pOsSysman) : L0::Sysman::LinuxPciImp(pOsSysman) {}
using L0::Sysman::LinuxPciImp::closeFunction;
using L0::Sysman::LinuxPciImp::openFunction;
using L0::Sysman::LinuxPciImp::preadFunction; using L0::Sysman::LinuxPciImp::preadFunction;
using L0::Sysman::LinuxPciImp::pSysfsAccess; using L0::Sysman::LinuxPciImp::pSysfsAccess;
}; };

66
level_zero/sysman/test/unit_tests/sources/pci/linux/test_zes_pci.cpp
View File

@ -25,32 +25,18 @@ constexpr int convertMegabitsPerSecondToBytesPerSecond = 125000;
constexpr int convertGigabitToMegabit = 1000; constexpr int convertGigabitToMegabit = 1000;
constexpr double encodingGen1Gen2 = 0.8; constexpr double encodingGen1Gen2 = 0.8;
constexpr double encodingGen3andAbove = 0.98461538461; constexpr double encodingGen3andAbove = 0.98461538461;
static int fakeFileDescriptor = 123;
inline static int openMock(const char *pathname, int flags) {
if ((strcmp(pathname, mockRealPathConfig.c_str()) == 0) || (strcmp(pathname, mockRealPath2LevelsUpConfig.c_str()) == 0)) {
return fakeFileDescriptor;
}
return -1;
}
inline static int openMockReturnFailure(const char *pathname, int flags) { inline static int openMockReturnFailure(const char *pathname, int flags) {
return -1; return -1;
} }
inline static int closeMock(int fd) { inline static int openMockReturnSuccess(const char *pathname, int flags) {
if (fd == fakeFileDescriptor) { NEO::SysCalls::closeFuncCalled = 0;
return 0; return 0;
}
return -1;
}
inline static int closeMockReturnFailure(int fd) {
return -1;
} }
ssize_t preadMock(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMock(int fd, void *buf, size_t count, off_t offset) {
EXPECT_EQ(0u, NEO::SysCalls::closeFuncCalled);
uint8_t *mockBuf = static_cast<uint8_t *>(buf); uint8_t *mockBuf = static_cast<uint8_t *>(buf);
// Sample config values // Sample config values
if (count == PCI_CFG_SPACE_EXP_SIZE) { if (count == PCI_CFG_SPACE_EXP_SIZE) {
@ -225,6 +211,7 @@ class ZesPciFixture : public SysmanDeviceFixture {
L0::Sysman::PciImp *pPciImp; L0::Sysman::PciImp *pPciImp;
L0::Sysman::OsPci *pOsPciPrev; L0::Sysman::OsPci *pOsPciPrev;
std::unique_ptr<L0::ult::Mock<L0::DriverHandleImp>> driverHandle; std::unique_ptr<L0::ult::Mock<L0::DriverHandleImp>> driverHandle;
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup{&NEO::SysCalls::sysCallsOpen, openMockReturnSuccess};
void SetUp() override { void SetUp() override {
SysmanDeviceFixture::SetUp(); SysmanDeviceFixture::SetUp();
@ -237,8 +224,6 @@ class ZesPciFixture : public SysmanDeviceFixture {
pOsPciPrev = pPciImp->pOsPci; pOsPciPrev = pPciImp->pOsPci;
pPciImp->pOsPci = nullptr; pPciImp->pOsPci = nullptr;
PublicLinuxPciImp *pLinuxPciImp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImp->openFunction = openMock;
pLinuxPciImp->closeFunction = closeMock;
pLinuxPciImp->preadFunction = preadMock; pLinuxPciImp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImp);
@ -289,8 +274,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingzetS
zes_pci_properties_t properties, propertiesBefore; zes_pci_properties_t properties, propertiesBefore;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -343,8 +326,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndCapabilityL
double speed = 0; double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockInvalidPos; pLinuxPciImpTemp->preadFunction = preadMockInvalidPos;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -362,8 +343,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndPCIExpressC
double speed = 0; double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockLoop; pLinuxPciImpTemp->preadFunction = preadMockLoop;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -381,8 +360,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndUserIsNonRo
double speed = 0; double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pSysfsAccess->isRootUserResult = false; pSysfsAccess->isRootUserResult = false;
@ -402,27 +379,7 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenInitializingPciAndPciConfigOpenFailsT
double speed = 0; double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
pPciImp->pciGetStaticFields();
pPciImp->pOsPci->getMaxLinkCaps(speed, width);
EXPECT_EQ(width, -1);
EXPECT_EQ(speed, 0);
delete pLinuxPciImpTemp;
pPciImp->pOsPci = pOsPciOriginal;
}
TEST_F(ZesPciFixture, GivenSysmanHandleWhenInitializingPciAndPciConfigCloseFailsThenInvalidSpeedAndWidthAreReturned) {
int32_t width = 0;
double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMockReturnFailure;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -440,8 +397,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndPCIHeaderIs
double speed = 0; double speed = 0;
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure; pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -478,8 +433,7 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetBarsThenVe
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigOpenFailsThenResizableBarSupportWillBeFalse) { TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigOpenFailsThenResizableBarSupportWillBeFalse) {
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -494,8 +448,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigOpenF
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadFailsThenResizableBarSupportWillBeFalse) { TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadFailsThenResizableBarSupportWillBeFalse) {
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockFailure; pLinuxPciImpTemp->preadFunction = preadMockFailure;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -510,8 +462,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadF
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderFieldNotPresentThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderFieldNotPresentThenResizableBarSupportFalseReturned) {
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure; pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -526,8 +476,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderF
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabilityLinkListIsBrokenThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabilityLinkListIsBrokenThenResizableBarSupportFalseReturned) {
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockInvalidPos; pLinuxPciImpTemp->preadFunction = preadMockInvalidPos;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);
@ -542,8 +490,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabil
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndIfRebarCapabilityNotPresentThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndIfRebarCapabilityNotPresentThenResizableBarSupportFalseReturned) {
L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci; L0::Sysman::OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockLoop; pLinuxPciImpTemp->preadFunction = preadMockLoop;
pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<L0::Sysman::OsPci *>(pLinuxPciImpTemp);

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

@ -284,9 +284,7 @@ struct MockPowerSysfsAccess : public L0::Sysman::SysfsAccess {
}; };
struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech { struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
using L0::Sysman::PlatformMonitoringTech::closeFunction;
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap; using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::openFunction;
using L0::Sysman::PlatformMonitoringTech::preadFunction; using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry; using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;

2
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power_prelim.h
View File

@ -218,9 +218,7 @@ struct MockPowerSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech { struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
MockPowerPmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} MockPowerPmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using L0::Sysman::PlatformMonitoringTech::closeFunction;
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap; using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::openFunction;
using L0::Sysman::PlatformMonitoringTech::preadFunction; using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry; using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
~MockPowerPmt() override { ~MockPowerPmt() override {

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

@ -11,27 +11,9 @@ namespace L0 {
namespace Sysman { namespace Sysman {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
constexpr uint64_t convertJouleToMicroJoule = 1000000u; constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u; constexpr uint32_t powerHandleComponentCount = 1u;
inline static int openMockPower(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int closeMockPower(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf); uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter; *mockBuf = setEnergyCounter;
@ -183,8 +165,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);
@ -506,8 +486,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);
@ -658,8 +636,6 @@ TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowe
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);

24
level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_prelim.cpp
View File

@ -11,27 +11,9 @@ namespace L0 {
namespace Sysman { namespace Sysman {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
constexpr uint64_t convertJouleToMicroJoule = 1000000u; constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u; constexpr uint32_t powerHandleComponentCount = 1u;
inline static int openMockPower(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int closeMockPower(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf); uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter; *mockBuf = setEnergyCounter;
@ -190,8 +172,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);
@ -666,8 +646,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);
@ -778,8 +756,6 @@ TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowe
uint32_t subdeviceId = 0; uint32_t subdeviceId = 0;
do { do {
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} while (++subdeviceId < subDeviceCount); } while (++subdeviceId < subDeviceCount);

2
level_zero/sysman/test/unit_tests/sources/temperature/linux/mock_sysfs_temperature.h
View File

@ -44,9 +44,7 @@ const std::string sysfsPahTelem5 = "/sys/class/intel_pmt/telem5";
struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech { struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
MockTemperaturePmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} MockTemperaturePmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using L0::Sysman::PlatformMonitoringTech::closeFunction;
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap; using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::openFunction;
using L0::Sysman::PlatformMonitoringTech::preadFunction; using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry; using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;

14
level_zero/tools/source/sysman/linux/pmt/pmt.cpp
View File

@ -9,6 +9,7 @@
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/debug_helpers.h" #include "shared/source/helpers/debug_helpers.h"
#include "shared/source/os_interface/linux/file_descriptor.h"
#include "level_zero/tools/source/sysman/sysman_imp.h" #include "level_zero/tools/source/sysman/sysman_imp.h"
@ -31,7 +32,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &v
if (offset == keyOffsetMap.end()) { if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
int fd = this->openFunction(telemetryDeviceEntry.c_str(), O_RDONLY); auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) { if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
@ -40,11 +41,6 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &v
if (this->preadFunction(fd, &value, sizeof(uint32_t), baseOffset + offset->second) != sizeof(uint32_t)) { if (this->preadFunction(fd, &value, sizeof(uint32_t), baseOffset + offset->second) != sizeof(uint32_t)) {
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
if (this->closeFunction(fd) < 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return res; return res;
} }
@ -53,7 +49,7 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint64_t &v
if (offset == keyOffsetMap.end()) { if (offset == keyOffsetMap.end()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
} }
int fd = this->openFunction(telemetryDeviceEntry.c_str(), O_RDONLY); auto fd = NEO::FileDescriptor(telemetryDeviceEntry.c_str(), O_RDONLY);
if (fd == -1) { if (fd == -1) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
@ -63,10 +59,6 @@ ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint64_t &v
res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; res = ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
} }
if (this->closeFunction(fd) < 0) {
return ZE_RESULT_ERROR_UNKNOWN;
}
return res; return res;
} }

2
level_zero/tools/source/sysman/linux/pmt/pmt.h
View File

@ -42,8 +42,6 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
ze_result_t init(FsAccess *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily); ze_result_t init(FsAccess *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily);
static void doInitPmtObject(FsAccess *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath, static void doInitPmtObject(FsAccess *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily); std::map<uint32_t, L0::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily);
decltype(&NEO::SysCalls::open) openFunction = NEO::SysCalls::open;
decltype(&NEO::SysCalls::close) closeFunction = NEO::SysCalls::close;
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread; decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private: private:

2
level_zero/tools/source/sysman/pci/linux/os_pci_imp.h
View File

@ -37,8 +37,6 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
SysfsAccess *pSysfsAccess = nullptr; SysfsAccess *pSysfsAccess = nullptr;
LinuxSysmanImp *pLinuxSysmanImp = nullptr; LinuxSysmanImp *pLinuxSysmanImp = nullptr;
bool getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &configMem); bool getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &configMem);
decltype(&NEO::SysCalls::open) openFunction = NEO::SysCalls::open;
decltype(&NEO::SysCalls::close) closeFunction = NEO::SysCalls::close;
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread; decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private: private:

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

@ -145,11 +145,9 @@ struct MockPmtFsAccess : public FsAccess {
class PublicPlatformMonitoringTech : public L0::PlatformMonitoringTech { class PublicPlatformMonitoringTech : public L0::PlatformMonitoringTech {
public: public:
PublicPlatformMonitoringTech(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} PublicPlatformMonitoringTech(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::closeFunction;
using PlatformMonitoringTech::doInitPmtObject; using PlatformMonitoringTech::doInitPmtObject;
using PlatformMonitoringTech::init; using PlatformMonitoringTech::init;
using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::openFunction;
using PlatformMonitoringTech::preadFunction; using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::telemetryDeviceEntry; using PlatformMonitoringTech::telemetryDeviceEntry;
}; };

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

@ -5,6 +5,8 @@
* *
*/ */
#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h" #include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "mock_pmt.h" #include "mock_pmt.h"
@ -13,7 +15,6 @@ extern bool sysmanUltsEnable;
namespace L0 { namespace L0 {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
const std::map<std::string, uint64_t> dummyKeyOffsetMap = { const std::map<std::string, uint64_t> dummyKeyOffsetMap = {
{"DUMMY_KEY", 0x0}}; {"DUMMY_KEY", 0x0}};
@ -119,32 +120,24 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesTh
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE); EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE);
} }
inline static int openMock(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int openMockReturnFailure(const char *pathname, int flags) { inline static int openMockReturnFailure(const char *pathname, int flags) {
return -1; return -1;
} }
inline static int closeMock(int fd) { inline static int openMockReturnSuccess(const char *pathname, int flags) {
if (fd == fakeFileDescriptor) { NEO::SysCalls::closeFuncCalled = 0;
return 0; return 0;
}
return -1;
}
inline static int closeMockReturnFailure(int fd) {
return -1;
} }
ssize_t preadMockPmt(int fd, void *buf, size_t count, off_t offset) { 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; return count;
} }
@ -154,52 +147,49 @@ ssize_t preadMockPmtFailure(int fd, void *buf, size_t count, off_t offset) {
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndOpenSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val)); EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
} }
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndCloseSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingReadValueWithUint32TypeThenSuccessIsReturned) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnSuccess);
pPmt->openFunction = openMock; VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, preadMockPmt);
pPmt->preadFunction = preadMockPmt;
pPmt->closeFunction = closeMockReturnFailure;
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); 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) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndOpenSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->openFunction = openMockReturnFailure; VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
uint64_t val = 0; uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val)); EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pPmt->readValue("DUMMY_KEY", val));
} }
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndCloseSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmt;
pPmt->closeFunction = closeMockReturnFailure;
uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndPreadSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint32TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmtFailure; pPmt->preadFunction = preadMockPmtFailure;
pPmt->closeFunction = closeMock;
uint32_t val = 0; uint32_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;
@ -209,9 +199,7 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint3
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndPreadSysCallFailsThenreadValueFails) { TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint64TypeAndPreadSysCallFailsThenreadValueFails) {
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0); auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem; pPmt->telemetryDeviceEntry = baseTelemSysFS + "/" + telemNodeForSubdevice0 + "/" + telem;
pPmt->openFunction = openMock;
pPmt->preadFunction = preadMockPmtFailure; pPmt->preadFunction = preadMockPmtFailure;
pPmt->closeFunction = closeMock;
uint64_t val = 0; uint64_t val = 0;
pPmt->keyOffsetMap = dummyKeyOffsetMap; pPmt->keyOffsetMap = dummyKeyOffsetMap;

2
level_zero/tools/test/unit_tests/sources/sysman/pci/linux/mock_sysfs_pci.h
View File

@ -92,8 +92,6 @@ struct MockPciSysfsAccess : public SysfsAccess {
class PublicLinuxPciImp : public L0::LinuxPciImp { class PublicLinuxPciImp : public L0::LinuxPciImp {
public: public:
PublicLinuxPciImp(OsSysman *pOsSysman) : LinuxPciImp(pOsSysman) {} PublicLinuxPciImp(OsSysman *pOsSysman) : LinuxPciImp(pOsSysman) {}
using LinuxPciImp::closeFunction;
using LinuxPciImp::openFunction;
using LinuxPciImp::preadFunction; using LinuxPciImp::preadFunction;
using LinuxPciImp::pSysfsAccess; using LinuxPciImp::pSysfsAccess;
}; };

39
level_zero/tools/test/unit_tests/sources/sysman/pci/linux/test_zes_pci.cpp
View File

@ -30,27 +30,11 @@ constexpr int convertMegabitsPerSecondToBytesPerSecond = 125000;
constexpr int convertGigabitToMegabit = 1000; constexpr int convertGigabitToMegabit = 1000;
constexpr double encodingGen1Gen2 = 0.8; constexpr double encodingGen1Gen2 = 0.8;
constexpr double encodingGen3andAbove = 0.98461538461; constexpr double encodingGen3andAbove = 0.98461538461;
static int fakeFileDescriptor = 123;
inline static int openMock(const char *pathname, int flags) {
if ((strcmp(pathname, mockRealPathConfig.c_str()) == 0) || (strcmp(pathname, mockRealPath2LevelsUpConfig.c_str()) == 0)) {
return fakeFileDescriptor;
}
return -1;
}
inline static int openMockReturnFailure(const char *pathname, int flags) { inline static int openMockReturnFailure(const char *pathname, int flags) {
return -1; return -1;
} }
inline static int closeMock(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMock(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMock(int fd, void *buf, size_t count, off_t offset) {
uint8_t *mockBuf = static_cast<uint8_t *>(buf); uint8_t *mockBuf = static_cast<uint8_t *>(buf);
// Sample config values // Sample config values
@ -252,8 +236,6 @@ class ZesPciFixture : public SysmanDeviceFixture {
pPciImp->pOsPci = nullptr; pPciImp->pOsPci = nullptr;
memoryManager->localMemorySupported[0] = 0; memoryManager->localMemorySupported[0] = 0;
PublicLinuxPciImp *pLinuxPciImp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImp->openFunction = openMock;
pLinuxPciImp->closeFunction = closeMock;
pLinuxPciImp->preadFunction = preadMock; pLinuxPciImp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImp);
@ -314,8 +296,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenSettingLmemSupportAndCallingzetS
memoryManager->localMemorySupported[0] = 1; memoryManager->localMemorySupported[0] = 1;
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -369,8 +349,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndCapabilityL
memoryManager->localMemorySupported[0] = 1; memoryManager->localMemorySupported[0] = 1;
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockInvalidPos; pLinuxPciImpTemp->preadFunction = preadMockInvalidPos;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -389,8 +367,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndUserIsNonRo
memoryManager->localMemorySupported[0] = 1; memoryManager->localMemorySupported[0] = 1;
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pSysfsAccess->isRootUserResult = false; pSysfsAccess->isRootUserResult = false;
@ -411,8 +387,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndPCIExpressC
memoryManager->localMemorySupported[0] = 1; memoryManager->localMemorySupported[0] = 1;
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockLoop; pLinuxPciImpTemp->preadFunction = preadMockLoop;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -432,7 +406,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenInitializingPciAndPciConfigOpenFailsT
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure); VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -451,9 +424,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenGettingPCIWidthAndSpeedAndPCIHeaderIs
memoryManager->localMemorySupported[0] = 1; memoryManager->localMemorySupported[0] = 1;
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
pPciImp->pciGetStaticFields(); pPciImp->pciGetStaticFields();
@ -490,7 +460,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigOpenF
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure); VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, openMockReturnFailure);
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMock; pLinuxPciImpTemp->preadFunction = preadMock;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -505,8 +474,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigOpenF
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadFailsThenResizableBarSupportWillBeFalse) { TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadFailsThenResizableBarSupportWillBeFalse) {
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockFailure; pLinuxPciImpTemp->preadFunction = preadMockFailure;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -521,8 +488,6 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenInitializingPciAndPciConfigReadF
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderFieldNotPresentThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderFieldNotPresentThenResizableBarSupportFalseReturned) {
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure; pLinuxPciImpTemp->preadFunction = preadMockHeaderFailure;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -537,8 +502,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndHeaderF
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabilityLinkListIsBrokenThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabilityLinkListIsBrokenThenResizableBarSupportFalseReturned) {
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockInvalidPos; pLinuxPciImpTemp->preadFunction = preadMockInvalidPos;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);
@ -553,8 +516,6 @@ TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndCapabil
TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndIfRebarCapabilityNotPresentThenResizableBarSupportFalseReturned) { TEST_F(ZesPciFixture, GivenSysmanHandleWhenCheckForResizableBarSupportAndIfRebarCapabilityNotPresentThenResizableBarSupportFalseReturned) {
OsPci *pOsPciOriginal = pPciImp->pOsPci; OsPci *pOsPciOriginal = pPciImp->pOsPci;
PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman); PublicLinuxPciImp *pLinuxPciImpTemp = new PublicLinuxPciImp(pOsSysman);
pLinuxPciImpTemp->openFunction = openMock;
pLinuxPciImpTemp->closeFunction = closeMock;
pLinuxPciImpTemp->preadFunction = preadMockLoop; pLinuxPciImpTemp->preadFunction = preadMockLoop;
pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp); pPciImp->pOsPci = static_cast<OsPci *>(pLinuxPciImpTemp);

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

@ -282,9 +282,7 @@ struct MockPowerSysfsAccess : public SysfsAccess {
}; };
struct MockPowerPmt : public PlatformMonitoringTech { struct MockPowerPmt : public PlatformMonitoringTech {
using PlatformMonitoringTech::closeFunction;
using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::openFunction;
using PlatformMonitoringTech::preadFunction; using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::telemetryDeviceEntry; using PlatformMonitoringTech::telemetryDeviceEntry;

2
level_zero/tools/test/unit_tests/sources/sysman/power/linux/mock_sysfs_power_prelim.h
View File

@ -216,9 +216,7 @@ struct MockPowerSysfsAccess : public SysfsAccess {
struct MockPowerPmt : public PlatformMonitoringTech { struct MockPowerPmt : public PlatformMonitoringTech {
MockPowerPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} MockPowerPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::closeFunction;
using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::openFunction;
using PlatformMonitoringTech::preadFunction; using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::telemetryDeviceEntry; using PlatformMonitoringTech::telemetryDeviceEntry;
~MockPowerPmt() override { ~MockPowerPmt() override {

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

@ -11,27 +11,9 @@
namespace L0 { namespace L0 {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
constexpr uint64_t convertJouleToMicroJoule = 1000000u; constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u; constexpr uint32_t powerHandleComponentCount = 1u;
inline static int openMockPower(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int closeMockPower(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf); uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter; *mockBuf = setEnergyCounter;
@ -184,8 +166,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }
@ -507,8 +487,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }
@ -657,8 +635,6 @@ TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowe
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }

24
level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_prelim.cpp
View File

@ -11,27 +11,9 @@
namespace L0 { namespace L0 {
namespace ult { namespace ult {
static int fakeFileDescriptor = 123;
constexpr uint64_t convertJouleToMicroJoule = 1000000u; constexpr uint64_t convertJouleToMicroJoule = 1000000u;
constexpr uint32_t powerHandleComponentCount = 1u; constexpr uint32_t powerHandleComponentCount = 1u;
inline static int openMockPower(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int closeMockPower(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) { ssize_t preadMockPower(int fd, void *buf, size_t count, off_t offset) {
uint64_t *mockBuf = static_cast<uint64_t *>(buf); uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = setEnergyCounter; *mockBuf = setEnergyCounter;
@ -191,8 +173,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }
@ -666,8 +646,6 @@ TEST_F(SysmanDevicePowerFixture, GivenValidPowerHandleWhenGettingPowerEnergyCoun
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }
@ -776,8 +754,6 @@ TEST_F(SysmanDevicePowerMultiDeviceFixture, GivenValidPowerHandleWhenGettingPowe
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES}; ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties); Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId)); auto pPmt = static_cast<MockPowerPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockPower;
pPmt->closeFunction = closeMockPower;
pPmt->preadFunction = preadMockPower; pPmt->preadFunction = preadMockPower;
} }

2
level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h
View File

@ -41,9 +41,7 @@ const std::string sysfsPahTelem5 = "/sys/class/intel_pmt/telem5";
struct MockTemperaturePmt : public PlatformMonitoringTech { struct MockTemperaturePmt : public PlatformMonitoringTech {
MockTemperaturePmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {} MockTemperaturePmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::closeFunction;
using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::keyOffsetMap;
using PlatformMonitoringTech::openFunction;
using PlatformMonitoringTech::preadFunction; using PlatformMonitoringTech::preadFunction;
using PlatformMonitoringTech::telemetryDeviceEntry; using PlatformMonitoringTech::telemetryDeviceEntry;