intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 06:24:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(sysman): Add missing support of isMemoryMaxTemperatureSupported() for BMG

Browse Source 
Related-To: NEO-12916

Signed-off-by: Anvesh Bakwad <anvesh.bakwad@intel.com>
This commit is contained in:
Anvesh Bakwad
2024-10-17 08:01:00 +00:00
committed by Compute-Runtime-Automation
parent f117b5fb68
commit 2844cba1f1
2 changed files with 69 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
level_zero/sysman/source/shared/linux/product_helper/xe2_hpg_core/bmg/sysman_product_helper_bmg.cpp
View File

@@ -426,6 +426,11 @@ ze_result_t SysmanProductHelperHw<gfxProduct>::getGpuMaxTemperature(LinuxSysmanI
return ZE_RESULT_SUCCESS;
}
template <>
bool SysmanProductHelperHw<gfxProduct>::isMemoryMaxTemperatureSupported() {
return true;
}
template <>
ze_result_t SysmanProductHelperHw<gfxProduct>::getMemoryMaxTemperature(LinuxSysmanImp *pLinuxSysmanImp, double *pTemperature, uint32_t subdeviceId) {
std::string telemDir = "";

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

@@ -738,6 +738,11 @@ HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidHandleWhenQueryingMemory
EXPECT_EQ(false, result);
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenSysmanProductHelperInstanceWhenQueryingIsMemoryMaxTemperatureSupportedThenTrueIsReturned, IsBMG) {
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
EXPECT_TRUE(pSysmanProductHelper->isMemoryMaxTemperatureSupported());
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenSysmanProductHelperInstanceAndNoTelemNodesAvailableWhenGettingGpuMaxTemperatureThenFailureIsReturned, IsBMG) {
uint32_t subdeviceId = 0;
auto pSysmanProductHelper = L0::Sysman::SysmanProductHelper::create(defaultHwInfo->platform.eProductFamily);
@@ -1011,6 +1016,65 @@ HWTEST2_F(SysmanProductHelperTemperatureTest, GivenSysmanProductHelperInstanceWh
EXPECT_EQ(expectedValue, temperature);
}
HWTEST2_F(SysmanProductHelperTemperatureTest, GivenValidTemperatureHandleWhenZesGetTemperatureStateIsCalledThenValidTemperatureValueForEachSensorTypeIsReturned, IsBMG) {
static uint32_t gpuMaxTemperature = 10;
static uint32_t memoryMaxTemperature = 20;
static uint32_t validTemperatureHandleCount = 3u;
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, &mockReadLinkSingleTelemetryNodesSuccess);
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, &mockOpenSuccess);
VariableBackup<bool> allowFakeDevicePathBackup(&NEO::SysCalls::allowFakeDevicePath, true);
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
uint64_t telemOffset = 0;
std::string validGuid = "0x5e2f8210";
long gpuMaxTemperatureKeyOffset = 41;
long memoryMaxTemperatureKeyOffset = 42;
if (fd == 4) {
memcpy(buf, &telemOffset, count);
} else if (fd == 5) {
memcpy(buf, validGuid.data(), count);
} else if (fd == 6) {
if (offset == gpuMaxTemperatureKeyOffset) {
memcpy(buf, &gpuMaxTemperature, count);
} else if (offset == memoryMaxTemperatureKeyOffset) {
memcpy(buf, &memoryMaxTemperature, count);
}
}
return count;
});
uint32_t count = 0;
ze_result_t result = zesDeviceEnumTemperatureSensors(pSysmanDevice->toHandle(), &count, NULL);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, validTemperatureHandleCount);
uint32_t testcount = count + 1;
result = zesDeviceEnumTemperatureSensors(pSysmanDevice->toHandle(), &testcount, NULL);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(testcount, validTemperatureHandleCount);
std::vector<zes_temp_handle_t> handles(count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumTemperatureSensors(pSysmanDevice->toHandle(), &count, handles.data()));
for (auto handle : handles) {
ASSERT_NE(nullptr, handle);
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
double temperature;
if (properties.type == ZES_TEMP_SENSORS_GPU) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(gpuMaxTemperature));
} else if (properties.type == ZES_TEMP_SENSORS_MEMORY) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(memoryMaxTemperature));
} else if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(std::max(gpuMaxTemperature, memoryMaxTemperature)));
}
}
}
} // namespace ult
} // namespace Sysman
} // namespace L0