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

feature(sysman): Add Support for zesDevicePciGetStats API for BMG Linux Platform 

Related-To: NEO-11294

Signed-off-by: Anvesh Bakwad <anvesh.bakwad@intel.com>
This commit is contained in:
Anvesh Bakwad 2024-07-31 15:30:01 +00:00 committed by Compute-Runtime-Automation
parent 0ac9491a0a
commit 290a9bd3ad
12 changed files with 441 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -298,7 +298,8 @@ ze_result_t LinuxPciImp::getState(zes_pci_state_t *state) {
}
ze_result_t LinuxPciImp::getStats(zes_pci_stats_t *stats) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
return pSysmanProductHelper->getPciStats(stats, pLinuxSysmanImp);
}
bool LinuxPciImp::getPciConfigMemory(std::string pciPath, std::vector<uint8_t> &configMem) {

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

@ -255,6 +255,7 @@ bool PlatformMonitoringTech::readValue(const std::map<std::string, uint64_t> key
uint64_t offset = telemOffset + containerOffset->second;
ssize_t bytesRead = NEO::PmtUtil::readTelem(telemDir.data(), sizeof(uint32_t), offset, &value);
if (bytesRead != sizeof(uint32_t)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read value for %s key \n", __FUNCTION__, key.c_str());
return false;
}
return true;
@ -271,6 +272,7 @@ bool PlatformMonitoringTech::readValue(const std::map<std::string, uint64_t> key
uint64_t offset = telemOffset + containerOffset->second;
ssize_t bytesRead = NEO::PmtUtil::readTelem(telemDir.data(), sizeof(uint64_t), offset, &value);
if (bytesRead != sizeof(uint64_t)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read value for %s key \n", __FUNCTION__, key.c_str());
return false;
}
return true;

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

@ -99,6 +99,9 @@ class SysmanProductHelper {
// Device
virtual bool isUpstreamPortConnected() = 0;
// Pci
virtual ze_result_t getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) = 0;
virtual ~SysmanProductHelper() = default;
virtual const std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() = 0;

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

@ -74,6 +74,9 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// Device
bool isUpstreamPortConnected() override;
// Pci
ze_result_t getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) override;
~SysmanProductHelperHw() override = default;
const std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() override;

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

@ -301,5 +301,10 @@ bool SysmanProductHelperHw<gfxProduct>::isUpstreamPortConnected() {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
};
} // namespace Sysman
} // namespace L0

