diff --git a/level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.cpp b/level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.cpp index 0df354e916..ef264b4882 100644 --- a/level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.cpp +++ b/level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.cpp @@ -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 &configMem) { diff --git a/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp b/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp index 2e52a93398..cca8c92eb6 100644 --- a/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp +++ b/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp @@ -255,6 +255,7 @@ bool PlatformMonitoringTech::readValue(const std::map 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 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; diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h index 3788364989..f559552460 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h +++ b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h @@ -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> *getGuidToKeyOffsetMap() = 0; diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h index a6089d4efb..ca35632cb4 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h +++ b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h @@ -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> *getGuidToKeyOffsetMap() override; diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl index 63fdd7440e..52bee240ec 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl +++ b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl @@ -301,5 +301,10 @@ bool SysmanProductHelperHw::isUpstreamPortConnected() { return false; } +template +ze_result_t SysmanProductHelperHw::getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +}; + } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp index 8419ec6c76..fd23c79cb3 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp +++ b/level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp @@ -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> 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> *SysmanProductHelperHw::getGuidToKeyOffsetMap() { + return &guidToKeyOffsetMap; +} + template <> RasInterfaceType SysmanProductHelperHw::getGtRasUtilInterface() { return RasInterfaceType::netlink; @@ -29,6 +47,104 @@ bool SysmanProductHelperHw::isUpstreamPortConnected() { return true; } +static ze_result_t getPciStatsValues(zes_pci_stats_t *pStats, std::map &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::getPciStats(zes_pci_stats_t *pStats, LinuxSysmanImp *pLinuxSysmanImp) { + std::string &rootPath = pLinuxSysmanImp->getPciRootPath(); + std::map 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 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; } // namespace Sysman diff --git a/level_zero/sysman/source/sysman_const.h b/level_zero/sysman/source/sysman_const.h index 33e8b3dcd8..769e1facc8 100644 --- a/level_zero/sysman/source/sysman_const.h +++ b/level_zero/sysman/source/sysman_const.h @@ -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(msb) << 32) | static_cast(lsb)) const std::map sysfsEngineMapToLevel0EngineType = { {"rcs", ZES_ENGINE_TYPE_FLAG_RENDER}, diff --git a/level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h b/level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h index 6adb422fb7..4b41749125 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h +++ b/level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h @@ -28,6 +28,11 @@ struct MockSysmanProductHelper : public L0::Sysman::SysmanProductHelperHw @@ -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 pMockSysmanProductHelper = std::make_unique(); + pMockSysmanProductHelper->mockGetPciStatsResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + std::unique_ptr pMockLinuxPciImp = std::make_unique(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 pMockSysmanProductHelper = std::make_unique(); + std::unique_ptr pMockLinuxPciImp = std::make_unique(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) { diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt index 4cae1cab10..7b27036a4e 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/CMakeLists.txt @@ -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() \ No newline at end of file diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pci_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pci_tests.cpp new file mode 100644 index 0000000000..a0f99f4539 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pci_tests.cpp @@ -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 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; + +static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) { + std::map 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(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 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 mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup 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 mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup 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 mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockPreadSuccess); + VariableBackup 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 mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup 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 mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup 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 \ No newline at end of file diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp index 872df7470b..759a68fef2 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp @@ -13,39 +13,13 @@ namespace L0 { namespace Sysman { namespace ult { -const std::map> mockDg1GuidToKeyOffsetMap = {{"0x490e01", - {{"PACKAGE_ENERGY", 0x420}, - {"COMPUTE_TEMPERATURES", 0x68}}}}; - -const std::map> mockDg2GuidToKeyOffsetMap = {{"0x4f95", - {{"PACKAGE_ENERGY", 1032}, - {"SOC_TEMPERATURES", 56}}}}; - -const std::map> mockPvcGuidToKeyOffsetMap = {{"0xb15a0edc", - {{"HBM0MaxDeviceTemperature", 28}, - {"HBM1MaxDeviceTemperature", 36}, - {"TileMinTemperature", 40}, - {"TileMaxTemperature", 44}}}}; - -using IsUnknown = IsProduct; - -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> 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> 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> 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> 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);