From 0dacb78d78636d0dba8225cead3e9d95f72e53b7 Mon Sep 17 00:00:00 2001 From: Pratik Bari Date: Tue, 23 Jul 2024 12:44:12 +0000 Subject: [PATCH] refactor(sysman): Remove Pmt tile aggregator from Memory Module The PMT tile aggregator used in the memory module has been replaced with the wrapper functions which calls the functions from Pmt Util class. Related-To: NEO-11992 Signed-off-by: Pratik Bari --- .../api/memory/linux/sysman_os_memory_imp.cpp | 9 +- .../api/memory/linux/sysman_os_memory_imp.h | 2 - .../source/shared/linux/pmt/sysman_pmt.cpp | 68 +- .../source/shared/linux/pmt/sysman_pmt.h | 6 +- .../product_helper/sysman_product_helper.h | 2 +- .../product_helper/sysman_product_helper_hw.h | 2 +- .../sysman_product_helper_hw.inl | 2 +- .../pvc/sysman_product_helper_pvc.cpp | 109 ++- .../dg2/sysman_product_helper_dg2.cpp | 29 +- .../source/shared/linux/zes_os_sysman_imp.cpp | 26 + .../source/shared/linux/zes_os_sysman_imp.h | 6 + .../sources/memory/linux/mock_memory.h | 274 ++---- .../memory/linux/test_sysman_memory.cpp | 365 ++++++-- .../sysman_product_helper_memory_tests.cpp | 808 +++++++++++++++--- 14 files changed, 1183 insertions(+), 525 deletions(-) diff --git a/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.cpp b/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.cpp index daa7524317..2025433dd1 100644 --- a/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.cpp +++ b/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.cpp @@ -16,7 +16,6 @@ #include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h" #include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h" -#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h" #include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h" #include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h" @@ -29,19 +28,14 @@ ze_result_t LinuxMemoryImp::getProperties(zes_mem_properties_t *pProperties) { } ze_result_t LinuxMemoryImp::getBandwidth(zes_mem_bandwidth_t *pBandwidth) { - if (pPmt == nullptr) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); - return pSysmanProductHelper->getMemoryBandwidth(pBandwidth, pPmt, pDevice, pSysmanKmdInterface, subdeviceId); + return pSysmanProductHelper->getMemoryBandwidth(pBandwidth, pLinuxSysmanImp, subdeviceId); } ze_result_t LinuxMemoryImp::getState(zes_mem_state_t *pState) { ze_result_t status = ZE_RESULT_SUCCESS; pState->health = ZES_MEM_HEALTH_UNKNOWN; FirmwareUtil *pFwInterface = pLinuxSysmanImp->getFwUtilInterface(); - // get memory health indicator if supported auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); pSysmanProductHelper->getMemoryHealthIndicator(pFwInterface, &pState->health); @@ -70,7 +64,6 @@ LinuxMemoryImp::LinuxMemoryImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint3 pLinuxSysmanImp = static_cast(pOsSysman); pDrm = pLinuxSysmanImp->getDrm(); pDevice = pLinuxSysmanImp->getSysmanDeviceImp(); - pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId); pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface(); } diff --git a/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.h b/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.h index b40b2b0659..51a3d725d7 100644 --- a/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.h +++ b/level_zero/sysman/source/api/memory/linux/sysman_os_memory_imp.h @@ -19,7 +19,6 @@ class Drm; namespace L0 { namespace Sysman { -class PlatformMonitoringTech; class LinuxSysmanImp; class SysmanKmdInterface; struct SysmanDeviceImp; @@ -38,7 +37,6 @@ class LinuxMemoryImp : public OsMemory, NEO::NonCopyableOrMovableClass { LinuxSysmanImp *pLinuxSysmanImp = nullptr; NEO::Drm *pDrm = nullptr; SysmanDeviceImp *pDevice = nullptr; - PlatformMonitoringTech *pPmt = nullptr; SysmanKmdInterface *pSysmanKmdInterface = nullptr; private: 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 c9bde48006..0c4818bdda 100644 --- a/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp +++ b/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.cpp @@ -27,10 +27,6 @@ const std::string PlatformMonitoringTech::baseTelemSysFS("/sys/class/intel_pmt") const std::string PlatformMonitoringTech::telem("telem"); uint32_t PlatformMonitoringTech::rootDeviceTelemNodeIndex = 0; -std::string PlatformMonitoringTech::getGuid() { - return guid; -} - ze_result_t PlatformMonitoringTech::readValue(const std::string key, uint32_t &value) { auto offset = keyOffsetMap.find(key); if (offset == keyOffsetMap.end()) { @@ -148,7 +144,7 @@ ze_result_t PlatformMonitoringTech::init(LinuxSysmanImp *pLinuxSysmanImp, const return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; } - std::string guid; + std::string guid = ""; std::string guidPath = baseTelemSysFSNode + std::string("/guid"); ze_result_t result = pFsAccess->read(guidPath, guid); if (ZE_RESULT_SUCCESS != result) { @@ -248,6 +244,68 @@ bool PlatformMonitoringTech::getTelemOffsetForContainer(SysmanProductHelper *pSy return false; } +bool PlatformMonitoringTech::getTelemNodes(LinuxSysmanImp *pLinuxSysmanImp, std::map &telemNodes) { + std::string &rootPath = pLinuxSysmanImp->getPciRootPath(); + + if (!pLinuxSysmanImp->getTelemNodes(telemNodes)) { + NEO::PmtUtil::getTelemNodesInPciPath(std::string_view(rootPath), telemNodes); + pLinuxSysmanImp->addTelemNodes(telemNodes); + } + uint32_t deviceCount = pLinuxSysmanImp->getSubDeviceCount() + 1; + if (telemNodes.size() < deviceCount) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Number of telemetry nodes:%d is less than device count: %d \n", __FUNCTION__, telemNodes.size(), deviceCount); + return false; + } + return true; +} + +bool PlatformMonitoringTech::getTelemOffsetAndTelemDirForTileAggregator(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &telemOffset, std::string &telemDir, uint32_t subdeviceId) { + + std::map telemNodesInPciPath; + if (!getTelemNodes(pLinuxSysmanImp, telemNodesInPciPath)) { + return false; + } + + uint32_t rootDeviceTelemIndex = telemNodesInPciPath.begin()->first; + std::string telemNode = telem + std::to_string(rootDeviceTelemIndex + subdeviceId + 1); + telemDir = baseTelemSysFS + "/" + telemNode; + if (!NEO::PmtUtil::readOffset(telemDir, telemOffset)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read offset from %s\n", __FUNCTION__, telemDir.c_str()); + return false; + } + return true; +} + +bool PlatformMonitoringTech::readValue(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset, uint32_t &value) { + + uint64_t keyOffset = 0; + if (!getTelemOffsetForContainer(pSysmanProductHelper, telemDir, key, keyOffset)) { + return false; + } + + keyOffset += telemOffset; + ssize_t bytesRead = NEO::PmtUtil::readTelem(telemDir.data(), sizeof(uint32_t), keyOffset, &value); + if (bytesRead != sizeof(uint32_t)) { + return false; + } + return true; +} + +bool PlatformMonitoringTech::readValue(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset, uint64_t &value) { + + uint64_t keyOffset = 0; + if (!getTelemOffsetForContainer(pSysmanProductHelper, telemDir, key, keyOffset)) { + return false; + } + + keyOffset += telemOffset; + ssize_t bytesRead = NEO::PmtUtil::readTelem(telemDir.data(), sizeof(uint64_t), keyOffset, &value); + if (bytesRead != sizeof(uint64_t)) { + return false; + } + return true; +} + PlatformMonitoringTech::~PlatformMonitoringTech() { } diff --git a/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h b/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h index 02a249f4e3..d1445b3e22 100644 --- a/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h +++ b/level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h @@ -30,19 +30,21 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass { virtual ze_result_t readValue(const std::string key, uint32_t &value); virtual ze_result_t readValue(const std::string key, uint64_t &value); - std::string getGuid(); static ze_result_t enumerateRootTelemIndex(FsAccessInterface *pFsAccess, std::string &gpuUpstreamPortPath); static void create(LinuxSysmanImp *pLinuxSysmanImp, std::string &gpuUpstreamPortPath, std::map &mapOfSubDeviceIdToPmtObject); static ze_result_t getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map &keyOffsetMap); static bool getTelemOffsetAndTelemDir(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &telemOffset, std::string &telemDir); + static bool getTelemOffsetAndTelemDirForTileAggregator(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &telemOffset, std::string &telemDir, uint32_t subdeviceId); static bool getTelemOffsetForContainer(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset); + static bool getTelemNodes(LinuxSysmanImp *pLinuxSysmanImp, std::map &telemNodes); + static bool readValue(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset, uint32_t &value); + static bool readValue(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset, uint64_t &value); protected: static uint32_t rootDeviceTelemNodeIndex; std::string telemetryDeviceEntry{}; std::map keyOffsetMap; - std::string guid; ze_result_t init(LinuxSysmanImp *pLinuxSysmanImp, const std::string &gpuUpstreamPortPath); static void doInitPmtObject(LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath, std::map &mapOfSubDeviceIdToPmtObject); 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 ca6d3be7a8..9032d3c57a 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 @@ -53,7 +53,7 @@ class SysmanProductHelper { // Memory virtual ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) = 0; - virtual ze_result_t getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) = 0; + virtual ze_result_t getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) = 0; virtual void getMemoryHealthIndicator(FirmwareUtil *pFwInterface, zes_mem_health_t *health) = 0; // Performance 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 f8c5998478..7bbe95000c 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 @@ -28,7 +28,7 @@ class SysmanProductHelperHw : public SysmanProductHelper { // Memory ze_result_t getMemoryProperties(zes_mem_properties_t *pProperties, LinuxSysmanImp *pLinuxSysmanImp, NEO::Drm *pDrm, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subDeviceId, bool isSubdevice) override; - ze_result_t getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) override; + ze_result_t getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) override; void getMemoryHealthIndicator(FirmwareUtil *pFwInterface, zes_mem_health_t *health) override; // Performance 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 045c9485b7..c1f172d7a3 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 @@ -93,7 +93,7 @@ ze_result_t SysmanProductHelperHw::getMemoryProperties(zes_mem_prope } template -ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) { +ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } diff --git a/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp b/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp index 3c6a92a320..b3fb3d6182 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp +++ b/level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.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" #include "level_zero/sysman/source/sysman_const.h" @@ -145,21 +147,19 @@ void getHBMFrequency(SysmanKmdInterface *pSysmanKmdInterface, SysFsAccessInterfa } } -ze_result_t getVFIDString(std::string &vfID, PlatformMonitoringTech *pPmt) { +ze_result_t getVFIDString(SysmanProductHelper *pSysmanProductHelper, std::string &vfID, std::string telemDir, uint64_t telemOffset) { uint32_t vf0VfIdVal = 0; std::string key = "VF0_VFID"; - auto result = pPmt->readValue(key, vf0VfIdVal); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for VF0_VFID is returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, key, telemOffset, vf0VfIdVal)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for VF0_VFID is returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } uint32_t vf1VfIdVal = 0; key = "VF1_VFID"; - result = pPmt->readValue(key, vf1VfIdVal); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for VF1_VFID is returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, key, telemOffset, vf1VfIdVal)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for VF1_VFID is returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } if (((vf0VfIdVal == 0) && (vf1VfIdVal == 0)) || @@ -174,17 +174,19 @@ ze_result_t getVFIDString(std::string &vfID, PlatformMonitoringTech *pPmt) { if (vf1VfIdVal > 0) { vfID = "VF1"; } - return result; + return ZE_RESULT_SUCCESS; } -ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanKmdInterface *pSysmanKmdInterface, SysFsAccessInterface *pSysFsAccess, uint32_t subdeviceId, unsigned short stepping) { +ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, std::string telemDir, uint64_t telemOffset, uint32_t subdeviceId, unsigned short stepping) { + pBandwidth->readCounter = 0; pBandwidth->writeCounter = 0; pBandwidth->timestamp = 0; pBandwidth->maxBandwidth = 0; ze_result_t result = ZE_RESULT_ERROR_UNKNOWN; std::string vfId = ""; - result = getVFIDString(vfId, pPmt); + auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); + result = getVFIDString(pSysmanProductHelper, vfId, telemDir, telemOffset); if (result != ZE_RESULT_SUCCESS) { NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():getVFIDString returning error:0x%x while retriving VFID string \n", __FUNCTION__, result); return result; @@ -193,19 +195,17 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT for (auto hbmModuleIndex = 0u; hbmModuleIndex < numHbmModules; hbmModuleIndex++) { uint32_t counterValue = 0; std::string readCounterKey = vfId + "_HBM" + std::to_string(hbmModuleIndex) + "_READ"; - result = pPmt->readValue(readCounterKey, counterValue); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterKey returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, readCounterKey, telemOffset, counterValue)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterKey returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } pBandwidth->readCounter += counterValue; counterValue = 0; std::string writeCounterKey = vfId + "_HBM" + std::to_string(hbmModuleIndex) + "_WRITE"; - result = pPmt->readValue(writeCounterKey, counterValue); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterKey returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, writeCounterKey, telemOffset, counterValue)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterKey returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } pBandwidth->writeCounter += counterValue; } @@ -216,21 +216,38 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT pBandwidth->timestamp = SysmanDevice::getSysmanTimestamp(); uint64_t hbmFrequency = 0; + auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface(); + auto pSysFsAccess = pSysmanKmdInterface->getSysFsAccess(); getHBMFrequency(pSysmanKmdInterface, pSysFsAccess, hbmFrequency, subdeviceId, stepping); - pBandwidth->maxBandwidth = memoryBusWidth * hbmFrequency * numHbmModules; - return result; + return ZE_RESULT_SUCCESS; } -ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) { - auto pSysFsAccess = pSysmanKmdInterface->getSysFsAccess(); +ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) { + + auto pDevice = pLinuxSysmanImp->getSysmanDeviceImp(); auto &hwInfo = pDevice->getHardwareInfo(); auto &productHelper = pDevice->getRootDeviceEnvironment().getHelper(); auto stepping = productHelper.getSteppingFromHwRevId(hwInfo); + std::string telemDir = ""; + uint64_t telemOffset = 0; - std::string guid = pPmt->getGuid(); + if (!pLinuxSysmanImp->getTelemOffsetAndDir(subdeviceId, telemOffset, telemDir)) { + if (!PlatformMonitoringTech::getTelemOffsetAndTelemDirForTileAggregator(pLinuxSysmanImp, telemOffset, telemDir, subdeviceId)) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + pLinuxSysmanImp->addTelemOffsetAndDirPair(subdeviceId, std::make_pair(telemOffset, telemDir)); + } + + std::array guidString = {}; + if (!NEO::PmtUtil::readGuid(telemDir, guidString)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Failed to read GUID from %s \n", __FUNCTION__, telemDir.c_str()); + return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; + } + + std::string guid = guidString.data(); if (guid != guid64BitMemoryCounters) { - return getHBMBandwidth(pBandwidth, pPmt, pSysmanKmdInterface, pSysFsAccess, subdeviceId, stepping); + return getHBMBandwidth(pBandwidth, pLinuxSysmanImp, telemDir, telemOffset, subdeviceId, stepping); } pBandwidth->readCounter = 0; @@ -241,7 +258,8 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT ze_result_t result = ZE_RESULT_ERROR_UNKNOWN; std::string vfId = ""; - result = getVFIDString(vfId, pPmt); + auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); + result = getVFIDString(pSysmanProductHelper, vfId, telemDir, telemOffset); if (result != ZE_RESULT_SUCCESS) { NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():getVFIDString returning error:0x%x while retriving VFID string \n", __FUNCTION__, result); return result; @@ -249,18 +267,16 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT uint32_t readCounterL = 0; std::string readCounterKey = vfId + "_HBM_READ_L"; - result = pPmt->readValue(readCounterKey, readCounterL); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterL returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, readCounterKey, telemOffset, readCounterL)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterL returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } uint32_t readCounterH = 0; readCounterKey = vfId + "_HBM_READ_H"; - result = pPmt->readValue(readCounterKey, readCounterH); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterH returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, readCounterKey, telemOffset, readCounterH)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterH returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } constexpr uint64_t transactionSize = 32; @@ -270,18 +286,16 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT uint32_t writeCounterL = 0; std::string writeCounterKey = vfId + "_HBM_WRITE_L"; - result = pPmt->readValue(writeCounterKey, writeCounterL); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterL returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, writeCounterKey, telemOffset, writeCounterL)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterL returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } uint32_t writeCounterH = 0; writeCounterKey = vfId + "_HBM_WRITE_H"; - result = pPmt->readValue(writeCounterKey, writeCounterH); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterH returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, writeCounterKey, telemOffset, writeCounterH)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for writeCounterH returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } pBandwidth->writeCounter = writeCounterH; @@ -290,15 +304,16 @@ ze_result_t getHBMBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringT pBandwidth->timestamp = SysmanDevice::getSysmanTimestamp(); uint64_t hbmFrequency = 0; + auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface(); + auto pSysFsAccess = pSysmanKmdInterface->getSysFsAccess(); getHBMFrequency(pSysmanKmdInterface, pSysFsAccess, hbmFrequency, subdeviceId, stepping); - pBandwidth->maxBandwidth = memoryBusWidth * hbmFrequency * numHbmModules; - return result; + return ZE_RESULT_SUCCESS; } template <> -ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) { - return getHBMBandwidth(pBandwidth, pPmt, pDevice, pSysmanKmdInterface, subdeviceId); +ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) { + return getHBMBandwidth(pBandwidth, pLinuxSysmanImp, subdeviceId); } template <> diff --git a/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp b/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp index 3b9bfa0ab7..147872c0bd 100644 --- a/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp +++ b/level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp @@ -137,19 +137,18 @@ const std::map> *SysmanProductHelpe return &guidToKeyOffsetMap; } -ze_result_t readMcChannelCounters(PlatformMonitoringTech *pPmt, uint64_t &readCounters, uint64_t &writeCounters) { +ze_result_t readMcChannelCounters(LinuxSysmanImp *pLinuxSysmanImp, uint64_t &readCounters, uint64_t &writeCounters, std::string telemDir, uint64_t telemOffset) { + auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper(); uint32_t numMcChannels = 16u; - ze_result_t result = ZE_RESULT_ERROR_UNKNOWN; std::vector nameOfCounters{"IDI_READS", "IDI_WRITES", "DISPLAY_VC1_READS"}; std::vector counterValues(3, 0); for (uint64_t counterIndex = 0; counterIndex < nameOfCounters.size(); counterIndex++) { for (uint32_t mcChannelIndex = 0; mcChannelIndex < numMcChannels; mcChannelIndex++) { uint64_t val = 0; std::string readCounterKey = nameOfCounters[counterIndex] + "[" + std::to_string(mcChannelIndex) + "]"; - result = pPmt->readValue(readCounterKey, val); - if (result != ZE_RESULT_SUCCESS) { - NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterKey returning error:0x%x \n", __FUNCTION__, result); - return result; + if (!PlatformMonitoringTech::readValue(pSysmanProductHelper, telemDir, readCounterKey, telemOffset, val)) { + NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readValue for readCounterKey returning error:0x%x \n", __FUNCTION__, ZE_RESULT_ERROR_NOT_AVAILABLE); + return ZE_RESULT_ERROR_NOT_AVAILABLE; } counterValues[counterIndex] += val; } @@ -158,18 +157,30 @@ ze_result_t readMcChannelCounters(PlatformMonitoringTech *pPmt, uint64_t &readCo constexpr uint64_t transactionSize = 32; readCounters = (counterValues[0] + counterValues[2]) * transactionSize; writeCounters = (counterValues[1]) * transactionSize; - return result; + return ZE_RESULT_SUCCESS; } template <> -ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) { +ze_result_t SysmanProductHelperHw::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) { + auto pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface(); auto pSysFsAccess = pSysmanKmdInterface->getSysFsAccess(); ze_result_t result = ZE_RESULT_ERROR_UNKNOWN; pBandwidth->readCounter = 0; pBandwidth->writeCounter = 0; pBandwidth->timestamp = 0; pBandwidth->maxBandwidth = 0; - result = readMcChannelCounters(pPmt, pBandwidth->readCounter, pBandwidth->writeCounter); + + std::string telemDir = ""; + uint64_t telemOffset = 0; + + if (!pLinuxSysmanImp->getTelemOffsetAndDir(subdeviceId, telemOffset, telemDir)) { + if (!PlatformMonitoringTech::getTelemOffsetAndTelemDir(pLinuxSysmanImp, telemOffset, telemDir)) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + pLinuxSysmanImp->addTelemOffsetAndDirPair(subdeviceId, std::make_pair(telemOffset, telemDir)); + } + + result = readMcChannelCounters(pLinuxSysmanImp, pBandwidth->readCounter, pBandwidth->writeCounter, telemDir, telemOffset); if (result != ZE_RESULT_SUCCESS) { NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s():readMcChannelCounters returning error:0x%x \n", __FUNCTION__, result); return result; diff --git a/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.cpp b/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.cpp index 7749898b3c..2a8c6e6bcc 100644 --- a/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.cpp +++ b/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.cpp @@ -543,6 +543,32 @@ uint32_t LinuxSysmanImp::getMemoryType() { return memType; } +void LinuxSysmanImp::addTelemOffsetAndDirPair(uint32_t subdeviceId, std::pair pairTelemOffsetAndDir) { + mapOfSubDeviceIdToTelemOffsetAndDirPair[subdeviceId] = pairTelemOffsetAndDir; +} + +bool LinuxSysmanImp::getTelemOffsetAndDir(uint32_t subdeviceId, uint64_t &telemOffset, std::string &telemDir) { + + if (mapOfSubDeviceIdToTelemOffsetAndDirPair.find(subdeviceId) != mapOfSubDeviceIdToTelemOffsetAndDirPair.end()) { + telemOffset = mapOfSubDeviceIdToTelemOffsetAndDirPair[subdeviceId].first; + telemDir = mapOfSubDeviceIdToTelemOffsetAndDirPair[subdeviceId].second; + return true; + } + return false; +} + +void LinuxSysmanImp::addTelemNodes(std::map telemNodes) { + telemNodesInPCIPath = telemNodes; +} + +bool LinuxSysmanImp::getTelemNodes(std::map &telemNodes) { + if (telemNodesInPCIPath.empty()) { + return false; + } + telemNodes = telemNodesInPCIPath; + return true; +} + OsSysman *OsSysman::create(SysmanDeviceImp *pParentSysmanDeviceImp) { LinuxSysmanImp *pLinuxSysmanImp = new LinuxSysmanImp(pParentSysmanDeviceImp); return static_cast(pLinuxSysmanImp); diff --git a/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h b/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h index 9da43bb362..5ce7930851 100644 --- a/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h +++ b/level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h @@ -80,6 +80,10 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass { std::string gtDevicePath; SysmanKmdInterface *getSysmanKmdInterface() { return pSysmanKmdInterface.get(); } static ze_result_t getResult(int err); + void addTelemNodes(std::map telemNodes); + bool getTelemNodes(std::map &telemNodes); + void addTelemOffsetAndDirPair(uint32_t subdeviceId, std::pair pairTelemOffsetAndDir); + bool getTelemOffsetAndDir(uint32_t subdeviceId, uint64_t &telemOffset, std::string &telemDir); protected: std::unique_ptr pSysmanProductHelper; @@ -94,6 +98,8 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass { std::string rootPath; void releaseFwUtilInterface(); uint32_t memType = unknownMemoryType; + std::map> mapOfSubDeviceIdToTelemOffsetAndDirPair; + std::map telemNodesInPCIPath; private: LinuxSysmanImp() = delete; diff --git a/level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory.h b/level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory.h index 989a1f5ed5..a89e764419 100644 --- a/level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory.h +++ b/level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory.h @@ -20,50 +20,74 @@ using namespace NEO; +constexpr uint64_t transactionSize = 32; constexpr uint64_t hbmRP0Frequency = 4200; constexpr uint64_t mockMaxBwDg2 = 1343616u; -constexpr uint32_t vF0HbmLRead = 16; -constexpr uint32_t vF0HbmHRead = 2; -constexpr uint32_t vF0HbmLWrite = 8; -constexpr uint32_t vF0HbmHWrite = 2; -constexpr uint32_t vF1HbmLRead = 16; -constexpr uint32_t vF1HbmHRead = 2; -constexpr uint32_t vF1HbmLWrite = 8; -constexpr uint32_t vF1HbmHWrite = 2; +constexpr uint32_t vFHbmLRead = 16; +constexpr uint32_t vFHbmHRead = 2; +constexpr uint32_t vFHbmLWrite = 8; +constexpr uint32_t vFHbmHWrite = 2; -constexpr uint8_t vF0Hbm0ReadValue = 92; -constexpr uint8_t vF0Hbm0WriteValue = 96; -constexpr uint8_t vF0Hbm1ReadValue = 104; -constexpr uint8_t vF0Hbm1WriteValue = 108; -constexpr uint8_t vF0TimestampLValue = 168; -constexpr uint8_t vF0TimestampHValue = 172; -constexpr uint8_t vF0Hbm2ReadValue = 113; -constexpr uint8_t vF0Hbm2WriteValue = 125; -constexpr uint8_t vF0Hbm3ReadValue = 135; -constexpr uint8_t vF0Hbm3WriteValue = 20; +constexpr uint32_t vF0Vfid = 88; +constexpr uint32_t vF1Vfid = 176; +constexpr uint32_t vF0HbmReadL = 384; +constexpr uint32_t vF0HbmReadH = 388; +constexpr uint32_t vF0HbmWriteL = 392; +constexpr uint32_t vF0HbmWriteH = 396; + +constexpr uint32_t vF1HbmReadL = 400; +constexpr uint32_t vF1HbmReadH = 404; +constexpr uint32_t vF1HbmWriteL = 408; +constexpr uint32_t vF1HbmWriteH = 412; + +constexpr uint32_t vF0Hbm0Read = 92; +constexpr uint32_t vF0Hbm0Write = 96; +constexpr uint32_t vF0Hbm1Read = 104; +constexpr uint32_t vF0Hbm1Write = 108; +constexpr uint32_t vF0Hbm2Read = 312; +constexpr uint32_t vF0Hbm2Write = 316; +constexpr uint32_t vF0Hbm3Read = 328; +constexpr uint32_t vF0Hbm3Write = 332; + +constexpr uint32_t vFHbm0ReadValue = 92; +constexpr uint32_t vFHbm0WriteValue = 96; +constexpr uint32_t vFHbm1ReadValue = 104; +constexpr uint32_t vFHbm1WriteValue = 108; +constexpr uint32_t vFHbm2ReadValue = 113; +constexpr uint32_t vFHbm2WriteValue = 125; +constexpr uint32_t vFHbm3ReadValue = 135; +constexpr uint32_t vFHbm3WriteValue = 20; + +constexpr uint32_t minIdiReadOffset = 1096; +constexpr uint32_t minIdiWriteOffset = 1224; +constexpr uint32_t minDisplayVc1ReadOffset = 1352; -constexpr uint8_t vF1Hbm0ReadValue = 92; -constexpr uint8_t vF1Hbm0WriteValue = 96; -constexpr uint8_t vF1Hbm1ReadValue = 104; -constexpr uint8_t vF1Hbm1WriteValue = 108; -constexpr uint8_t vF1TimestampLValue = 168; -constexpr uint8_t vF1TimestampHValue = 172; -constexpr uint8_t vF1Hbm2ReadValue = 113; -constexpr uint8_t vF1Hbm2WriteValue = 125; -constexpr uint8_t vF1Hbm3ReadValue = 135; -constexpr uint8_t vF1Hbm3WriteValue = 20; constexpr uint64_t mockIdiReadVal = 8u; constexpr uint64_t mockIdiWriteVal = 9u; constexpr uint64_t mockDisplayVc1ReadVal = 10u; constexpr uint64_t numberMcChannels = 16; -constexpr uint64_t transactionSize = 32; namespace L0 { namespace Sysman { namespace ult { const std::string deviceMemoryHealth("device_memory_health"); +const std::string telem1NodeName("/sys/class/intel_pmt/telem1"); +const std::string telem2NodeName("/sys/class/intel_pmt/telem2"); +const std::string telem3NodeName("/sys/class/intel_pmt/telem3"); +const std::string telem1OffsetFileName("/sys/class/intel_pmt/telem1/offset"); +const std::string telem1GuidFileName("/sys/class/intel_pmt/telem1/guid"); +const std::string telem1TelemFileName("/sys/class/intel_pmt/telem1/telem"); +const std::string telem2OffsetFileName("/sys/class/intel_pmt/telem2/offset"); +const std::string telem2GuidFileName("/sys/class/intel_pmt/telem2/guid"); +const std::string telem2TelemFileName("/sys/class/intel_pmt/telem2/telem"); +const std::string telem3OffsetFileName("/sys/class/intel_pmt/telem3/offset"); +const std::string telem3GuidFileName("/sys/class/intel_pmt/telem3/guid"); +const std::string telem3TelemFileName("/sys/class/intel_pmt/telem3/telem"); +const std::string hbmFreqFilePath("gt/gt0/mem_RP0_freq_mhz"); +const std::string hbmFreqFilePath2("gt/gt1/mem_RP0_freq_mhz"); +const std::string maxBwFileName("prelim_lmem_max_bw_Mbps"); struct MockMemoryNeoDrm : public NEO::Drm { using Drm::ioctlHelper; @@ -104,198 +128,6 @@ struct MockMemoryNeoDrm : public NEO::Drm { } }; -struct MockMemoryPmt : public L0::Sysman::PlatformMonitoringTech { - using L0::Sysman::PlatformMonitoringTech::guid; - using L0::Sysman::PlatformMonitoringTech::keyOffsetMap; - std::vector mockReadValueReturnStatus{}; - std::vector mockReadArgumentValue{}; - ze_result_t mockIdiReadValueFailureReturnStatus = ZE_RESULT_SUCCESS; - ze_result_t mockIdiWriteFailureReturnStatus = ZE_RESULT_SUCCESS; - ze_result_t mockDisplayVc1ReadFailureReturnStatus = ZE_RESULT_SUCCESS; - ze_result_t mockReadTimeStampFailureReturnStatus = ZE_RESULT_SUCCESS; - bool mockVfid0Status = false; - bool mockVfid1Status = false; - bool isRepeated = false; - - void setGuid(std::string guid) { - this->guid = guid; - } - - MockMemoryPmt() = default; - ze_result_t readValue(const std::string key, uint32_t &val) override { - ze_result_t result = ZE_RESULT_SUCCESS; - - if (mockVfid0Status == true) { - return mockedReadValueWithVfid0True(key, val); - } - - if (mockVfid1Status == true) { - return mockedReadValueWithVfid1True(key, val); - } - - if (!mockReadValueReturnStatus.empty()) { - result = mockReadValueReturnStatus.front(); - if (!mockReadArgumentValue.empty()) { - val = mockReadArgumentValue.front(); - } - - if (isRepeated != true) { - mockReadValueReturnStatus.erase(mockReadValueReturnStatus.begin()); - if (!mockReadArgumentValue.empty()) { - mockReadArgumentValue.erase(mockReadArgumentValue.begin()); - } - } - } - return result; - } - - ze_result_t mockedReadValueWithVfid0True(const std::string key, uint32_t &val) { - if (key.compare("VF0_VFID") == 0) { - val = 1; - } else if (key.compare("VF1_VFID") == 0) { - val = 0; - } else if (key.compare("VF0_HBM0_READ") == 0) { - val = vF0Hbm0ReadValue; - } else if (key.compare("VF0_HBM0_WRITE") == 0) { - val = vF0Hbm0WriteValue; - } else if (key.compare("VF0_HBM1_READ") == 0) { - val = vF0Hbm1ReadValue; - } else if (key.compare("VF0_HBM1_WRITE") == 0) { - val = vF0Hbm1WriteValue; - } else if (key.compare("VF0_TIMESTAMP_L") == 0) { - val = vF0TimestampLValue; - } else if (key.compare("VF0_TIMESTAMP_H") == 0) { - val = vF0TimestampHValue; - } else if (key.compare("VF0_HBM2_READ") == 0) { - val = vF0Hbm2ReadValue; - } else if (key.compare("VF0_HBM2_WRITE") == 0) { - val = vF0Hbm2WriteValue; - } else if (key.compare("VF0_HBM3_READ") == 0) { - val = vF0Hbm3ReadValue; - } else if (key.compare("VF0_HBM3_WRITE") == 0) { - val = vF0Hbm3WriteValue; - } else if (key.compare("VF0_HBM_READ_L") == 0) { - val = vF0HbmLRead; - } else if (key.compare("VF0_HBM_READ_H") == 0) { - val = vF0HbmHRead; - } else if (key.compare("VF0_HBM_WRITE_L") == 0) { - val = vF0HbmLWrite; - } else if (key.compare("VF0_HBM_WRITE_H") == 0) { - val = vF0HbmHWrite; - } else { - return ZE_RESULT_ERROR_NOT_AVAILABLE; - } - return ZE_RESULT_SUCCESS; - } - - ze_result_t mockedReadValueWithVfid1True(const std::string key, uint32_t &val) { - if (key.compare("VF0_VFID") == 0) { - val = 0; - } else if (key.compare("VF1_VFID") == 0) { - val = 1; - } else if (key.compare("VF1_HBM0_READ") == 0) { - val = vF1Hbm0ReadValue; - } else if (key.compare("VF1_HBM0_WRITE") == 0) { - val = vF1Hbm0WriteValue; - } else if (key.compare("VF1_HBM1_READ") == 0) { - val = vF1Hbm1ReadValue; - } else if (key.compare("VF1_HBM1_WRITE") == 0) { - val = vF1Hbm1WriteValue; - } else if (key.compare("VF1_TIMESTAMP_L") == 0) { - val = vF1TimestampLValue; - } else if (key.compare("VF1_TIMESTAMP_H") == 0) { - val = vF1TimestampHValue; - } else if (key.compare("VF1_HBM2_READ") == 0) { - val = vF1Hbm2ReadValue; - } else if (key.compare("VF1_HBM2_WRITE") == 0) { - val = vF1Hbm2WriteValue; - } else if (key.compare("VF1_HBM3_READ") == 0) { - val = vF1Hbm3ReadValue; - } else if (key.compare("VF1_HBM3_WRITE") == 0) { - val = vF1Hbm3WriteValue; - } else if (key.compare("VF1_HBM_READ_L") == 0) { - val = vF1HbmLRead; - } else if (key.compare("VF1_HBM_READ_H") == 0) { - val = vF1HbmHRead; - } else if (key.compare("VF1_HBM_WRITE_L") == 0) { - val = vF1HbmLWrite; - } else if (key.compare("VF1_HBM_WRITE_H") == 0) { - val = vF1HbmHWrite; - } else { - return ZE_RESULT_ERROR_NOT_AVAILABLE; - } - return ZE_RESULT_SUCCESS; - } - - ze_result_t readValue(const std::string key, uint64_t &val) override { - ze_result_t result = ZE_RESULT_SUCCESS; - - if (mockIdiReadValueFailureReturnStatus != ZE_RESULT_SUCCESS) { - return mockIdiReadValueFailure(key, val); - } - - if (mockIdiWriteFailureReturnStatus != ZE_RESULT_SUCCESS) { - return mockIdiWriteFailure(key, val); - } - - if (mockDisplayVc1ReadFailureReturnStatus != ZE_RESULT_SUCCESS) { - return mockDisplayVc1ReadFailure(key, val); - } - - if (mockReadTimeStampFailureReturnStatus != ZE_RESULT_SUCCESS) { - return mockReadTimeStampFailure(key, val); - } - - if (key.compare("IDI_READS[0]") == 0 || key.compare("IDI_READS[1]") == 0 || key.compare("IDI_READS[2]") == 0 || key.compare("IDI_READS[3]") == 0 || key.compare("IDI_READS[4]") == 0 || key.compare("IDI_READS[5]") == 0 || key.compare("IDI_READS[6]") == 0 || key.compare("IDI_READS[7]") == 0 || key.compare("IDI_READS[8]") == 0 || key.compare("IDI_READS[9]") == 0 || key.compare("IDI_READS[10]") == 0 || key.compare("IDI_READS[11]") == 0 || key.compare("IDI_READS[12]") == 0 || key.compare("IDI_READS[13]") == 0 || key.compare("IDI_READS[14]") == 0 || key.compare("IDI_READS[15]") == 0) { - val = mockIdiReadVal; - } else if (key.compare("IDI_WRITES[0]") == 0 || key.compare("IDI_WRITES[1]") == 0 || key.compare("IDI_WRITES[2]") == 0 || key.compare("IDI_WRITES[3]") == 0 || key.compare("IDI_WRITES[4]") == 0 || key.compare("IDI_WRITES[5]") == 0 || key.compare("IDI_WRITES[6]") == 0 || key.compare("IDI_WRITES[7]") == 0 || key.compare("IDI_WRITES[8]") == 0 || key.compare("IDI_WRITES[9]") == 0 || key.compare("IDI_WRITES[10]") == 0 || key.compare("IDI_WRITES[11]") == 0 || key.compare("IDI_WRITES[12]") == 0 || key.compare("IDI_WRITES[13]") == 0 || key.compare("IDI_WRITES[14]") == 0 || key.compare("IDI_WRITES[15]") == 0) { - val = mockIdiWriteVal; - } else if (key.compare("DISPLAY_VC1_READS[0]") == 0 || key.compare("DISPLAY_VC1_READS[1]") == 0 || key.compare("DISPLAY_VC1_READS[2]") == 0 || key.compare("DISPLAY_VC1_READS[3]") == 0 || key.compare("DISPLAY_VC1_READS[4]") == 0 || key.compare("DISPLAY_VC1_READS[5]") == 0 || key.compare("DISPLAY_VC1_READS[6]") == 0 || key.compare("DISPLAY_VC1_READS[7]") == 0 || key.compare("DISPLAY_VC1_READS[8]") == 0 || key.compare("DISPLAY_VC1_READS[9]") == 0 || key.compare("DISPLAY_VC1_READS[10]") == 0 || key.compare("DISPLAY_VC1_READS[11]") == 0 || key.compare("DISPLAY_VC1_READS[12]") == 0 || key.compare("DISPLAY_VC1_READS[13]") == 0 || key.compare("DISPLAY_VC1_READS[14]") == 0 || key.compare("DISPLAY_VC1_READS[15]") == 0) { - val = mockDisplayVc1ReadVal; - } else { - result = ZE_RESULT_ERROR_NOT_AVAILABLE; - } - return result; - } - - ze_result_t mockIdiReadValueFailure(const std::string key, uint64_t &val) { - return ZE_RESULT_ERROR_UNKNOWN; - } - - ze_result_t mockIdiWriteFailure(const std::string key, uint64_t &val) { - if (key.compare("IDI_READS[0]") == 0 || key.compare("IDI_READS[1]") == 0 || key.compare("IDI_READS[2]") == 0 || key.compare("IDI_READS[3]") == 0 || key.compare("IDI_READS[4]") == 0 || key.compare("IDI_READS[5]") == 0 || key.compare("IDI_READS[6]") == 0 || key.compare("IDI_READS[7]") == 0 || key.compare("IDI_READS[8]") == 0 || key.compare("IDI_READS[9]") == 0 || key.compare("IDI_READS[10]") == 0 || key.compare("IDI_READS[11]") == 0 || key.compare("IDI_READS[12]") == 0 || key.compare("IDI_READS[13]") == 0 || key.compare("IDI_READS[14]") == 0 || key.compare("IDI_READS[15]") == 0) { - val = mockIdiReadVal; - } else if (key.compare("IDI_WRITES[0]") == 0 || key.compare("IDI_WRITES[1]") == 0 || key.compare("IDI_WRITES[2]") == 0 || key.compare("IDI_WRITES[3]") == 0 || key.compare("IDI_WRITES[4]") == 0 || key.compare("IDI_WRITES[5]") == 0 || key.compare("IDI_WRITES[6]") == 0 || key.compare("IDI_WRITES[7]") == 0 || key.compare("IDI_WRITES[8]") == 0 || key.compare("IDI_WRITES[9]") == 0 || key.compare("IDI_WRITES[10]") == 0 || key.compare("IDI_WRITES[11]") == 0 || key.compare("IDI_WRITES[12]") == 0 || key.compare("IDI_WRITES[13]") == 0 || key.compare("IDI_WRITES[14]") == 0 || key.compare("IDI_WRITES[15]") == 0) { - return ZE_RESULT_ERROR_UNKNOWN; - } - return ZE_RESULT_SUCCESS; - } - - ze_result_t mockDisplayVc1ReadFailure(const std::string key, uint64_t &val) { - if (key.compare("IDI_READS[0]") == 0 || key.compare("IDI_READS[1]") == 0 || key.compare("IDI_READS[2]") == 0 || key.compare("IDI_READS[3]") == 0 || key.compare("IDI_READS[4]") == 0 || key.compare("IDI_READS[5]") == 0 || key.compare("IDI_READS[6]") == 0 || key.compare("IDI_READS[7]") == 0 || key.compare("IDI_READS[8]") == 0 || key.compare("IDI_READS[9]") == 0 || key.compare("IDI_READS[10]") == 0 || key.compare("IDI_READS[11]") == 0 || key.compare("IDI_READS[12]") == 0 || key.compare("IDI_READS[13]") == 0 || key.compare("IDI_READS[14]") == 0 || key.compare("IDI_READS[15]") == 0) { - val = mockIdiReadVal; - } else if (key.compare("IDI_WRITES[0]") == 0 || key.compare("IDI_WRITES[1]") == 0 || key.compare("IDI_WRITES[2]") == 0 || key.compare("IDI_WRITES[3]") == 0 || key.compare("IDI_WRITES[4]") == 0 || key.compare("IDI_WRITES[5]") == 0 || key.compare("IDI_WRITES[6]") == 0 || key.compare("IDI_WRITES[7]") == 0 || key.compare("IDI_WRITES[8]") == 0 || key.compare("IDI_WRITES[9]") == 0 || key.compare("IDI_WRITES[10]") == 0 || key.compare("IDI_WRITES[11]") == 0 || key.compare("IDI_WRITES[12]") == 0 || key.compare("IDI_WRITES[13]") == 0 || key.compare("IDI_WRITES[14]") == 0 || key.compare("IDI_WRITES[15]") == 0) { - val = mockIdiWriteVal; - } else if (key.compare("DISPLAY_VC1_READS[0]") == 0 || key.compare("DISPLAY_VC1_READS[1]") == 0 || key.compare("DISPLAY_VC1_READS[2]") == 0 || key.compare("DISPLAY_VC1_READS[3]") == 0 || key.compare("DISPLAY_VC1_READS[4]") == 0 || key.compare("DISPLAY_VC1_READS[5]") == 0 || key.compare("DISPLAY_VC1_READS[6]") == 0 || key.compare("DISPLAY_VC1_READS[7]") == 0 || key.compare("DISPLAY_VC1_READS[8]") == 0 || key.compare("DISPLAY_VC1_READS[9]") == 0 || key.compare("DISPLAY_VC1_READS[10]") == 0 || key.compare("DISPLAY_VC1_READS[11]") == 0 || key.compare("DISPLAY_VC1_READS[12]") == 0 || key.compare("DISPLAY_VC1_READS[13]") == 0 || key.compare("DISPLAY_VC1_READS[14]") == 0 || key.compare("DISPLAY_VC1_READS[15]") == 0) { - return ZE_RESULT_ERROR_UNKNOWN; - } - return ZE_RESULT_SUCCESS; - } - - ze_result_t mockReadTimeStampFailure(const std::string key, uint64_t &val) { - if (key.compare("IDI_READS[0]") == 0 || key.compare("IDI_READS[1]") == 0 || key.compare("IDI_READS[2]") == 0 || key.compare("IDI_READS[3]") == 0 || key.compare("IDI_READS[4]") == 0 || key.compare("IDI_READS[5]") == 0 || key.compare("IDI_READS[6]") == 0 || key.compare("IDI_READS[7]") == 0 || key.compare("IDI_READS[8]") == 0 || key.compare("IDI_READS[9]") == 0 || key.compare("IDI_READS[10]") == 0 || key.compare("IDI_READS[11]") == 0 || key.compare("IDI_READS[12]") == 0 || key.compare("IDI_READS[13]") == 0 || key.compare("IDI_READS[14]") == 0 || key.compare("IDI_READS[15]") == 0) { - val = mockIdiReadVal; - } else if (key.compare("IDI_WRITES[0]") == 0 || key.compare("IDI_WRITES[1]") == 0 || key.compare("IDI_WRITES[2]") == 0 || key.compare("IDI_WRITES[3]") == 0 || key.compare("IDI_WRITES[4]") == 0 || key.compare("IDI_WRITES[5]") == 0 || key.compare("IDI_WRITES[6]") == 0 || key.compare("IDI_WRITES[7]") == 0 || key.compare("IDI_WRITES[8]") == 0 || key.compare("IDI_WRITES[9]") == 0 || key.compare("IDI_WRITES[10]") == 0 || key.compare("IDI_WRITES[11]") == 0 || key.compare("IDI_WRITES[12]") == 0 || key.compare("IDI_WRITES[13]") == 0 || key.compare("IDI_WRITES[14]") == 0 || key.compare("IDI_WRITES[15]") == 0) { - val = mockIdiWriteVal; - } else if (key.compare("DISPLAY_VC1_READS[0]") == 0 || key.compare("DISPLAY_VC1_READS[1]") == 0 || key.compare("DISPLAY_VC1_READS[2]") == 0 || key.compare("DISPLAY_VC1_READS[3]") == 0 || key.compare("DISPLAY_VC1_READS[4]") == 0 || key.compare("DISPLAY_VC1_READS[5]") == 0 || key.compare("DISPLAY_VC1_READS[6]") == 0 || key.compare("DISPLAY_VC1_READS[7]") == 0 || key.compare("DISPLAY_VC1_READS[8]") == 0 || key.compare("DISPLAY_VC1_READS[9]") == 0 || key.compare("DISPLAY_VC1_READS[10]") == 0 || key.compare("DISPLAY_VC1_READS[11]") == 0 || key.compare("DISPLAY_VC1_READS[12]") == 0 || key.compare("DISPLAY_VC1_READS[13]") == 0 || key.compare("DISPLAY_VC1_READS[14]") == 0 || key.compare("DISPLAY_VC1_READS[15]") == 0) { - val = mockDisplayVc1ReadVal; - } else { - return ZE_RESULT_ERROR_NOT_AVAILABLE; - } - return ZE_RESULT_SUCCESS; - } -}; - class PublicLinuxMemoryImp : public L0::Sysman::LinuxMemoryImp { public: PublicLinuxMemoryImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : LinuxMemoryImp(pOsSysman, onSubdevice, subdeviceId) {} diff --git a/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory.cpp b/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory.cpp index 45c6d16687..fb2d4b6d43 100644 --- a/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory.cpp +++ b/level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory.cpp @@ -73,13 +73,6 @@ class SysmanDeviceMemoryFixtureI915 : public SysmanDeviceMemoryFixture { osInterface->setDriverModel(std::unique_ptr(pDrm)); pDrm->setMemoryType(NEO::DeviceBlobConstants::MemoryType::hbm2e); pDrm->ioctlHelper = static_cast>(std::make_unique(*pDrm)); - pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear(); - auto subdeviceId = 0u; - auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); - do { - auto pPmt = new MockMemoryPmt(); - pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt); - } while (++subdeviceId < subDeviceCount); } void TearDown() override { @@ -88,6 +81,122 @@ class SysmanDeviceMemoryFixtureI915 : public SysmanDeviceMemoryFixture { } }; +static int mockReadLinkSingleTelemetryNodeSuccess(const char *path, char *buf, size_t bufsize) { + std::map fileNameLinkMap = { + {telem1NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem1/"}, + }; + 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 mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) { + + std::map fileNameLinkMap = { + {telem1NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem1/"}, + {telem2NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem2/"}, + }; + 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 mockOpenSingleTelemetryNodeSuccess(const char *pathname, int flags) { + + int returnValue = -1; + std::string strPathName(pathname); + if (strPathName == telem1OffsetFileName) { + returnValue = 4; + } else if (strPathName == telem1GuidFileName) { + returnValue = 5; + } else if (strPathName == telem1TelemFileName) { + returnValue = 6; + } else if (strPathName == maxBwFileName) { + returnValue = 7; + } + return returnValue; +} + +static int mockOpenSuccess(const char *pathname, int flags) { + + int returnValue = -1; + std::string strPathName(pathname); + if (strPathName == telem2OffsetFileName) { + returnValue = 4; + } else if (strPathName == telem2GuidFileName) { + returnValue = 5; + } else if (strPathName == telem2TelemFileName) { + returnValue = 6; + } else if (strPathName == hbmFreqFilePath) { + returnValue = 7; + } + return returnValue; +} + +static ssize_t mockReadSuccess(int fd, void *buf, size_t count, off_t offset) { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF1Vfid) { + val = 1; + } else if (offset == vF1HbmReadL) { + val = vFHbmLRead; + } else if (offset == vF1HbmReadH) { + val = vFHbmHRead; + } else if (offset == vF1HbmWriteL) { + val = vFHbmLWrite; + } else if (offset == vF1HbmWriteH) { + val = vFHbmHWrite; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; +} + +static ssize_t mockReadIdiFilesSuccess(int fd, void *buf, size_t count, off_t offset) { + std::ostringstream oStream; + uint64_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0x4f9502"; + } else if (fd == 6) { + if (offset >= minIdiReadOffset && offset < minIdiWriteOffset) { + val = mockIdiReadVal; + } else if (offset >= minIdiWriteOffset && offset < minDisplayVc1ReadOffset) { + val = mockIdiWriteVal; + } else if (offset >= minDisplayVc1ReadOffset) { + val = mockDisplayVc1ReadVal; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << mockMaxBwDg2; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; +} + TEST_F(SysmanDeviceMemoryFixtureI915, GivenI915DriverVersionWhenValidCallingSysfsFilenamesThenProperPathsAreReturned) { auto pSysmanKmdInterface = pLinuxSysmanImp->pSysmanKmdInterface.get(); EXPECT_STREQ("gt/gt0/mem_RP0_freq_mhz", pSysmanKmdInterface->getSysfsFilePath(SysfsName::sysfsNameMaxMemoryFrequency, 0, true).c_str()); @@ -309,69 +418,75 @@ HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesSys } } -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenBothVfid0AndVfid1AreTrueThenErrorIsReturnedWhileGettingMemoryBandwidth, IsPVC) { +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenNoTelemNodesAvailableWhenCallingZesMemoryGetBandwidthThenErrorIsReturned, IsPVC) { auto handles = getMemoryHandles(memoryHandleComponentCount); - for (auto handle : handles) { - zes_mem_properties_t properties = {}; - zesMemoryGetProperties(handle, &properties); - zes_mem_bandwidth_t bandwidth; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockReadArgumentValue.push_back(1); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadArgumentValue.push_back(1); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNKNOWN); - } -} - -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthWhenPmtObjectIsNullThenFailureRetuned, IsPVC) { - for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) { - if (subDeviceIdToPmtEntry.second != nullptr) { - delete subDeviceIdToPmtEntry.second; - subDeviceIdToPmtEntry.second = nullptr; - } - } - auto handles = getMemoryHandles(memoryHandleComponentCount); - for (auto &handle : handles) { + for (const auto &handle : handles) { zes_mem_bandwidth_t bandwidth; EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); } } -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthWhenVfid0IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsPVC) { +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenTelemOffsetFileNotAvailableWhenCallingZesMemoryGetBandwidthThenErrorIsReturned, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + auto handles = getMemoryHandles(memoryHandleComponentCount); + for (const auto &handle : handles) { + zes_mem_bandwidth_t bandwidth; + EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + } +} + +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenBothVfid0AndVfid1AreTrueThenErrorIsReturnedWhileGettingMemoryBandwidth, IsPVC) { + + 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 { std::ostringstream oStream; - oStream << hbmRP0Frequency; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + oStream << "5"; + } else { + oStream << "-1"; + } std::string value = oStream.str(); memcpy(buf, value.data(), count); return count; }); + auto handles = getMemoryHandles(memoryHandleComponentCount); + for (auto handle : handles) { + zes_mem_properties_t properties = {}; + zesMemoryGetProperties(handle, &properties); + zes_mem_bandwidth_t bandwidth; + EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNKNOWN); + } +} + +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthWhenVfid0IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess); + auto handles = getMemoryHandles(memoryHandleComponentCount); for (auto &handle : handles) { zes_mem_bandwidth_t bandwidth{}; - uint64_t expectedReadCounters = 0, expectedWriteCounters = 0; - uint64_t expectedBandwidth = 0; - zes_mem_properties_t properties = {ZES_STRUCTURE_TYPE_MEM_PROPERTIES}; - zesMemoryGetProperties(handle, &properties); - + uint64_t expectedReadCounters = 0, expectedWriteCounters = 0, expectedBandwidth = 0; auto hwInfo = pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo(); auto &productHelper = pSysmanDeviceImp->getRootDeviceEnvironment().getHelper(); hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo); - - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockVfid0Status = true; - EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS); - expectedReadCounters |= vF0HbmHRead; - expectedReadCounters = (expectedReadCounters << 32) | vF0HbmLRead; + expectedReadCounters |= vFHbmHRead; + expectedReadCounters = (expectedReadCounters << 32) | vFHbmLRead; expectedReadCounters = expectedReadCounters * transactionSize; EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); - expectedWriteCounters |= vF0HbmHWrite; - expectedWriteCounters = (expectedWriteCounters << 32) | vF0HbmLWrite; + expectedWriteCounters |= vFHbmHWrite; + expectedWriteCounters = (expectedWriteCounters << 32) | vFHbmLWrite; expectedWriteCounters = expectedWriteCounters * transactionSize; EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; @@ -380,9 +495,36 @@ HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMem } HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthWhenVfid1IsActiveThenSuccessIsReturnedAndBandwidthIsValid, IsPVC) { + + 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 { std::ostringstream oStream; - oStream << hbmRP0Frequency; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF1Vfid) { + val = 1; + } else if (offset == vF1HbmReadL) { + val = vFHbmLRead; + } else if (offset == vF1HbmReadH) { + val = vFHbmHRead; + } else if (offset == vF1HbmWriteL) { + val = vFHbmLWrite; + } else if (offset == vF1HbmWriteH) { + val = vFHbmHWrite; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } std::string value = oStream.str(); memcpy(buf, value.data(), count); return count; @@ -401,17 +543,13 @@ HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMem auto &productHelper = pSysmanDeviceImp->getRootDeviceEnvironment().getHelper(); hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo); - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockVfid1Status = true; - EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS); - expectedReadCounters |= vF0HbmHRead; - expectedReadCounters = (expectedReadCounters << 32) | vF0HbmLRead; + expectedReadCounters |= vFHbmHRead; + expectedReadCounters = (expectedReadCounters << 32) | vFHbmLRead; expectedReadCounters = expectedReadCounters * transactionSize; EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); - expectedWriteCounters |= vF0HbmHWrite; - expectedWriteCounters = (expectedWriteCounters << 32) | vF0HbmLWrite; + expectedWriteCounters |= vFHbmHWrite; + expectedWriteCounters = (expectedWriteCounters << 32) | vFHbmLWrite; expectedWriteCounters = expectedWriteCounters * transactionSize; EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; @@ -419,19 +557,24 @@ HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMem } } +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenTelemOffsetFileNotAvailableWhenCallingZesMemoryGetBandwidthThenErrorIsReturned, IsDG2) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + auto handles = getMemoryHandles(memoryHandleComponentCount); + for (const auto &handle : handles) { + zes_mem_bandwidth_t bandwidth; + EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); + } +} + HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthThenSuccessIsReturnedAndBandwidthIsValid, IsDG2) { - VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { - std::ostringstream oStream; - oStream << mockMaxBwDg2; - std::string value = oStream.str(); - memcpy(buf, value.data(), count); - return count; - }); + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadIdiFilesSuccess); auto handles = getMemoryHandles(memoryHandleComponentCount); for (const auto &handle : handles) { - zes_mem_properties_t properties = {}; - zesMemoryGetProperties(handle, &properties); zes_mem_bandwidth_t bandwidth; uint64_t expectedReadCounters = 0, expectedWriteCounters = 0, expectedBandwidth = 0; EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_SUCCESS); @@ -445,44 +588,76 @@ HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMem } } -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthIfIdiReadFailsTheFailureIsReturned, IsDG2) { - auto handles = getMemoryHandles(memoryHandleComponentCount); +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthIfIdiReadFailsThenErrorIsReturned, IsDG2) { - for (auto handle : handles) { - zes_mem_properties_t properties = {}; - zesMemoryGetProperties(handle, &properties); - zes_mem_bandwidth_t bandwidth; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->mockIdiReadValueFailureReturnStatus = ZE_RESULT_ERROR_UNKNOWN; - EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNKNOWN); - } -} + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesMemoryGetBandwidthIfDisplayVc1ReadFailsTheFailureIsReturned, IsDG2) { - auto handles = getMemoryHandles(memoryHandleComponentCount); - - for (auto handle : handles) { - zes_mem_properties_t properties = {}; - zesMemoryGetProperties(handle, &properties); - zes_mem_bandwidth_t bandwidth; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->mockDisplayVc1ReadFailureReturnStatus = ZE_RESULT_ERROR_UNKNOWN; - EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNKNOWN); - } -} - -HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesSysmanMemoryGetBandwidthForDg2PlatformAndReadingMaxBwFailsThenMaxBwIsReturnedAsZero, IsDG2) { VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { - errno = ENOENT; - return -1; + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0x4f9502"; + } else if (fd == 6) { + memcpy(buf, &val, sizeof(val)); + return sizeof(val); + } else if (fd == 7) { + oStream << mockMaxBwDg2; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto handles = getMemoryHandles(memoryHandleComponentCount); + for (auto handle : handles) { + zes_mem_properties_t properties = {}; + zesMemoryGetProperties(handle, &properties); + zes_mem_bandwidth_t bandwidth; + EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_NOT_AVAILABLE); + } +} + +HWTEST2_F(SysmanDeviceMemoryFixtureI915, GivenValidMemoryHandleWhenCallingZesSysmanMemoryGetBandwidthAndReadingMaxBwFailsThenMaxBwIsReturnedAsZero, IsDG2) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); + + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { + std::ostringstream oStream; + uint64_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0x4f9502"; + } else if (fd == 6) { + if (offset >= minIdiReadOffset && offset < minIdiWriteOffset) { + val = mockIdiReadVal; + } else if (offset >= minIdiWriteOffset && offset < minDisplayVc1ReadOffset) { + val = mockIdiWriteVal; + } else if (offset >= minDisplayVc1ReadOffset) { + val = mockDisplayVc1ReadVal; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + errno = ENOENT; + return -1; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; }); auto handles = getMemoryHandles(memoryHandleComponentCount); for (const auto &handle : handles) { ASSERT_NE(nullptr, handle); - zes_mem_properties_t properties = {}; - zesMemoryGetProperties(handle, &properties); - zes_mem_bandwidth_t bandwidth; EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_NOT_AVAILABLE); diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp index 037781e5aa..261de12ad3 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp @@ -39,13 +39,6 @@ class SysmanProductHelperMemoryTest : public SysmanDeviceFixture { pDrm = new MockMemoryNeoDrm(const_cast(pSysmanDeviceImp->getRootDeviceEnvironment())); auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface; osInterface->setDriverModel(std::unique_ptr(pDrm)); - pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear(); - auto subdeviceId = 0u; - auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount(); - do { - auto pPmt = new MockMemoryPmt(); - pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt); - } while (++subdeviceId < subDeviceCount); } void TearDown() override { @@ -54,15 +47,194 @@ class SysmanProductHelperMemoryTest : public SysmanDeviceFixture { } }; -HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthAndVfid0IsActiveThenVerifyBandWidthIsValid, IsPVC) { - VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { - std::ostringstream oStream; +static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) { + + std::map fileNameLinkMap = { + {telem1NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem1/"}, + {telem2NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem2/"}, + {telem3NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem3/"}, + }; + 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 mockReadLinkSingleTelemetryNodeSuccess(const char *path, char *buf, size_t bufsize) { + std::map fileNameLinkMap = { + {telem1NodeName, "../../devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/intel-dvsec-2.1.auto/intel_pmt/telem1/"}, + }; + 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) { + + int returnValue = -1; + std::string strPathName(pathname); + if (strPathName == telem2OffsetFileName) { + returnValue = 4; + } else if (strPathName == telem2GuidFileName) { + returnValue = 5; + } else if (strPathName == telem2TelemFileName) { + returnValue = 6; + } else if (strPathName == hbmFreqFilePath) { + returnValue = 7; + } else if (strPathName == telem3OffsetFileName) { + returnValue = 8; + } else if (strPathName == telem3GuidFileName) { + returnValue = 9; + } else if (strPathName == telem3TelemFileName) { + returnValue = 10; + } else if (strPathName == hbmFreqFilePath2) { + returnValue = 11; + } + return returnValue; +} + +static int mockOpenSingleTelemetryNodeSuccess(const char *pathname, int flags) { + + int returnValue = -1; + std::string strPathName(pathname); + if (strPathName == telem1OffsetFileName) { + returnValue = 4; + } else if (strPathName == telem1GuidFileName) { + returnValue = 5; + } else if (strPathName == telem1TelemFileName) { + returnValue = 6; + } else if (strPathName == maxBwFileName) { + returnValue = 7; + } + return returnValue; +} + +static ssize_t mockReadSuccess(int fd, void *buf, size_t count, off_t offset) { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0Hbm0Read) { + val = vFHbm0ReadValue; + } else if (offset == vF0Hbm0Write) { + val = vFHbm0WriteValue; + } else if (offset == vF0Hbm1Read) { + val = vFHbm1ReadValue; + } else if (offset == vF0Hbm1Write) { + val = vFHbm1WriteValue; + } else if (offset == vF0Hbm2Read) { + val = vFHbm2ReadValue; + } else if (offset == vF0Hbm2Write) { + val = vFHbm2WriteValue; + } else if (offset == vF0Hbm3Read) { + val = vFHbm3ReadValue; + } else if (offset == vF0Hbm3Write) { + val = vFHbm3WriteValue; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { oStream << hbmRP0Frequency; - std::string value = oStream.str(); - memcpy(buf, value.data(), count); + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; +} + +static ssize_t mockReadSuccess64BitRead(int fd, void *buf, size_t count, off_t offset) { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4 || fd == 8) { + oStream << "0"; + } else if (fd == 5 || fd == 9) { + oStream << "0xb15a0ede"; + } else if (fd == 6 || fd == 10) { + if (offset == vF1Vfid) { + val = 1; + } else if (offset == vF1HbmReadL) { + val = vFHbmLRead; + } else if (offset == vF1HbmReadH) { + val = vFHbmHRead; + } else if (offset == vF1HbmWriteL) { + val = vFHbmLWrite; + } else if (offset == vF1HbmWriteH) { + val = vFHbmHWrite; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7 || fd == 11) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; +} + +static ssize_t mockReadIdiFilesSuccess(int fd, void *buf, size_t count, off_t offset) { + std::ostringstream oStream; + uint64_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0x4f9502"; + } else if (fd == 6) { + if (offset >= minIdiReadOffset && offset < minIdiWriteOffset) { + val = mockIdiReadVal; + } else if (offset >= minIdiWriteOffset && offset < minDisplayVc1ReadOffset) { + val = mockIdiWriteVal; + } else if (offset >= minDisplayVc1ReadOffset) { + val = mockDisplayVc1ReadVal; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << mockMaxBwDg2; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthAndReadGuidFailsThenErrorIsReturned, IsPVC) { + 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 == 5) { + errno = ENOENT; + return -1; + } return count; }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + zes_mem_bandwidth_t bandwidth = {}; + EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId)); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthAndVfid0IsActiveThenVerifyBandWidthIsValid, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); zes_mem_properties_t properties; bool isSubdevice = true; @@ -70,14 +242,11 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal auto result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); EXPECT_EQ(result, ZE_RESULT_SUCCESS); - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->mockVfid0Status = true; - zes_mem_bandwidth_t bandwidth = {}; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); EXPECT_EQ(result, ZE_RESULT_SUCCESS); - uint64_t expectedReadCounters = vF0Hbm0ReadValue + vF0Hbm1ReadValue + vF0Hbm2ReadValue + vF0Hbm3ReadValue; - uint64_t expectedWriteCounters = vF0Hbm0WriteValue + vF0Hbm1WriteValue + vF0Hbm2WriteValue + vF0Hbm3WriteValue; + uint64_t expectedReadCounters = vFHbm0ReadValue + vFHbm1ReadValue + vFHbm2ReadValue + vFHbm3ReadValue; + uint64_t expectedWriteCounters = vFHbm0WriteValue + vFHbm1WriteValue + vFHbm2WriteValue + vFHbm3WriteValue; uint64_t expectedBandwidth = 0; expectedReadCounters = expectedReadCounters * transactionSize; @@ -89,9 +258,259 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal } HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthAndVfid1IsActiveThenVerifyBandWidthIsValid, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess64BitRead); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + zes_mem_properties_t properties; + bool isSubdevice = true; + uint32_t subDeviceId = 0; + auto result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + + zes_mem_bandwidth_t bandwidth = {}; + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + uint64_t expectedReadCounters = 0, expectedWriteCounters = 0; + expectedReadCounters |= vFHbmHRead; + expectedReadCounters = (expectedReadCounters << 32) | vFHbmLRead; + expectedReadCounters = expectedReadCounters * transactionSize; + expectedWriteCounters |= vFHbmHWrite; + expectedWriteCounters = (expectedWriteCounters << 32) | vFHbmLWrite; + expectedWriteCounters = expectedWriteCounters * transactionSize; + uint64_t expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; + + EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); + EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); + EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthTwiceAndVfid1IsActiveThenVerifyBandWidthIsValid, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess64BitRead); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + + zes_mem_bandwidth_t bandwidth = {}; + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + uint64_t expectedReadCounters = 0, expectedWriteCounters = 0; + expectedReadCounters |= vFHbmHRead; + expectedReadCounters = (expectedReadCounters << 32) | vFHbmLRead; + expectedReadCounters = expectedReadCounters * transactionSize; + expectedWriteCounters |= vFHbmHWrite; + expectedWriteCounters = (expectedWriteCounters << 32) | vFHbmLWrite; + expectedWriteCounters = expectedWriteCounters * transactionSize; + uint64_t expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; + + EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); + EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); + EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); + + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); + EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); + EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthForEachSubdeviceAndVfid1IsActiveThenVerifyBandWidthIsValid, IsPVC) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadSuccess64BitRead); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + + zes_mem_bandwidth_t bandwidth = {}; + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + uint64_t expectedReadCounters = 0, expectedWriteCounters = 0; + expectedReadCounters |= vFHbmHRead; + expectedReadCounters = (expectedReadCounters << 32) | vFHbmLRead; + expectedReadCounters = expectedReadCounters * transactionSize; + expectedWriteCounters |= vFHbmHWrite; + expectedWriteCounters = (expectedWriteCounters << 32) | vFHbmLWrite; + expectedWriteCounters = expectedWriteCounters * transactionSize; + uint64_t expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; + + EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); + EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); + EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); + + subDeviceId += 1; + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); + EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); + EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenBothVfid0AndVfid1ActiveAndGuidNotSetWhenCallingGetBandwidthThenFailureIsReturned, IsPVC) { + + 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 { std::ostringstream oStream; - oStream << hbmRP0Frequency; + uint32_t val = -1; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid || offset == vF1Vfid) { + val = 1; + } + memcpy(buf, &val, sizeof(uint32_t)); + return sizeof(uint32_t); + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + zes_mem_bandwidth_t bandwidth = {}; + EXPECT_EQ(pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId), ZE_RESULT_ERROR_UNKNOWN); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenBothVfid0AndVfid1NotActiveAndGuidNotSetWhenCallingGetBandwidthThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = -1; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid || offset == vF1Vfid) { + val = 0; + } + memcpy(buf, &val, sizeof(uint32_t)); + return sizeof(uint32_t); + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + zes_mem_bandwidth_t bandwidth = {}; + EXPECT_EQ(pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId), ZE_RESULT_ERROR_UNKNOWN); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ReadFailsAndGuidNotSetWhenCallingGetBandwidthThenFailureIsReturned, IsPVC) { + 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 { + std::ostringstream oStream; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + errno = ENOENT; + return -1; + } + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + + zes_mem_bandwidth_t bandwidth = {}; + EXPECT_EQ(pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId), ZE_RESULT_ERROR_NOT_AVAILABLE); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ActiveAndVfid1ReadFailsAndGuidNotSetWhenCallingGetBandwidthThenFailureIsReturned, IsPVC) { + 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 { + std::ostringstream oStream; + uint32_t val = -1; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF1Vfid) { + errno = ENOENT; + return -1; + } + memcpy(buf, &val, sizeof(uint32_t)); + return sizeof(uint32_t); + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + + zes_mem_bandwidth_t bandwidth = {}; + EXPECT_EQ(pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId), ZE_RESULT_ERROR_NOT_AVAILABLE); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenHbm0ReadFailsAndGuidNotSetWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0Hbm0Read) { + errno = ENOENT; + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } std::string value = oStream.str(); memcpy(buf, value.data(), count); return count; @@ -104,48 +523,42 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal auto result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); EXPECT_EQ(result, ZE_RESULT_SUCCESS); - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockVfid1Status = true; - zes_mem_bandwidth_t bandwidth = {}; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_SUCCESS); - uint64_t expectedReadCounters = 0, expectedWriteCounters = 0; - expectedReadCounters |= vF0HbmHRead; - expectedReadCounters = (expectedReadCounters << 32) | vF0HbmLRead; - expectedReadCounters = expectedReadCounters * transactionSize; - expectedWriteCounters |= vF0HbmHWrite; - expectedWriteCounters = (expectedWriteCounters << 32) | vF0HbmLWrite; - expectedWriteCounters = expectedWriteCounters * transactionSize; - uint64_t expectedBandwidth = 128 * hbmRP0Frequency * 1000 * 1000 * 4; - - EXPECT_EQ(bandwidth.readCounter, expectedReadCounters); - EXPECT_EQ(bandwidth.writeCounter, expectedWriteCounters); - EXPECT_EQ(bandwidth.maxBandwidth, expectedBandwidth); -} - -HWTEST2_F(SysmanProductHelperMemoryTest, GivenHbm0ReadFailsAndGuidNotSetWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { - auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); - zes_mem_properties_t properties; - bool isSubdevice = true; - uint32_t subDeviceId = 0; - auto result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); - EXPECT_EQ(result, ZE_RESULT_SUCCESS); - - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->mockReadArgumentValue.push_back(1); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadArgumentValue.push_back(0); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNKNOWN); - - zes_mem_bandwidth_t bandwidth = {}; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } HWTEST2_F(SysmanProductHelperMemoryTest, GivenHbm0WriteFailsAndGuidNotSetWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0edd"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0Hbm0Write) { + errno = ENOENT; + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); zes_mem_properties_t properties; bool isSubdevice = true; @@ -153,74 +566,213 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenHbm0WriteFailsAndGuidNotSetWhenCal auto result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); EXPECT_EQ(result, ZE_RESULT_SUCCESS); - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId)); - pPmt->mockReadArgumentValue.push_back(1); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadArgumentValue.push_back(0); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadArgumentValue.push_back(vF0Hbm0ReadValue); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNKNOWN); - zes_mem_bandwidth_t bandwidth = {}; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ReadFailsWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ReadLFailsWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0HbmReadL) { + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); uint32_t subDeviceId = 0; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNKNOWN); - zes_mem_bandwidth_t bandwidth{}; - auto result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ReadFailsAndGuidNotSetBitWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0ReadHFailsWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0HbmReadH) { + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); uint32_t subDeviceId = 0; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId)); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNKNOWN); - zes_mem_bandwidth_t bandwidth{}; - auto result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid1ReadFailsWhenCallingGetBandwidthAndVfid1IsActiveThenFailureIsReturned, IsPVC) { +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0WriteLFailsWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0HbmWriteL) { + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); uint32_t subDeviceId = 0; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockReadArgumentValue.push_back(1); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_ERROR_UNKNOWN); - zes_mem_bandwidth_t bandwidth{}; - auto result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenBothVfid0AndVfid1AreFalseWhenGettingMemoryBandwidthThenFailureIsReturned, IsPVC) { +HWTEST2_F(SysmanProductHelperMemoryTest, GivenVfid0WriteHFailsWhenCallingGetBandwidthAndVfid0IsActiveThenFailureIsReturned, IsPVC) { + + 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 { + std::ostringstream oStream; + uint32_t val = 0; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xb15a0ede"; + } else if (fd == 6) { + if (offset == vF0Vfid) { + val = 1; + } else if (offset == vF0HbmWriteH) { + return -1; + } + memcpy(buf, &val, count); + return count; + } else if (fd == 7) { + oStream << hbmRP0Frequency; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); uint32_t subDeviceId = 0; - auto pPmt = static_cast(pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId)); - pPmt->setGuid(guid64BitMemoryCounters); - pPmt->mockReadArgumentValue.push_back(0); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); - pPmt->mockReadArgumentValue.push_back(0); - pPmt->mockReadValueReturnStatus.push_back(ZE_RESULT_SUCCESS); + zes_mem_bandwidth_t bandwidth{}; + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenInvalidGuidWhenCallingGetBandwidthThenFailureIsReturned, IsPVC) { + 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 { + std::ostringstream oStream; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xABCDEF"; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; zes_mem_bandwidth_t bandwidth{}; - auto result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); - EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN); + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); +} + +HWTEST2_F(SysmanProductHelperMemoryTest, GivenInvalidGuidWhenCallingGetBandwidthThenFailureIsReturned, IsDG2) { + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); + + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { + std::ostringstream oStream; + if (fd == 4) { + oStream << "0"; + } else if (fd == 5) { + oStream << "0xABCDEF"; + } else { + oStream << "-1"; + } + std::string value = oStream.str(); + memcpy(buf, value.data(), count); + return count; + }); + + auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); + uint32_t subDeviceId = 0; + + zes_mem_bandwidth_t bandwidth{}; + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_ERROR_NOT_AVAILABLE); } HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthAPIsThenErrorIsReturned, IsDG1) { @@ -238,7 +790,7 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal EXPECT_EQ(properties.numChannels, -1); EXPECT_EQ(properties.busWidth, -1); zes_mem_bandwidth_t bandwidth; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); } @@ -286,14 +838,11 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceAndPhys EXPECT_EQ(properties.physicalSize, 0u); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsDG2) { - VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { - std::ostringstream oStream; - oStream << mockMaxBwDg2; - std::string value = oStream.str(); - memcpy(buf, value.data(), count); - return count; - }); +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenSuccessIsReturned, IsDG2) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadIdiFilesSuccess); auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); zes_mem_properties_t properties; @@ -310,7 +859,7 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal EXPECT_EQ(properties.busWidth, memoryBusWidth); zes_mem_bandwidth_t bandwidth; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); EXPECT_EQ(result, ZE_RESULT_SUCCESS); expectedReadCounters = numberMcChannels * (mockIdiReadVal + mockDisplayVc1ReadVal) * transactionSize; EXPECT_EQ(expectedReadCounters, bandwidth.readCounter); @@ -321,37 +870,30 @@ HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCal EXPECT_GT(bandwidth.timestamp, 0u); } -HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceAndPhysicalSizeSupportedWhenCallingMemoryAPIsThenErrorIsReturned, IsDG2) { - VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { - std::ostringstream oStream; - oStream << mockMaxBwDg2; - std::string value = oStream.str(); - memcpy(buf, value.data(), count); - return count; - }); +HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingGetMemoryBandwidthTwiceThenSuccessIsReturned, IsDG2) { + + VariableBackup mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess); + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess); + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, &mockReadIdiFilesSuccess); auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily); - zes_mem_properties_t properties; - uint64_t expectedReadCounters = 0, expectedWriteCounters = 0, expectedBandwidth = 0; - bool isSubdevice = true; - uint32_t subDeviceId = 0; - ze_result_t result = pSysmanProductHelper->getMemoryProperties(&properties, pLinuxSysmanImp, pDrm, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId, isSubdevice); - EXPECT_EQ(result, ZE_RESULT_SUCCESS); - EXPECT_EQ(properties.location, ZES_MEM_LOC_DEVICE); - EXPECT_TRUE(properties.onSubdevice); - EXPECT_EQ(properties.subdeviceId, 0u); - EXPECT_EQ(properties.physicalSize, 0u); - EXPECT_EQ(properties.numChannels, numMemoryChannels); - EXPECT_EQ(properties.busWidth, memoryBusWidth); - zes_mem_bandwidth_t bandwidth; - result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp->getPlatformMonitoringTechAccess(subDeviceId), pSysmanDeviceImp, pLinuxSysmanImp->getSysmanKmdInterface(), subDeviceId); + uint32_t subDeviceId = 0; + uint64_t expectedReadCounters = 0, expectedWriteCounters = 0, expectedBandwidth = 0; + ze_result_t result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); EXPECT_EQ(result, ZE_RESULT_SUCCESS); expectedReadCounters = numberMcChannels * (mockIdiReadVal + mockDisplayVc1ReadVal) * transactionSize; - EXPECT_EQ(expectedReadCounters, bandwidth.readCounter); expectedWriteCounters = numberMcChannels * mockIdiWriteVal * transactionSize; - EXPECT_EQ(expectedWriteCounters, bandwidth.writeCounter); expectedBandwidth = mockMaxBwDg2 * mbpsToBytesPerSecond; + EXPECT_EQ(expectedReadCounters, bandwidth.readCounter); + EXPECT_EQ(expectedWriteCounters, bandwidth.writeCounter); + EXPECT_EQ(expectedBandwidth, bandwidth.maxBandwidth); + EXPECT_GT(bandwidth.timestamp, 0u); + + result = pSysmanProductHelper->getMemoryBandwidth(&bandwidth, pLinuxSysmanImp, subDeviceId); + EXPECT_EQ(result, ZE_RESULT_SUCCESS); + EXPECT_EQ(expectedReadCounters, bandwidth.readCounter); + EXPECT_EQ(expectedWriteCounters, bandwidth.writeCounter); EXPECT_EQ(expectedBandwidth, bandwidth.maxBandwidth); EXPECT_GT(bandwidth.timestamp, 0u); }