116
level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@ -5,6 +5,8 @@
*
*/
#include "shared/source/os_interface/linux/pmt_util.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl"
@ -14,6 +16,22 @@ constexpr static auto gfxProduct = IGFX_BMG;
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_xe_hp_and_later.inl"
static std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap = {
{"0x5e2F8210", // BMG OOBMSM Rev 15
{{"reg_PCIESS_rx_bytecount_lsb", 70},
{"reg_PCIESS_rx_bytecount_msb", 69},
{"reg_PCIESS_tx_bytecount_lsb", 72},
{"reg_PCIESS_tx_bytecount_msb", 71},
{"reg_PCIESS_rx_pktcount_lsb", 74},
{"reg_PCIESS_rx_pktcount_msb", 73},
{"reg_PCIESS_tx_pktcount_lsb", 76},
{"reg_PCIESS_tx_pktcount_msb", 75}}}};
template <>
const std::map<std::string, std::map<std::string, uint64_t>> *SysmanProductHelperHw<gfxProduct>::getGuidToKeyOffsetMap() {
return &guidToKeyOffsetMap;
}
template <>
RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
return RasInterfaceType::netlink;
@ -29,6 +47,104 @@ bool SysmanProductHelperHw<gfxProduct>::isUpstreamPortConnected() {
return true;
}
static ze_result_t getPciStatsValues(zes_pci_stats_t *pStats, std::map<std::string, uint64_t> &keyOffsetMap, const std::string &telemNodeDir, uint64_t telemOffset) {
uint32_t rxCounterLsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_rx_bytecount_lsb", telemOffset, rxCounterLsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint32_t rxCounterMsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_rx_bytecount_msb", telemOffset, rxCounterMsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint64_t rxCounter = PACK_INTO_64BIT(rxCounterMsb, rxCounterLsb);
uint32_t txCounterLsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_tx_bytecount_lsb", telemOffset, txCounterLsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint32_t txCounterMsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_tx_bytecount_msb", telemOffset, txCounterMsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint64_t txCounter = PACK_INTO_64BIT(txCounterMsb, txCounterLsb);
uint32_t rxPacketCounterLsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_rx_pktcount_lsb", telemOffset, rxPacketCounterLsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint32_t rxPacketCounterMsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_rx_pktcount_msb", telemOffset, rxPacketCounterMsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint64_t rxPacketCounter = PACK_INTO_64BIT(rxPacketCounterMsb, rxPacketCounterLsb);
uint32_t txPacketCounterLsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_tx_pktcount_lsb", telemOffset, txPacketCounterLsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint32_t txPacketCounterMsb = 0;
if (!PlatformMonitoringTech::readValue(keyOffsetMap, telemNodeDir, "reg_PCIESS_tx_pktcount_msb", telemOffset, txPacketCounterMsb)) {
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
uint64_t txPacketCounter = PACK_INTO_64BIT(txPacketCounterMsb, txPacketCounterLsb);
pStats->speed.gen = -1;
pStats->speed.width = -1;
pStats->speed.maxBandwidth = -1;
pStats->replayCounter = 0;
pStats->rxCounter = rxCounter;
pStats->txCounter = txCounter;
pStats->packetCounter = rxPacketCounter + txPacketCounter;
pStats->timestamp = SysmanDevice::getSysmanTimestamp();
return ZE_RESULT_SUCCESS;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) {
std::string &rootPath = pLinuxSysmanImp->getPciRootPath();
std::map<uint32_t, std::string> telemNodes;
NEO::PmtUtil::getTelemNodesInPciPath(std::string_view(rootPath), telemNodes);
if (telemNodes.empty()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
for (auto it : telemNodes) {
std::string telemNodeDir = it.second;
std::array<char, NEO::PmtUtil::guidStringSize> guidString = {};
if (!NEO::PmtUtil::readGuid(telemNodeDir, guidString)) {
continue;
}
auto keyOffsetMapIterator = guidToKeyOffsetMap.find(guidString.data());
if (keyOffsetMapIterator == guidToKeyOffsetMap.end()) {
continue;
}
uint64_t telemOffset = 0;
if (!NEO::PmtUtil::readOffset(telemNodeDir, telemOffset)) {
break;
}
result = getPciStatsValues(pStats, keyOffsetMapIterator->second, telemNodeDir, telemOffset);
if (result == ZE_RESULT_SUCCESS) {
break;
}
}
return result;
};
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

1
level_zero/sysman/source/sysman_const.h
View File

@ -81,6 +81,7 @@ constexpr int32_t memoryBusWidth = 128; // bus width in bytes
constexpr int32_t numMemoryChannels = 8;
constexpr uint32_t unknownMemoryType = UINT32_MAX;
#define BITS(x, at, width) (((x) >> (at)) & ((1 << (width)) - 1))
#define PACK_INTO_64BIT(msb, lsb) ((static_cast<uint64_t>(msb) << 32) | static_cast<uint64_t>(lsb))
const std::map<std::string, zes_engine_type_flag_t> sysfsEngineMapToLevel0EngineType = {
{"rcs", ZES_ENGINE_TYPE_FLAG_RENDER},

5
level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h
View File

@ -28,6 +28,11 @@ struct MockSysmanProductHelper : public L0::Sysman::SysmanProductHelperHw<IGFX_U
ADDMETHOD_NOBASE(isFrequencySetRangeSupported, bool, false, ());
ADDMETHOD_NOBASE(isPowerSetLimitSupported, bool, false, ());
ADDMETHOD_NOBASE(isUpstreamPortConnected, bool, true, ());
ze_result_t mockGetPciStatsResult = ZE_RESULT_SUCCESS;
ze_result_t getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) override {
return mockGetPciStatsResult;
}
};
} // namespace ult

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

