Update sysman temperature APIs as per latest spec

Change-Id: I171c5afe33fa216097b175e335d90692abfefa24
Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>

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;
 };
 

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);
 }

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 <typename T>

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<double>(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<double>(std::max({static_cast<uint64_t>(computeTemperature),
                                                       static_cast<uint64_t>(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<LinuxSysmanImp *>(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<OsTemperature *>(pLinuxTemperatureImp);
+}
+
+OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) {
+    LinuxTemperatureImp *pLinuxTemperatureImp = new LinuxTemperatureImp(pOsSysman);
+    pLinuxTemperatureImp->setSensorType(sensorType);
     return static_cast<OsTemperature *>(pLinuxTemperatureImp);
 }
 

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

level_zero/tools/source/sysman/temperature/os_temperature.h

@@ -9,6 +9,8 @@
 
 #include <level_zero/zet_api.h>
 
+#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;
 };
 

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<uint32_t>(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<uint32_t>(handleList.size());
     uint32_t numToCopy = std::min(*pCount, handleListSize);
     if (0 == *pCount || *pCount > handleListSize) {

level_zero/tools/source/sysman/temperature/temperature.h

@@ -8,28 +8,41 @@
 #pragma once
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 #include <vector>
 
 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<Temperature *>(handle);
     }
-    inline zet_sysman_temp_handle_t toHandle() { return this; }
+    static Temperature *fromHandle(zes_temp_handle_t handle) {
+        return static_cast<Temperature *>(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<Temperature *> handleList = {};
 
   private:
     void createHandle(zet_temp_sensors_t type);
+    void createHandle(zes_temp_sensors_t type);
 };
 
 } // namespace L0

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();
 }
 

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 <level_zero/zet_api.h>
 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;

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<OsTemperature *>(pWddmTemperatureImp);
+}
 
-OsTemperature *OsTemperature::create(OsSysman *pOsSysman) {
+OsTemperature *OsTemperature::create(OsSysman *pOsSysman, zes_temp_sensors_t sensorType) {
     WddmTemperatureImp *pWddmTemperatureImp = new WddmTemperatureImp();
     return static_cast<OsTemperature *>(pWddmTemperatureImp);
 }