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

feature(sysman): supports product helper for temperature module 

Related-To: NEO-8720

Signed-off-by: Kulkarni, Ashwin Kumar <ashwin.kumar.kulkarni@intel.com>
This commit is contained in:
Kulkarni, Ashwin Kumar 2023-11-23 14:12:29 +00:00 committed by Compute-Runtime-Automation
parent 985186242e
commit d7aea3e745
13 changed files with 538 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
level_zero/sysman/source/api/temperature/linux/sysman_os_temperature_imp.cpp
View File

@ -9,17 +9,12 @@
#include "shared/source/debug_settings/debug_settings_manager.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"
namespace L0 {
namespace Sysman {
constexpr uint32_t numSocTemperatureEntries = 7; // entries would be PCH or GT_TEMP, DRAM, SA, PSF, DE, PCIE, TYPEC
constexpr uint32_t numCoreTemperatureEntries = 4; // entries would be CORE0, CORE1, CORE2, CORE3
constexpr uint32_t numComputeTemperatureEntries = 3; // entries would be IA, GT and LLC
constexpr uint32_t invalidMaxTemperature = 125;
constexpr uint32_t invalidMinTemperature = 10;
ze_result_t LinuxTemperatureImp::getProperties(zes_temp_properties_t *pProperties) {
pProperties->type = type;
pProperties->onSubdevice = 0;
@ -31,157 +26,16 @@ ze_result_t LinuxTemperatureImp::getProperties(zes_temp_properties_t *pPropertie
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxTemperatureImp::getGlobalMaxTemperatureNoSubDevice(double *pTemperature) {
auto isValidTemperature = [](auto temperature) {
if ((temperature > invalidMaxTemperature) || (temperature < invalidMinTemperature)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): temperature:%f is not in valid limits \n", __FUNCTION__, temperature);
return false;
}
return true;
};
auto getMaxTemperature = [&](auto temperature, auto numTemperatureEntries) {
uint32_t maxTemperature = 0;
for (uint32_t count = 0; count < numTemperatureEntries; count++) {
uint32_t localTemperatureVal = (temperature >> (8 * count)) & 0xff;
if (isValidTemperature(localTemperatureVal)) {
if (localTemperatureVal > maxTemperature) {
maxTemperature = localTemperatureVal;
}
}
}
return maxTemperature;
};
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint32_t maxComputeTemperature = 0;
uint32_t maxCoreTemperature = 0;
std::string key;
if (productFamily == IGFX_DG1) {
uint32_t computeTemperature = 0;
key = "COMPUTE_TEMPERATURES";
result = pPmt->readValue(key, computeTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for COMPUTE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among IA, GT and LLC sensors across COMPUTE_TEMPERATURES
maxComputeTemperature = getMaxTemperature(computeTemperature, numComputeTemperatureEntries);
uint32_t coreTemperature = 0;
key = "CORE_TEMPERATURES";
result = pPmt->readValue(key, coreTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for CORE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among CORE0, CORE1, CORE2, CORE3 sensors across CORE_TEMPERATURES
maxCoreTemperature = getMaxTemperature(coreTemperature, numCoreTemperatureEntries);
}
// SOC_TEMPERATURES is present in all product families
uint64_t socTemperature = 0;
key = "SOC_TEMPERATURES";
result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for SOC_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among possible sensors like PCH or GT_TEMP, DRAM, SA, PSF, DE, PCIE, TYPEC across SOC_TEMPERATURES
uint32_t maxSocTemperature = getMaxTemperature(socTemperature, numSocTemperatureEntries);
*pTemperature = static_cast<double>(std::max({maxComputeTemperature, maxCoreTemperature, maxSocTemperature}));
return result;
}
ze_result_t LinuxTemperatureImp::getGlobalMaxTemperature(double *pTemperature) {
// For XE_HP_SDV and PVC single tile devices, telemetry info is retrieved from
// tile's telem node rather from root device telem node.
if ((!isSubdevice) && (!(productFamily == IGFX_PVC))) {
return getGlobalMaxTemperatureNoSubDevice(pTemperature);
}
uint32_t globalMaxTemperature = 0;
std::string key("TileMaxTemperature");
ze_result_t result = pPmt->readValue(key, globalMaxTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for TileMaxTemperature is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
*pTemperature = static_cast<double>(globalMaxTemperature);
return result;
}
ze_result_t LinuxTemperatureImp::getGpuMaxTemperatureNoSubDevice(double *pTemperature) {
double gpuMaxTemperature = 0;
uint64_t socTemperature = 0;
// Gpu temperature is obtained from GT_TEMP in SOC_TEMPERATURE's bit 0 to 7.
std::string key = "SOC_TEMPERATURES";
auto result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for SOC_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
gpuMaxTemperature = static_cast<double>(socTemperature & 0xff);
if (productFamily == IGFX_DG1) {
// In DG1 platform, Gpu Max Temperature is obtained from COMPUTE_TEMPERATURE only
uint32_t computeTemperature = 0;
std::string key("COMPUTE_TEMPERATURES");
ze_result_t result = pPmt->readValue(key, computeTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for COMPUTE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// GT temperature could be read via 8th to 15th bit in the value read in temperature
computeTemperature = (computeTemperature >> 8) & 0xff;
gpuMaxTemperature = static_cast<double>(computeTemperature);
}
*pTemperature = gpuMaxTemperature;
return ZE_RESULT_SUCCESS;
return pSysmanProductHelper->getGlobalMaxTemperature(pPmt, pTemperature);
}
ze_result_t LinuxTemperatureImp::getGpuMaxTemperature(double *pTemperature) {
if ((!isSubdevice) && (!(productFamily == IGFX_PVC))) {
return getGpuMaxTemperatureNoSubDevice(pTemperature);
}
uint32_t gpuMaxTemperature = 0;
std::string key("GTMaxTemperature");
ze_result_t result = pPmt->readValue(key, gpuMaxTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for GTMaxTemperature is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
*pTemperature = static_cast<double>(gpuMaxTemperature);
return result;
return pSysmanProductHelper->getGpuMaxTemperature(pPmt, pTemperature);
}
ze_result_t LinuxTemperatureImp::getMemoryMaxTemperature(double *pTemperature) {
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint32_t numHbmModules = 0u;
if (productFamily == IGFX_PVC) {
numHbmModules = 4u;
} else {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
std::vector<uint32_t> maxDeviceTemperatureList;
for (auto hbmModuleIndex = 0u; hbmModuleIndex < numHbmModules; hbmModuleIndex++) {
uint32_t maxDeviceTemperature = 0;
// To read HBM 0's max device temperature key would be HBM0MaxDeviceTemperature
std::string key = "HBM" + std::to_string(hbmModuleIndex) + "MaxDeviceTemperature";
result = pPmt->readValue(key, maxDeviceTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for %s is returning error:0x%x \n", __FUNCTION__, key.c_str(), result);
return result;
}
maxDeviceTemperatureList.push_back(maxDeviceTemperature);
}
*pTemperature = static_cast<double>(*std::max_element(maxDeviceTemperatureList.begin(), maxDeviceTemperatureList.end()));
return result;
return pSysmanProductHelper->getMemoryMaxTemperature(pPmt, pTemperature);
}
ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) {
@ -189,21 +43,12 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) {
switch (type) {
case ZES_TEMP_SENSORS_GLOBAL:
result = getGlobalMaxTemperature(pTemperature);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
case ZES_TEMP_SENSORS_GPU:
result = getGpuMaxTemperature(pTemperature);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
case ZES_TEMP_SENSORS_MEMORY:
result = getMemoryMaxTemperature(pTemperature);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
break;
default:
*pTemperature = 0;
@ -215,13 +60,19 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) {
}
bool LinuxTemperatureImp::isTempModuleSupported() {
if ((!isSubdevice) && (!(productFamily == IGFX_PVC))) {
if (type == ZES_TEMP_SENSORS_MEMORY) {
return false;
}
bool result = (pPmt != nullptr);
switch (type) {
case ZES_TEMP_SENSORS_GLOBAL:
case ZES_TEMP_SENSORS_GPU:
break;
case ZES_TEMP_SENSORS_MEMORY:
result &= pSysmanProductHelper->isMemoryMaxTemperatureSupported();
break;
default:
result = false;
break;
}
return (pPmt != nullptr);
return result;
}
void LinuxTemperatureImp::setSensorType(zes_temp_sensors_t sensorType) {
@ -232,7 +83,7 @@ LinuxTemperatureImp::LinuxTemperatureImp(OsSysman *pOsSysman, ze_bool_t onSubdev
uint32_t subdeviceId) : subdeviceId(subdeviceId), isSubdevice(onSubdevice) {
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
pPmt = pLinuxSysmanImp->getPlatformMonitoringTechAccess(subdeviceId);
productFamily = pLinuxSysmanImp->getProductFamily();
pSysmanProductHelper = pLinuxSysmanImp->getSysmanProductHelper();
}
std::unique_ptr<OsTemperature> OsTemperature::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_temp_sensors_t sensorType) {

7
level_zero/sysman/source/api/temperature/linux/sysman_os_temperature_imp.h
View File

@ -20,6 +20,7 @@ namespace Sysman {
class SysfsAccess;
class PlatformMonitoringTech;
class SysmanProductHelper;
class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass {
public:
ze_result_t getProperties(zes_temp_properties_t *pProperties) override;
@ -36,15 +37,11 @@ class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass
private:
ze_result_t getGlobalMaxTemperature(double *pTemperature);
ze_result_t getGlobalMinTemperature(double *pTemperature);
ze_result_t getGpuMaxTemperature(double *pTemperature);
ze_result_t getGpuMinTemperature(double *pTemperature);
ze_result_t getMemoryMaxTemperature(double *pTemperature);
ze_result_t getGlobalMaxTemperatureNoSubDevice(double *pTemperature);
ze_result_t getGpuMaxTemperatureNoSubDevice(double *pTemperature);
uint32_t subdeviceId = 0;
ze_bool_t isSubdevice = 0;
PRODUCT_FAMILY productFamily = IGFX_UNKNOWN;
SysmanProductHelper *pSysmanProductHelper = nullptr;
};
} // namespace Sysman

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

@ -5,13 +5,102 @@
*
*/
#include "shared/source/debug_settings/debug_settings_manager.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"
#include <algorithm>
namespace L0 {
namespace Sysman {
constexpr static auto gfxProduct = IGFX_DG1;
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
auto isValidTemperature = [](auto temperature) {
if ((temperature > invalidMaxTemperature) || (temperature < invalidMinTemperature)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): temperature:%f is not in valid limits \n", __FUNCTION__, temperature);
return false;
}
return true;
};
auto getMaxTemperature = [&](auto temperature, auto numTemperatureEntries) {
uint32_t maxTemperature = 0;
for (uint32_t count = 0; count < numTemperatureEntries; count++) {
uint32_t localTemperatureVal = (temperature >> (8 * count)) & 0xff;
if (isValidTemperature(localTemperatureVal)) {
if (localTemperatureVal > maxTemperature) {
maxTemperature = localTemperatureVal;
}
}
}
return maxTemperature;
};
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint32_t maxComputeTemperature = 0;
uint32_t maxCoreTemperature = 0;
std::string key;
uint32_t computeTemperature = 0;
key = "COMPUTE_TEMPERATURES";
result = pPmt->readValue(key, computeTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for COMPUTE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among IA, GT and LLC sensors across COMPUTE_TEMPERATURES
maxComputeTemperature = getMaxTemperature(computeTemperature, numComputeTemperatureEntries);
uint32_t coreTemperature = 0;
key = "CORE_TEMPERATURES";
result = pPmt->readValue(key, coreTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for CORE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among CORE0, CORE1, CORE2, CORE3 sensors across CORE_TEMPERATURES
maxCoreTemperature = getMaxTemperature(coreTemperature, numCoreTemperatureEntries);
uint64_t socTemperature = 0;
key = "SOC_TEMPERATURES";
result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for SOC_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among possible sensors like PCH or GT_TEMP, DRAM, SA, PSF, DE, PCIE, TYPEC across SOC_TEMPERATURES
uint32_t maxSocTemperature = getMaxTemperature(socTemperature, numSocTemperatureEntries);
*pTemperature = static_cast<double>(std::max({maxComputeTemperature, maxCoreTemperature, maxSocTemperature}));
return result;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGpuMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
double gpuMaxTemperature = 0;
// In DG1 platform, Gpu Max Temperature is obtained from COMPUTE_TEMPERATURE only
uint32_t computeTemperature = 0;
std::string key("COMPUTE_TEMPERATURES");
ze_result_t result = pPmt->readValue(key, computeTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for COMPUTE_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// GT temperature could be read via 8th to 15th bit in the value read in temperature
computeTemperature = (computeTemperature >> 8) & 0xff;
gpuMaxTemperature = static_cast<double>(computeTemperature);
*pTemperature = gpuMaxTemperature;
return ZE_RESULT_SUCCESS;
}
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

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

@ -19,6 +19,7 @@ namespace Sysman {
class SysmanProductHelper;
class LinuxSysmanImp;
class PlatformMonitoringTech;
using SysmanProductHelperCreateFunctionType = std::unique_ptr<SysmanProductHelper> (*)();
extern SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[IGFX_MAX_PRODUCT];
@ -41,6 +42,12 @@ class SysmanProductHelper {
// Performance
virtual void getMediaPerformanceFactorMultiplier(const double performanceFactor, double *pMultiplier) = 0;
// temperature
virtual ze_result_t getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) = 0;
virtual ze_result_t getGpuMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) = 0;
virtual ze_result_t getMemoryMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) = 0;
virtual bool isMemoryMaxTemperatureSupported() = 0;
virtual ~SysmanProductHelper() = default;
protected:

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

@ -6,6 +6,9 @@
*/
#pragma once
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h"
namespace L0 {
@ -26,6 +29,12 @@ class SysmanProductHelperHw : public SysmanProductHelper {
// Performance
void getMediaPerformanceFactorMultiplier(const double performanceFactor, double *pMultiplier) override;
// temperature
ze_result_t getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) override;
ze_result_t getGpuMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) override;
ze_result_t getMemoryMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) override;
bool isMemoryMaxTemperatureSupported() override;
~SysmanProductHelperHw() override = default;
protected:
@ -41,4 +50,4 @@ struct EnableSysmanProductHelper {
};
} // namespace Sysman
} // namespace L0
} // namespace L0

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

@ -5,10 +5,13 @@
*
*/
#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/product_helper/sysman_product_helper_hw.h"
#include "level_zero/sysman/source/sysman_const.h"
#include <algorithm>
namespace L0 {
namespace Sysman {
@ -33,5 +36,74 @@ void SysmanProductHelperHw<gfxProduct>::getMediaPerformanceFactorMultiplier(cons
}
}
template <PRODUCT_FAMILY gfxProduct>
bool SysmanProductHelperHw<gfxProduct>::isMemoryMaxTemperatureSupported() {
return false;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
auto isValidTemperature = [](auto temperature) {
if ((temperature > invalidMaxTemperature) || (temperature < invalidMinTemperature)) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): temperature:%f is not in valid limits \n", __FUNCTION__, temperature);
return false;
}
return true;
};
auto getMaxTemperature = [&](auto temperature, auto numTemperatureEntries) {
uint32_t maxTemperature = 0;
for (uint32_t count = 0; count < numTemperatureEntries; count++) {
uint32_t localTemperatureVal = (temperature >> (8 * count)) & 0xff;
if (isValidTemperature(localTemperatureVal)) {
if (localTemperatureVal > maxTemperature) {
maxTemperature = localTemperatureVal;
}
}
}
return maxTemperature;
};
ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
std::string key;
// SOC_TEMPERATURES is present in all product families
uint64_t socTemperature = 0;
key = "SOC_TEMPERATURES";
result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for SOC_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
// Check max temperature among possible sensors like PCH or GT_TEMP, DRAM, SA, PSF, DE, PCIE, TYPEC across SOC_TEMPERATURES
uint32_t maxSocTemperature = getMaxTemperature(socTemperature, numSocTemperatureEntries);
*pTemperature = static_cast<double>(maxSocTemperature);
return result;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGpuMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
double gpuMaxTemperature = 0;
uint64_t socTemperature = 0;
// Gpu temperature is obtained from GT_TEMP in SOC_TEMPERATURE's bit 0 to 7.
std::string key = "SOC_TEMPERATURES";
auto result = pPmt->readValue(key, socTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for SOC_TEMPERATURES is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
gpuMaxTemperature = static_cast<double>(socTemperature & 0xff);
*pTemperature = gpuMaxTemperature;
return ZE_RESULT_SUCCESS;
}
template <PRODUCT_FAMILY gfxProduct>
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
} // namespace Sysman
} // namespace L0
} // namespace L0

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

@ -9,6 +9,9 @@
#include "level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper_hw.inl"
#include "level_zero/sysman/source/sysman_const.h"
#include <algorithm>
#include <vector>
namespace L0 {
namespace Sysman {
constexpr static auto gfxProduct = IGFX_PVC;
@ -32,6 +35,58 @@ void SysmanProductHelperHw<gfxProduct>::getMediaPerformanceFactorMultiplier(cons
}
}
template <>
bool SysmanProductHelperHw<gfxProduct>::isMemoryMaxTemperatureSupported() {
return true;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGlobalMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
uint32_t globalMaxTemperature = 0;
std::string key("TileMaxTemperature");
ze_result_t result = pPmt->readValue(key, globalMaxTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for TileMaxTemperature is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
*pTemperature = static_cast<double>(globalMaxTemperature);
return result;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getGpuMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
uint32_t gpuMaxTemperature = 0;
std::string key("GTMaxTemperature");
ze_result_t result = pPmt->readValue(key, gpuMaxTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for GTMaxTemperature is returning error:0x%x \n", __FUNCTION__, result);
return result;
}
*pTemperature = static_cast<double>(gpuMaxTemperature);
return result;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryMaxTemperature(PlatformMonitoringTech *pPmt, double *pTemperature) {
uint32_t numHbmModules = 4u;
ze_result_t result = ZE_RESULT_SUCCESS;
std::vector<uint32_t> maxDeviceTemperatureList;
for (auto hbmModuleIndex = 0u; hbmModuleIndex < numHbmModules; hbmModuleIndex++) {
uint32_t maxDeviceTemperature = 0;
// To read HBM 0's max device temperature key would be HBM0MaxDeviceTemperature
std::string key = "HBM" + std::to_string(hbmModuleIndex) + "MaxDeviceTemperature";
result = pPmt->readValue(key, maxDeviceTemperature);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): Pmt->readvalue() for %s is returning error:0x%x \n", __FUNCTION__, key.c_str(), result);
return result;
}
maxDeviceTemperatureList.push_back(maxDeviceTemperature);
}
*pTemperature = static_cast<double>(*std::max_element(maxDeviceTemperatureList.begin(), maxDeviceTemperatureList.end()));
return result;
}
template class SysmanProductHelperHw<gfxProduct>;
} // namespace Sysman

6
level_zero/sysman/source/sysman_const.h
View File

@ -20,6 +20,12 @@ constexpr double maxPerformanceFactor = 100;
constexpr double halfOfMaxPerformanceFactor = 50;
constexpr double minPerformanceFactor = 0;
constexpr uint32_t numSocTemperatureEntries = 7; // entries would be PCH or GT_TEMP, DRAM, SA, PSF, DE, PCIE, TYPEC
constexpr uint32_t numCoreTemperatureEntries = 4; // entries would be CORE0, CORE1, CORE2, CORE3
constexpr uint32_t numComputeTemperatureEntries = 3; // entries would be IA, GT and LLC
constexpr uint32_t invalidMaxTemperature = 125;
constexpr uint32_t invalidMinTemperature = 10;
namespace L0 {
namespace Sysman {
struct SteadyClock {

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

@ -7,8 +7,9 @@
if(UNIX)
target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_performance_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_memory_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_product_helper_temperature_tests.cpp
)
endif()

10
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_tests.cpp → level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_memory_tests.cpp
View File

@ -13,7 +13,7 @@ namespace L0 {
namespace Sysman {
namespace ult {
struct SysmanProductHelperTest : public SysmanDeviceFixture {
struct SysmanProductHelperMemoryTest : public SysmanDeviceFixture {
void SetUp() override {
SysmanDeviceFixture::SetUp();
}
@ -22,7 +22,7 @@ struct SysmanProductHelperTest : public SysmanDeviceFixture {
}
};
HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsPVC) {
HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_mem_properties_t properties;
ze_result_t result = pSysmanProductHelper->getMemoryProperties(&properties, static_cast<const L0::Sysman::LinuxSysmanImp *>(pLinuxSysmanImp));
@ -32,7 +32,7 @@ HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMe
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsDG1) {
HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsDG1) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_mem_properties_t properties;
ze_result_t result = pSysmanProductHelper->getMemoryProperties(&properties, static_cast<const L0::Sysman::LinuxSysmanImp *>(pLinuxSysmanImp));
@ -42,7 +42,7 @@ HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMe
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsDG2) {
HWTEST2_F(SysmanProductHelperMemoryTest, GivenSysmanProductHelperInstanceWhenCallingMemoryAPIsThenErrorIsReturned, IsDG2) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
zes_mem_properties_t properties;
ze_result_t result = pSysmanProductHelper->getMemoryProperties(&properties, static_cast<const L0::Sysman::LinuxSysmanImp *>(pLinuxSysmanImp));
@ -52,7 +52,7 @@ HWTEST2_F(SysmanProductHelperTest, GivenSysmanProductHelperInstanceWhenCallingMe
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
}
TEST_F(SysmanProductHelperTest, GivenInvalidProductFamilyWhenCallingProductHelperCreateThenNullPtrIsReturned) {
TEST_F(SysmanProductHelperMemoryTest, GivenInvalidProductFamilyWhenCallingProductHelperCreateThenNullPtrIsReturned) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(IGFX_UNKNOWN);
EXPECT_EQ(nullptr, pSysmanProductHelper);
}

252
level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_temperature_tests.cpp Normal file
View File

@ -0,0 +1,252 @@
/*
* Copyright (C) 2023 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"
namespace L0 {
namespace Sysman {
namespace ult {
struct SysmanProductHelperTemperatureTest : public SysmanDeviceFixture {
void SetUp() override {
SysmanDeviceFixture::SetUp();
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
}
};
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadSocTemperatureFailsWhenGettingGlobalTemperatureThenFailureIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadSocTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadCoreTemperatureFailsWhenGettingGlobalTemperatureThenFailureIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadCoreTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadComputeTemperatureFailsWhenGettingGlobalTemperatureThenFailureIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadComputeTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGlobalTemperatureThenSuccessIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadComputeTemperatureFailsWhenGettingGpuTemperatureThenFailureIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadComputeTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGpuTemperatureThenSuccessIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingMemoryTemperatureThenUnsupportedIsReturned, IsDG1) {
uint32_t subdeviceId = 0;
bool onSubdevice = false;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getMemoryMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadTileMaxTemperatureFailsWhenGettingGlobalTemperatureThenFailureIsReturned, IsPVC) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGlobalTemperatureThenSuccessIsReturned, IsPVC) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadGTMaxTemperatureFailsWhenGettingGpuTemperatureThenFailureIsReturned, IsPVC) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGpuMaxTemperatureThenSuccessIsReturned, IsPVC) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingMemoryMaxTemperatureThenSuccessIsReturned, IsPVC) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getMemoryMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidHandleWhenQueryingMemoryTemperatureSupportThenTrueIsReturned, IsPVC) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
bool result = pSysmanProductHelper->isMemoryMaxTemperatureSupported();
EXPECT_EQ(true, result);
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadSocTemperatureFailsWhenGettingGlobalTemperatureThenFailureIsReturned, IsDG2) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadSocTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGlobalTemperatureThenSuccessIsReturned, IsDG2) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGlobalMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleAndReadSocTemperatureFailsWhenGettingGpuTemperatureThenFailureIsReturned, IsDG2) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
pPmt->mockReadSocTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingGpuMaxTemperatureThenSuccessIsReturned, IsDG2) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getGpuMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidPmtHandleWhenGettingMemoryMaxTemperatureThenUnSupportedIsReturned, IsDG2) {
uint32_t subdeviceId = 0;
bool onSubdevice = true;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
std::unique_ptr<MockTemperatureFsAccess> pFsAccess = std::make_unique<MockTemperatureFsAccess>();
auto pPmt = new MockTemperaturePmt(pFsAccess.get(), onSubdevice, subdeviceId);
double temperature = 0;
ze_result_t result = pSysmanProductHelper->getMemoryMaxTemperature(pPmt, &temperature);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
delete pPmt;
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidHandleWhenQueryingMemoryTemperatureSupportThenFalseIsReturned, IsDG2) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
bool result = pSysmanProductHelper->isMemoryMaxTemperatureSupported();
EXPECT_EQ(false, result);
}
} // namespace ult
} // namespace Sysman
} // namespace L0

8
level_zero/sysman/test/unit_tests/sources/temperature/linux/mock_sysfs_temperature.h
View File

@ -26,11 +26,11 @@ constexpr uint32_t tileMaxTemperature = 0x34;
constexpr uint8_t computeTempIndex = 8;
constexpr uint8_t coreTempIndex = 12;
constexpr uint8_t socTempIndex = 0;
constexpr uint8_t tempArrForNoSubDevices[19] = {0x12, 0x23, 0x43, 0xde, 0xa3, 0xce, 0x23, 0x11, 0x45, 0x32, 0x67, 0x47, 0xac, 0x21, 0x03, 0x90, 0, 0, 0};
constexpr uint8_t tempArrForNoSubDevices[19] = {0x09, 0x23, 0x43, 0xde, 0xa3, 0xce, 0x23, 0x11, 0x45, 0x32, 0x67, 0x47, 0xac, 0x21, 0x03, 0x90, 0, 0, 0};
constexpr uint8_t computeIndexForNoSubDevices = 9;
constexpr uint8_t gtTempIndexForNoSubDevices = 0;
const std::string baseTelemSysFS("/sys/class/intel_pmt");
std::string gpuUpstreamPortPathInTemperature = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
static std::string gpuUpstreamPortPathInTemperature = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
const std::string realPathTelem1 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem1";
const std::string realPathTelem2 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem2";
const std::string realPathTelem3 = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:02.0/0000:8e:00.1/pmt_telemetry.1.auto/intel_pmt/telem3";
@ -51,6 +51,7 @@ struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
ze_result_t mockReadValueResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadCoreTempResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadComputeTempResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadSocTempResult = ZE_RESULT_SUCCESS;
~MockTemperaturePmt() override {
rootDeviceTelemNodeIndex = 0;
@ -112,6 +113,9 @@ struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
}
if (key.compare("SOC_TEMPERATURES") == 0) {
if (mockReadSocTempResult != ZE_RESULT_SUCCESS) {
return mockReadSocTempResult;
}
val = 0;
for (uint8_t i = 0; i < sizeof(uint64_t); i++) {
val |= (uint64_t)tempArrForNoSubDevices[(socTempIndex) + i] << (i * 8);

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

@ -68,7 +68,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
}
};
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) {
HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds, IsPVC) {
uint32_t count = 0;
ze_result_t result = zesDeviceEnumTemperatureSensors(device->toHandle(), &count, NULL);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@ -107,7 +107,7 @@ HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTe
}
}
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) {
HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned, IsPVC) {
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
@ -116,7 +116,7 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTempe
}
}
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned) {
HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned, IsPVC) {
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
@ -137,7 +137,7 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileInd
}
}
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned, IsPVC) {
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
@ -322,6 +322,16 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupporte
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPublicLinuxTemperatureImp->getSensorTemperature(&temperature));
}
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTempSensorsMemoryMinSupportThenFalseIsReturned) {
auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
uint32_t subdeviceId = 0;
auto pPublicLinuxTemperatureImp = std::make_unique<L0::Sysman::LinuxTemperatureImp>(pOsSysman, onSubdevice, subdeviceId);
pPublicLinuxTemperatureImp->setSensorType(ZES_TEMP_SENSORS_MEMORY_MIN);
EXPECT_EQ(false, pPublicLinuxTemperatureImp->isTempModuleSupported());
}
TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWhengetRealPathFailsThenFailureReturned) {
pFsAccess->mockErrorListDirectory = ZE_RESULT_ERROR_NOT_AVAILABLE;
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE,