mirror of
https://github.com/intel/compute-runtime.git
synced 2025-12-30 09:58:55 +08:00
refactor(sysman): Remove Pmt tile aggregator from Memory Module
The PMT tile aggregator used in the memory module has been replaced with the wrapper functions which calls the functions from Pmt Util class. Related-To: NEO-11992 Signed-off-by: Pratik Bari <pratik.bari@intel.com>
This commit is contained in:
Pratik Bari
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
357a607d22
commit
0dacb78d78
@@ -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<LinuxSysmanImp *>(pOsSysman);
|
||||
pDrm = pLinuxSysmanImp->getDrm();
|
||||
pDevice = pLinuxSysmanImp->getSysmanDeviceImp();
|
||||
pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
|
||||
pSysmanKmdInterface = pLinuxSysmanImp->getSysmanKmdInterface();
|
||||
}
|
||||
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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<uint32_t, std::string> &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<uint32_t, std::string> 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() {
|
||||
}
|
||||
|
||||
|
||||
@@ -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<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject);
|
||||
static ze_result_t getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &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<uint32_t, std::string> &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<std::string, uint64_t> 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<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -93,7 +93,7 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryProperties(zes_mem_prope
|
||||
}
|
||||
|
||||
template <PRODUCT_FAMILY gfxProduct>
|
||||
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) {
|
||||
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
|
||||
@@ -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<NEO::ProductHelper>();
|
||||
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<char, NEO::PmtUtil::guidStringSize> 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<gfxProduct>::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<gfxProduct>::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId) {
|
||||
return getHBMBandwidth(pBandwidth, pLinuxSysmanImp, subdeviceId);
|
||||
}
|
||||
|
||||
template <>
|
||||
|
||||
@@ -137,19 +137,18 @@ const std::map<std::string, std::map<std::string, uint64_t>> *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<std::string> nameOfCounters{"IDI_READS", "IDI_WRITES", "DISPLAY_VC1_READS"};
|
||||
std::vector<uint64_t> 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<gfxProduct>::getMemoryBandwidth(zes_mem_bandwidth_t *pBandwidth, PlatformMonitoringTech *pPmt, SysmanDeviceImp *pDevice, SysmanKmdInterface *pSysmanKmdInterface, uint32_t subdeviceId) {
|
||||
ze_result_t SysmanProductHelperHw<gfxProduct>::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;
|
||||
|
||||
@@ -543,6 +543,32 @@ uint32_t LinuxSysmanImp::getMemoryType() {
|
||||
return memType;
|
||||
}
|
||||
|
||||
void LinuxSysmanImp::addTelemOffsetAndDirPair(uint32_t subdeviceId, std::pair<uint64_t, std::string> 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<uint32_t, std::string> telemNodes) {
|
||||
telemNodesInPCIPath = telemNodes;
|
||||
}
|
||||
|
||||
bool LinuxSysmanImp::getTelemNodes(std::map<uint32_t, std::string> &telemNodes) {
|
||||
if (telemNodesInPCIPath.empty()) {
|
||||
return false;
|
||||
}
|
||||
telemNodes = telemNodesInPCIPath;
|
||||
return true;
|
||||
}
|
||||
|
||||
OsSysman *OsSysman::create(SysmanDeviceImp *pParentSysmanDeviceImp) {
|
||||
LinuxSysmanImp *pLinuxSysmanImp = new LinuxSysmanImp(pParentSysmanDeviceImp);
|
||||
return static_cast<OsSysman *>(pLinuxSysmanImp);
|
||||
|
||||
@@ -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<uint32_t, std::string> telemNodes);
|
||||
bool getTelemNodes(std::map<uint32_t, std::string> &telemNodes);
|
||||
void addTelemOffsetAndDirPair(uint32_t subdeviceId, std::pair<uint64_t, std::string> pairTelemOffsetAndDir);
|
||||
bool getTelemOffsetAndDir(uint32_t subdeviceId, uint64_t &telemOffset, std::string &telemDir);
|
||||
|
||||
protected:
|
||||
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper;
|
||||
@@ -94,6 +98,8 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
|
||||
std::string rootPath;
|
||||
void releaseFwUtilInterface();
|
||||
uint32_t memType = unknownMemoryType;
|
||||
std::map<uint32_t, std::pair<uint64_t, std::string>> mapOfSubDeviceIdToTelemOffsetAndDirPair;
|
||||
std::map<uint32_t, std::string> telemNodesInPCIPath;
|
||||
|
||||
private:
|
||||
LinuxSysmanImp() = delete;
|
||||
|
||||
@@ -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<ze_result_t> mockReadValueReturnStatus{};
|
||||
std::vector<uint32_t> 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) {}
|
||||
|
||||
@@ -73,13 +73,6 @@ class SysmanDeviceMemoryFixtureI915 : public SysmanDeviceMemoryFixture {
|
||||
osInterface->setDriverModel(std::unique_ptr<MockMemoryNeoDrm>(pDrm));
|
||||
pDrm->setMemoryType(NEO::DeviceBlobConstants::MemoryType::hbm2e);
|
||||
pDrm->ioctlHelper = static_cast<std::unique_ptr<NEO::IoctlHelper>>(std::make_unique<SysmanMemoryMockIoctlHelper>(*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<std::string, std::string> 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<int>(it->second.size());
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) {
|
||||
|
||||
std::map<std::string, std::string> 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<int>(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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &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<NEO::ProductHelper>();
|
||||
hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo);
|
||||
|
||||
auto pPmt = static_cast<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<NEO::ProductHelper>();
|
||||
hwInfo->platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, *hwInfo);
|
||||
|
||||
auto pPmt = static_cast<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> 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<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> 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<MockMemoryPmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(properties.subdeviceId));
|
||||
pPmt->mockIdiReadValueFailureReturnStatus = ZE_RESULT_ERROR_UNKNOWN;
|
||||
EXPECT_EQ(zesMemoryGetBandwidth(handle, &bandwidth), ZE_RESULT_ERROR_UNKNOWN);
|
||||
}
|
||||
}
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> 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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> 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);
|
||||
|
||||
@@ -39,13 +39,6 @@ class SysmanProductHelperMemoryTest : public SysmanDeviceFixture {
|
||||
pDrm = new MockMemoryNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
|
||||
auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface;
|
||||
osInterface->setDriverModel(std::unique_ptr<MockMemoryNeoDrm>(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<decltype(NEO::SysCalls::sysCallsPread)> 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<std::string, std::string> 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<int>(it->second.size());
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int mockReadLinkSingleTelemetryNodeSuccess(const char *path, char *buf, size_t bufsize) {
|
||||
std::map<std::string, std::string> 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<int>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
if (fd == 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, &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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<MockMemoryPmt *>(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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
|
||||
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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess);
|
||||
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsPread)> 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<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSingleTelemetryNodeSuccess);
|
||||
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> 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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user