From 5da472e84f5dc18ef3e677321b24cf74dad4ef46 Mon Sep 17 00:00:00 2001 From: Bellekallu Rajkiran Date: Mon, 21 Nov 2022 16:57:01 +0000 Subject: [PATCH] Sysman: Refine test for temperature module Related-To: LOCI-2519 Signed-off-by: Bellekallu Rajkiran --- .../linux/mock_sysfs_temperature.h | 79 +++++- .../linux/test_zes_temperature.cpp | 233 +++++------------- 2 files changed, 135 insertions(+), 177 deletions(-) diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h index 1126885ea2..121cfed497 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h @@ -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 : public TemperaturePmt { + ze_result_t mockReadValueResult = ZE_RESULT_SUCCESS; + ze_result_t mockReadCoreTempResult = ZE_RESULT_SUCCESS; + ze_result_t mockReadComputeTempResult = ZE_RESULT_SUCCESS; + Mock(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : TemperaturePmt(pFsAccess, onSubdevice, subdeviceId) {} ~Mock() override { rootDeviceTelemNodeIndex = 0; @@ -66,6 +66,65 @@ struct Mock : 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 {}; diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp index ecc1084a0f..3f60150d5f 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp @@ -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(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(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(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(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 pPublicLinuxTemperatureImp; @@ -96,7 +40,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture { handle = nullptr; } pSysmanDeviceImp->pTempHandleContext->handleList.clear(); - pFsAccess = std::make_unique>>(); + pFsAccess = std::make_unique>(); 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>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, - deviceProperties.subdeviceId); + auto pPmt = new Mock(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> *>(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(tempArrForSubDevices[subDeviceMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(tileMaxTemperature)); } if (properties.type == ZES_TEMP_SENSORS_GPU) { ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature)); - EXPECT_EQ(temperature, static_cast(tempArrForSubDevices[gtMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(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(std::max({tempArrForSubDevices[memory0MaxTempIndex], tempArrForSubDevices[memory1MaxTempIndex]}))); + EXPECT_EQ(temperature, static_cast(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>(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 *>(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>>(); + pFsAccess = std::make_unique>(); 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>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, - deviceProperties.subdeviceId); + auto pPmt = new Mock(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> *>(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(maxTemp)); - } + EXPECT_EQ(temperature, static_cast(maxTemp)); } if (properties.type == ZES_TEMP_SENSORS_GPU) { - if (productFamily == IGFX_DG1) { - EXPECT_EQ(temperature, static_cast(tempArrForNoSubDevices[computeIndexForNoSubDevices])); - } + EXPECT_EQ(temperature, static_cast(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 *>(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(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 *>(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> *>(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(maxTemp)); - } + EXPECT_EQ(temperature, static_cast(maxTemp)); } if (properties.type == ZES_TEMP_SENSORS_GPU) { - if (productFamily == IGFX_DG1) { - EXPECT_EQ(temperature, static_cast(tempArrForNoSubDevices[computeIndexForNoSubDevices])); - } + EXPECT_EQ(temperature, static_cast(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>(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 *>(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>>(pFsAccess.get(), 0, 0); + auto pPmt = std::make_unique>(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> *>(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(tempArrForSubDevices[subDeviceMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(tileMaxTemperature)); } if (properties.type == ZES_TEMP_SENSORS_GPU) { ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature)); - EXPECT_EQ(temperature, static_cast(tempArrForSubDevices[gtMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(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(std::max({tempArrForSubDevices[memory0MaxTempIndex], tempArrForSubDevices[memory1MaxTempIndex]}))); + EXPECT_EQ(temperature, static_cast(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> *>(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(tempArrForSubDevices[subDeviceMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(tileMaxTemperature)); } if (properties.type == ZES_TEMP_SENSORS_GPU) { ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature)); - EXPECT_EQ(temperature, static_cast(tempArrForSubDevices[gtMaxTempIndex])); + EXPECT_EQ(temperature, static_cast(gtMaxTemperature)); } if (properties.type == ZES_TEMP_SENSORS_MEMORY) { if (productFamily == IGFX_PVC) {