feature: Support for Engine APIs with zesinit

Related-To: LOCI-4199

Signed-off-by: Kumar, Shubham <shubham.kumar@intel.com>

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

@@ -7,16 +7,104 @@
 
 #include "level_zero/sysman/source/engine/windows/os_engine_imp.h"
 
+#include "level_zero/sysman/source/windows/kmd_sys.h"
+#include "level_zero/sysman/source/windows/kmd_sys_manager.h"
+
 namespace L0 {
 namespace Sysman {
 
+ze_result_t WddmEngineImp::getActivity(zes_engine_stats_t *pStats) {
+    uint64_t activeTime = 0;
+    uint64_t timeStamp = 0;
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::ActivityComponent;
+
+    switch (this->engineGroup) {
+    case ZES_ENGINE_GROUP_ALL:
+        request.paramInfo = KmdSysman::ActivityDomainsType::ActitvityDomainGT;
+        break;
+    case ZES_ENGINE_GROUP_COMPUTE_ALL:
+        request.paramInfo = KmdSysman::ActivityDomainsType::ActivityDomainRenderCompute;
+        break;
+    case ZES_ENGINE_GROUP_MEDIA_ALL:
+        request.paramInfo = KmdSysman::ActivityDomainsType::ActivityDomainMedia;
+        break;
+    default:
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        break;
+    }
+
+    request.requestId = KmdSysman::Requests::Activity::CurrentActivityCounter;
+
+    ze_result_t status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    }
+
+    memcpy_s(&activeTime, sizeof(uint64_t), response.dataBuffer, sizeof(uint64_t));
+    memcpy_s(&timeStamp, sizeof(uint64_t), (response.dataBuffer + sizeof(uint64_t)), sizeof(uint64_t));
+
+    pStats->activeTime = activeTime;
+    pStats->timestamp = timeStamp;
+
+    return status;
+}
+
+ze_result_t WddmEngineImp::getProperties(zes_engine_properties_t &properties) {
+    properties.type = engineGroup;
+    properties.onSubdevice = false;
+    properties.subdeviceId = 0;
+    return ZE_RESULT_SUCCESS;
+}
+
+bool WddmEngineImp::isEngineModuleSupported() {
+    return true;
+}
+
+WddmEngineImp::WddmEngineImp(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t subDeviceId) {
+    WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
+    this->engineGroup = engineType;
+    pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
+}
+
 std::unique_ptr<OsEngine> OsEngine::create(OsSysman *pOsSysman, zes_engine_group_t engineType, uint32_t engineInstance, uint32_t subDeviceId, ze_bool_t onSubDevice) {
     std::unique_ptr<WddmEngineImp> pWddmEngineImp = std::make_unique<WddmEngineImp>(pOsSysman, engineType, engineInstance, subDeviceId);
     return pWddmEngineImp;
 }
 
 ze_result_t OsEngine::getNumEngineTypeAndInstances(std::set<std::pair<zes_engine_group_t, EngineInstanceSubDeviceId>> &engineGroupInstance, OsSysman *pOsSysman) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
+    KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
+
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::ActivityComponent;
+    request.requestId = KmdSysman::Requests::Activity::NumActivityDomains;
+
+    ze_result_t status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    }
+
+    uint32_t maxNumEnginesSupported = 0;
+    memcpy_s(&maxNumEnginesSupported, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+
+    if (maxNumEnginesSupported == 0) {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    for (uint32_t i = 0; i < maxNumEnginesSupported; i++) {
+        engineGroupInstance.insert({static_cast<zes_engine_group_t>(i), {0, 0}});
+    }
+
+    return status;
 }
 
 } // namespace Sysman

level_zero/sysman/source/engine/windows/os_engine_imp.h

