diff --git a/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.cpp b/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.cpp index af0aa09496..3f08bcaf4d 100644 --- a/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.cpp +++ b/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.cpp @@ -15,6 +15,13 @@ namespace L0 { constexpr uint64_t numSocTemperatureEntries = 7; constexpr uint32_t numCoreTemperatureEntries = 4; +ze_result_t LinuxTemperatureImp::getProperties(zes_temp_properties_t *pProperties) { + pProperties->type = type; + pProperties->onSubdevice = false; + pProperties->subdeviceId = 0; + return ZE_RESULT_SUCCESS; +} + ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) { uint64_t socTemperature = 0; uint32_t computeTemperature = 0, coreTemperature = 0; @@ -27,9 +34,9 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) { // GT temperature could be read via 8th to 15th bit in the value read in temperature computeTemperature = (computeTemperature >> 8) & 0xff; - if ((zetType == ZES_TEMP_SENSORS_GPU) || (type == ZES_TEMP_SENSORS_GPU)) { + if (type == ZES_TEMP_SENSORS_GPU) { *pTemperature = static_cast(computeTemperature); - } else if ((zetType == ZES_TEMP_SENSORS_GLOBAL) || (type == ZES_TEMP_SENSORS_GLOBAL)) { + } else if (type == ZES_TEMP_SENSORS_GLOBAL) { key = "SOC_TEMPERATURES"; result = pPmt->readValue(key, socTemperature); if (result != ZE_RESULT_SUCCESS) { diff --git a/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h b/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h index f0c212ff06..a94be8e67a 100644 --- a/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h +++ b/level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h @@ -16,6 +16,7 @@ class SysfsAccess; class PlatformMonitoringTech; class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass { public: + ze_result_t getProperties(zes_temp_properties_t *pProperties) override; ze_result_t getSensorTemperature(double *pTemperature) override; bool isTempModuleSupported() override; void setSensorType(zes_temp_sensors_t sensorType); @@ -25,7 +26,6 @@ class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass protected: PlatformMonitoringTech *pPmt = nullptr; - int zetType = 0x7fffffff; zes_temp_sensors_t type = ZES_TEMP_SENSORS_GLOBAL; }; } // namespace L0 diff --git a/level_zero/tools/source/sysman/temperature/os_temperature.h b/level_zero/tools/source/sysman/temperature/os_temperature.h index 2989867280..c4b3de956d 100644 --- a/level_zero/tools/source/sysman/temperature/os_temperature.h +++ b/level_zero/tools/source/sysman/temperature/os_temperature.h @@ -14,6 +14,7 @@ namespace L0 { struct OsSysman; class OsTemperature { public: + virtual ze_result_t getProperties(zes_temp_properties_t *pProperties) = 0; virtual ze_result_t getSensorTemperature(double *pTemperature) = 0; virtual bool isTempModuleSupported() = 0; static OsTemperature *create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType); diff --git a/level_zero/tools/source/sysman/temperature/temperature.cpp b/level_zero/tools/source/sysman/temperature/temperature.cpp index a931b86ce2..fc6462435f 100644 --- a/level_zero/tools/source/sysman/temperature/temperature.cpp +++ b/level_zero/tools/source/sysman/temperature/temperature.cpp @@ -29,6 +29,7 @@ void TemperatureHandleContext::createHandle(zes_temp_sensors_t type) { void TemperatureHandleContext::init() { createHandle(ZES_TEMP_SENSORS_GLOBAL); createHandle(ZES_TEMP_SENSORS_GPU); + createHandle(ZES_TEMP_SENSORS_MEMORY); } ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) { diff --git a/level_zero/tools/source/sysman/temperature/temperature.h b/level_zero/tools/source/sysman/temperature/temperature.h index 55c3add394..7c4cf21db0 100644 --- a/level_zero/tools/source/sysman/temperature/temperature.h +++ b/level_zero/tools/source/sysman/temperature/temperature.h @@ -29,6 +29,7 @@ class Temperature : _zes_temp_handle_t { } inline zes_temp_handle_t toHandle() { return this; } bool initSuccess = false; + zes_temp_properties_t tempProperties = {}; }; struct TemperatureHandleContext { diff --git a/level_zero/tools/source/sysman/temperature/temperature_imp.cpp b/level_zero/tools/source/sysman/temperature/temperature_imp.cpp index c49a2e33f6..6559554676 100644 --- a/level_zero/tools/source/sysman/temperature/temperature_imp.cpp +++ b/level_zero/tools/source/sysman/temperature/temperature_imp.cpp @@ -12,7 +12,8 @@ namespace L0 { ze_result_t TemperatureImp::temperatureGetProperties(zes_temp_properties_t *pProperties) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + *pProperties = tempProperties; + return ZE_RESULT_SUCCESS; } ze_result_t TemperatureImp::temperatureGetConfig(zes_temp_config_t *pConfig) { @@ -28,7 +29,10 @@ ze_result_t TemperatureImp::temperatureGetState(double *pTemperature) { } void TemperatureImp::init() { - this->initSuccess = pOsTemperature->isTempModuleSupported(); + if (pOsTemperature->isTempModuleSupported()) { + pOsTemperature->getProperties(&tempProperties); + this->initSuccess = true; + } } TemperatureImp::TemperatureImp(OsSysman *pOsSysman, zes_temp_sensors_t type) { diff --git a/level_zero/tools/source/sysman/temperature/windows/CMakeLists.txt b/level_zero/tools/source/sysman/temperature/windows/CMakeLists.txt index da894378c7..b6697c5f76 100644 --- a/level_zero/tools/source/sysman/temperature/windows/CMakeLists.txt +++ b/level_zero/tools/source/sysman/temperature/windows/CMakeLists.txt @@ -5,6 +5,8 @@ # set(L0_SRCS_TOOLS_SYSMAN_TEMPERATURE_WINDOWS + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/os_temperature_imp.h ${CMAKE_CURRENT_SOURCE_DIR}/os_temperature_imp.cpp ) diff --git a/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp b/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp index f51ee78fe5..647edb19cd 100644 --- a/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp +++ b/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.cpp @@ -5,26 +5,143 @@ * */ -#include "sysman/temperature/os_temperature.h" +#include "sysman/temperature/windows/os_temperature_imp.h" namespace L0 { -class WddmTemperatureImp : public OsTemperature { - public: - ze_result_t getSensorTemperature(double *pTemperature) override; - bool isTempModuleSupported() override; -}; +ze_result_t WddmTemperatureImp::getProperties(zes_temp_properties_t *pProperties) { + ze_result_t status = ZE_RESULT_SUCCESS; + uint32_t value = 0; + KmdSysman::RequestProperty request; + KmdSysman::ResponseProperty response; + + pProperties->type = this->type; + pProperties->onSubdevice = false; + pProperties->subdeviceId = 0; + + request.commandId = KmdSysman::Command::Get; + request.componentId = KmdSysman::Component::TemperatureComponent; + + switch (this->type) { + case ZES_TEMP_SENSORS_GLOBAL: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainPackage; + break; + case ZES_TEMP_SENSORS_GPU: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainDGPU; + break; + case ZES_TEMP_SENSORS_MEMORY: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainPackage; + break; + default: + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + break; + } + + request.requestId = KmdSysman::Requests::Temperature::TempCriticalEventSupported; + + status = pKmdSysManager->requestSingle(request, response); + + if (status != ZE_RESULT_SUCCESS) { + return status; + } + + memcpy_s(&pProperties->isCriticalTempSupported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t)); + + request.requestId = KmdSysman::Requests::Temperature::TempThreshold1EventSupported; + + status = pKmdSysManager->requestSingle(request, response); + + if (status != ZE_RESULT_SUCCESS) { + return status; + } + + memcpy_s(&pProperties->isThreshold1Supported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t)); + + request.requestId = KmdSysman::Requests::Temperature::TempThreshold2EventSupported; + + status = pKmdSysManager->requestSingle(request, response); + + if (status != ZE_RESULT_SUCCESS) { + return status; + } + + memcpy_s(&pProperties->isThreshold2Supported, sizeof(ze_bool_t), response.dataBuffer, sizeof(ze_bool_t)); + + request.requestId = KmdSysman::Requests::Temperature::MaxTempSupported; + + status = pKmdSysManager->requestSingle(request, response); + + if (status != ZE_RESULT_SUCCESS) { + return status; + } + + memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t)); + pProperties->maxTemperature = static_cast(value); + + return status; +} ze_result_t WddmTemperatureImp::getSensorTemperature(double *pTemperature) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + ze_result_t status = ZE_RESULT_SUCCESS; + KmdSysman::RequestProperty request; + KmdSysman::ResponseProperty response; + + request.commandId = KmdSysman::Command::Get; + request.componentId = KmdSysman::Component::TemperatureComponent; + request.requestId = KmdSysman::Requests::Temperature::CurrentTemperature; + + switch (type) { + case ZES_TEMP_SENSORS_GLOBAL: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainPackage; + break; + case ZES_TEMP_SENSORS_GPU: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainDGPU; + break; + case ZES_TEMP_SENSORS_MEMORY: + request.paramInfo = KmdSysman::TemperatureDomainsType::TemperatureDomainHBM; + break; + default: + *pTemperature = 0; + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + break; + } + + status = pKmdSysManager->requestSingle(request, response); + + if (status != ZE_RESULT_SUCCESS) { + return status; + } + + uint32_t value = 0; + memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t)); + *pTemperature = static_cast(value); + + return status; } bool WddmTemperatureImp::isTempModuleSupported() { - return false; + KmdSysman::RequestProperty request; + KmdSysman::ResponseProperty response; + + request.commandId = KmdSysman::Command::Get; + request.componentId = KmdSysman::Component::TemperatureComponent; + request.requestId = KmdSysman::Requests::Temperature::CurrentTemperature; + + return (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS); +} + +void WddmTemperatureImp::setSensorType(zes_temp_sensors_t sensorType) { + type = sensorType; +} + +WddmTemperatureImp::WddmTemperatureImp(OsSysman *pOsSysman) { + WddmSysmanImp *pWddmSysmanImp = static_cast(pOsSysman); + pKmdSysManager = &pWddmSysmanImp->getKmdSysManager(); } OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) { - WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp(); + WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp(pOsSysman); + pWddmTemperatureImp->setSensorType(sensorType); return static_cast(pWddmTemperatureImp); } diff --git a/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.h b/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.h new file mode 100644 index 0000000000..e50c33757e --- /dev/null +++ b/level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "shared/source/helpers/non_copyable_or_moveable.h" + +#include "sysman/temperature/os_temperature.h" +#include "sysman/windows/os_sysman_imp.h" + +namespace L0 { +class KmdSysManager; +class WddmTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass { + public: + ze_result_t getProperties(zes_temp_properties_t *pProperties) override; + ze_result_t getSensorTemperature(double *pTemperature) override; + bool isTempModuleSupported() override; + + void setSensorType(zes_temp_sensors_t sensorType); + WddmTemperatureImp(OsSysman *pOsSysman); + WddmTemperatureImp() = default; + ~WddmTemperatureImp() override = default; + + protected: + KmdSysManager *pKmdSysManager = nullptr; + zes_temp_sensors_t type = ZES_TEMP_SENSORS_GLOBAL; +}; + +} // namespace L0 \ No newline at end of file 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 eb365cf137..da7f0dc2aa 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 @@ -10,7 +10,7 @@ namespace L0 { namespace ult { -constexpr uint32_t handleComponentCount = 2u; +constexpr uint32_t handleComponentCount = 3u; const std::string deviceName("testDevice"); FsAccess *pFsAccessTemp = nullptr; class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture { @@ -70,7 +70,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemp } TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) { - auto pTemperatureImpMemory = std::make_unique(pOsSysman, ZES_TEMP_SENSORS_MEMORY); + auto pTemperatureImpMemory = std::make_unique(pOsSysman, ZES_TEMP_SENSORS_GLOBAL_MIN); auto pLinuxTemperatureImpMemory = static_cast(pTemperatureImpMemory->pOsTemperature); double pTemperature = 0; EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxTemperatureImpMemory->getSensorTemperature(&pTemperature)); @@ -112,7 +112,9 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatur auto handles = get_temp_handles(handleComponentCount); for (auto handle : handles) { zes_temp_properties_t properties = {}; - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetProperties(handle, &properties)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties)); + EXPECT_FALSE(properties.onSubdevice); + EXPECT_EQ(properties.subdeviceId, 0u); } } diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/CMakeLists.txt new file mode 100644 index 0000000000..cc9a6aadaf --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/CMakeLists.txt @@ -0,0 +1,14 @@ +# +# Copyright (C) 2020 Intel Corporation +# +# SPDX-License-Identifier: MIT +# + +if(WIN32) + target_sources(${TARGET_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt + ${CMAKE_CURRENT_SOURCE_DIR}/mock_temperature.h + ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_temperature.cpp + ) +endif() \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/mock_temperature.h b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/mock_temperature.h new file mode 100644 index 0000000000..80d4c96c85 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/mock_temperature.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#pragma once +#include "level_zero/core/test/unit_tests/mock.h" +#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h" + +#include "sysman/temperature/temperature_imp.h" + +namespace L0 { +namespace ult { + +class TemperatureKmdSysManager : public Mock {}; + +template <> +struct Mock : public TemperatureKmdSysManager { + + uint32_t mockTempGlobal = 26; + uint32_t mockTempGPU = 25; + uint32_t mockTempMemory = 23; + uint32_t mockMaxTemperature = 100; + zes_temp_sensors_t mockSensorTypes[3] = {ZES_TEMP_SENSORS_GLOBAL, ZES_TEMP_SENSORS_GPU, ZES_TEMP_SENSORS_MEMORY}; + + void getTemperatureProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override { + uint8_t *pBuffer = reinterpret_cast(pResponse); + pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut); + + KmdSysman::TemperatureDomainsType domain = static_cast(pRequest->inCommandParam); + + if (domain < KmdSysman::TemperatureDomainsType::TemperatureDomainPackage || domain >= KmdSysman::TemperatureDomainsType::TempetatureMaxDomainTypes) { + pResponse->outDataSize = 0; + pResponse->outReturnCode = KmdSysman::KmdSysmanFail; + return; + } + + switch (pRequest->inRequestId) { + case KmdSysman::Requests::Temperature::TempCriticalEventSupported: + case KmdSysman::Requests::Temperature::TempThreshold1EventSupported: + case KmdSysman::Requests::Temperature::TempThreshold2EventSupported: { + uint32_t *pValue = reinterpret_cast(pBuffer); + *pValue = 0; + pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outDataSize = sizeof(uint32_t); + } break; + case KmdSysman::Requests::Temperature::MaxTempSupported: { + uint32_t *pValue = reinterpret_cast(pBuffer); + *pValue = mockMaxTemperature; + pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outDataSize = sizeof(uint32_t); + } break; + case KmdSysman::Requests::Temperature::CurrentTemperature: { + uint32_t *pValue = reinterpret_cast(pBuffer); + switch (domain) { + case KmdSysman::TemperatureDomainsType::TemperatureDomainPackage: { + *pValue = mockTempGlobal; + } break; + case KmdSysman::TemperatureDomainsType::TemperatureDomainDGPU: { + *pValue = mockTempGPU; + } break; + case KmdSysman::TemperatureDomainsType::TemperatureDomainHBM: { + *pValue = mockTempMemory; + } break; + } + pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess; + pResponse->outDataSize = sizeof(uint32_t); + } break; + default: { + pResponse->outDataSize = 0; + pResponse->outReturnCode = KmdSysman::KmdSysmanFail; + } break; + } + } + + Mock() = default; + ~Mock() = default; +}; + +} // namespace ult +} // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp new file mode 100644 index 0000000000..c18b4ce993 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/source/sysman/temperature/windows/os_temperature_imp.h" +#include "level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/mock_temperature.h" +#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h" + +namespace L0 { +namespace ult { + +constexpr uint32_t temperatureHandleComponentCount = 3u; +class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture { + + protected: + Mock *pKmdSysManager = nullptr; + KmdSysManager *pOriginalKmdSysManager = nullptr; + void SetUp() override { + SysmanDeviceFixture::SetUp(); + + pKmdSysManager = new Mock; + + EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _)) + .WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock::mock_escape)); + + pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; + pWddmSysmanImp->pKmdSysManager = pKmdSysManager; + + for (auto handle : pSysmanDeviceImp->pTempHandleContext->handleList) { + delete handle; + } + + pSysmanDeviceImp->pTempHandleContext->handleList.clear(); + pSysmanDeviceImp->pTempHandleContext->init(); + } + void TearDown() override { + SysmanDeviceFixture::TearDown(); + pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager; + if (pKmdSysManager != nullptr) { + delete pKmdSysManager; + pKmdSysManager = nullptr; + } + } + + std::vector get_temp_handles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + +TEST_F(SysmanDeviceTemperatureFixture, GivenComponentCountZeroWhenEnumeratingTemperatureSensorsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) { + uint32_t count = 0; + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, temperatureHandleComponentCount); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenInvalidComponentCountWhenEnumeratingTemperatureSensorsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) { + uint32_t count = 0; + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, temperatureHandleComponentCount); + + count = count + 1; + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, temperatureHandleComponentCount); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenComponentCountZeroWhenEnumeratingTemperatureSensorsThenValidPowerHandlesIsReturned) { + uint32_t count = 0; + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, temperatureHandleComponentCount); + + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + for (auto handle : handles) { + EXPECT_NE(handle, nullptr); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidPowerHandleWhenGettingTemperaturePropertiesAllowSetToTrueThenCallSucceeds) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + uint32_t sensorTypeIndex = 0; + for (auto handle : handles) { + zes_temp_properties_t properties; + + ze_result_t result = zesTemperatureGetProperties(handle, &properties); + + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_FALSE(properties.onSubdevice); + EXPECT_EQ(properties.subdeviceId, 0); + EXPECT_FALSE(properties.isCriticalTempSupported); + EXPECT_FALSE(properties.isThreshold1Supported); + EXPECT_FALSE(properties.isThreshold2Supported); + EXPECT_EQ(properties.maxTemperature, pKmdSysManager->mockMaxTemperature); + EXPECT_EQ(properties.type, pKmdSysManager->mockSensorTypes[sensorTypeIndex++]); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingMemoryTemperatureThenValidTemperatureReadingsRetrieved) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + double temperature; + ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[ZES_TEMP_SENSORS_MEMORY], &temperature)); + EXPECT_EQ(temperature, static_cast(pKmdSysManager->mockTempMemory)); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUTemperatureThenValidTemperatureReadingsRetrieved) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + double temperature; + ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[ZES_TEMP_SENSORS_GPU], &temperature)); + EXPECT_EQ(temperature, static_cast(pKmdSysManager->mockTempGPU)); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemperatureThenValidTemperatureReadingsRetrieved) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + double temperature; + ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[ZES_TEMP_SENSORS_GLOBAL], &temperature)); + EXPECT_EQ(temperature, static_cast(pKmdSysManager->mockTempGlobal)); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) { + auto pTemperatureImpMemory = std::make_unique(pOsSysman, ZES_TEMP_SENSORS_GLOBAL_MIN); + auto pWddmTemperatureImp = static_cast(pTemperatureImpMemory->pOsTemperature); + double pTemperature = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pWddmTemperatureImp->getSensorTemperature(&pTemperature)); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + for (auto handle : handles) { + zes_temp_config_t config = {}; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetConfig(handle, &config)); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned) { + auto handles = get_temp_handles(temperatureHandleComponentCount); + for (auto handle : handles) { + zes_temp_config_t config = {}; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureSetConfig(handle, &config)); + } +} + +} // namespace ult +} // namespace L0 \ No newline at end of file