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); }