@ -7,6 +7,7 @@
#include "level_zero/sysman/source/api/pci/sysman_pci_utils.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h"
#include "level_zero/sysman/test/unit_tests/sources/pci/linux/mock_sysfs_pci.h"
#include <string>
@ -607,9 +608,33 @@ TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStateThenV
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDevicePciGetState(device, &state));
}
TEST_F(ZesPciFixture, GivenValidSysmanHandleWhenCallingzetSysmanPciGetStatsThenVerifyzetSysmanPciGetStatsCallReturnNotSupported) {
TEST_F(ZesPciFixture, GivenValidLinuxPciImpInstanceAndGetPciStatsFailsFromSysmanProductHelperWhenGetStatsIsCalledThenCallFails) {
std::unique_ptr<MockSysmanProductHelper> pMockSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
pMockSysmanProductHelper->mockGetPciStatsResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
std::unique_ptr<PublicLinuxPciImp> pMockLinuxPciImp = std::make_unique<PublicLinuxPciImp>(pOsSysman);
pLinuxSysmanImp->pSysmanProductHelper = std::move(pMockSysmanProductHelper);
auto pOsPciPrev = pPciImp->pOsPci;
pPciImp->pOsPci = pMockLinuxPciImp.get();
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDevicePciGetStats(device, &stats));
pPciImp->pOsPci = pOsPciPrev;
}
TEST_F(ZesPciFixture, GivenValidLinuxPciImpInstanceWhenGetStatsIsCalledThenCallSucceeds) {
std::unique_ptr<SysmanProductHelper> pMockSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
std::unique_ptr<PublicLinuxPciImp> pMockLinuxPciImp = std::make_unique<PublicLinuxPciImp>(pOsSysman);
pLinuxSysmanImp->pSysmanProductHelper = std::move(pMockSysmanProductHelper);
auto pOsPciPrev = pPciImp->pOsPci;
pPciImp->pOsPci = pMockLinuxPciImp.get();
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDevicePciGetStats(device, &stats));
pPciImp->pOsPci = pOsPciPrev;
}
TEST_F(ZesPciFixture, WhenConvertingLinkSpeedThenResultIsCorrect) {

1
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt
View File

@ -16,6 +16,7 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_power_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_pmt_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_device_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_pci_tests.cpp
)
endif()
add_subdirectories()

249
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pci_tests.cpp Normal file
View File

