From b6e98c4eb4345b04b407fc5b8402c6649d5518e2 Mon Sep 17 00:00:00 2001 From: Jitendra Sharma Date: Thu, 30 Jul 2020 18:01:57 +0530 Subject: [PATCH] Update Sysman engine APIs as per latest spec Change-Id: I477435714a20f7a9c8fd4bb1ef6b852eeaabd5e2 Signed-off-by: Jitendra Sharma --- level_zero/api/tools/zet_sysman.cpp | 6 +- .../tools/source/sysman/engine/engine.cpp | 40 +++++- .../tools/source/sysman/engine/engine.h | 24 +++- .../tools/source/sysman/engine/engine_imp.cpp | 70 +++++++---- .../tools/source/sysman/engine/engine_imp.h | 12 +- .../sysman/engine/linux/os_engine_imp.cpp | 26 ++++ .../sysman/engine/linux/os_engine_imp.h | 3 +- .../tools/source/sysman/engine/os_engine.h | 4 + .../sysman/engine/windows/os_engine_imp.cpp | 11 ++ level_zero/tools/source/sysman/sysman.h | 1 + level_zero/tools/source/sysman/sysman_imp.cpp | 9 ++ level_zero/tools/source/sysman/sysman_imp.h | 2 + .../sysman/engine/linux/CMakeLists.txt | 1 + .../sysman/engine/linux/mock_sysfs_engine.h | 22 ++-- .../engine/linux/test_sysman_engine.cpp | 11 +- .../sysman/engine/linux/test_zes_engine.cpp | 114 +++++++++++++++++ .../sysman/engine/windows/CMakeLists.txt | 14 --- .../sysman/engine/windows/mock_engine.h | 36 ------ .../engine/windows/test_sysman_engine.cpp | 115 ------------------ 19 files changed, 304 insertions(+), 217 deletions(-) create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp delete mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/windows/CMakeLists.txt delete mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h delete mode 100644 level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp diff --git a/level_zero/api/tools/zet_sysman.cpp b/level_zero/api/tools/zet_sysman.cpp index c7f9d07d79..a7a8b56f33 100644 --- a/level_zero/api/tools/zet_sysman.cpp +++ b/level_zero/api/tools/zet_sysman.cpp @@ -600,7 +600,7 @@ zesDeviceEnumEngineGroups( zes_device_handle_t hDevice, uint32_t *pCount, zes_engine_handle_t *phEngine) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::SysmanDevice::fromHandle(hDevice)->engineGet(pCount, phEngine); } __zedllexport ze_result_t __zecall @@ -615,7 +615,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesEngineGetProperties( zes_engine_handle_t hEngine, zes_engine_properties_t *pProperties) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Engine::fromHandle(hEngine)->engineGetProperties(pProperties); } __zedllexport ze_result_t __zecall @@ -629,7 +629,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL zesEngineGetActivity( zes_engine_handle_t hEngine, zes_engine_stats_t *pStats) { - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + return L0::Engine::fromHandle(hEngine)->engineGetActivity(pStats); } __zedllexport ze_result_t __zecall diff --git a/level_zero/tools/source/sysman/engine/engine.cpp b/level_zero/tools/source/sysman/engine/engine.cpp index 22792fc085..c93f19d386 100644 --- a/level_zero/tools/source/sysman/engine/engine.cpp +++ b/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(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(handleList.size()); uint32_t numToCopy = std::min(*pCount, handleListSize); if (0 == *pCount || *pCount > handleListSize) { diff --git a/level_zero/tools/source/sysman/engine/engine.h b/level_zero/tools/source/sysman/engine/engine.h index 31db2d52fb..9402e5f3f5 100644 --- a/level_zero/tools/source/sysman/engine/engine.h +++ b/level_zero/tools/source/sysman/engine/engine.h @@ -8,25 +8,38 @@ #pragma once #include +#include "third_party/level_zero/zes_api_ext.h" + #include 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(handle); } - inline zet_sysman_engine_handle_t toHandle() { return this; } + static Engine *fromHandle(zes_engine_handle_t handle) { + return static_cast(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 handleList = {}; + + private: + void createHandle(zet_engine_group_t type); + void createHandle(zes_engine_group_t type); }; } // namespace L0 diff --git a/level_zero/tools/source/sysman/engine/engine_imp.cpp b/level_zero/tools/source/sysman/engine/engine_imp.cpp index 3cd4d6b3dc..a127899c85 100644 --- a/level_zero/tools/source/sysman/engine/engine_imp.cpp +++ b/level_zero/tools/source/sysman/engine/engine_imp.cpp @@ -9,44 +9,64 @@ #include "level_zero/core/source/device/device.h" -#include - namespace L0 { -void engineGetTimestamp(uint64_t ×tamp) { - std::chrono::time_point ts = std::chrono::steady_clock::now(); - timestamp = std::chrono::duration_cast(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() { diff --git a/level_zero/tools/source/sysman/engine/engine_imp.h b/level_zero/tools/source/sysman/engine/engine_imp.h index 25d86d8af6..d3a821f1b1 100644 --- a/level_zero/tools/source/sysman/engine/engine_imp.h +++ b/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 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 80dbdafa85..8f20a226c2 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 @@ -6,6 +6,10 @@ */ #include "level_zero/tools/source/sysman/engine/linux/os_engine_imp.h" + +#include "sysman/linux/os_sysman_imp.h" + +#include 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 ts = std::chrono::steady_clock::now(); + timeStamp = std::chrono::duration_cast(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(pOsSysman); 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 index 0c22740fc7..cc00991dea 100644 --- a/level_zero/tools/source/sysman/engine/linux/os_engine_imp.h +++ b/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; diff --git a/level_zero/tools/source/sysman/engine/os_engine.h b/level_zero/tools/source/sysman/engine/os_engine.h index 5e37aedade..e0a599adce 100644 --- a/level_zero/tools/source/sysman/engine/os_engine.h +++ b/level_zero/tools/source/sysman/engine/os_engine.h @@ -9,13 +9,17 @@ #include +#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; }; diff --git a/level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp b/level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp index 7b0a8cbd4c..62205e8570 100644 --- a/level_zero/tools/source/sysman/engine/windows/os_engine_imp.cpp +++ b/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(pWddmEngineImp); diff --git a/level_zero/tools/source/sysman/sysman.h b/level_zero/tools/source/sysman/sysman.h index 82ca30b41b..28f63f12dd 100644 --- a/level_zero/tools/source/sysman/sysman.h +++ b/level_zero/tools/source/sysman/sysman.h @@ -86,6 +86,7 @@ struct SysmanDevice : _ze_device_handle_t { 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 ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) = 0; + virtual ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) = 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 e36d06f982..c72c82a88f 100644 --- a/level_zero/tools/source/sysman/sysman_imp.cpp +++ b/level_zero/tools/source/sysman/sysman_imp.cpp @@ -27,9 +27,11 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) { pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman); pTempHandleContext = new TemperatureHandleContext(pOsSysman); pStandbyHandleContext = new StandbyHandleContext(pOsSysman); + pEngineHandleContext = new EngineHandleContext(pOsSysman); } SysmanDeviceImp::~SysmanDeviceImp() { + freeResource(pEngineHandleContext); freeResource(pStandbyHandleContext); freeResource(pTempHandleContext); freeResource(pFabricPortHandleContext); @@ -55,6 +57,9 @@ void SysmanDeviceImp::init() { if (pStandbyHandleContext) { pStandbyHandleContext->init(); } + if (pEngineHandleContext) { + pEngineHandleContext->init(); + } } SysmanImp::SysmanImp(ze_device_handle_t hDevice) { @@ -227,6 +232,10 @@ ze_result_t SysmanImp::engineGet(uint32_t *pCount, zet_sysman_engine_handle_t *p return pEngineHandleContext->engineGet(pCount, phEngine); } +ze_result_t SysmanDeviceImp::engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) { + return pEngineHandleContext->engineGet(pCount, phEngine); +} + ze_result_t SysmanImp::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) { return pStandbyHandleContext->standbyGet(pCount, phStandby); } diff --git a/level_zero/tools/source/sysman/sysman_imp.h b/level_zero/tools/source/sysman/sysman_imp.h index 3568ca76e6..538ad49729 100644 --- a/level_zero/tools/source/sysman/sysman_imp.h +++ b/level_zero/tools/source/sysman/sysman_imp.h @@ -96,12 +96,14 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass { FabricPortHandleContext *pFabricPortHandleContext = nullptr; TemperatureHandleContext *pTempHandleContext = nullptr; StandbyHandleContext *pStandbyHandleContext = nullptr; + EngineHandleContext *pEngineHandleContext = 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; ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) override; + ze_result_t engineGet(uint32_t *pCount, zes_engine_handle_t *phEngine) override; private: template 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 index c85c085f48..130a57feb3 100644 --- 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 @@ -9,6 +9,7 @@ if(UNIX) PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_engine.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_engine.cpp ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_engine.h ) endif() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_sysfs_engine.h b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_sysfs_engine.h index 26c1683e1a..a3cff734bc 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_sysfs_engine.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/mock_sysfs_engine.h @@ -6,18 +6,11 @@ */ #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" -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Winconsistent-missing-override" -#endif - using ::testing::_; namespace L0 { @@ -29,7 +22,7 @@ class EngineSysfsAccess : public SysfsAccess {}; template <> struct Mock : public EngineSysfsAccess { - MOCK_METHOD2(read, ze_result_t(const std::string file, std::string &val)); + MOCK_METHOD(ze_result_t, read, (const std::string file, std::string &val), (override)); ze_result_t getVal(const std::string file, std::string &val) { if (file.compare(computeEngineGroupFile) == 0) { @@ -37,6 +30,15 @@ struct Mock : public EngineSysfsAccess { } return ZE_RESULT_SUCCESS; } + ze_result_t getValReturnError(const std::string file, std::string &val) { + return ZE_RESULT_ERROR_NOT_AVAILABLE; + } + ze_result_t getIncorrectVal(const std::string file, std::string &val) { + if (file.compare(computeEngineGroupFile) == 0) { + val = ""; + } + return ZE_RESULT_SUCCESS; + } Mock() = default; ~Mock() override = default; @@ -47,7 +49,3 @@ class PublicLinuxEngineImp : public L0::LinuxEngineImp { }; } // 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 index 06b746ba62..60474cc891 100644 --- 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 @@ -60,11 +60,11 @@ class SysmanEngineFixture : public DeviceFixture, public ::testing::Test { ON_CALL(*pSysfsAccess, read(_, Matcher(_))) .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock::getVal)); - pEngineImp->init(); + pEngineImp->init(ZET_ENGINE_GROUP_COMPUTE_ALL); sysmanImp->pEngineHandleContext->handleList.push_back(pEngineImp); hSysman = sysmanImp->toHandle(); - hSysmanEngine = pEngineImp->toHandle(); + hSysmanEngine = pEngineImp->toZetHandle(); } void TearDown() override { //pOsEngine is static_cast of LinuxEngineImp class , hence in cleanup assign to nullptr @@ -116,5 +116,12 @@ TEST_F(SysmanEngineFixture, GivenValidEngineHandleWhenCallingZetSysmanGetActivit EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); } +TEST_F(SysmanEngineFixture, GivenEngineGroupEmptyWhenGettingEngineGroupAndIfRetrievedEngineGroupNotComputeThenErrorReturned) { + zet_engine_group_t engineGroup; + ON_CALL(*pSysfsAccess, read(_, Matcher(_))) + .WillByDefault(::testing::Invoke(pSysfsAccess, &Mock::getIncorrectVal)); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pEngineImp->pOsEngine->getEngineGroup(engineGroup)); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp new file mode 100644 index 0000000000..5ee472da38 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/engine/linux/test_zes_engine.cpp @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2020 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/tools/test/unit_tests/sources/sysman/mock_sysman_fixture.h" + +#include "mock_sysfs_engine.h" + +using ::testing::Matcher; +namespace L0 { +namespace ult { +constexpr uint32_t handleComponentCount = 1u; +class SysmanDeviceEngineFixture : public SysmanDeviceFixture { + + protected: + std::unique_ptr> pSysfsAccess; + SysfsAccess *pSysfsAccessOld = nullptr; + + void SetUp() override { + SysmanDeviceFixture::SetUp(); + pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess; + pSysfsAccess = std::make_unique>>(); + pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); + + ON_CALL(*pSysfsAccess.get(), read(_, Matcher(_))) + .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getVal)); + + pSysmanDeviceImp->pEngineHandleContext->init(); + } + + void TearDown() override { + SysmanDeviceFixture::TearDown(); + pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld; + } + + std::vector get_engine_handles(uint32_t count) { + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + return handles; + } +}; + +TEST_F(SysmanDeviceEngineFixture, GivenSysmanEnvironmentVariableSetToZeroWhenCreatingEngineHandlesThenHandlesNotCreated) { + setenv("ZES_ENABLE_SYSMAN", "0", 1); + auto pEngineHandleContextTest = std::make_unique(pOsSysman); + pEngineHandleContextTest->init(); + uint32_t count = 0; + std::vector handles(count, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, pEngineHandleContextTest->engineGet(&count, handles.data())); + EXPECT_EQ(count, 0u); +} + +TEST_F(SysmanDeviceEngineFixture, GivenSysmanEnvironmentVariableNotSetWhenCreatingEngineEngineThenZetHandlesCreated) { + unsetenv("ZES_ENABLE_SYSMAN"); + auto pEngineHandleContextTestWithoutEnvSet = std::make_unique(pOsSysman); + pEngineHandleContextTestWithoutEnvSet->init(); + EXPECT_EQ(handleComponentCount, static_cast(pEngineHandleContextTestWithoutEnvSet->handleList.size())); +} + +TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) { + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL)); + EXPECT_EQ(count, handleComponentCount); + + uint32_t testcount = count + 1; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &testcount, NULL)); + EXPECT_EQ(testcount, count); + + count = 0; + std::vector handles(count, nullptr); + EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); + EXPECT_EQ(count, handleComponentCount); +} + +TEST_F(SysmanDeviceEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) { + zes_engine_properties_t properties; + auto handle = get_engine_handles(handleComponentCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesEngineGetProperties(handle[0], &properties)); + EXPECT_EQ(ZES_ENGINE_GROUP_COMPUTE_ALL, properties.type); + EXPECT_FALSE(properties.onSubdevice); +} +TEST_F(SysmanDeviceEngineFixture, GivenValidEngineHandleWhenCallingZesEngineGetActivityThenVerifyCallReturnsUnsupportedErrorStatus) { + zes_engine_stats_t Stats; + auto handle = get_engine_handles(handleComponentCount); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesEngineGetActivity(handle[0], &Stats)); +} + +TEST_F(SysmanDeviceEngineFixture, GivenEngineGroupEmptyWhenGettingEngineGroupAndIfRetrievedEngineGroupNotComputeThenErrorReturned) { + auto pZesEngineImpTest = std::make_unique(pOsSysman, ZES_ENGINE_GROUP_COMPUTE_ALL); + zes_engine_group_t engineGroup; + ON_CALL(*pSysfsAccess.get(), read(_, Matcher(_))) + .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getIncorrectVal)); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pZesEngineImpTest->pOsEngine->getEngineGroup(engineGroup)); +} + +TEST_F(SysmanDeviceEngineFixture, GivenEmptyTimeStampWhenGettingTimeStampThenSuccessIsReturned) { + auto pZesEngineImpTest = std::make_unique(pOsSysman, ZES_ENGINE_GROUP_COMPUTE_ALL); + uint64_t timeStamp = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, pZesEngineImpTest->pOsEngine->getTimeStamp(timeStamp)); +} + +TEST_F(SysmanDeviceEngineFixture, GivenEngineGroupEmptyWhenGettingEngineGroupAndIfAPIFailsThenErrorReturned) { + auto pZesEngineImpTest = std::make_unique(pOsSysman, ZES_ENGINE_GROUP_COMPUTE_ALL); + zes_engine_group_t engineGroup; + ON_CALL(*pSysfsAccess.get(), read(_, Matcher(_))) + .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValReturnError)); + EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pZesEngineImpTest->pOsEngine->getEngineGroup(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 deleted file mode 100644 index 0ee08a01f6..0000000000 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/CMakeLists.txt +++ /dev/null @@ -1,14 +0,0 @@ -# -# 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/windows/mock_engine.h b/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h deleted file mode 100644 index 4124feb7e8..0000000000 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/mock_engine.h +++ /dev/null @@ -1,36 +0,0 @@ -/* - * Copyright (C) 2020 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once -#include "level_zero/core/test/unit_tests/mock.h" - -#include "sysman/engine/engine_imp.h" -#include "sysman/engine/os_engine.h" - -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Winconsistent-missing-override" -#endif - -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)); -}; - -} // namespace ult -} // namespace L0 - -#if defined(__clang__) -#pragma clang diagnostic pop -#endif diff --git a/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp b/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp deleted file mode 100644 index bffc06720d..0000000000 --- a/level_zero/tools/test/unit_tests/sources/sysman/engine/windows/test_sysman_engine.cpp +++ /dev/null @@ -1,115 +0,0 @@ -/* - * 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/sysman_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; -} -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_MEDIA_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_MEDIA_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); -} -} // namespace ult -} // namespace L0