Update Sysman engine APIs as per latest spec

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

level_zero/tools/source/sysman/engine/engine.cpp

@@ -19,17 +19,51 @@ EngineHandleContext::~EngineHandleContext() {
     }
 }
 
-ze_result_t EngineHandleContext::init() {
-    Engine *pEngine = new EngineImp(pOsSysman);
+void EngineHandleContext::createHandle(zet_engine_group_t type) {
+    Engine *pEngine = new EngineImp(pOsSysman, type);
     if (pEngine->initSuccess == true) {
         handleList.push_back(pEngine);
     } else {
         delete pEngine;
     }
-    return ZE_RESULT_SUCCESS;
+}
+
+void EngineHandleContext::createHandle(zes_engine_group_t type) {
+    Engine *pEngine = new EngineImp(pOsSysman, type);
+    if (pEngine->initSuccess == true) {
+        handleList.push_back(pEngine);
+    } else {
+        delete pEngine;
+    }
+}
+
+void EngineHandleContext::init() {
+    auto isSysmanEnabled = getenv("ZES_ENABLE_SYSMAN");
+    if (isSysmanEnabled != nullptr) {
+        auto isSysmanEnabledAsInt = atoi(isSysmanEnabled);
+        if (isSysmanEnabledAsInt == 1) {
+            createHandle(ZES_ENGINE_GROUP_COMPUTE_ALL);
+        }
+        return;
+    }
+    createHandle(ZET_ENGINE_GROUP_COMPUTE_ALL);
 }
 
 ze_result_t EngineHandleContext::engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine) {
+    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 != phEngine) {
+        for (uint32_t i = 0; i < numToCopy; i++) {
+            phEngine[i] = handleList[i]->toZetHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t EngineHandleContext::engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) {
     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/engine/engine.h

@@ -8,25 +8,38 @@
 #pragma once
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 #include <vector>
 
 struct _zet_sysman_engine_handle_t {
     virtual ~_zet_sysman_engine_handle_t() = default;
 };
 
+struct _zes_engine_handle_t {
+    virtual ~_zes_engine_handle_t() = default;
+};
+
 namespace L0 {
 
 struct OsSysman;
 
-class Engine : _zet_sysman_engine_handle_t {
+class Engine : _zet_sysman_engine_handle_t, _zes_engine_handle_t {
   public:
     virtual ze_result_t engineGetProperties(zet_engine_properties_t *pProperties) = 0;
     virtual ze_result_t engineGetActivity(zet_engine_stats_t *pStats) = 0;
 
+    virtual ze_result_t engineGetProperties(zes_engine_properties_t *pProperties) = 0;
+    virtual ze_result_t engineGetActivity(zes_engine_stats_t *pStats) = 0;
+
     static Engine *fromHandle(zet_sysman_engine_handle_t handle) {
         return static_cast<Engine *>(handle);
     }
-    inline zet_sysman_engine_handle_t toHandle() { return this; }
+    static Engine *fromHandle(zes_engine_handle_t handle) {
+        return static_cast<Engine *>(handle);
+    }
+    inline zet_sysman_engine_handle_t toZetHandle() { return this; }
+    inline zes_engine_handle_t toHandle() { return this; }
     bool initSuccess = false;
 };
 
@@ -34,12 +47,17 @@ struct EngineHandleContext {
     EngineHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
     ~EngineHandleContext();
 
-    ze_result_t init();
+    void init();
 
     ze_result_t engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *phEngine);
+    ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine);
 
     OsSysman *pOsSysman = nullptr;
     std::vector<Engine *> handleList = {};
+
+  private:
+    void createHandle(zet_engine_group_t type);
+    void createHandle(zes_engine_group_t type);
 };
 
 } // namespace L0

level_zero/tools/source/sysman/engine/engine_imp.cpp

@@ -9,44 +9,64 @@
 
 #include "level_zero/core/source/device/device.h"
 
-#include <chrono>
-
 namespace L0 {
 
-void engineGetTimestamp(uint64_t &timestamp) {
-    std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
-    timestamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
-}
 ze_result_t EngineImp::engineGetActivity(zet_engine_stats_t *pStats) {
-
-    ze_result_t result;
-
-    result = pOsEngine->getActiveTime(pStats->activeTime);
-
-    engineGetTimestamp(pStats->timestamp);
-
-    return result;
+    ze_result_t result = pOsEngine->getActiveTime(pStats->activeTime);
+    if (result != ZE_RESULT_SUCCESS) {
+        return result;
+    }
+    return pOsEngine->getTimeStamp(pStats->timestamp);
 }
 
-void EngineImp::init() {
-    zet_engine_group_t engineGroup = ZET_ENGINE_GROUP_ALL;
-    if (pOsEngine->getEngineGroup(engineGroup) == ZE_RESULT_SUCCESS) {
+ze_result_t EngineImp::engineGetActivity(zes_engine_stats_t *pStats) {
+    ze_result_t result = pOsEngine->getActiveTime(pStats->activeTime);
+    if (result != ZE_RESULT_SUCCESS) {
+        return result;
+    }
+    return pOsEngine->getTimeStamp(pStats->timestamp);
+}
+
+ze_result_t EngineImp::engineGetProperties(zet_engine_properties_t *pProperties) {
+    *pProperties = zetEngineProperties;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t EngineImp::engineGetProperties(zes_engine_properties_t *pProperties) {
+    *pProperties = engineProperties;
+    return ZE_RESULT_SUCCESS;
+}
+
+void EngineImp::init(zet_engine_group_t type) {
+    if (pOsEngine->getEngineGroup(type) == ZE_RESULT_SUCCESS) {
         this->initSuccess = true;
     } else {
         this->initSuccess = false;
     }
-    engineProperties.type = engineGroup;
+    zetEngineProperties.type = type;
+    zetEngineProperties.onSubdevice = false;
+    zetEngineProperties.subdeviceId = 0;
+}
+
+void EngineImp::init(zes_engine_group_t type) {
+    if (pOsEngine->getEngineGroup(type) == ZE_RESULT_SUCCESS) {
+        this->initSuccess = true;
+    } else {
+        this->initSuccess = false;
+    }
+    engineProperties.type = type;
     engineProperties.onSubdevice = false;
     engineProperties.subdeviceId = 0;
 }
-ze_result_t EngineImp::engineGetProperties(zet_engine_properties_t *pProperties) {
-    *pProperties = engineProperties;
-    return ZE_RESULT_SUCCESS;
-}
-EngineImp::EngineImp(OsSysman *pOsSysman) {
-    pOsEngine = OsEngine::create(pOsSysman);
 
-    init();
+EngineImp::EngineImp(OsSysman *pOsSysman, zet_engine_group_t type) {
+    pOsEngine = OsEngine::create(pOsSysman);
+    init(type);
+}
+
+EngineImp::EngineImp(OsSysman *pOsSysman, zes_engine_group_t type) {
+    pOsEngine = OsEngine::create(pOsSysman);
+    init(type);
 }
 
 EngineImp::~EngineImp() {

level_zero/tools/source/sysman/engine/engine_imp.h

@@ -18,14 +18,20 @@ class EngineImp : public Engine, NEO::NonCopyableOrMovableClass {
     ze_result_t engineGetProperties(zet_engine_properties_t *pProperties) override;
     ze_result_t engineGetActivity(zet_engine_stats_t *pStats) override;
 
+    ze_result_t engineGetProperties(zes_engine_properties_t *pProperties) override;
+    ze_result_t engineGetActivity(zes_engine_stats_t *pStats) override;
+
     EngineImp() = default;
-    EngineImp(OsSysman *pOsSysman);
+    EngineImp(OsSysman *pOsSysman, zet_engine_group_t type);
+    EngineImp(OsSysman *pOsSysman, zes_engine_group_t type);
     ~EngineImp() override;
 
     OsEngine *pOsEngine = nullptr;
-    void init();
+    void init(zet_engine_group_t type);
+    void init(zes_engine_group_t type);
 
   private:
-    zet_engine_properties_t engineProperties = {};
+    zet_engine_properties_t zetEngineProperties = {};
+    zes_engine_properties_t engineProperties = {};
 };
 } // namespace L0

level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp

@@ -6,6 +6,10 @@
  */
 
 #include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h"
+
+#include "sysman/linux/os_sysman_imp.h"
+
+#include <chrono>
 namespace L0 {
 
 const std::string LinuxEngineImp::computeEngineGroupFile("engine/rcs0/name");
@@ -14,6 +18,12 @@ ze_result_t LinuxEngineImp::getActiveTime(uint64_t &activeTime) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
+ze_result_t LinuxEngineImp::getTimeStamp(uint64_t &timeStamp) {
+    std::chrono::time_point<std::chrono::steady_clock> ts = std::chrono::steady_clock::now();
+    timeStamp = std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t LinuxEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
     std::string strVal;
     ze_result_t result = pSysfsAccess->read(computeEngineGroupFile, strVal);
@@ -30,6 +40,22 @@ ze_result_t LinuxEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
     return result;
 }
 
+ze_result_t LinuxEngineImp::getEngineGroup(zes_engine_group_t &engineGroup) {
+    std::string strVal;
+    ze_result_t result = pSysfsAccess->read(computeEngineGroupFile, strVal);
+    if (ZE_RESULT_SUCCESS != result) {
+        return result;
+    }
+
+    if (strVal.compare(computeEngineGroupName) == 0) {
+        engineGroup = ZES_ENGINE_GROUP_COMPUTE_ALL;
+    } else {
+        engineGroup = ZES_ENGINE_GROUP_ALL;
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
 LinuxEngineImp::LinuxEngineImp(OsSysman *pOsSysman) {
     LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
 

level_zero/tools/source/sysman/engine/linux/os_engine_imp.h

@@ -10,13 +10,14 @@
 
 #include "sysman/engine/os_engine.h"
 #include "sysman/linux/fs_access.h"
-#include "sysman/linux/os_sysman_imp.h"
 namespace L0 {
 
 class LinuxEngineImp : public OsEngine, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getActiveTime(uint64_t &activeTime) override;
+    ze_result_t getTimeStamp(uint64_t &timeStamp) override;
     ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
+    ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) override;
     LinuxEngineImp() = default;
     LinuxEngineImp(OsSysman *pOsSysman);
     ~LinuxEngineImp() override = default;

level_zero/tools/source/sysman/engine/os_engine.h

@@ -9,13 +9,17 @@
 
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 namespace L0 {
 
 struct OsSysman;
 class OsEngine {
   public:
     virtual ze_result_t getActiveTime(uint64_t &activeTime) = 0;
+    virtual ze_result_t getTimeStamp(uint64_t &timeStamp) = 0;
     virtual ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) = 0;
+    virtual ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) = 0;
     static OsEngine *create(OsSysman *pOsSysman);
     virtual ~OsEngine() = default;
 };

level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp

@@ -12,16 +12,27 @@ namespace L0 {
 class WddmEngineImp : public OsEngine {
   public:
     ze_result_t getActiveTime(uint64_t &activeTime) override;
+    ze_result_t getTimeStamp(uint64_t &timeStamp) override;
     ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
+    ze_result_t getEngineGroup(zes_engine_group_t &engineGroup) override;
 };
 
 ze_result_t WddmEngineImp::getActiveTime(uint64_t &activeTime) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
+ze_result_t WddmEngineImp::getTimeStamp(uint64_t &timeStamp) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
 ze_result_t WddmEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
+
+ze_result_t WddmEngineImp::getEngineGroup(zes_engine_group_t &engineGroup) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
 OsEngine *OsEngine::create(OsSysman *pOsSysman) {
     WddmEngineImp *pWddmEngineImp = new WddmEngineImp();
     return static_cast<OsEngine *>(pWddmEngineImp);