@ -0,0 +1,249 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#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"
namespace L0 {
namespace Sysman {
namespace ult {
const std::string telem1NodePath("/sys/class/intel_pmt/telem1");
const std::string telem2NodePath("/sys/class/intel_pmt/telem2");
const std::string telem3NodePath("/sys/class/intel_pmt/telem3");
const std::string telem4NodePath("/sys/class/intel_pmt/telem4");
const std::string mockValidGuid("0x5e2F8210");
const std::string telem3OffsetString = "10";
const std::string telem3GuidFile = "/sys/class/intel_pmt/telem3/guid";
const std::string telem3OffsetFile = "/sys/class/intel_pmt/telem3/offset";
const std::string telem3TelemFile = "/sys/class/intel_pmt/telem3/telem";
const std::unordered_map<std::string, int> telem3FileAndFdMap = {{telem3GuidFile, 1},
{telem3OffsetFile, 2},
{telem3TelemFile, 3}};
constexpr uint64_t telem3OffsetValue = 10;
constexpr uint64_t mockRxCounterLsbOffset = telem3OffsetValue + 70;
constexpr uint64_t mockRxCounterMsbOffset = telem3OffsetValue + 69;
constexpr uint64_t mockTxCounterLsbOffset = telem3OffsetValue + 72;
constexpr uint64_t mockTxCounterMsbOffset = telem3OffsetValue + 71;
constexpr uint64_t mockRxPacketCounterLsbOffset = telem3OffsetValue + 74;
constexpr uint64_t mockRxPacketCounterMsbOffset = telem3OffsetValue + 73;
constexpr uint64_t mockTxPacketCounterLsbOffset = telem3OffsetValue + 76;
constexpr uint64_t mockTxPacketCounterMsbOffset = telem3OffsetValue + 75;
constexpr uint32_t mockRxCounterLsb = 0xA2u;
constexpr uint32_t mockRxCounterMsb = 0xF5u;
constexpr uint32_t mockTxCounterLsb = 0xCDu;
constexpr uint32_t mockTxCounterMsb = 0xABu;
constexpr uint32_t mockRxPacketCounterLsb = 0xA0u;
constexpr uint32_t mockRxPacketCounterMsb = 0xBCu;
constexpr uint32_t mockTxPacketCounterLsb = 0xFAu;
constexpr uint32_t mockTxPacketCounterMsb = 0xFFu;
using SysmanProductHelperPciTest = SysmanDeviceFixture;
using IsNotBMG = IsNotWithinProducts<IGFX_BMG, IGFX_BMG>;
static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) {
std::map<std::string, std::string> fileNameLinkMap = {
{telem1NodePath, "../../devices/pci0000:00/0000:00:0a.0/intel-vsec.telemetry.0/intel_pmt/telem1/"},
{telem2NodePath, "../../devices/pci0000:00/0000:00:0a.0/intel-vsec.telemetry.0/intel_pmt/telem2/"},
{telem3NodePath, "../../devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0/intel-vsec.telemetry.1/intel_pmt/telem3/"},
{telem4NodePath, "../../devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0/intel-vsec.telemetry.1/intel_pmt/telem4/"},
};
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 int mockOpenSuccess(const char *pathname, int flags) {
std::string strPathName(pathname);
if (telem3FileAndFdMap.find(strPathName) != telem3FileAndFdMap.end()) {
return telem3FileAndFdMap.at(strPathName);
}
return -1;
}
static ssize_t mockPreadSuccess(int fd, void *buf, size_t count, off_t offset) {
if (fd == telem3FileAndFdMap.at(telem3GuidFile)) {
memcpy(buf, mockValidGuid.data(), count);
} else if (fd == telem3FileAndFdMap.at(telem3OffsetFile)) {
memcpy(buf, telem3OffsetString.data(), count);
} else if (fd == telem3FileAndFdMap.at(telem3TelemFile)) {
switch (offset) {
case mockRxCounterLsbOffset:
memcpy(buf, &mockRxCounterLsb, count);
break;
case mockRxCounterMsbOffset:
memcpy(buf, &mockRxCounterMsb, count);
break;
case mockTxCounterLsbOffset:
memcpy(buf, &mockTxCounterLsb, count);
break;
case mockTxCounterMsbOffset:
memcpy(buf, &mockTxCounterMsb, count);
break;
case mockRxPacketCounterLsbOffset:
memcpy(buf, &mockRxPacketCounterLsb, count);
break;
case mockRxPacketCounterMsbOffset:
memcpy(buf, &mockRxPacketCounterMsb, count);
break;
case mockTxPacketCounterLsbOffset:
memcpy(buf, &mockTxPacketCounterLsb, count);
break;
case mockTxPacketCounterMsbOffset:
memcpy(buf, &mockTxPacketCounterMsb, count);
break;
}
}
return count;
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndTelemNodesAreNotAvailableThenCallFails, IsBMG) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndReadGuidFromPmtUtilFailsThenCallFails, IsBMG) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndGuidIsNotPresentInGuidToKeyOffsetMapThenCallFails, IsBMG) {
static std::string dummyGuid("dummyGuid");
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 {
if (fd == telem3FileAndFdMap.at(telem3GuidFile)) {
memcpy(buf, dummyGuid.data(), count);
}
return count;
});
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndReadOffsetFromPmtUtilFailsDueToPreadSysCallThenCallFails, IsBMG) {
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 {
if (fd == telem3FileAndFdMap.at(telem3GuidFile)) {
memcpy(buf, mockValidGuid.data(), count);
} else if (fd == telem3FileAndFdMap.at(telem3OffsetFile)) {
count = -1;
}
return count;
});
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndTelemFileIsNotAvailableThenCallFails, IsBMG) {
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &mockPreadSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
std::string strPathName(pathname);
if (strPathName == telem3TelemFile) {
return -1;
}
return (telem3FileAndFdMap.find(strPathName) != telem3FileAndFdMap.end()) ? telem3FileAndFdMap.at(strPathName) : -1;
});
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledAndReadValueFromPmtUtilFailsThenCallFails, IsBMG) {
static int readFailCount = 1;
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 {
if (fd == telem3FileAndFdMap.at(telem3GuidFile)) {
memcpy(buf, mockValidGuid.data(), count);
} else if (fd == telem3FileAndFdMap.at(telem3OffsetFile)) {
memcpy(buf, telem3OffsetString.data(), count);
} else if (fd == telem3FileAndFdMap.at(telem3TelemFile)) {
switch (offset) {
case mockRxCounterLsbOffset:
count = (readFailCount == 1) ? -1 : sizeof(uint32_t);
break;
case mockRxCounterMsbOffset:
count = (readFailCount == 2) ? -1 : sizeof(uint32_t);
break;
case mockTxCounterLsbOffset:
count = (readFailCount == 3) ? -1 : sizeof(uint32_t);
break;
case mockTxCounterMsbOffset:
count = (readFailCount == 4) ? -1 : sizeof(uint32_t);
break;
case mockRxPacketCounterLsbOffset:
count = (readFailCount == 5) ? -1 : sizeof(uint32_t);
break;
case mockRxPacketCounterMsbOffset:
count = (readFailCount == 6) ? -1 : sizeof(uint32_t);
break;
case mockTxPacketCounterLsbOffset:
count = (readFailCount == 7) ? -1 : sizeof(uint32_t);
break;
case mockTxPacketCounterMsbOffset:
count = (readFailCount == 8) ? -1 : sizeof(uint32_t);
break;
}
}
return count;
});
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
while (readFailCount <= 8) {
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
readFailCount++;
}
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledThenCallSucceeds, IsBMG) {
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, &mockPreadSuccess);
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_SUCCESS, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
uint64_t mockRxCounter = PACK_INTO_64BIT(mockRxCounterMsb, mockRxCounterLsb);
EXPECT_EQ(mockRxCounter, stats.rxCounter);
uint64_t mockTxCounter = PACK_INTO_64BIT(mockTxCounterMsb, mockTxCounterLsb);
EXPECT_EQ(mockTxCounter, stats.txCounter);
uint64_t mockRxPacketCounter = PACK_INTO_64BIT(mockRxPacketCounterMsb, mockRxPacketCounterLsb);
uint64_t mockTxPacketCounter = PACK_INTO_64BIT(mockTxPacketCounterMsb, mockTxPacketCounterLsb);
EXPECT_EQ(mockRxPacketCounter + mockTxPacketCounter, stats.packetCounter);
}
HWTEST2_F(SysmanProductHelperPciTest, GivenSysmanProductHelperInstanceWhenGetPciStatsIsCalledThenCallFails, IsNotBMG) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_pci_stats_t stats;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pSysmanProductHelper->getPciStats(&stats, pLinuxSysmanImp));
}
} // namespace ult
} // namespace Sysman
} // namespace L0