@@ -13,15 +13,20 @@
 
 namespace L0 {
 namespace Sysman {
+class KmdSysManager;
 class WddmEngineImp : public OsEngine, NEO::NonCopyableOrMovableClass {
   public:
-    ze_result_t getActivity(zes_engine_stats_t *pStats) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; }
-    ze_result_t getProperties(zes_engine_properties_t &properties) override { return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; };
-    bool isEngineModuleSupported() override { return false; };
+    ze_result_t getActivity(zes_engine_stats_t *pStats) override;
+    ze_result_t getProperties(zes_engine_properties_t &properties) override;
+    bool isEngineModuleSupported() override;
 
     WddmEngineImp() = default;
-    WddmEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t subDeviceId) {}
+    WddmEngineImp(OsSysman *pOsSysman, zes_engine_group_t type, uint32_t engineInstance, uint32_t subDeviceId);
     ~WddmEngineImp() override = default;
+
+  protected:
+    KmdSysManager *pKmdSysManager = nullptr;
+    zes_engine_group_t engineGroup = ZES_ENGINE_GROUP_ALL;
 };
 } // namespace Sysman
 } // namespace L0

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

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

level_zero/sysman/test/unit_tests/sources/engine/windows/mock_engine.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"
+
+namespace L0 {
+namespace ult {
+
+struct MockEngineKmdSysManager : public MockKmdSysManager {
+
+    KmdSysman::ActivityDomainsType mockEngineTypes[3] = {KmdSysman::ActivityDomainsType::ActitvityDomainGT, KmdSysman::ActivityDomainsType::ActivityDomainRenderCompute, KmdSysman::ActivityDomainsType::ActivityDomainMedia};
+    uint64_t mockActivityCounters[3] = {652411, 222115, 451115};
+    uint64_t mockActivityTimeStamps[3] = {4465421, 2566851, 1226621};
+    uint32_t mockNumSupportedEngineGroups = 3;
+    uint32_t mockFrequencyTimeStamp = 38400000;
+    uint32_t mockFrequencyActivity = 1200000;
+
+    void getActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pResponse);
+        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderOut);
+
+        KmdSysman::ActivityDomainsType domain = static_cast<KmdSysman::ActivityDomainsType>(pRequest->inCommandParam);
+
+        if (domain < KmdSysman::ActivityDomainsType::ActitvityDomainGT || domain >= KmdSysman::ActivityDomainsType::ActivityDomainMaxTypes) {
+            pResponse->outDataSize = 0;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+            return;
+        }
+
+        switch (pRequest->inRequestId) {
+        case KmdSysman::Requests::Activity::NumActivityDomains: {
+            uint32_t *pValueCounter = reinterpret_cast<uint32_t *>(pBuffer);
+            *pValueCounter = mockNumSupportedEngineGroups;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = sizeof(uint32_t);
+        } break;
+        case KmdSysman::Requests::Activity::CurrentActivityCounter: {
+            uint64_t *pValueCounter = reinterpret_cast<uint64_t *>(pBuffer);
+            uint64_t *pValueTimeStamp = reinterpret_cast<uint64_t *>(pBuffer + sizeof(uint64_t));
+            *pValueCounter = mockActivityCounters[domain];
+            *pValueTimeStamp = mockActivityTimeStamps[domain];
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = 2 * sizeof(uint64_t);
+        } break;
+        case KmdSysman::Requests::Activity::TimestampFrequency: {
+            uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
+            *pValueFrequency = mockFrequencyTimeStamp;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = sizeof(uint32_t);
+        } break;
+        case KmdSysman::Requests::Activity::ActivityCounterFrequency: {
+            uint32_t *pValueFrequency = reinterpret_cast<uint32_t *>(pBuffer);
+            *pValueFrequency = mockFrequencyActivity;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+            pResponse->outDataSize = sizeof(uint32_t);
+        } break;
+        default: {
+            pResponse->outDataSize = 0;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+        } break;
+        }
+    }
+
+    void setActivityProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
+        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
+        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
+
+        pResponse->outDataSize = 0;
+        pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+    }
+};
+
+} // namespace ult
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/engine/windows/test_zes_engine.cpp

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/engine/windows/os_engine_imp.h"
+#include "level_zero/sysman/test/unit_tests/sources/engine/windows/mock_engine.h"
+#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h"
+
+namespace L0 {
+namespace ult {
+
+constexpr uint32_t engineHandleComponentCount = 3u;
+class SysmanDeviceEngineFixture : public SysmanDeviceFixture {
+  protected:
+    std::unique_ptr<MockEngineKmdSysManager> pKmdSysManager = nullptr;
+    L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+
+        pKmdSysManager.reset(new MockEngineKmdSysManager);
+
+        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
+        pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
+
+        pSysmanDeviceImp->pEngineHandleContext->handleList.clear();
+    }
+
+    void TearDown() override {
+        pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
+        SysmanDeviceFixture::TearDown();
+    }
+
+    std::vector<zes_engine_handle_t> get_engine_handles(uint32_t count) {
+        std::vector<zes_engine_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
+    uint32_t count = 0;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, engineHandleComponentCount);
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenInvalidComponentCountWhenEnumeratingEngineGroupsThenValidCountIsReturnedAndVerifySysmanPowerGetCallSucceeds) {
+    uint32_t count = 0;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, engineHandleComponentCount);
+
+    count = count + 1;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, engineHandleComponentCount);
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsThenValidPowerHandlesIsReturned) {
+    uint32_t count = 0;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, engineHandleComponentCount);
+
+    std::vector<zes_engine_handle_t> handles(count, nullptr);
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+    for (auto handle : handles) {
+        EXPECT_NE(handle, nullptr);
+    }
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsAndRequestSingleFailsThenZeroHandlesAreReturned) {
+    pKmdSysManager->mockRequestSingle = true;
+    pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    uint32_t count = 0;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, 0);
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsIfEngineSupportIsAbsentThenZeroHandlesAreReturned) {
+    pKmdSysManager->mockNumSupportedEngineGroups = 0;
+    uint32_t count = 0;
+    EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, 0);
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenUnsupportedEngineHandleWhenGettingEngineActivityThenFailureIsReturned) {
+    std::unique_ptr<L0::Sysman::WddmEngineImp> pEngineImp = std::make_unique<L0::Sysman::WddmEngineImp>(pOsSysman, ZES_ENGINE_GROUP_3D_ALL, 0, 0);
+    zes_engine_stats_t pStats = {};
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pEngineImp->getActivity(&pStats));
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetPropertiesThenCorrectEngineGroupIsReturned) {
+    auto handles = get_engine_handles(engineHandleComponentCount);
+    uint32_t engineGroupIndex = 0;
+    for (auto handle : handles) {
+        zes_engine_properties_t properties = {};
+
+        ze_result_t result = zesEngineGetProperties(handle, &properties);
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_FALSE(properties.onSubdevice);
+        EXPECT_EQ(properties.subdeviceId, 0);
+        EXPECT_EQ(properties.type, pKmdSysManager->mockEngineTypes[engineGroupIndex++]);
+    }
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenValidHandleGetAvtivityThenCorrectValuesAreReturned) {
+    auto handles = get_engine_handles(engineHandleComponentCount);
+    uint32_t engineGroupIndex = 0;
+    for (auto handle : handles) {
+        zes_engine_stats_t stats;
+
+        ze_result_t result = zesEngineGetActivity(handle, &stats);
+
+        EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+        EXPECT_EQ(stats.activeTime, pKmdSysManager->mockActivityCounters[engineGroupIndex]);
+        EXPECT_EQ(stats.timestamp, pKmdSysManager->mockActivityTimeStamps[engineGroupIndex]);
+        engineGroupIndex++;
+    }
+}
+
+TEST_F(SysmanDeviceEngineFixture, GivenValidHandleWhenGettingEngineActivityAndRequestSingleFailsThenFailureIsReturned) {
+    auto handles = get_engine_handles(engineHandleComponentCount);
+    for (auto handle : handles) {
+        pKmdSysManager->mockRequestSingle = true;
+        pKmdSysManager->mockRequestSingleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        zes_engine_stats_t stats;
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesEngineGetActivity(handle, &stats));
+    }
+}
+
+} // namespace ult
+} // namespace L0