From 093180183065f707391d616e3e38c8f2533af50c Mon Sep 17 00:00:00 2001 From: Jitendra Sharma Date: Wed, 29 Jul 2020 16:28:08 +0530 Subject: [PATCH] Update sysman temperature APIs as per latest spec Change-Id: I171c5afe33fa216097b175e335d90692abfefa24 Signed-off-by: Jitendra Sharma --- level_zero/api/tools/zet_sysman.cpp | 10 +- level_zero/tools/source/sysman/sysman.h | 1 + level_zero/tools/source/sysman/sysman_imp.cpp | 13 +- level_zero/tools/source/sysman/sysman_imp.h | 5 +- .../temperature/linux/os_temperature_imp.cpp | 28 ++-- .../temperature/linux/os_temperature_imp.h | 7 +- .../sysman/temperature/os_temperature.h | 6 +- .../source/sysman/temperature/temperature.cpp | 34 +++- .../source/sysman/temperature/temperature.h | 21 ++- .../sysman/temperature/temperature_imp.cpp | 21 ++- .../sysman/temperature/temperature_imp.h | 6 +- .../windows/os_temperature_imp.cpp | 8 +- .../sysman/temperature/linux/CMakeLists.txt | 1 + .../linux/mock_sysfs_temperature.h | 17 +- .../linux/test_sysman_temperature.cpp | 30 +++- .../linux/test_zes_temperature.cpp | 153 ++++++++++++++++++ 16 files changed, 302 insertions(+), 59 deletions(-) create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp diff --git a/level_zero/api/tools/zet_sysman.cpp b/level_zero/api/tools/zet_sysman.cpp index 64f43b4c57..ed70e42a0d 100644 --- a/level_zero/api/tools/zet_sysman.cpp +++ b/level_zero/api/tools/zet_sysman.cpp @@ -914,7 +914,7 @@ zesDeviceEnumTemperatureSensors( zes_device_handle_t hDevice, uint32_t *pCount, zes_temp_handle_t *phTemperature) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::SysmanDevice::fromHandle(hDevice)->temperatureGet(pCount, phTemperature); } __zedllexport ze_result_t __zecall @@ -929,7 +929,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetProperties( zes_temp_handle_t hTemperature, zes_temp_properties_t *pProperties) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Temperature::fromHandle(hTemperature)->temperatureGetProperties(pProperties); } __zedllexport ze_result_t __zecall @@ -943,7 +943,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetConfig( zes_temp_handle_t hTemperature, zes_temp_config_t *pConfig) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Temperature::fromHandle(hTemperature)->temperatureGetConfig(pConfig); } __zedllexport ze_result_t __zecall @@ -957,7 +957,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureSetConfig( zes_temp_handle_t hTemperature, const zes_temp_config_t *pConfig) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Temperature::fromHandle(hTemperature)->temperatureSetConfig(pConfig); } __zedllexport ze_result_t __zecall @@ -971,7 +971,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetState( zes_temp_handle_t hTemperature, double *pTemperature) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Temperature::fromHandle(hTemperature)->temperatureGetState(pTemperature); } __zedllexport ze_result_t __zecall diff --git a/level_zero/tools/source/sysman/sysman.h b/level_zero/tools/source/sysman/sysman.h index 715ba629c6..62465379ed 100644 --- a/level_zero/tools/source/sysman/sysman.h +++ b/level_zero/tools/source/sysman/sysman.h @@ -84,6 +84,7 @@ struct SysmanDevice : _ze_device_handle_t { virtual ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) = 0; virtual ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) = 0; virtual ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) = 0; + virtual ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) = 0; virtual ~SysmanDevice() = default; }; diff --git a/level_zero/tools/source/sysman/sysman_imp.cpp b/level_zero/tools/source/sysman/sysman_imp.cpp index 0ab44493f6..de016082f4 100644 --- a/level_zero/tools/source/sysman/sysman_imp.cpp +++ b/level_zero/tools/source/sysman/sysman_imp.cpp @@ -25,13 +25,15 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) { pPowerHandleContext = new PowerHandleContext(pOsSysman); pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman); pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman); + pTempHandleContext = new TemperatureHandleContext(pOsSysman); } SysmanDeviceImp::~SysmanDeviceImp() { + freeResource(pTempHandleContext); freeResource(pFabricPortHandleContext); - freeResource(pOsSysman); - freeResource(pPowerHandleContext); freeResource(pFrequencyHandleContext); + freeResource(pPowerHandleContext); + freeResource(pOsSysman); } void SysmanDeviceImp::init() { @@ -45,6 +47,9 @@ void SysmanDeviceImp::init() { if (pFabricPortHandleContext) { pFabricPortHandleContext->init(); } + if (pTempHandleContext) { + pTempHandleContext->init(); + } } SysmanImp::SysmanImp(ze_device_handle_t hDevice) { @@ -237,6 +242,10 @@ ze_result_t SysmanImp::fabricPortGet(uint32_t *pCount, zet_sysman_fabric_port_ha return pFabricPortHandleContext->fabricPortGet(pCount, phPort); } +ze_result_t SysmanDeviceImp::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) { + return pTempHandleContext->temperatureGet(pCount, phTemperature); +} + ze_result_t SysmanImp::temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) { return pTempHandleContext->temperatureGet(pCount, phTemperature); } diff --git a/level_zero/tools/source/sysman/sysman_imp.h b/level_zero/tools/source/sysman/sysman_imp.h index c7ce6e61b7..35632bacc0 100644 --- a/level_zero/tools/source/sysman/sysman_imp.h +++ b/level_zero/tools/source/sysman/sysman_imp.h @@ -89,16 +89,17 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass { SysmanDeviceImp() = delete; void init(); - ze_device_handle_t hCoreDevice; - + ze_device_handle_t hCoreDevice = nullptr; OsSysman *pOsSysman = nullptr; PowerHandleContext *pPowerHandleContext = nullptr; FrequencyHandleContext *pFrequencyHandleContext = nullptr; FabricPortHandleContext *pFabricPortHandleContext = nullptr; + TemperatureHandleContext *pTempHandleContext = nullptr; ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) override; ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override; ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override; + ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) override; private: template 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 376df7c7c4..9e0504ad63 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 @@ -27,15 +27,13 @@ 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; - switch (type) { - case ZET_TEMP_SENSORS_GPU: + if ((zetType == ZET_TEMP_SENSORS_GPU) || (type == ZES_TEMP_SENSORS_GPU)) { *pTemperature = static_cast(computeTemperature); - break; - case ZET_TEMP_SENSORS_GLOBAL: + } else if ((zetType == ZET_TEMP_SENSORS_GLOBAL) || (type == ZES_TEMP_SENSORS_GLOBAL)) { key = "SOC_TEMPERATURES"; result = pPmt->readValue(key, socTemperature); if (result != ZE_RESULT_SUCCESS) { - break; + return result; } uint64_t socTemperatureList[numSocTemperatureEntries]; @@ -48,7 +46,7 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) { key = "CORE_TEMPERATURES"; result = pPmt->readValue(key, coreTemperature); if (result != ZE_RESULT_SUCCESS) { - break; + return result; } uint32_t coreTemperatureList[numCoreTemperatureEntries]; @@ -60,11 +58,9 @@ ze_result_t LinuxTemperatureImp::getSensorTemperature(double *pTemperature) { *pTemperature = static_cast(std::max({static_cast(computeTemperature), static_cast(coreTemperature), socTemperature})); - break; - default: + } else { *pTemperature = 0; result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - break; } return result; @@ -75,17 +71,27 @@ bool LinuxTemperatureImp::isTempModuleSupported() { } void LinuxTemperatureImp::setSensorType(zet_temp_sensors_t sensorType) { + zetType = sensorType; +} + +void LinuxTemperatureImp::setSensorType(zes_temp_sensors_t sensorType) { type = sensorType; } LinuxTemperatureImp::LinuxTemperatureImp(OsSysman *pOsSysman) { LinuxSysmanImp *pLinuxSysmanImp = static_cast(pOsSysman); - pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess(); pPmt = &pLinuxSysmanImp->getPlatformMonitoringTechAccess(); } -OsTemperature *OsTemperature::create(OsSysman *pOsSysman) { +OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType) { LinuxTemperatureImp *pLinuxTemperatureImp = new LinuxTemperatureImp(pOsSysman); + pLinuxTemperatureImp->setSensorType(sensorType); + return static_cast(pLinuxTemperatureImp); +} + +OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) { + LinuxTemperatureImp *pLinuxTemperatureImp = new LinuxTemperatureImp(pOsSysman); + pLinuxTemperatureImp->setSensorType(sensorType); return static_cast(pLinuxTemperatureImp); } 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 bd7ce404c9..03a47ae05d 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 @@ -18,14 +18,15 @@ class LinuxTemperatureImp : public OsTemperature, NEO::NonCopyableOrMovableClass public: ze_result_t getSensorTemperature(double *pTemperature) override; bool isTempModuleSupported() override; - void setSensorType(zet_temp_sensors_t sensorType) override; + void setSensorType(zet_temp_sensors_t sensorType); + void setSensorType(zes_temp_sensors_t sensorType); LinuxTemperatureImp(OsSysman *pOsSysman); LinuxTemperatureImp() = default; ~LinuxTemperatureImp() override = default; protected: - SysfsAccess *pSysfsAccess = nullptr; PlatformMonitoringTech *pPmt = nullptr; - zet_temp_sensors_t type; + int zetType = 0x7fffffff; + zes_temp_sensors_t type = ZES_TEMP_SENSORS_FORCE_UINT32; }; } // 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 bb93adfa8b..5f691ccec5 100644 --- a/level_zero/tools/source/sysman/temperature/os_temperature.h +++ b/level_zero/tools/source/sysman/temperature/os_temperature.h @@ -9,6 +9,8 @@ #include +#include "third_party/level_zero/zes_api_ext.h" + namespace L0 { struct OsSysman; @@ -16,8 +18,8 @@ class OsTemperature { public: virtual ze_result_t getSensorTemperature(double *pTemperature) = 0; virtual bool isTempModuleSupported() = 0; - virtual void setSensorType(zet_temp_sensors_t sensorType) = 0; - static OsTemperature *create(OsSysman *pOsSysman); + static OsTemperature *create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType); + static OsTemperature *create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType); virtual ~OsTemperature() = default; }; diff --git a/level_zero/tools/source/sysman/temperature/temperature.cpp b/level_zero/tools/source/sysman/temperature/temperature.cpp index 5ac7146d0f..36831ce5e5 100644 --- a/level_zero/tools/source/sysman/temperature/temperature.cpp +++ b/level_zero/tools/source/sysman/temperature/temperature.cpp @@ -5,8 +5,6 @@ * */ -#include "level_zero/tools/source/sysman/temperature/temperature.h" - #include "shared/source/helpers/basic_math.h" #include "level_zero/tools/source/sysman/temperature/temperature_imp.h" @@ -28,12 +26,44 @@ void TemperatureHandleContext::createHandle(zet_temp_sensors_t type) { } } +void TemperatureHandleContext::createHandle(zes_temp_sensors_t type) { + Temperature *pTemperature = new TemperatureImp(pOsSysman, type); + if (pTemperature->initSuccess == true) { + handleList.push_back(pTemperature); + } else { + delete pTemperature; + } +} + void TemperatureHandleContext::init() { + auto isSysmanEnabled = getenv("ZES_ENABLE_SYSMAN"); + if (isSysmanEnabled != nullptr) { + auto isSysmanEnabledAsInt = atoi(isSysmanEnabled); + if (isSysmanEnabledAsInt == 1) { + createHandle(ZES_TEMP_SENSORS_GLOBAL); + createHandle(ZES_TEMP_SENSORS_GPU); + } + return; + } createHandle(ZET_TEMP_SENSORS_GLOBAL); createHandle(ZET_TEMP_SENSORS_GPU); } ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature) { + uint32_t handleListSize = static_cast(handleList.size()); + uint32_t numToCopy = std::min(*pCount, handleListSize); + if (0 == *pCount || *pCount > handleListSize) { + *pCount = handleListSize; + } + if (nullptr != phTemperature) { + for (uint32_t i = 0; i < numToCopy; i++) { + phTemperature[i] = handleList[i]->toZetHandle(); + } + } + return ZE_RESULT_SUCCESS; +} + +ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) { uint32_t handleListSize = static_cast(handleList.size()); uint32_t numToCopy = std::min(*pCount, handleListSize); if (0 == *pCount || *pCount > handleListSize) { diff --git a/level_zero/tools/source/sysman/temperature/temperature.h b/level_zero/tools/source/sysman/temperature/temperature.h index bc73c25ab6..dd355e724f 100644 --- a/level_zero/tools/source/sysman/temperature/temperature.h +++ b/level_zero/tools/source/sysman/temperature/temperature.h @@ -8,28 +8,41 @@ #pragma once #include +#include "third_party/level_zero/zes_api_ext.h" + #include struct _zet_sysman_temp_handle_t { virtual ~_zet_sysman_temp_handle_t() = default; }; +struct _zes_temp_handle_t { + virtual ~_zes_temp_handle_t() = default; +}; + namespace L0 { struct OsSysman; -class Temperature : _zet_sysman_temp_handle_t { +class Temperature : _zet_sysman_temp_handle_t, _zes_temp_handle_t { public: virtual ze_result_t temperatureGetProperties(zet_temp_properties_t *pProperties) = 0; virtual ze_result_t temperatureGetConfig(zet_temp_config_t *pConfig) = 0; virtual ze_result_t temperatureSetConfig(const zet_temp_config_t *pConfig) = 0; virtual ze_result_t temperatureGetState(double *pTemperature) = 0; + virtual ze_result_t temperatureGetProperties(zes_temp_properties_t *pProperties) = 0; + virtual ze_result_t temperatureGetConfig(zes_temp_config_t *pConfig) = 0; + virtual ze_result_t temperatureSetConfig(const zes_temp_config_t *pConfig) = 0; + static Temperature *fromHandle(zet_sysman_temp_handle_t handle) { return static_cast(handle); } - inline zet_sysman_temp_handle_t toHandle() { return this; } + static Temperature *fromHandle(zes_temp_handle_t handle) { + return static_cast(handle); + } + inline zet_sysman_temp_handle_t toZetHandle() { return this; } + inline zes_temp_handle_t toHandle() { return this; } bool initSuccess = false; - zet_temp_sensors_t sensorType; }; struct TemperatureHandleContext { @@ -39,12 +52,14 @@ struct TemperatureHandleContext { void init(); ze_result_t temperatureGet(uint32_t *pCount, zet_sysman_temp_handle_t *phTemperature); + ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature); OsSysman *pOsSysman = nullptr; std::vector handleList = {}; private: void createHandle(zet_temp_sensors_t type); + void createHandle(zes_temp_sensors_t type); }; } // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/source/sysman/temperature/temperature_imp.cpp b/level_zero/tools/source/sysman/temperature/temperature_imp.cpp index a9fae23677..8438894356 100644 --- a/level_zero/tools/source/sysman/temperature/temperature_imp.cpp +++ b/level_zero/tools/source/sysman/temperature/temperature_imp.cpp @@ -11,6 +11,18 @@ namespace L0 { +ze_result_t TemperatureImp::temperatureGetProperties(zes_temp_properties_t *pProperties) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +ze_result_t TemperatureImp::temperatureGetConfig(zes_temp_config_t *pConfig) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + +ze_result_t TemperatureImp::temperatureSetConfig(const zes_temp_config_t *pConfig) { + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; +} + ze_result_t TemperatureImp::temperatureGetProperties(zet_temp_properties_t *pProperties) { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } @@ -29,12 +41,15 @@ ze_result_t TemperatureImp::temperatureGetState(double *pTemperature) { void TemperatureImp::init() { this->initSuccess = pOsTemperature->isTempModuleSupported(); - pOsTemperature->setSensorType(this->sensorType); } TemperatureImp::TemperatureImp(OsSysman *pOsSysman, zet_temp_sensors_t type) { - pOsTemperature = OsTemperature::create(pOsSysman); - this->sensorType = type; + pOsTemperature = OsTemperature::create(pOsSysman, type); + init(); +} + +TemperatureImp::TemperatureImp(OsSysman *pOsSysman, zes_temp_sensors_t type) { + pOsTemperature = OsTemperature::create(pOsSysman, type); init(); } diff --git a/level_zero/tools/source/sysman/temperature/temperature_imp.h b/level_zero/tools/source/sysman/temperature/temperature_imp.h index 601bc0f20c..9789490309 100644 --- a/level_zero/tools/source/sysman/temperature/temperature_imp.h +++ b/level_zero/tools/source/sysman/temperature/temperature_imp.h @@ -11,17 +11,21 @@ #include "level_zero/tools/source/sysman/temperature/os_temperature.h" #include "level_zero/tools/source/sysman/temperature/temperature.h" -#include namespace L0 { class TemperatureImp : public Temperature, NEO::NonCopyableOrMovableClass { public: ze_result_t temperatureGetProperties(zet_temp_properties_t *pProperties) override; ze_result_t temperatureGetConfig(zet_temp_config_t *pConfig) override; ze_result_t temperatureSetConfig(const zet_temp_config_t *pConfig) override; + + ze_result_t temperatureGetProperties(zes_temp_properties_t *pProperties) override; + ze_result_t temperatureGetConfig(zes_temp_config_t *pConfig) override; + ze_result_t temperatureSetConfig(const zes_temp_config_t *pConfig) override; ze_result_t temperatureGetState(double *pTemperature) override; TemperatureImp() = default; TemperatureImp(OsSysman *pOsSysman, zet_temp_sensors_t type); + TemperatureImp(OsSysman *pOsSysman, zes_temp_sensors_t type); ~TemperatureImp() override; OsTemperature *pOsTemperature = nullptr; 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 535619afdf..2b8af03f98 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 @@ -13,7 +13,6 @@ class WddmTemperatureImp : public OsTemperature { public: ze_result_t getSensorTemperature(double *pTemperature) override; bool isTempModuleSupported() override; - void setSensorType(zet_temp_sensors_t sensorType) override; }; ze_result_t WddmTemperatureImp::getSensorTemperature(double *pTemperature) { @@ -24,9 +23,12 @@ bool WddmTemperatureImp::isTempModuleSupported() { return false; } -void WddmTemperatureImp::setSensorType(zet_temp_sensors_t sensorType) {} +OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zet_temp_sensors_t sensorType) { + WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp(); + return static_cast(pWddmTemperatureImp); +} -OsTemperature *OsTemperature::create(OsSysman *pOsSysman) { +OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) { WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp(); return static_cast(pWddmTemperatureImp); } diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt index 3615029fc6..20bcff4a5e 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt @@ -9,6 +9,7 @@ if(UNIX) PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_temperature.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_temperature.cpp ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_temperature.h ) endif() \ No newline at end of file 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 e201bf1a5a..64d4790943 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 @@ -6,21 +6,11 @@ */ #pragma once -#include "shared/source/helpers/string.h" - -#include "level_zero/core/test/unit_tests/mock.h" #include "level_zero/tools/source/sysman/temperature/linux/os_temperature_imp.h" #include "sysman/linux/pmt.h" #include "sysman/temperature/temperature_imp.h" -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Winconsistent-missing-override" -#endif - -using ::testing::_; - namespace L0 { namespace ult { constexpr uint8_t computeIndex = 9; @@ -62,12 +52,7 @@ struct Mock : public TemperaturePmt { class PublicLinuxTemperatureImp : public L0::LinuxTemperatureImp { public: using LinuxTemperatureImp::pPmt; - using LinuxTemperatureImp::pSysfsAccess; using LinuxTemperatureImp::type; }; } // namespace ult -} // namespace L0 - -#if defined(__clang__) -#pragma clang diagnostic pop -#endif +} // namespace L0 \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_sysman_temperature.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_sysman_temperature.cpp index db90a8a827..b4a34304e7 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_sysman_temperature.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_sysman_temperature.cpp @@ -42,13 +42,13 @@ class SysmanTemperatureFixture : public DeviceFixture, public ::testing::Test { for (uint32_t i = 0; i < handleCount; i++) { linuxTemperatureImp[i].pPmt = pPmt; + linuxTemperatureImp[i].setSensorType(static_cast(i)); OsTemperature *pOsTemperature = static_cast(&linuxTemperatureImp[i]); pTemperatureImp[i] = new TemperatureImp(); pTemperatureImp[i]->pOsTemperature = pOsTemperature; pTemperatureImp[i]->init(); - pTemperatureImp[i]->pOsTemperature->setSensorType(static_cast(i)); sysmanImp->pTempHandleContext->handleList.push_back(pTemperatureImp[i]); - hSysmanTempHandle[i] = pTemperatureImp[i]->toHandle(); + hSysmanTempHandle[i] = pTemperatureImp[i]->toZetHandle(); } hSysman = sysmanImp->toHandle(); } @@ -90,10 +90,13 @@ TEST_F(SysmanTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemperatur TEST_F(SysmanTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) { double pTemperature = 0; - pTemperatureImp[0]->pOsTemperature->setSensorType(ZET_TEMP_SENSORS_MEMORY); - pTemperatureImp[1]->pOsTemperature->setSensorType(ZET_TEMP_SENSORS_MEMORY); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pTemperatureImp[0]->pOsTemperature->getSensorTemperature(&pTemperature)); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pTemperatureImp[1]->pOsTemperature->getSensorTemperature(&pTemperature)); + linuxTemperatureImp[0].setSensorType(ZET_TEMP_SENSORS_MEMORY); + OsTemperature *pOsTemperatureTest1 = static_cast(&linuxTemperatureImp[0]); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsTemperatureTest1->getSensorTemperature(&pTemperature)); + + linuxTemperatureImp[1].setSensorType(ZET_TEMP_SENSORS_MEMORY); + OsTemperature *pOsTemperatureTest2 = static_cast(&linuxTemperatureImp[1]); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pOsTemperatureTest2->getSensorTemperature(&pTemperature)); } TEST_F(SysmanTemperatureFixture, GivenPmtSupportNotAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnFalse) { @@ -122,5 +125,20 @@ TEST_F(SysmanTemperatureFixture, GivenPmtSupportAvailableWhenCheckingForTempModu EXPECT_TRUE(pTemperatureImp[1]->pOsTemperature->isTempModuleSupported()); } +class ZetPublicLinuxSysmanImpTemperature : public L0::LinuxSysmanImp { + public: + using LinuxSysmanImp::pPmt; + ZetPublicLinuxSysmanImpTemperature(SysmanImp *pParentSysmanImp) : LinuxSysmanImp(pParentSysmanImp) {} +}; + +TEST_F(SysmanTemperatureFixture, GivenOsSysmanPointerWhenCreatingOsTemperaturePointerThenValidOsTemperatureIsCreated) { + auto pLinuxSysmanImpTest = std::make_unique(sysmanImp.get()); + pLinuxSysmanImpTest->pPmt = new PlatformMonitoringTech(); + auto pOsSysmanTest = static_cast(pLinuxSysmanImpTest.get()); + auto pOsTemperatureTest = OsTemperature::create(pOsSysmanTest, ZET_TEMP_SENSORS_GLOBAL); + EXPECT_NE(pOsTemperatureTest, nullptr); + delete pOsTemperatureTest; +} + } // namespace ult } // namespace L0 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 new file mode 100644 index 0000000000..711ba64d51 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/test/unit_tests/sources/sysman/mock_sysman_fixture.h" +#include "level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h" + +namespace L0 { +namespace ult { +constexpr uint32_t handleComponentCount = 2u; +const std::string deviceName("testDevice"); +FsAccess *pFsAccessTemp = nullptr; +class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture { + protected: + std::unique_ptr> pPmt; + PlatformMonitoringTech *pPmtOld = nullptr; + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pPmtOld = pLinuxSysmanImp->pPmt; + pPmt = std::make_unique>>(); + pPmt->setVal(true); + pPmt->init(deviceName, pFsAccessTemp); + pLinuxSysmanImp->pPmt = pPmt.get(); + pSysmanDeviceImp->pTempHandleContext->init(); + } + void TearDown() override { + SysmanDeviceFixture::TearDown(); + pLinuxSysmanImp->pPmt = pPmtOld; + } + + 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, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) { + uint32_t count = 0; + ze_result_t result = zesDeviceEnumTemperatureSensors(device->toHandle(), &count, NULL); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(count, handleComponentCount); + + uint32_t testcount = count + 1; + result = zesDeviceEnumTemperatureSensors(device->toHandle(), &testcount, NULL); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(testcount, handleComponentCount); + + count = 0; + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, handleComponentCount); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUTemperatureThenValidTemperatureReadingsRetrieved) { + auto handles = get_temp_handles(handleComponentCount); + double temperature; + ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[1], &temperature)); + EXPECT_EQ(temperature, static_cast(tempArr[computeIndex])); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGlobalTemperatureThenValidTemperatureReadingsRetrieved) { + auto handles = get_temp_handles(handleComponentCount); + double temperature; + ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handles[0], &temperature)); + EXPECT_EQ(temperature, static_cast(tempArr[globalIndex])); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) { + auto pTemperatureImpMemory = std::make_unique(pOsSysman, ZES_TEMP_SENSORS_MEMORY); + auto pLinuxTemperatureImpMemory = static_cast(pTemperatureImpMemory->pOsTemperature); + double pTemperature = 0; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxTemperatureImpMemory->getSensorTemperature(&pTemperature)); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenPmtSupportNotAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnFalse) { + //delete previously allocated memory, allocated by init() call in SetUp() + if (pPmt->mappedMemory != nullptr) { + delete pPmt->mappedMemory; + pPmt->mappedMemory = nullptr; + } + pPmt->setVal(false); + //FsAccess *pFsAccessTemp = nullptr; + pPmt->init(deviceName, pFsAccessTemp); + auto handles = get_temp_handles(handleComponentCount); + for (auto handle : handles) { + auto pTemperatureImpTest = static_cast(L0::Temperature::fromHandle(handle)); + EXPECT_FALSE(pTemperatureImpTest->pOsTemperature->isTempModuleSupported()); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenPmtSupportAvailableWhenCheckingForTempModuleSupportThenTempModuleSupportShouldReturnTrue) { + //delete previously allocated memory, allocated by init() call in SetUp() + if (pPmt->mappedMemory != nullptr) { + delete pPmt->mappedMemory; + pPmt->mappedMemory = nullptr; + } + pPmt->setVal(true); + //FsAccess *pFsAccessTemp = nullptr; + pPmt->init(deviceName, pFsAccessTemp); + auto handles = get_temp_handles(handleComponentCount); + for (auto handle : handles) { + auto pTemperatureImpTest = static_cast(L0::Temperature::fromHandle(handle)); + EXPECT_TRUE(pTemperatureImpTest->pOsTemperature->isTempModuleSupported()); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenSysmanEnvironmentVariableSetToZeroWhenCreatingTemperatureHandlesThenHandlesNotCreated) { + setenv("ZES_ENABLE_SYSMAN", "0", 1); + auto pTempHandleContextTest = std::make_unique(pOsSysman); + pTempHandleContextTest->init(); + uint32_t count = 0; + std::vector handles(count, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, pTempHandleContextTest->temperatureGet(&count, handles.data())); + EXPECT_EQ(count, 0u); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenSysmanEnvironmentVariableNotSetWhenCreatingTemperatureHandlesThenZetHandlesCreated) { + unsetenv("ZES_ENABLE_SYSMAN"); + auto pTempHandleContextTestWithoutEnvSet = std::make_unique(pOsSysman); + pTempHandleContextTestWithoutEnvSet->init(); + EXPECT_EQ(handleComponentCount, static_cast(pTempHandleContextTestWithoutEnvSet->handleList.size())); +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperaturePropertiesThenUnsupportedIsReturned) { + 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)); + } +} + +TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) { + auto handles = get_temp_handles(handleComponentCount); + 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(handleComponentCount); + for (auto handle : handles) { + zes_temp_config_t config = {}; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureSetConfig(handle, &config)); + } +} + +} // namespace ult +} // namespace L0