60
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp
View File

@ -13,39 +13,13 @@ namespace L0 {
namespace Sysman {
namespace ult {
const std::map<std::string, std::map<std::string, uint64_t>> mockDg1GuidToKeyOffsetMap = {{"0x490e01",
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68}}}};
const std::map<std::string, std::map<std::string, uint64_t>> mockDg2GuidToKeyOffsetMap = {{"0x4f95",
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}};
const std::map<std::string, std::map<std::string, uint64_t>> mockPvcGuidToKeyOffsetMap = {{"0xb15a0edc",
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44}}}};
using IsUnknown = IsProduct<IGFX_UNKNOWN>;
class SysmanProductHelperPmtTest : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
device = pSysmanDeviceImp;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
pLinuxSysmanImp->pSysmanProductHelper = std::move(pSysmanProductHelper);
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
}
};
using SysmanProductHelperPmtTest = ::testing::Test;
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsDG1) {
const std::map<std::string, std::map<std::string, uint64_t>> mockDg1GuidToKeyOffsetMap = {{"0x490e01",
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68}}}};
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
@ -54,6 +28,10 @@ HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGui
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsDG2) {
const std::map<std::string, std::map<std::string, uint64_t>> mockDg2GuidToKeyOffsetMap = {{"0x4f95",
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}};
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
@ -62,6 +40,12 @@ HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGui
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsPVC) {
const std::map<std::string, std::map<std::string, uint64_t>> mockPvcGuidToKeyOffsetMap = {{"0xb15a0edc",
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44}}}};
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
@ -71,7 +55,19 @@ HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGui
EXPECT_EQ(mockPvcGuidToKeyOffsetMap.at("0xb15a0edc").at("TileMaxTemperature"), (*pGuidToKeyOffsetMap).at("0xb15a0edc").at("TileMaxTemperature"));
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledForUnsupportedProductThenNullptrIsReturned, IsUnknown) {
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsBMG) {
const std::map<std::string, std::map<std::string, uint64_t>> mockBmgGuidToKeyOffsetMap = {{"0x5e2F8210",
{{"reg_PCIESS_rx_bytecount_lsb", 70},
{"reg_PCIESS_tx_bytecount_msb", 71}}}};
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
EXPECT_EQ(mockBmgGuidToKeyOffsetMap.at("0x5e2F8210").at("reg_PCIESS_rx_bytecount_lsb"), (*pGuidToKeyOffsetMap).at("0x5e2F8210").at("reg_PCIESS_rx_bytecount_lsb"));
EXPECT_EQ(mockBmgGuidToKeyOffsetMap.at("0x5e2F8210").at("reg_PCIESS_tx_bytecount_msb"), (*pGuidToKeyOffsetMap).at("0x5e2F8210").at("reg_PCIESS_tx_bytecount_msb"));
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledForUnsupportedProductThenNullptrIsReturned, IsCFL) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_EQ(nullptr, pGuidToKeyOffsetMap);