From 7c1eaadf503b9eb3dd415fd27f72a6c31ba6948d Mon Sep 17 00:00:00 2001 From: SaiKishore Konda Date: Sun, 3 May 2020 04:23:27 -0400 Subject: [PATCH] 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 --- .../source/sysman/engine/linux/CMakeLists.txt | 1 + .../sysman/engine/linux/os_engine_imp.cpp | 30 +--- .../sysman/engine/linux/os_engine_imp.h | 31 ++++ .../tools/source/sysman/linux/fs_access.h | 10 +- .../sources/sysman/engine/CMakeLists.txt | 4 +- .../sysman/engine/linux/CMakeLists.txt | 14 ++ .../sources/sysman/engine/linux/mock_engine.h | 59 +++++++ .../engine/linux/test_sysman_engine.cpp | 150 ++++++++++++++++++ .../sysman/engine/windows/CMakeLists.txt | 14 ++ .../sysman/engine/{ => windows}/mock_engine.h | 0 .../{ => windows}/test_sysman_engine.cpp | 0 11 files changed, 283 insertions(+), 30 deletions(-) create mode 100644 level_zero/tools/source/sysman/engine/linux/os_engine_imp.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/linux/CMakeLists.txt create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_sysman_engine.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/windows/CMakeLists.txt rename level_zero/tools/test/unit_tests/sources/sysman/engine/{ => windows}/mock_engine.h (100%) rename level_zero/tools/test/unit_tests/sources/sysman/engine/{ => windows}/test_sysman_engine.cpp (100%) diff --git a/level_zero/tools/source/sysman/engine/linux/CMakeLists.txt b/level_zero/tools/source/sysman/engine/linux/CMakeLists.txt index 89f0d9f64e..b7c66cb8b5 100755 --- a/level_zero/tools/source/sysman/engine/linux/CMakeLists.txt +++ b/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) diff --git a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp b/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp index ecd0b2402f..80dbdafa85 100644 --- a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.cpp +++ b/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; diff --git a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.h b/level_zero/tools/source/sysman/engine/linux/os_engine_imp.h new file mode 100644 index 0000000000..4b5cd5aa47 --- /dev/null +++ b/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 diff --git a/level_zero/tools/source/sysman/linux/fs_access.h b/level_zero/tools/source/sysman/linux/fs_access.h index b6bbec174e..dbfd6aa967 100644 --- a/level_zero/tools/source/sysman/linux/fs_access.h +++ b/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); diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/engine/CMakeLists.txt index 61b4241883..292a5dd53a 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/CMakeLists.txt +++ b/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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/CMakeLists.txt new file mode 100644 index 0000000000..f3886363ff --- /dev/null +++ b/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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_engine.h new file mode 100644 index 0000000000..392e08dc24 --- /dev/null +++ b/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 : public OsEngine { + + Mock() = default; + + MOCK_METHOD1(getActiveTime, ze_result_t(uint64_t &activeTime)); + MOCK_METHOD1(getEngineGroup, ze_result_t(zet_engine_group_t &engineGroup)); +}; + +template <> +struct Mock : 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() = 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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_sysman_engine.cpp b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_sysman_engine.cpp new file mode 100644 index 0000000000..dceec27d63 --- /dev/null +++ b/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 *pOsEngine; + EngineImp *pEngineImp; + const uint64_t activeTime = 2147483648u; + + void SetUp() override { + + DeviceFixture::SetUp(); + sysmanImp = new SysmanImp(device->toHandle()); + pOsEngine = new NiceMock>; + 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>(); + + Mock 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>(); + + Mock sysfsAccess; + engineImp->pSysfsAccess = &sysfsAccess; + + zet_engine_group_t engineGroup; + EXPECT_CALL(sysfsAccess, read(_, _)) + .Times(1) + .WillOnce(::testing::Invoke(&sysfsAccess, &Mock::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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/CMakeLists.txt new file mode 100644 index 0000000000..0ee08a01f6 --- /dev/null +++ b/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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/mock_engine.h b/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h similarity index 100% rename from level_zero/tools/test/unit_tests/sources/sysman/engine/mock_engine.h rename to level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/test_sysman_engine.cpp b/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp similarity index 100% rename from level_zero/tools/test/unit_tests/sources/sysman/engine/test_sysman_engine.cpp rename to level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp