Implementing Reset Device Level 0 Sysman Windows

Enabling Device Reset for Windows.

Signed-off-by: Daniel Enriquez daniel.enriquez.montanez@intel.com

level_zero/tools/source/sysman/global_operations/windows/CMakeLists.txt

@@ -1,11 +1,12 @@
 #
-# Copyright (C) 2020 Intel Corporation
+# Copyright (C) 2020-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
 
 set(L0_SRCS_TOOLS_GLOBAL_OPERATIONS_WINDOWS
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.h
     ${CMAKE_CURRENT_SOURCE_DIR}/os_global_operations_imp.cpp
 )
 

level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.cpp

@@ -1,39 +1,14 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
-#include "level_zero/tools/source/sysman/global_operations/os_global_operations.h"
-#include "level_zero/tools/source/sysman/windows/os_sysman_imp.h"
+#include "level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h"
 
 namespace L0 {
 
-class WddmGlobalOperationsImp : public OsGlobalOperations {
-  public:
-    void getSerialNumber(char (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) override;
-    void getBoardNumber(char (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) override;
-    void getBrandName(char (&brandName)[ZES_STRING_PROPERTY_SIZE]) override;
-    void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
-    void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
-    void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
-    Device *getDevice() override;
-    ze_result_t reset(ze_bool_t force) override;
-    ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
-    ze_result_t deviceGetState(zes_device_state_t *pState) override;
-
-    WddmGlobalOperationsImp(OsSysman *pOsSysman);
-    ~WddmGlobalOperationsImp() = default;
-
-    // Don't allow copies of the WddmGlobalOperationsImp object
-    WddmGlobalOperationsImp(const WddmGlobalOperationsImp &obj) = delete;
-    WddmGlobalOperationsImp &operator=(const WddmGlobalOperationsImp &obj) = delete;
-
-  private:
-    Device *pDevice = nullptr;
-};
-
 Device *WddmGlobalOperationsImp::getDevice() {
     return pDevice;
 }
@@ -57,7 +32,16 @@ void WddmGlobalOperationsImp::getDriverVersion(char (&driverVersion)[ZES_STRING_
 }
 
 ze_result_t WddmGlobalOperationsImp::reset(ze_bool_t force) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    uint32_t value = 0;
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+    request.commandId = KmdSysman::Command::Set;
+    request.componentId = KmdSysman::Component::GlobalOperationsComponent;
+    request.requestId = KmdSysman::Requests::GlobalOperation::TriggerDeviceLevelReset;
+    request.dataSize = sizeof(uint32_t);
+    value = static_cast<uint32_t>(force);
+    memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
+    return pKmdSysManager->requestSingle(request, response);
 }
 
 ze_result_t WddmGlobalOperationsImp::scanProcessesState(std::vector<zes_process_state_t> &pProcessList) {
@@ -71,6 +55,7 @@ ze_result_t WddmGlobalOperationsImp::deviceGetState(zes_device_state_t *pState)
 WddmGlobalOperationsImp::WddmGlobalOperationsImp(OsSysman *pOsSysman) {
     WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
     pDevice = pWddmSysmanImp->getDeviceHandle();
+    pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
 }
 
 OsGlobalOperations *OsGlobalOperations::create(OsSysman *pOsSysman) {

level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "sysman/global_operations/os_global_operations.h"
+#include "sysman/windows/os_sysman_imp.h"
+
+namespace L0 {
+
+class KmdSysManager;
+class WddmGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMovableClass {
+  public:
+    void getSerialNumber(char (&serialNumber)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getBoardNumber(char (&boardNumber)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getBrandName(char (&brandName)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getModelName(char (&modelName)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getVendorName(char (&vendorName)[ZES_STRING_PROPERTY_SIZE]) override;
+    void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) override;
+    Device *getDevice() override;
+    ze_result_t reset(ze_bool_t force) override;
+    ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
+    ze_result_t deviceGetState(zes_device_state_t *pState) override;
+
+    WddmGlobalOperationsImp(OsSysman *pOsSysman);
+    WddmGlobalOperationsImp(const WddmGlobalOperationsImp &obj) = delete;
+    WddmGlobalOperationsImp() = default;
+    WddmGlobalOperationsImp &operator=(const WddmGlobalOperationsImp &obj) = delete;
+    ~WddmGlobalOperationsImp() override = default;
+
+  private:
+    Device *pDevice = nullptr;
+
+  protected:
+    KmdSysManager *pKmdSysManager = nullptr;
+};
+
+} // namespace L0

level_zero/tools/source/sysman/windows/kmd_sys.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Intel Corporation
+ * Copyright (C) 2020-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -85,6 +85,7 @@ enum Component {
     SchedulerComponent,
     MemoryComponent,
     PciComponent,
+    GlobalOperationsComponent,
 
     MaxComponents,
 };
@@ -304,6 +305,13 @@ enum Pci {
 
     MaxPciRequests,
 };
+
+enum GlobalOperation {
+    NumGlobalOperationDomains = 0,
+
+    TriggerDeviceLevelReset
+};
+
 } // namespace Requests
 
 enum FlipType {

level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2020-2021 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_global_operations.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/mock_global_operations.h
+  )
+endif()

level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/mock_global_operations.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2020-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/core/test/unit_tests/mock.h"
+#include "level_zero/tools/source/sysman/global_operations/global_operations_imp.h"
+#include "level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h"
+
+namespace L0 {
+namespace ult {
+
+class GlobalOpsKmdSysManager : public Mock<MockKmdSysManager> {};
+
+template <>
+struct Mock<GlobalOpsKmdSysManager> : public GlobalOpsKmdSysManager {
+
+    void setGlobalOperationsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) override {
+        uint8_t *pBuffer = reinterpret_cast<uint8_t *>(pRequest);
+        pBuffer += sizeof(KmdSysman::GfxSysmanReqHeaderIn);
+
+        switch (pRequest->inRequestId) {
+        case KmdSysman::Requests::GlobalOperation::TriggerDeviceLevelReset: {
+            uint32_t *value = reinterpret_cast<uint32_t *>(pBuffer);
+            *value = 0;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanSuccess;
+        } break;
+        default: {
+            pResponse->outDataSize = 0;
+            pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+        } break;
+        }
+    }
+    Mock() = default;
+    ~Mock() = default;
+};
+
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/test_zes_global_operations.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2020-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/global_operations/windows/os_global_operations_imp.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/global_operations/windows/mock_global_operations.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h"
+
+namespace L0 {
+namespace ult {
+
+class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
+  protected:
+    OsGlobalOperations *pOsGlobalOperationsPrev = nullptr;
+    L0::GlobalOperations *pGlobalOperationsPrev = nullptr;
+    L0::GlobalOperationsImp *pGlobalOperationsImp;
+
+    Mock<GlobalOpsKmdSysManager> *pKmdSysManager = nullptr;
+    KmdSysManager *pOriginalKmdSysManager = nullptr;
+    void SetUp(bool allowSetCalls) { // NOLINT(readability-identifier-naming)
+        SysmanDeviceFixture::SetUp();
+
+        pKmdSysManager = new Mock<GlobalOpsKmdSysManager>;
+
+        pKmdSysManager->allowSetCalls = allowSetCalls;
+
+        EXPECT_CALL(*pKmdSysManager, escape(_, _, _, _, _))
+            .WillRepeatedly(::testing::Invoke(pKmdSysManager, &Mock<GlobalOpsKmdSysManager>::mock_escape));
+
+        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
+        pWddmSysmanImp->pKmdSysManager = pKmdSysManager;
+
+        pGlobalOperationsImp = static_cast<L0::GlobalOperationsImp *>(pSysmanDeviceImp->pGlobalOperations);
+        pOsGlobalOperationsPrev = pGlobalOperationsImp->pOsGlobalOperations;
+        pGlobalOperationsImp->pOsGlobalOperations = nullptr;
+        pGlobalOperationsImp->init();
+    }
+
+    void TearDown() override {
+        if (nullptr != pGlobalOperationsImp->pOsGlobalOperations) {
+            delete pGlobalOperationsImp->pOsGlobalOperations;
+        }
+        pGlobalOperationsImp->pOsGlobalOperations = pOsGlobalOperationsPrev;
+        pGlobalOperationsImp = nullptr;
+        SysmanDeviceFixture::TearDown();
+        pWddmSysmanImp->pKmdSysManager = pOriginalKmdSysManager;
+        if (pKmdSysManager != nullptr) {
+            delete pKmdSysManager;
+            pKmdSysManager = nullptr;
+        }
+    }
+};
+
+TEST_F(SysmanGlobalOperationsFixture, GivenForceTrueAndDeviceInUseWhenCallingResetThenSuccessIsReturned) {
+    SetUp(true);
+    pGlobalOperationsImp->init();
+    ze_result_t result = zesDeviceReset(device, true);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST_F(SysmanGlobalOperationsFixture, GivenProcessStartsMidResetWhenCallingResetThenSuccessIsReturned) {
+    SetUp(false);
+    pGlobalOperationsImp->init();
+    ze_result_t result = zesDeviceReset(device, true);
+    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
+}
+
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/windows/mock_kmd_sys_manager.h

@@ -159,6 +159,16 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
         pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
     }
 
+    MOCKABLE_VIRTUAL void getGlobalOperationsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+        pResponse->outDataSize = 0;
+        pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+    }
+
+    MOCKABLE_VIRTUAL void setGlobalOperationsProperty(KmdSysman::GfxSysmanReqHeaderIn *pRequest, KmdSysman::GfxSysmanReqHeaderOut *pResponse) {
+        pResponse->outDataSize = 0;
+        pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
+    }
+
     void retrieveCorrectVersion(KmdSysman::GfxSysmanMainHeaderOut *pHeaderOut) {
         pHeaderOut->outNumElements = 1;
         pHeaderOut->outTotalSize = 0;
@@ -317,6 +327,9 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
         case KmdSysman::Component::PciComponent: {
             setPciProperty(pRequest, pResponse);
         } break;
+        case KmdSysman::Component::GlobalOperationsComponent: {
+            setGlobalOperationsProperty(pRequest, pResponse);
+        } break;
         default: {
             pResponse->outDataSize = 0;
             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;
@@ -356,6 +369,9 @@ struct Mock<MockKmdSysManager> : public MockKmdSysManager {
         case KmdSysman::Component::PciComponent: {
             getPciProperty(pRequest, pResponse);
         } break;
+        case KmdSysman::Component::GlobalOperationsComponent: {
+            getGlobalOperationsProperty(pRequest, pResponse);
+        } break;
         default: {
             pResponse->outDataSize = 0;
             pResponse->outReturnCode = KmdSysman::KmdSysmanFail;