Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Sysman: Refine test for temperature module

Browse Source 
Related-To: LOCI-2519

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2022-11-21 16:57:01 +00:00
committed by Compute-Runtime-Automation
parent 25a95bd0c5
commit 5da472e84f
2 changed files with 135 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -18,19 +18,15 @@ constexpr uint8_t memory0MaxTemperature = 0x12;
constexpr uint8_t memory1MaxTemperature = 0x45;
constexpr uint8_t memory2MaxTemperature = 0x32;
constexpr uint8_t memory3MaxTemperature = 0x36;
constexpr uint8_t tempArrForSubDevices[28] = {memory0MaxTemperature, 0, 0, 0, 0, 0, 0, 0, memory1MaxTemperature, 0, 0, 0, 0x6f, 0, 0, 0, 0x34, 0, 0, 0, 0x16, 0, 0, 0, 0x1d, 0, 0, 0};
constexpr uint64_t offsetForSubDevices = 28;
constexpr uint16_t memory0MaxTempIndex = 0;
constexpr uint16_t memory1MaxTempIndex = 8;
constexpr uint16_t memory2MaxTempIndex = 300;
constexpr uint16_t memory3MaxTempIndex = 308;
constexpr uint8_t subDeviceMaxTempIndex = 16;
constexpr uint8_t gtMaxTempIndex = 24;
constexpr uint32_t gtMaxTemperature = 0x1d;
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 uint64_t offsetForNoSubDevices = 0x60;
constexpr uint8_t computeIndexForNoSubDevices = 9;
constexpr uint8_t globalIndexForNoSubDevices = 3;
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";
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";
@ -55,6 +51,10 @@ class TemperaturePmt : public PlatformMonitoringTech {
template <>
struct Mock<TemperaturePmt> : public TemperaturePmt {
ze_result_t mockReadValueResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadCoreTempResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadComputeTempResult = ZE_RESULT_SUCCESS;
Mock<TemperaturePmt>(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : TemperaturePmt(pFsAccess, onSubdevice, subdeviceId) {}
~Mock() override {
rootDeviceTelemNodeIndex = 0;
@ -66,6 +66,65 @@ struct Mock<TemperaturePmt> : public TemperaturePmt {
}
telemetryDeviceEntry = "/sys/class/intel_pmt/telem2/telem";
}
ze_result_t readValue(const std::string key, uint32_t &val) override {
if (mockReadValueResult != ZE_RESULT_SUCCESS) {
return mockReadValueResult;
}
ze_result_t result = ZE_RESULT_SUCCESS;
if (key.compare("HBM0MaxDeviceTemperature") == 0) {
val = memory0MaxTemperature;
} else if (key.compare("HBM1MaxDeviceTemperature") == 0) {
val = memory1MaxTemperature;
} else if (key.compare("HBM2MaxDeviceTemperature") == 0) {
val = memory2MaxTemperature;
} else if (key.compare("HBM3MaxDeviceTemperature") == 0) {
val = memory3MaxTemperature;
} else if (key.compare("GTMaxTemperature") == 0) {
val = gtMaxTemperature;
} else if (key.compare("TileMaxTemperature") == 0) {
val = tileMaxTemperature;
} else if (key.compare("COMPUTE_TEMPERATURES") == 0) {
if (mockReadComputeTempResult != ZE_RESULT_SUCCESS) {
return mockReadComputeTempResult;
}
val = 0;
for (uint8_t i = 0; i < sizeof(uint32_t); i++) {
val |= (uint32_t)tempArrForNoSubDevices[(computeTempIndex) + i] << (i * 8);
}
} else if (key.compare("CORE_TEMPERATURES") == 0) {
if (mockReadCoreTempResult != ZE_RESULT_SUCCESS) {
return mockReadCoreTempResult;
}
val = 0;
for (uint8_t i = 0; i < sizeof(uint32_t); i++) {
val |= (uint32_t)tempArrForNoSubDevices[(coreTempIndex) + i] << (i * 8);
}
} else {
result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
return result;
}
ze_result_t readValue(const std::string key, uint64_t &val) override {
if (mockReadValueResult != ZE_RESULT_SUCCESS) {
return mockReadValueResult;
}
if (key.compare("SOC_TEMPERATURES") == 0) {
val = 0;
for (uint8_t i = 0; i < sizeof(uint64_t); i++) {
val |= (uint64_t)tempArrForNoSubDevices[(socTempIndex) + i] << (i * 8);
}
return ZE_RESULT_SUCCESS;
} else {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
}
};
class TemperatureFsAccess : public FsAccess {};

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

@ -14,7 +14,6 @@ extern bool sysmanUltsEnable;
namespace L0 {
namespace ult {
const static int fakeFileDescriptor = 123;
constexpr uint32_t handleComponentCountForTwoTileDevices = 6u;
constexpr uint32_t handleComponentCountForSingleTileDevice = 3u;
constexpr uint32_t handleComponentCountForNoSubDevices = 2u;
@ -23,61 +22,6 @@ constexpr uint32_t invalidMinTemperature = 10;
const std::string sampleGuid1 = "0xb15a0edc";
const std::string sampleGuid2 = "0x490e01";
inline static int openMockTemp(const char *pathname, int flags) {
if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
return fakeFileDescriptor;
}
if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
return fakeFileDescriptor;
}
return -1;
}
inline static int closeMockTemp(int fd) {
if (fd == fakeFileDescriptor) {
return 0;
}
return -1;
}
ssize_t preadMockTemp(int fd, void *buf, size_t count, off_t offset) {
if (count == sizeof(uint32_t)) {
uint32_t *mockBuf = static_cast<uint32_t *>(buf);
if (offset == memory2MaxTempIndex) {
*mockBuf = memory2MaxTemperature;
} else if (offset == memory3MaxTempIndex) {
*mockBuf = memory3MaxTemperature;
} else {
for (uint64_t i = 0; i < sizeof(uint32_t); i++) {
*mockBuf |= (uint32_t)tempArrForSubDevices[(offset - offsetForSubDevices) + i] << (i * 8);
}
}
} else {
uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = 0;
for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
*mockBuf |= (uint64_t)tempArrForSubDevices[(offset - offsetForSubDevices) + i] << (i * 8);
}
}
return count;
}
ssize_t preadMockTempNoSubDevices(int fd, void *buf, size_t count, off_t offset) {
if (count == sizeof(uint32_t)) {
uint32_t *mockBuf = static_cast<uint32_t *>(buf);
for (uint64_t i = 0; i < sizeof(uint32_t); i++) {
*mockBuf |= (uint32_t)tempArrForNoSubDevices[(offset - offsetForNoSubDevices) + i] << (i * 8);
}
} else {
uint64_t *mockBuf = static_cast<uint64_t *>(buf);
*mockBuf = 0;
for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
*mockBuf |= (uint64_t)tempArrForNoSubDevices[(offset - offsetForNoSubDevices) + i] << (i * 8);
}
}
return count;
}
class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
@ -96,7 +40,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
handle = nullptr;
}
pSysmanDeviceImp->pTempHandleContext->handleList.clear();
pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
pFsAccess = std::make_unique<Mock<TemperatureFsAccess>>();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
@ -114,8 +58,8 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
auto pPmt = new Mock<TemperaturePmt>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
pPmt->mockedInit(pFsAccess.get());
// Get keyOffsetMap
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid1);
@ -164,31 +108,22 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZe
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved) {
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockTemp;
pPmt->closeFunction = closeMockTemp;
pPmt->preadFunction = preadMockTemp;
}
for (auto handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
double temperature;
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[subDeviceMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(tileMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[gtMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(gtMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_MEMORY) {
if (productFamily == IGFX_XE_HP_SDV) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(std::max({tempArrForSubDevices[memory0MaxTempIndex], tempArrForSubDevices[memory1MaxTempIndex]})));
EXPECT_EQ(temperature, static_cast<double>(std::max({memory0MaxTemperature, memory1MaxTemperature})));
}
if (productFamily == IGFX_PVC) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
@ -228,28 +163,14 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileInd
}
TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
// delete previously allocated pPmt objects
for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
// delete previously created temp handles
for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
delete handle;
handle = nullptr;
pSysmanDeviceImp->pTempHandleContext->handleList.pop_back();
}
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
auto handles = getTempHandles(handleComponentCountForTwoTileDevices);
for (auto &handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
@ -271,7 +192,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
pFsAccess = std::make_unique<Mock<TemperatureFsAccess>>();
pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
@ -289,8 +210,8 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
auto pPmt = new Mock<TemperaturePmt>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
pPmt->mockedInit(pFsAccess.get());
// Get keyOffsetMap
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);
@ -320,14 +241,6 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndGlobalTemperatureThenValidTemperatureReadingsRetrieved, IsDG1) {
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockTemp;
pPmt->closeFunction = closeMockTemp;
pPmt->preadFunction = preadMockTempNoSubDevices;
}
for (auto &handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
@ -342,28 +255,54 @@ HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndG
}
maxTemp = tempArrForNoSubDevices[i];
}
if (productFamily == IGFX_DG1) {
EXPECT_EQ(temperature, static_cast<double>(maxTemp));
}
EXPECT_EQ(temperature, static_cast<double>(maxTemp));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
if (productFamily == IGFX_DG1) {
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
}
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
}
}
}
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndReadCoreTemperatureFailsWhenGettingGpuAndGlobalTempThenValidGpuTempAndFailureForGlobalTempAreReturned, IsDG1) {
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->mockReadCoreTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
for (auto &handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
double temperature;
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
}
}
}
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndReadComputeTemperatureFailsWhenGettingGPUAndGlobalTemperatureThenFailureReturned, IsDG1) {
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->mockReadComputeTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
for (auto &handle : handles) {
double temperature;
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
}
}
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndGlobalTemperatureThenValidTemperatureReadingsRetrieved, IsDG2) {
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->openFunction = openMockTemp;
pPmt->closeFunction = closeMockTemp;
pPmt->preadFunction = preadMockTempNoSubDevices;
}
for (auto &handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
@ -371,48 +310,30 @@ HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndG
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
uint8_t maxTemp = 0;
for (uint64_t i = 0; i < sizeof(tempArrForNoSubDevices) / sizeof(uint8_t); i++) {
// For DG2, Global Max temperature will be Maximum of SOC_TEMPERATURES
for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
if ((tempArrForNoSubDevices[i] > invalidMaxTemperature) ||
(tempArrForNoSubDevices[i] < invalidMinTemperature) || (maxTemp > tempArrForNoSubDevices[i])) {
continue;
}
maxTemp = tempArrForNoSubDevices[i];
}
if (productFamily == IGFX_DG1) {
EXPECT_EQ(temperature, static_cast<double>(maxTemp));
}
EXPECT_EQ(temperature, static_cast<double>(maxTemp));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
if (productFamily == IGFX_DG1) {
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
}
EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[gtTempIndexForNoSubDevices]));
}
}
}
TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
// delete previously allocated pPmt objects
for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
delete subDeviceIdToPmtEntry.second;
}
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
// delete previously created temp handles
for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
delete handle;
handle = nullptr;
pSysmanDeviceImp->pTempHandleContext->handleList.pop_back();
}
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
deviceProperties.subdeviceId);
pPmt->mockedInit(pFsAccess.get());
pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
auto handles = getTempHandles(handleComponentCountForNoSubDevices);
for (auto &handle : handles) {
double temperature;
ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
@ -440,7 +361,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWheng
}
TEST_F(SysmanDeviceTemperatureFixture, GivenValidatePmtReadValueWhenkeyOffsetMapIsNotThereThenFailureReturned) {
auto pPmt = std::make_unique<NiceMock<Mock<TemperaturePmt>>>(pFsAccess.get(), 0, 0);
auto pPmt = std::make_unique<Mock<TemperaturePmt>>(pFsAccess.get(), 0, 0);
pPmt->mockedInit(pFsAccess.get());
// Get keyOffsetMap
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);
@ -501,62 +422,40 @@ HWTEST2_F(SysmanDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetS
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved, IsXEHP) {
auto handles = getTempHandles(handleComponentCountForSingleTileDevice);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid1);
pPmt->keyOffsetMap = keyOffsetMapEntry->second;
pPmt->openFunction = openMockTemp;
pPmt->closeFunction = closeMockTemp;
pPmt->preadFunction = preadMockTemp;
}
for (auto handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
double temperature;
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[subDeviceMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(tileMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[gtMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(gtMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_MEMORY) {
if (productFamily == IGFX_XE_HP_SDV) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(std::max({tempArrForSubDevices[memory0MaxTempIndex], tempArrForSubDevices[memory1MaxTempIndex]})));
EXPECT_EQ(temperature, static_cast<double>(std::max({memory0MaxTemperature, memory1MaxTemperature})));
}
}
}
}
HWTEST2_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved, IsPVC) {
HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved, IsPVC) {
auto handles = getTempHandles(handleComponentCountForSingleTileDevice);
for (auto &deviceHandle : deviceHandles) {
ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid1);
pPmt->keyOffsetMap = keyOffsetMapEntry->second;
pPmt->openFunction = openMockTemp;
pPmt->closeFunction = closeMockTemp;
pPmt->preadFunction = preadMockTemp;
}
for (auto handle : handles) {
zes_temp_properties_t properties = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
double temperature;
if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[subDeviceMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(tileMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_GPU) {
ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[gtMaxTempIndex]));
EXPECT_EQ(temperature, static_cast<double>(gtMaxTemperature));
}
if (properties.type == ZES_TEMP_SENSORS_MEMORY) {
if (productFamily == IGFX_PVC) {