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

refactor(sysman): Move guidToKeyOffsetMap to Product specific files 

Related-To: NEO-11821

Signed-off-by: Anvesh Bakwad <anvesh.bakwad@intel.com>
This commit is contained in:
Anvesh Bakwad 2024-06-28 21:38:20 +00:00 committed by Compute-Runtime-Automation
parent b8246d806f
commit aa7b306813
18 changed files with 410 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/sysman/source/api/global_operations/linux/sysman_os_global_operations_imp.cpp
View File

@ -61,7 +61,7 @@ bool LinuxGlobalOperationsImp::getSerialNumber(char (&serialNumber)[ZES_STRING_P
}
uint64_t containerOffset = 0;
if (!PlatformMonitoringTech::getTelemOffsetForContainer(telemDir, "PPIN", containerOffset)) {
if (!PlatformMonitoringTech::getTelemOffsetForContainer(pLinuxSysmanImp->getSysmanProductHelper(), telemDir, "PPIN", containerOffset)) {
return false;
}
@ -88,7 +88,7 @@ bool LinuxGlobalOperationsImp::getBoardNumber(char (&boardNumber)[ZES_STRING_PRO
}
uint64_t containerOffset = 0;
if (!PlatformMonitoringTech::getTelemOffsetForContainer(telemDir, "BoardNumber", containerOffset)) {
if (!PlatformMonitoringTech::getTelemOffsetForContainer(pLinuxSysmanImp->getSysmanProductHelper(), telemDir, "BoardNumber", containerOffset)) {
return false;
}

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

@ -12,6 +12,7 @@
#include "shared/source/os_interface/linux/pmt_util.h"
#include "level_zero/sysman/source/device/sysman_device_imp.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
@ -120,10 +121,11 @@ ze_result_t PlatformMonitoringTech::enumerateRootTelemIndex(FsAccessInterface *p
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
ze_result_t PlatformMonitoringTech::init(FsAccessInterface *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily) {
ze_result_t PlatformMonitoringTech::init(LinuxSysmanImp *pLinuxSysmanImp, const std::string &gpuUpstreamPortPath) {
std::string telemNode = telem + std::to_string(rootDeviceTelemNodeIndex);
// For XE_HP_SDV and PVC single tile devices, telemetry info is retrieved from
// tile's telem node rather from root device telem node.
auto productFamily = pLinuxSysmanImp->getSysmanDeviceImp()->getProductFamily();
if ((isSubdevice) || (productFamily == IGFX_PVC)) {
uint32_t telemNodeIndex = 0;
// If rootDeviceTelemNode is telem1, then rootDeviceTelemNodeIndex = 1
@ -132,7 +134,9 @@ ze_result_t PlatformMonitoringTech::init(FsAccessInterface *pFsAccess, const std
telemNodeIndex = rootDeviceTelemNodeIndex + subdeviceId + 1;
telemNode = telem + std::to_string(telemNodeIndex);
}
std::string baseTelemSysFSNode = baseTelemSysFS + "/" + telemNode;
auto pFsAccess = &pLinuxSysmanImp->getFsAccess();
if (!isValidTelemNode(pFsAccess, gpuUpstreamPortPath, baseTelemSysFSNode)) {
return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
}
@ -152,7 +156,9 @@ ze_result_t PlatformMonitoringTech::init(FsAccessInterface *pFsAccess, const std
"Telemetry sysfs entry not available %s\n", guidPath.c_str());
return result;
}
result = PlatformMonitoringTech::getKeyOffsetMap(guid, keyOffsetMap);
auto pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
result = PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guid, keyOffsetMap);
if (ZE_RESULT_SUCCESS != result) {
// We didnt have any entry for this guid in guidToKeyOffsetMap
return result;
@ -173,10 +179,10 @@ PlatformMonitoringTech::PlatformMonitoringTech(FsAccessInterface *pFsAccess, ze_
uint32_t subdeviceId) : subdeviceId(subdeviceId), isSubdevice(onSubdevice) {
}
void PlatformMonitoringTech::doInitPmtObject(FsAccessInterface *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt,
const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily) {
if (pPmt->init(pFsAccess, gpuUpstreamPortPath, productFamily) == ZE_RESULT_SUCCESS) {
void PlatformMonitoringTech::doInitPmtObject(LinuxSysmanImp *pLinuxSysmanImp, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject) {
if (pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPath) == ZE_RESULT_SUCCESS) {
mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stdout,
"Pmt object: 0x%llX initialization for subdeviceId %d successful\n", pPmt, static_cast<int>(subdeviceId));
@ -194,11 +200,9 @@ void PlatformMonitoringTech::create(LinuxSysmanImp *pLinuxSysmanImp, std::string
uint32_t subdeviceId = 0;
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto productFamily = pLinuxSysmanImp->getSysmanDeviceImp()->getProductFamily();
auto pPmt = new PlatformMonitoringTech(&pLinuxSysmanImp->getFsAccess(), onSubdevice, subdeviceId);
UNRECOVERABLE_IF(nullptr == pPmt);
PlatformMonitoringTech::doInitPmtObject(&pLinuxSysmanImp->getFsAccess(), subdeviceId, pPmt,
gpuUpstreamPortPath, mapOfSubDeviceIdToPmtObject, productFamily);
PlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPath, mapOfSubDeviceIdToPmtObject);
subdeviceId++;
} while (subdeviceId < subDeviceCount);
}
@ -225,7 +229,7 @@ bool PlatformMonitoringTech::getTelemOffsetAndTelemDir(LinuxSysmanImp *pLinuxSys
return true;
}
bool PlatformMonitoringTech::getTelemOffsetForContainer(const std::string &telemDir, const std::string &key, uint64_t &telemOffset) {
bool PlatformMonitoringTech::getTelemOffsetForContainer(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset) {
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());
@ -233,7 +237,7 @@ bool PlatformMonitoringTech::getTelemOffsetForContainer(const std::string &telem
}
std::map<std::string, uint64_t> keyOffsetMap;
if (ZE_RESULT_SUCCESS == PlatformMonitoringTech::getKeyOffsetMap(guidString.data(), keyOffsetMap)) {
if (ZE_RESULT_SUCCESS == PlatformMonitoringTech::getKeyOffsetMap(pSysmanProductHelper, guidString.data(), keyOffsetMap)) {
auto keyOffset = keyOffsetMap.find(key.c_str());
if (keyOffset != keyOffsetMap.end()) {
telemOffset = keyOffset->second;

13
level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h
View File

@ -11,8 +11,6 @@
#include "level_zero/zes_api.h"
#include "igfxfmid.h"
#include <fcntl.h>
#include <map>
#include <sys/stat.h>
@ -22,6 +20,7 @@ namespace L0 {
namespace Sysman {
class LinuxSysmanImp;
class FsAccessInterface;
class SysmanProductHelper;
class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
public:
@ -35,18 +34,18 @@ class PlatformMonitoringTech : NEO::NonCopyableOrMovableClass {
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(std::string guid, std::map<std::string, uint64_t> &keyOffsetMap);
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 getTelemOffsetForContainer(const std::string &telemDir, const std::string &key, uint64_t &telemOffset);
static bool getTelemOffsetForContainer(SysmanProductHelper *pSysmanProductHelper, const std::string &telemDir, const std::string &key, uint64_t &telemOffset);
protected:
static uint32_t rootDeviceTelemNodeIndex;
std::string telemetryDeviceEntry{};
std::map<std::string, uint64_t> keyOffsetMap;
std::string guid;
ze_result_t init(FsAccessInterface *pFsAccess, const std::string &gpuUpstreamPortPath, PRODUCT_FAMILY productFamily);
static void doInitPmtObject(FsAccessInterface *pFsAccess, uint32_t subdeviceId, PlatformMonitoringTech *pPmt, const std::string &gpuUpstreamPortPath,
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> &mapOfSubDeviceIdToPmtObject, PRODUCT_FAMILY productFamily);
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);
decltype(&NEO::SysCalls::pread) preadFunction = NEO::SysCalls::pread;
private:

14
level_zero/sysman/source/shared/linux/pmt/sysman_pmt_helper.cpp
View File

@ -1,20 +1,24 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt_xml_offsets.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
namespace L0 {
namespace Sysman {
ze_result_t PlatformMonitoringTech::getKeyOffsetMap(std::string guid, std::map<std::string, uint64_t> &keyOffsetMap) {
ze_result_t PlatformMonitoringTech::getKeyOffsetMap(SysmanProductHelper *pSysmanProductHelper, std::string guid, std::map<std::string, uint64_t> &keyOffsetMap) {
ze_result_t retVal = ZE_RESULT_ERROR_UNKNOWN;
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(guid);
if (keyOffsetMapEntry == guidToKeyOffsetMap.end()) {
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
if (pGuidToKeyOffsetMap == nullptr) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto keyOffsetMapEntry = pGuidToKeyOffsetMap->find(guid);
if (keyOffsetMapEntry == pGuidToKeyOffsetMap->end()) {
// We didnt have any entry for this guid in guidToKeyOffsetMap
retVal = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return retVal;

245
level_zero/sysman/source/shared/linux/pmt/sysman_pmt_xml_offsets.h
View File

@ -1,245 +0,0 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <cstdint>
#include <map>
#include <string>
namespace L0 {
namespace Sysman {
// Each entry of this map corresponds to one particular graphics card type for example, DG1 A or B step.
// or XeHP_SDV. GUID string will help in identify the card type
const std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap = {
{"0x490e01", // DG1 B stepping
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}}},
{"0x490e", // DG1 A stepping
{{"PACKAGE_ENERGY", 0x400},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}}},
{"0x4f95", // For DG2 device
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}, // SOC_TEMPERATURE contains GT_TEMP, DRAM_TEMP, SA_TEMP, DE_TEMP, PCIE_TEMP, TYPEC_TEMP
{"0x4f9301", // For ATSM device
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}, // SOC_TEMPERATURE contains GT_TEMP, DRAM_TEMP, SA_TEMP, DE_TEMP, PCIE_TEMP, TYPEC_TEMP
{"0x4f9302", // For DG2 512EU / ATS-M1
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56},
{"MC_CAPTURE_TIMESTAMP", 1088},
{"IDI_READS[0]", 1096},
{"IDI_READS[1]", 1104},
{"IDI_READS[2]", 1112},
{"IDI_READS[3]", 1120},
{"IDI_READS[4]", 1128},
{"IDI_READS[5]", 1136},
{"IDI_READS[6]", 1144},
{"IDI_READS[7]", 1152},
{"IDI_READS[8]", 1160},
{"IDI_READS[9]", 1168},
{"IDI_READS[10]", 1176},
{"IDI_READS[11]", 1184},
{"IDI_READS[12]", 1192},
{"IDI_READS[13]", 1200},
{"IDI_READS[14]", 1208},
{"IDI_READS[15]", 1216},
{"IDI_WRITES[0]", 1224},
{"IDI_WRITES[1]", 1232},
{"IDI_WRITES[2]", 1240},
{"IDI_WRITES[3]", 1248},
{"IDI_WRITES[4]", 1256},
{"IDI_WRITES[5]", 1264},
{"IDI_WRITES[6]", 1272},
{"IDI_WRITES[7]", 1280},
{"IDI_WRITES[8]", 1288},
{"IDI_WRITES[9]", 1296},
{"IDI_WRITES[10]", 1304},
{"IDI_WRITES[11]", 1312},
{"IDI_WRITES[12]", 1320},
{"IDI_WRITES[13]", 1328},
{"IDI_WRITES[14]", 1336},
{"IDI_WRITES[15]", 1344},
{"DISPLAY_VC1_READS[0]", 1352},
{"DISPLAY_VC1_READS[1]", 1360},
{"DISPLAY_VC1_READS[2]", 1368},
{"DISPLAY_VC1_READS[3]", 1376},
{"DISPLAY_VC1_READS[4]", 1384},
{"DISPLAY_VC1_READS[5]", 1392},
{"DISPLAY_VC1_READS[6]", 1400},
{"DISPLAY_VC1_READS[7]", 1408},
{"DISPLAY_VC1_READS[8]", 1416},
{"DISPLAY_VC1_READS[9]", 1424},
{"DISPLAY_VC1_READS[10]", 1432},
{"DISPLAY_VC1_READS[11]", 1440},
{"DISPLAY_VC1_READS[12]", 1448},
{"DISPLAY_VC1_READS[13]", 1456},
{"DISPLAY_VC1_READS[14]", 1464},
{"DISPLAY_VC1_READS[15]", 1472}}},
{"0x4f9502", // For DG2 128EU / ATS-M3
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56},
{"MC_CAPTURE_TIMESTAMP", 1088},
{"IDI_READS[0]", 1096},
{"IDI_READS[1]", 1104},
{"IDI_READS[2]", 1112},
{"IDI_READS[3]", 1120},
{"IDI_READS[4]", 1128},
{"IDI_READS[5]", 1136},
{"IDI_READS[6]", 1144},
{"IDI_READS[7]", 1152},
{"IDI_READS[8]", 1160},
{"IDI_READS[9]", 1168},
{"IDI_READS[10]", 1176},
{"IDI_READS[11]", 1184},
{"IDI_READS[12]", 1192},
{"IDI_READS[13]", 1200},
{"IDI_READS[14]", 1208},
{"IDI_READS[15]", 1216},
{"IDI_WRITES[0]", 1224},
{"IDI_WRITES[1]", 1232},
{"IDI_WRITES[2]", 1240},
{"IDI_WRITES[3]", 1248},
{"IDI_WRITES[4]", 1256},
{"IDI_WRITES[5]", 1264},
{"IDI_WRITES[6]", 1272},
{"IDI_WRITES[7]", 1280},
{"IDI_WRITES[8]", 1288},
{"IDI_WRITES[9]", 1296},
{"IDI_WRITES[10]", 1304},
{"IDI_WRITES[11]", 1312},
{"IDI_WRITES[12]", 1320},
{"IDI_WRITES[13]", 1328},
{"IDI_WRITES[14]", 1336},
{"IDI_WRITES[15]", 1344},
{"DISPLAY_VC1_READS[0]", 1352},
{"DISPLAY_VC1_READS[1]", 1360},
{"DISPLAY_VC1_READS[2]", 1368},
{"DISPLAY_VC1_READS[3]", 1376},
{"DISPLAY_VC1_READS[4]", 1384},
{"DISPLAY_VC1_READS[5]", 1392},
{"DISPLAY_VC1_READS[6]", 1400},
{"DISPLAY_VC1_READS[7]", 1408},
{"DISPLAY_VC1_READS[8]", 1416},
{"DISPLAY_VC1_READS[9]", 1424},
{"DISPLAY_VC1_READS[10]", 1432},
{"DISPLAY_VC1_READS[11]", 1440},
{"DISPLAY_VC1_READS[12]", 1448},
{"DISPLAY_VC1_READS[13]", 1456},
{"DISPLAY_VC1_READS[14]", 1464},
{"DISPLAY_VC1_READS[15]", 1472}}},
{"0xb15a0edc", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364}}},
{"0xb15a0edd", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364}}},
{"0xb15a0ede", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364},
{"VF0_HBM_READ_L", 384},
{"VF0_HBM_READ_H", 388},
{"VF0_HBM_WRITE_L", 392},
{"VF0_HBM_WRITE_H", 396},
{"VF1_HBM_READ_L", 400},
{"VF1_HBM_READ_H", 404},
{"VF1_HBM_WRITE_L", 408},
{"VF1_HBM_WRITE_H", 412}}},
{"0x41fe79a5", // For PVC root device
{{"PPIN", 152},
{"BoardNumber", 72}}}};
} // namespace Sysman
} // namespace L0

19
level_zero/sysman/source/shared/linux/product_helper/gen12lp/dg1/sysman_product_helper_dg1.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -17,6 +17,23 @@ namespace L0 {
namespace Sysman {
constexpr static auto gfxProduct = IGFX_DG1;
static std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap = {
{"0x490e01", // DG1 B stepping
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}}},
{"0x490e", // DG1 A stepping
{{"PACKAGE_ENERGY", 0x400},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}}}};
template <>
const std::map<std::string, std::map<std::string, uint64_t>> *SysmanProductHelperHw<gfxProduct>::getGuidToKeyOffsetMap() {
return &guidToKeyOffsetMap;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
auto isValidTemperature = [](auto temperature) {

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

@ -12,6 +12,7 @@
#include "igfxfmid.h"
#include <map>
#include <memory>
#include <vector>
@ -96,6 +97,7 @@ class SysmanProductHelper {
virtual bool isEccConfigurationSupported() = 0;
virtual ~SysmanProductHelper() = default;
virtual const std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() = 0;
protected:
SysmanProductHelper() = default;

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

@ -73,6 +73,8 @@ class SysmanProductHelperHw : public SysmanProductHelper {
~SysmanProductHelperHw() override = default;
const std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() override;
protected:
SysmanProductHelperHw() = default;
};

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

@ -24,6 +24,11 @@
namespace L0 {
namespace Sysman {
template <PRODUCT_FAMILY gfxProduct>
const std::map<std::string, std::map<std::string, uint64_t>> *SysmanProductHelperHw<gfxProduct>::getGuidToKeyOffsetMap() {
return nullptr;
}
template <PRODUCT_FAMILY gfxProduct>
void SysmanProductHelperHw<gfxProduct>::getFrequencyStepSize(double *pStepSize) {
*pStepSize = (50.0 / 3); // Step of 16.6666667 Mhz

111
level_zero/sysman/source/shared/linux/product_helper/xe_hpc_core/pvc/sysman_product_helper_pvc.cpp
View File

@ -19,6 +19,117 @@ static const uint32_t numHbmModules = 4;
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_xe_hp_and_later.inl"
static std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap = {
{"0xb15a0edc", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364}}},
{"0xb15a0edd", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364}}},
{"0xb15a0ede", // For PVC device
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"VF0_VFID", 88},
{"VF0_HBM0_READ", 92},
{"VF0_HBM0_WRITE", 96},
{"VF0_HBM1_READ", 104},
{"VF0_HBM1_WRITE", 108},
{"VF0_TIMESTAMP_L", 168},
{"VF0_TIMESTAMP_H", 172},
{"VF1_VFID", 176},
{"VF1_HBM0_READ", 180},
{"VF1_HBM0_WRITE", 184},
{"VF1_HBM1_READ", 192},
{"VF1_HBM1_WRITE", 196},
{"VF1_TIMESTAMP_L", 256},
{"VF1_TIMESTAMP_H", 260},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308},
{"VF0_HBM2_READ", 312},
{"VF0_HBM2_WRITE", 316},
{"VF0_HBM3_READ", 328},
{"VF0_HBM3_WRITE", 332},
{"VF1_HBM2_READ", 344},
{"VF1_HBM2_WRITE", 348},
{"VF1_HBM3_READ", 360},
{"VF1_HBM3_WRITE", 364},
{"VF0_HBM_READ_L", 384},
{"VF0_HBM_READ_H", 388},
{"VF0_HBM_WRITE_L", 392},
{"VF0_HBM_WRITE_H", 396},
{"VF1_HBM_READ_L", 400},
{"VF1_HBM_READ_H", 404},
{"VF1_HBM_WRITE_L", 408},
{"VF1_HBM_WRITE_H", 412}}},
{"0x41fe79a5", // For PVC root device
{{"PPIN", 152},
{"BoardNumber", 72}}}};
template <>
const std::map<std::string, std::map<std::string, uint64_t>> *SysmanProductHelperHw<gfxProduct>::getGuidToKeyOffsetMap() {
return &guidToKeyOffsetMap;
}
void getHBMFrequency(SysmanKmdInterface *pSysmanKmdInterface, SysFsAccessInterface *pSysFsAccess, uint64_t &hbmFrequency, uint32_t subdeviceId, unsigned short stepping) {
hbmFrequency = 0;
if (stepping >= REVISION_B) {

117
level_zero/sysman/source/shared/linux/product_helper/xe_hpg_core/dg2/sysman_product_helper_dg2.cpp
View File

@ -20,6 +20,123 @@ RasInterfaceType SysmanProductHelperHw<gfxProduct>::getGtRasUtilInterface() {
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_xe_hp_and_later.inl"
static std::map<std::string, std::map<std::string, uint64_t>> guidToKeyOffsetMap = {
{"0x4f95", // For DG2 device
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}, // SOC_TEMPERATURE contains GT_TEMP, DRAM_TEMP, SA_TEMP, DE_TEMP, PCIE_TEMP, TYPEC_TEMP
{"0x4f9301", // For ATSM device
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}, // SOC_TEMPERATURE contains GT_TEMP, DRAM_TEMP, SA_TEMP, DE_TEMP, PCIE_TEMP, TYPEC_TEMP
{"0x4f9302", // For DG2 512EU / ATS-M1
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56},
{"MC_CAPTURE_TIMESTAMP", 1088},
{"IDI_READS[0]", 1096},
{"IDI_READS[1]", 1104},
{"IDI_READS[2]", 1112},
{"IDI_READS[3]", 1120},
{"IDI_READS[4]", 1128},
{"IDI_READS[5]", 1136},
{"IDI_READS[6]", 1144},
{"IDI_READS[7]", 1152},
{"IDI_READS[8]", 1160},
{"IDI_READS[9]", 1168},
{"IDI_READS[10]", 1176},
{"IDI_READS[11]", 1184},
{"IDI_READS[12]", 1192},
{"IDI_READS[13]", 1200},
{"IDI_READS[14]", 1208},
{"IDI_READS[15]", 1216},
{"IDI_WRITES[0]", 1224},
{"IDI_WRITES[1]", 1232},
{"IDI_WRITES[2]", 1240},
{"IDI_WRITES[3]", 1248},
{"IDI_WRITES[4]", 1256},
{"IDI_WRITES[5]", 1264},
{"IDI_WRITES[6]", 1272},
{"IDI_WRITES[7]", 1280},
{"IDI_WRITES[8]", 1288},
{"IDI_WRITES[9]", 1296},
{"IDI_WRITES[10]", 1304},
{"IDI_WRITES[11]", 1312},
{"IDI_WRITES[12]", 1320},
{"IDI_WRITES[13]", 1328},
{"IDI_WRITES[14]", 1336},
{"IDI_WRITES[15]", 1344},
{"DISPLAY_VC1_READS[0]", 1352},
{"DISPLAY_VC1_READS[1]", 1360},
{"DISPLAY_VC1_READS[2]", 1368},
{"DISPLAY_VC1_READS[3]", 1376},
{"DISPLAY_VC1_READS[4]", 1384},
{"DISPLAY_VC1_READS[5]", 1392},
{"DISPLAY_VC1_READS[6]", 1400},
{"DISPLAY_VC1_READS[7]", 1408},
{"DISPLAY_VC1_READS[8]", 1416},
{"DISPLAY_VC1_READS[9]", 1424},
{"DISPLAY_VC1_READS[10]", 1432},
{"DISPLAY_VC1_READS[11]", 1440},
{"DISPLAY_VC1_READS[12]", 1448},
{"DISPLAY_VC1_READS[13]", 1456},
{"DISPLAY_VC1_READS[14]", 1464},
{"DISPLAY_VC1_READS[15]", 1472}}},
{"0x4f9502", // For DG2 128EU / ATS-M3
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56},
{"MC_CAPTURE_TIMESTAMP", 1088},
{"IDI_READS[0]", 1096},
{"IDI_READS[1]", 1104},
{"IDI_READS[2]", 1112},
{"IDI_READS[3]", 1120},
{"IDI_READS[4]", 1128},
{"IDI_READS[5]", 1136},
{"IDI_READS[6]", 1144},
{"IDI_READS[7]", 1152},
{"IDI_READS[8]", 1160},
{"IDI_READS[9]", 1168},
{"IDI_READS[10]", 1176},
{"IDI_READS[11]", 1184},
{"IDI_READS[12]", 1192},
{"IDI_READS[13]", 1200},
{"IDI_READS[14]", 1208},
{"IDI_READS[15]", 1216},
{"IDI_WRITES[0]", 1224},
{"IDI_WRITES[1]", 1232},
{"IDI_WRITES[2]", 1240},
{"IDI_WRITES[3]", 1248},
{"IDI_WRITES[4]", 1256},
{"IDI_WRITES[5]", 1264},
{"IDI_WRITES[6]", 1272},
{"IDI_WRITES[7]", 1280},
{"IDI_WRITES[8]", 1288},
{"IDI_WRITES[9]", 1296},
{"IDI_WRITES[10]", 1304},
{"IDI_WRITES[11]", 1312},
{"IDI_WRITES[12]", 1320},
{"IDI_WRITES[13]", 1328},
{"IDI_WRITES[14]", 1336},
{"IDI_WRITES[15]", 1344},
{"DISPLAY_VC1_READS[0]", 1352},
{"DISPLAY_VC1_READS[1]", 1360},
{"DISPLAY_VC1_READS[2]", 1368},
{"DISPLAY_VC1_READS[3]", 1376},
{"DISPLAY_VC1_READS[4]", 1384},
{"DISPLAY_VC1_READS[5]", 1392},
{"DISPLAY_VC1_READS[6]", 1400},
{"DISPLAY_VC1_READS[7]", 1408},
{"DISPLAY_VC1_READS[8]", 1416},
{"DISPLAY_VC1_READS[9]", 1424},
{"DISPLAY_VC1_READS[10]", 1432},
{"DISPLAY_VC1_READS[11]", 1440},
{"DISPLAY_VC1_READS[12]", 1448},
{"DISPLAY_VC1_READS[13]", 1456},
{"DISPLAY_VC1_READS[14]", 1464},
{"DISPLAY_VC1_READS[15]", 1472}}}};
template <>
const std::map<std::string, std::map<std::string, uint64_t>> *SysmanProductHelperHw<gfxProduct>::getGuidToKeyOffsetMap() {
return &guidToKeyOffsetMap;
}
ze_result_t readMcChannelCounters(PlatformMonitoringTech *pPmt, uint64_t &readCounters, uint64_t &writeCounters) {
uint32_t numMcChannels = 16u;
ze_result_t result = ZE_RESULT_ERROR_UNKNOWN;

14
level_zero/sysman/test/unit_tests/sources/global_operations/linux/test_zes_global_operations.cpp
View File

@ -11,6 +11,7 @@
#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
#include "level_zero/sysman/source/shared/linux/kmd_interface/sysman_kmd_interface.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/shared/linux/kmd_interface/mock_sysman_kmd_interface_i915.h"
@ -202,6 +203,19 @@ TEST_F(SysmanGlobalOperationsFixture, GivenValidDeviceHandleWhenCallingzesGlobal
return -1;
});
struct MockSysmanProductHelperGlobalOperation : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelperGlobalOperation() = default;
std::unique_ptr<std::map<std::string, std::map<std::string, uint64_t>>> mockMap;
std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() override {
mockMap = std::make_unique<std::map<std::string, std::map<std::string, uint64_t>>>();
(*mockMap)["0x41fe79a5"] = {{"PPIN", 152},
{"BoardNumber", 72}};
return mockMap.get();
}
};
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperGlobalOperation>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
MockGlobalOperationsFsAccess *pFsAccess = new MockGlobalOperationsFsAccess();
MockGlobalOperationsSysfsAccess *pSysfsAccess = new MockGlobalOperationsSysfsAccess();
MockSysmanKmdInterfacePrelim *pSysmanKmdInterface = new MockSysmanKmdInterfacePrelim(pLinuxSysmanImp->getSysmanProductHelper());

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

@ -15,8 +15,16 @@ namespace L0 {
namespace Sysman {
namespace ult {
static std::map<std::string, std::map<std::string, uint64_t>> mockGuidToKeyOffsetMap = {
{"0x490e01",
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}}}};
struct MockSysmanProductHelper : public L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
MockSysmanProductHelper() = default;
std::map<std::string, std::map<std::string, uint64_t>> *getGuidToKeyOffsetMap() override { return &mockGuidToKeyOffsetMap; }
ADDMETHOD_NOBASE(isFrequencySetRangeSupported, bool, false, ());
ADDMETHOD_NOBASE(isPowerSetLimitSupported, bool, false, ());
};

29
level_zero/sysman/test/unit_tests/sources/linux/pmt/test_pmt.cpp
View File

@ -1,11 +1,13 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mocks/mock_sysman_product_helper.h"
#include "mock_pmt.h"
@ -23,6 +25,7 @@ class ZesPmtFixtureMultiDevice : public SysmanMultiDeviceFixture {
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();
pTestFsAccess = std::make_unique<MockPmtFsAccess>();
pLinuxSysmanImp->pFsAccess = pTestFsAccess.get();
L0::Sysman::PlatformMonitoringTech::create(pLinuxSysmanImp, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
}
void TearDown() override {
@ -59,25 +62,22 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenTelemDirectoryContainNowTelemEntryWhenenum
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringWhileValidatingTelemNode) {
pTestFsAccess->getRealPathResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto productFamily = pSysmanDeviceImp->getProductFamily();
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringGUIDRead) {
pTestFsAccess->readStringResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto productFamily = pSysmanDeviceImp->getProductFamily();
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_NOT_AVAILABLE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorIfGUIDReadValueIsNotSupported) {
pTestFsAccess->readInvalidString = true;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto productFamily = pSysmanDeviceImp->getProductFamily();
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(ZesPmtFixtureMultiDevice, GivenSomeKeyWhenCallingreadValueWithUint64TypeThenCheckForErrorBranches) {
@ -95,11 +95,12 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenSomeKeyWhenCallingreadValueWithUint32TypeT
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidDeviceHandlesWhenCreatingPMTHandlesThenCheckForErrorThatCouldHappenDuringbaseOffsetRead) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
pTestFsAccess->readUnsignedResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pTestFsAccess.get(), gpuUpstreamPortPathInPmt);
auto productFamily = pSysmanDeviceImp->getProductFamily();
auto pPmt = std::make_unique<PublicPlatformMonitoringTech>(pTestFsAccess.get(), 1, 0);
EXPECT_EQ(pPmt->init(pTestFsAccess.get(), gpuUpstreamPortPathInPmt, productFamily), ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(pPmt->init(pLinuxSysmanImp, gpuUpstreamPortPathInPmt), ZE_RESULT_ERROR_NOT_AVAILABLE);
}
inline static int openMockReturnFailure(const char *pathname, int flags) {
@ -189,6 +190,8 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenCallingreadValueWithUint6
}
TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenDoingPMTInitThenPMTmapOfSubDeviceIdToPmtObjectWouldContainValidEntries) {
std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelper>();
std::swap(pLinuxSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
uint32_t subdeviceId = 0;
@ -196,10 +199,8 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenValidSyscallsWhenDoingPMTInitThenPMTmapOfS
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new PublicPlatformMonitoringTech(pTestFsAccess.get(), onSubdevice, subdeviceId);
PublicPlatformMonitoringTech::rootDeviceTelemNodeIndex = 1;
auto productFamily = pSysmanDeviceImp->getProductFamily();
UNRECOVERABLE_IF(nullptr == pPmt);
PublicPlatformMonitoringTech::doInitPmtObject(pTestFsAccess.get(), subdeviceId, pPmt,
gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject, productFamily);
PublicPlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
auto subDeviceIdToPmtEntry = mapOfSubDeviceIdToPmtObject.find(subdeviceId);
EXPECT_EQ(subDeviceIdToPmtEntry->second, pPmt);
delete pPmt;
@ -215,10 +216,8 @@ TEST_F(ZesPmtFixtureMultiDevice, GivenBaseOffsetReadFailWhenDoingPMTInitThenPMTm
do {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new PublicPlatformMonitoringTech(pTestFsAccess.get(), onSubdevice, subdeviceId);
auto productFamily = pSysmanDeviceImp->getProductFamily();
UNRECOVERABLE_IF(nullptr == pPmt);
PublicPlatformMonitoringTech::doInitPmtObject(pTestFsAccess.get(), subdeviceId, pPmt,
gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject, productFamily);
PublicPlatformMonitoringTech::doInitPmtObject(pLinuxSysmanImp, subdeviceId, pPmt, gpuUpstreamPortPathInPmt, mapOfSubDeviceIdToPmtObject);
EXPECT_TRUE(mapOfSubDeviceIdToPmtObject.empty());
} while (++subdeviceId < subDeviceCount);

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

@ -14,6 +14,7 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_frequency_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_ras_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_power_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_pmt_tests.cpp
)
endif()
add_subdirectories()

67
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_pmt_tests.cpp Normal file
View File

@ -0,0 +1,67 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
namespace L0 {
namespace Sysman {
namespace ult {
const std::map<std::string, std::map<std::string, uint64_t>> mockDg1GuidToKeyOffsetMap = {{"0x490e01",
{{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68}}}};
const std::map<std::string, std::map<std::string, uint64_t>> mockDg2GuidToKeyOffsetMap = {{"0x4f95",
{{"PACKAGE_ENERGY", 1032},
{"SOC_TEMPERATURES", 56}}}};
const std::map<std::string, std::map<std::string, uint64_t>> mockPvcGuidToKeyOffsetMap = {{"0xb15a0edc",
{{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44}}}};
using IsUnknown = IsProduct<IGFX_UNKNOWN>;
using SysmanProductHelperPmtTest = ::testing::Test;
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsDG1) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
EXPECT_EQ(mockDg1GuidToKeyOffsetMap.at("0x490e01").at("PACKAGE_ENERGY"), (*pGuidToKeyOffsetMap).at("0x490e01").at("PACKAGE_ENERGY"));
EXPECT_EQ(mockDg1GuidToKeyOffsetMap.at("0x490e01").at("COMPUTE_TEMPERATURES"), (*pGuidToKeyOffsetMap).at("0x490e01").at("COMPUTE_TEMPERATURES"));
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsDG2) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
EXPECT_EQ(mockDg2GuidToKeyOffsetMap.at("0x4f95").at("PACKAGE_ENERGY"), (*pGuidToKeyOffsetMap).at("0x4f95").at("PACKAGE_ENERGY"));
EXPECT_EQ(mockDg2GuidToKeyOffsetMap.at("0x4f95").at("SOC_TEMPERATURES"), (*pGuidToKeyOffsetMap).at("0x4f95").at("SOC_TEMPERATURES"));
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledThenValidMapIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_NE(nullptr, pGuidToKeyOffsetMap);
EXPECT_EQ(mockPvcGuidToKeyOffsetMap.at("0xb15a0edc").at("HBM0MaxDeviceTemperature"), (*pGuidToKeyOffsetMap).at("0xb15a0edc").at("HBM0MaxDeviceTemperature"));
EXPECT_EQ(mockPvcGuidToKeyOffsetMap.at("0xb15a0edc").at("HBM1MaxDeviceTemperature"), (*pGuidToKeyOffsetMap).at("0xb15a0edc").at("HBM1MaxDeviceTemperature"));
EXPECT_EQ(mockPvcGuidToKeyOffsetMap.at("0xb15a0edc").at("TileMinTemperature"), (*pGuidToKeyOffsetMap).at("0xb15a0edc").at("TileMinTemperature"));
EXPECT_EQ(mockPvcGuidToKeyOffsetMap.at("0xb15a0edc").at("TileMaxTemperature"), (*pGuidToKeyOffsetMap).at("0xb15a0edc").at("TileMaxTemperature"));
}
HWTEST2_F(SysmanProductHelperPmtTest, GivenSysmanProductHelperInstanceWhenGetGuidToKeyOffsetMapIsCalledForUnsupportedProductThenNullptrIsReturned, IsUnknown) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
auto pGuidToKeyOffsetMap = pSysmanProductHelper->getGuidToKeyOffsetMap();
EXPECT_EQ(nullptr, pGuidToKeyOffsetMap);
}
} // namespace ult
} // namespace Sysman
} // namespace L0

