Engine Sysman APIs using RCS Engine

- Fixing the engine sysfs node path
- Using default engine as RCS (compute) engine for engine APIs
- Updating the ULT for the same

Change-Id: If11aea422ac7e73b7f5fd0bc30d0918915d73848
Signed-off-by: SaiKishore Konda <saikishore.konda@intel.com>

level_zero/tools/source/sysman/engine/linux/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 set(L0_SRCS_TOOLS_SYSMAN_ENGINE_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/os_engine_imp.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_engine_imp.h
 )
 
 if(UNIX)

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

@@ -5,40 +5,24 @@
  *
  */
 
-#include "shared/source/helpers/non_copyable_or_moveable.h"
-
-#include "sysman/engine/os_engine.h"
-#include "sysman/linux/fs_access.h"
-#include "sysman/linux/os_sysman_imp.h"
+#include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h"
 namespace L0 {
 
-class LinuxEngineImp : public OsEngine, public NEO::NonCopyableClass {
-  public:
-    ze_result_t getActiveTime(uint64_t &activeTime) override;
-    ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
-
-    LinuxEngineImp(OsSysman *pOsSysman);
-    ~LinuxEngineImp() override = default;
-
-  private:
-    SysfsAccess *pSysfsAccess;
-    static const std::string mediaEngineGroupFile;
-    static const std::string mediaEngineGroupName;
-};
-const std::string LinuxEngineImp::mediaEngineGroupFile("vcs0/name");
-const std::string LinuxEngineImp::mediaEngineGroupName("vcs0");
+const std::string LinuxEngineImp::computeEngineGroupFile("engine/rcs0/name");
+const std::string LinuxEngineImp::computeEngineGroupName("rcs0");
 ze_result_t LinuxEngineImp::getActiveTime(uint64_t &activeTime) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
 ze_result_t LinuxEngineImp::getEngineGroup(zet_engine_group_t &engineGroup) {
     std::string strVal;
-    ze_result_t result = pSysfsAccess->read(mediaEngineGroupFile, strVal);
+    ze_result_t result = pSysfsAccess->read(computeEngineGroupFile, strVal);
     if (ZE_RESULT_SUCCESS != result) {
         return result;
     }
-    if (strVal.compare(mediaEngineGroupName) == 0) {
-        engineGroup = ZET_ENGINE_GROUP_MEDIA_ALL;
+
+    if (strVal.compare(computeEngineGroupName) == 0) {
+        engineGroup = ZET_ENGINE_GROUP_COMPUTE_ALL;
     } else {
         engineGroup = ZET_ENGINE_GROUP_ALL;
         return ZE_RESULT_ERROR_UNKNOWN;

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#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, public NEO::NonCopyableClass {
+  public:
+    ze_result_t getActiveTime(uint64_t &activeTime) override;
+    ze_result_t getEngineGroup(zet_engine_group_t &engineGroup) override;
+
+    LinuxEngineImp() = default;
+    LinuxEngineImp(OsSysman *pOsSysman);
+    ~LinuxEngineImp() override = default;
+
+  protected:
+    SysfsAccess *pSysfsAccess = nullptr;
+    static const std::string computeEngineGroupFile;
+    static const std::string computeEngineGroupName;
+};
+
+} // namespace L0

level_zero/tools/source/sysman/linux/fs_access.h

@@ -26,7 +26,7 @@ namespace L0 {
 class FsAccess {
   public:
     static FsAccess *create();
-    ~FsAccess() = default;
+    virtual ~FsAccess() = default;
 
     ze_result_t canRead(const std::string file);
     ze_result_t canWrite(const std::string file);
@@ -52,7 +52,7 @@ class FsAccess {
 class ProcfsAccess : private FsAccess {
   public:
     static ProcfsAccess *create();
-    ~ProcfsAccess() = default;
+    ~ProcfsAccess() override = default;
 
     ze_result_t listProcesses(std::vector<::pid_t> &list);
     ::pid_t myProcessId();
@@ -72,13 +72,14 @@ class ProcfsAccess : private FsAccess {
 class SysfsAccess : private FsAccess {
   public:
     static SysfsAccess *create(const std::string file);
-    ~SysfsAccess() = default;
+    SysfsAccess() = default;
+    ~SysfsAccess() override = default;
 
     ze_result_t canRead(const std::string file);
     ze_result_t canWrite(const std::string file);
     ze_result_t getFileMode(const std::string file, ::mode_t &mode);
 
-    ze_result_t read(const std::string file, std::string &val);
+    MOCKABLE_VIRTUAL ze_result_t read(const std::string file, std::string &val);
     ze_result_t read(const std::string file, int &val);
     ze_result_t read(const std::string file, uint64_t &val);
     ze_result_t read(const std::string file, double &val);
@@ -97,7 +98,6 @@ class SysfsAccess : private FsAccess {
     ze_bool_t isMyDeviceFile(const std::string dev);
 
   private:
-    SysfsAccess() = delete;
     SysfsAccess(const std::string file);
 
     std::string fullPath(const std::string file);

level_zero/tools/test/unit_tests/sources/sysman/engine/CMakeLists.txt

@@ -6,6 +6,6 @@
 
 target_sources(${TARGET_NAME} PRIVATE
      ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-     ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_engine.cpp
-     ${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h
 )
+
+add_subdirectories()

level_zero/tools/test/unit_tests/sources/sysman/engine/linux/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+    target_sources(${TARGET_NAME}
+        PRIVATE
+           ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+           ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_engine.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h
+    )
+endif()

level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/test/unit_tests/mock.h"
+#include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h"
+
+#include "sysman/engine/engine_imp.h"
+#include "sysman/engine/os_engine.h"
+#include "sysman/linux/fs_access.h"
+#include "sysman/sysman_imp.h"
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winconsistent-missing-override"
+#endif
+
+using ::testing::_;
+
+namespace L0 {
+namespace ult {
+
+template <>
+struct Mock<OsEngine> : public OsEngine {
+
+    Mock<OsEngine>() = default;
+
+    MOCK_METHOD1(getActiveTime, ze_result_t(uint64_t &activeTime));
+    MOCK_METHOD1(getEngineGroup, ze_result_t(zet_engine_group_t &engineGroup));
+};
+
+template <>
+struct Mock<SysfsAccess> : public SysfsAccess {
+    MOCK_METHOD2(read, ze_result_t(const std::string file, std::string &val));
+
+    ze_result_t doRead(const std::string file, std::string &val) {
+        val = "rcs0";
+        return ZE_RESULT_SUCCESS;
+    }
+
+    Mock<SysfsAccess>() = default;
+};
+
+template <>
+struct WhiteBox<::L0::LinuxEngineImp> : public ::L0::LinuxEngineImp {
+    using BaseClass = ::L0::LinuxEngineImp;
+    using BaseClass::pSysfsAccess;
+};
+
+} // namespace ult
+} // namespace L0
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif

level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_sysman_engine.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "mock_engine.h"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::InSequence;
+using ::testing::Invoke;
+using ::testing::NiceMock;
+using ::testing::Return;
+
+namespace L0 {
+namespace ult {
+
+ACTION_P(SetUint64_t, value) {
+    arg0 = value;
+}
+ACTION_P(SetEngGroup_t, value) {
+    arg0 = value;
+}
+
+ACTION_P(SetString_t, value) {
+    arg1 = value;
+}
+
+class SysmanEngineFixture : public DeviceFixture, public ::testing::Test {
+
+  protected:
+    SysmanImp *sysmanImp;
+    zet_sysman_handle_t hSysman;
+    zet_sysman_engine_handle_t hSysmanEngine;
+
+    Mock<OsEngine> *pOsEngine;
+    EngineImp *pEngineImp;
+    const uint64_t activeTime = 2147483648u;
+
+    void SetUp() override {
+
+        DeviceFixture::SetUp();
+        sysmanImp = new SysmanImp(device->toHandle());
+        pOsEngine = new NiceMock<Mock<OsEngine>>;
+        pEngineImp = new EngineImp();
+        pEngineImp->pOsEngine = pOsEngine;
+        ON_CALL(*pOsEngine, getEngineGroup(_))
+            .WillByDefault(DoAll(
+                SetEngGroup_t(ZET_ENGINE_GROUP_COMPUTE_ALL),
+                Return(ZE_RESULT_SUCCESS)));
+        ON_CALL(*pOsEngine, getActiveTime(_))
+            .WillByDefault(DoAll(
+                SetUint64_t(activeTime),
+                Return(ZE_RESULT_SUCCESS)));
+
+        pEngineImp->init();
+        sysmanImp->pEngineHandleContext->handleList.push_back(pEngineImp);
+
+        hSysman = sysmanImp->toHandle();
+        hSysmanEngine = pEngineImp->toHandle();
+    }
+    void TearDown() override {
+        //pOsEngine will be deleted in pEngineImp destructor and pEngineImp will be deleted by sysmanImp destructor
+        if (sysmanImp != nullptr) {
+            delete sysmanImp;
+            sysmanImp = nullptr;
+        }
+        DeviceFixture::TearDown();
+    }
+};
+
+TEST_F(SysmanEngineFixture, GivenComponentCountZeroWhenCallingZetSysmanEngineGetThenNonZeroCountIsReturnedAndVerifySysmanEngineGetCallSucceeds) {
+    zet_sysman_engine_handle_t engineHandle;
+    uint32_t count = 0;
+    ze_result_t result = zetSysmanEngineGet(hSysman, &count, NULL);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_GT(count, 0u);
+
+    uint32_t testcount = count + 1;
+
+    result = zetSysmanEngineGet(hSysman, &testcount, NULL);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testcount, count);
+
+    result = zetSysmanEngineGet(hSysman, &count, &engineHandle);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, engineHandle);
+    EXPECT_GT(count, 0u);
+}
+TEST_F(SysmanEngineFixture, GivenValidEngineHandleWhenCallingZetSysmanEngineGetPropertiesThenVerifySysmanEngineGetPropertiesCallSucceeds) {
+    zet_engine_properties_t properties;
+
+    ze_result_t result = zetSysmanEngineGetProperties(hSysmanEngine, &properties);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(ZET_ENGINE_GROUP_COMPUTE_ALL, properties.type);
+    EXPECT_FALSE(properties.onSubdevice);
+}
+
+TEST_F(SysmanEngineFixture, GivenValidEngineHandleWhenCallingZetSysmanGetActivityThenVerifySysmanEngineGetActivityCallSucceeds) {
+    zet_engine_stats_t Stats;
+
+    ze_result_t result = zetSysmanEngineGetActivity(hSysmanEngine, &Stats);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(activeTime, Stats.activeTime);
+    EXPECT_GT(Stats.timestamp, 0u);
+}
+
+TEST_F(SysmanEngineFixture, whenCalllingGetEngineGroupWithNoValidGroupFileThenResultDifferentToSuccessIsRetured) {
+    auto engineImp = std::make_unique<WhiteBox<::L0::LinuxEngineImp>>();
+
+    Mock<SysfsAccess> sysfsAccess;
+    engineImp->pSysfsAccess = &sysfsAccess;
+
+    EXPECT_CALL(sysfsAccess, read(_, _))
+        .Times(1)
+        .WillOnce(Return(ZE_RESULT_ERROR_UNKNOWN));
+
+    zet_engine_group_t engineGroup;
+    ze_result_t res = engineImp->getEngineGroup(engineGroup);
+    EXPECT_NE(ZE_RESULT_SUCCESS, res);
+}
+
+TEST_F(SysmanEngineFixture, whenCalllingGetEngineGroupWithValidGroupFileThenResultSuccessIsRetured) {
+    auto engineImp = std::make_unique<WhiteBox<::L0::LinuxEngineImp>>();
+
+    Mock<SysfsAccess> sysfsAccess;
+    engineImp->pSysfsAccess = &sysfsAccess;
+
+    zet_engine_group_t engineGroup;
+    EXPECT_CALL(sysfsAccess, read(_, _))
+        .Times(1)
+        .WillOnce(::testing::Invoke(&sysfsAccess, &Mock<SysfsAccess>::doRead));
+    ze_result_t res = engineImp->getEngineGroup(engineGroup);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, res);
+    EXPECT_EQ(ZET_ENGINE_GROUP_COMPUTE_ALL, engineGroup);
+}
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/engine/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}/test_sysman_engine.cpp
+            ${CMAKE_CURRENT_SOURCE_DIR}/mock_engine.h
+    )
+endif()