3
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_temperature_tests.cpp
View File

@ -1,11 +1,10 @@
/*
* Copyright (C) 2023 Intel Corporation
* Copyright (C) 2023-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt_xml_offsets.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/temperature/linux/mock_sysfs_temperature.h"

29
level_zero/sysman/test/unit_tests/sources/temperature/linux/test_zes_temperature.cpp
View File

@ -1,11 +1,10 @@
/*
* Copyright (C) 2020-2023 Intel Corporation
* Copyright (C) 2020-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt_xml_offsets.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
#include "level_zero/sysman/test/unit_tests/sources/temperature/linux/mock_sysfs_temperature.h"
@ -18,8 +17,20 @@ constexpr uint32_t handleComponentCountForSingleTileDevice = 3u;
constexpr uint32_t handleComponentCountForNoSubDevices = 2u;
constexpr uint32_t invalidMaxTemperature = 125;
constexpr uint32_t invalidMinTemperature = 10;
const std::string sampleGuid1 = "0xb15a0edc";
const std::string sampleGuid2 = "0x490e01";
const std::map<std::string, uint64_t> mockMap1 = {{"HBM0MaxDeviceTemperature", 28},
{"HBM1MaxDeviceTemperature", 36},
{"TileMinTemperature", 40},
{"TileMaxTemperature", 44},
{"GTMinTemperature", 48},
{"GTMaxTemperature", 52},
{"HBM2MaxDeviceTemperature", 300},
{"HBM3MaxDeviceTemperature", 308}};
const std::map<std::string, uint64_t> mockMap2 = {{"PACKAGE_ENERGY", 0x420},
{"COMPUTE_TEMPERATURES", 0x68},
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}};
class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
protected:
@ -46,8 +57,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
auto keyOffsetMapEntry = L0::Sysman::guidToKeyOffsetMap.find(sampleGuid1);
pPmt->keyOffsetMap = keyOffsetMapEntry->second;
pPmt->keyOffsetMap = mockMap1;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
getTempHandles(0);
@ -179,8 +189,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockedInit(pFsAccess.get());
auto keyOffsetMapEntry = L0::Sysman::guidToKeyOffsetMap.find(sampleGuid2);
pPmt->keyOffsetMap = keyOffsetMapEntry->second;
pPmt->keyOffsetMap = mockMap2;
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(subdeviceId, pPmt);
} while (++subdeviceId < subDeviceCount);
getTempHandles(0);
@ -345,9 +354,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWheng
TEST_F(SysmanDeviceTemperatureFixture, GivenValidatePmtReadValueWhenkeyOffsetMapIsNotThereThenFailureReturned) {
auto pPmt = std::make_unique<MockTemperaturePmt>(pFsAccess.get(), 0, 0);
pPmt->mockedInit(pFsAccess.get());
// Get keyOffsetMap
auto keyOffsetMapEntry = L0::Sysman::guidToKeyOffsetMap.find(sampleGuid2);
pPmt->keyOffsetMap = keyOffsetMapEntry->second;
pPmt->keyOffsetMap = mockMap2;
uint32_t val = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPmt->readValue("SOMETHING", val));
}