DrmMM fixtures refactor

Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>

opencl/test/unit_test/os_interface/linux/cl_drm_memory_manager_tests.cpp

@@ -23,8 +23,10 @@
 #include "shared/test/common/helpers/unit_test_helper.h"
 #include "shared/test/common/libult/linux/drm_mock.h"
 #include "shared/test/common/mocks/linux/mock_drm_allocation.h"
+#include "shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h"
+#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
 #include "shared/test/common/mocks/mock_gmm.h"
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/test_macros/test.h"
 #include "shared/test/unit_test/helpers/gtest_helpers.h"
 

opencl/test/unit_test/os_interface/linux/drm_va_sharing_tests.cpp

@@ -1,11 +1,12 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
+#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include "opencl/source/mem_obj/image.h"

shared/test/common/libult/CMakeLists.txt

@@ -181,6 +181,7 @@ set(neo_libult_SRCS_LINUX
     ${NEO_SHARED_TEST_DIRECTORY}/common/mocks/linux/mock_drm_memory_manager.h
     ${NEO_SHARED_TEST_DIRECTORY}/common/mocks/mock_direct_submission_controller_enabled.cpp
     ${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/create_drm_memory_manager.cpp
+    ${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/drm_memory_manager_fixture.cpp
     ${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/drm_neo_create.cpp
     ${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/options.cpp
     ${NEO_SHARED_TEST_DIRECTORY}/common/os_interface/linux/sys_calls_linux_ult.cpp

shared/test/common/os_interface/linux/CMakeLists.txt

@@ -8,7 +8,7 @@ if(UNIX)
   target_sources(${TARGET_NAME} PRIVATE
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
                  ${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream_fixture.h
-                 ${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_tests.h
+                 ${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager_fixture.h
                  ${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_cache_info.h
                  ${CMAKE_CURRENT_SOURCE_DIR}/drm_mock_device_blob.h
   )

shared/test/common/os_interface/linux/drm_memory_manager_fixture.cpp

@@ -0,0 +1,158 @@
+/*
+ * Copyright (C) 2019-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
+
+#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
+#include "shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h"
+#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
+#include "shared/test/common/mocks/mock_builtins.h"
+#include "shared/test/common/mocks/mock_device.h"
+
+#include "hw_cmds.h"
+
+namespace NEO {
+
+extern std::vector<void *> mmapVector;
+
+void DrmMemoryManagerBasic::SetUp() {
+    for (auto i = 0u; i < numRootDevices; i++) {
+        executionEnvironment.rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
+        executionEnvironment.rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
+        auto drm = Drm::create(nullptr, *executionEnvironment.rootDeviceEnvironments[i]);
+        executionEnvironment.rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
+        executionEnvironment.rootDeviceEnvironments[i]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*drm, i);
+        executionEnvironment.rootDeviceEnvironments[i]->initGmm();
+    }
+}
+
+void DrmMemoryManagerFixture::SetUp() {
+    MemoryManagementFixture::SetUp();
+
+    executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), numRootDevices - 1);
+    SetUp(new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]), false);
+} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+
+void DrmMemoryManagerFixture::SetUp(DrmMockCustom *mock, bool localMemoryEnabled) {
+    ASSERT_NE(nullptr, executionEnvironment);
+    executionEnvironment->incRefInternal();
+    DebugManager.flags.DeferOsContextInitialization.set(0);
+
+    environmentWrapper.setCsrType<TestedDrmCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME>>();
+    allocationData.rootDeviceIndex = rootDeviceIndex;
+    this->mock = mock;
+    for (auto i = 0u; i < numRootDevices; i++) {
+        auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[i].get();
+        rootDeviceEnvironment->setHwInfo(defaultHwInfo.get());
+        rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
+        rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(new DrmMockCustom(*rootDeviceEnvironment)));
+        rootDeviceEnvironment->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*rootDeviceEnvironment->osInterface->getDriverModel()->as<Drm>(), i);
+        rootDeviceEnvironment->builtins.reset(new MockBuiltins);
+        rootDeviceEnvironment->initGmm();
+    }
+
+    rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
+
+    memoryManager = new (std::nothrow) TestedDrmMemoryManager(localMemoryEnabled, false, false, *executionEnvironment);
+    executionEnvironment->memoryManager.reset(memoryManager);
+    //assert we have memory manager
+    ASSERT_NE(nullptr, memoryManager);
+    if (memoryManager->getgemCloseWorker()) {
+        memoryManager->getgemCloseWorker()->close(true);
+    }
+    device = MockDevice::create<MockDevice>(executionEnvironment, rootDeviceIndex);
+    mock->reset();
+}
+
+void DrmMemoryManagerFixture::TearDown() {
+    mock->testIoctls();
+    mock->reset();
+
+    int enginesCount = static_cast<int>(device->getMemoryManager()->getRegisteredEnginesCount());
+
+    mock->ioctl_expected.contextDestroy = enginesCount;
+    mock->ioctl_expected.gemClose = enginesCount;
+    mock->ioctl_expected.gemWait = enginesCount;
+
+    auto csr = static_cast<TestedDrmCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> *>(device->getDefaultEngine().commandStreamReceiver);
+    if (csr->globalFenceAllocation) {
+        mock->ioctl_expected.gemClose += enginesCount;
+        mock->ioctl_expected.gemWait += enginesCount;
+    }
+    if (csr->getPreemptionAllocation()) {
+        mock->ioctl_expected.gemClose += enginesCount;
+        mock->ioctl_expected.gemWait += enginesCount;
+    }
+    mock->ioctl_expected.gemWait += additionalDestroyDeviceIoctls.gemWait.load();
+    mock->ioctl_expected.gemClose += additionalDestroyDeviceIoctls.gemClose.load();
+    delete device;
+    if (dontTestIoctlInTearDown) {
+        mock->reset();
+    }
+    mock->testIoctls();
+    executionEnvironment->decRefInternal();
+    MemoryManagementFixture::TearDown();
+    mmapVector.clear();
+}
+
+void DrmMemoryManagerWithLocalMemoryFixture::SetUp() {
+    backup = std::make_unique<VariableBackup<UltHwConfig>>(&ultHwConfig);
+    ultHwConfig.csrBaseCallCreatePreemption = false;
+
+    MemoryManagementFixture::SetUp();
+    executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), numRootDevices - 1);
+    DrmMemoryManagerFixture::SetUp(new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]), true);
+} // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
+void DrmMemoryManagerWithLocalMemoryFixture::TearDown() {
+    DrmMemoryManagerFixture::TearDown();
+}
+
+void DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::SetUp() {
+    SetUp(false);
+}
+void DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::SetUp(bool enableLocalMem) {
+    DebugManager.flags.DeferOsContextInitialization.set(0);
+
+    executionEnvironment = new ExecutionEnvironment;
+    executionEnvironment->prepareRootDeviceEnvironments(numRootDevices);
+    uint32_t i = 0;
+    for (auto &rootDeviceEnvironment : executionEnvironment->rootDeviceEnvironments) {
+        rootDeviceEnvironment->setHwInfo(defaultHwInfo.get());
+        rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
+        rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(new DrmMockCustom(*rootDeviceEnvironment)));
+        rootDeviceEnvironment->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*rootDeviceEnvironment->osInterface->getDriverModel()->as<Drm>(), i);
+        rootDeviceEnvironment->initGmm();
+        i++;
+    }
+    mock = static_cast<DrmMockCustom *>(executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Drm>());
+    std::vector<MemoryRegion> regionInfo(2);
+    regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
+    regionInfo[0].probedSize = 8 * GB;
+    regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
+    regionInfo[1].probedSize = 16 * GB;
+    mock->memoryInfo.reset(new MockedMemoryInfo(regionInfo));
+    executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0u);
+    memoryManager.reset(new TestedDrmMemoryManager(enableLocalMem, false, false, *executionEnvironment));
+
+    ASSERT_NE(nullptr, memoryManager);
+    if (memoryManager->getgemCloseWorker()) {
+        memoryManager->getgemCloseWorker()->close(true);
+    }
+    device.reset(MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, rootDeviceIndex));
+}
+void DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::TearDown() {
+}
+
+void DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation::SetUp() {
+    DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::SetUp(true);
+}
+void DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation::TearDown() {
+    DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::TearDown();
+}
+
+} // namespace NEO

shared/test/common/os_interface/linux/drm_memory_manager_fixture.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2019-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/test/common/fixtures/memory_management_fixture.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/mocks/mock_execution_environment.h"
+#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
+
+#include <memory>
+
+namespace NEO {
+class MockDevice;
+class TestedDrmMemoryManager;
+struct UltHwConfig;
+
+extern std::vector<void *> mmapVector;
+
+class DrmMemoryManagerBasic : public ::testing::Test {
+  public:
+    DrmMemoryManagerBasic() : executionEnvironment(defaultHwInfo.get(), false, numRootDevices){};
+    void SetUp() override;
+
+    const uint32_t rootDeviceIndex = 1u;
+    const uint32_t numRootDevices = 2u;
+    MockExecutionEnvironment executionEnvironment;
+};
+
+class DrmMemoryManagerFixture : public MemoryManagementFixture {
+  public:
+    DrmMockCustom *mock = nullptr;
+    bool dontTestIoctlInTearDown = false;
+    const uint32_t rootDeviceIndex = 1u;
+    const uint32_t numRootDevices = 2u;
+    TestedDrmMemoryManager *memoryManager = nullptr;
+    MockDevice *device = nullptr;
+
+    void SetUp() override;
+    void SetUp(DrmMockCustom *mock, bool localMemoryEnabled);
+    void TearDown() override;
+
+  protected:
+    ExecutionEnvironment *executionEnvironment = nullptr;
+    RootDeviceEnvironment *rootDeviceEnvironment = nullptr;
+    DrmMockCustom::IoctlResExt ioctlResExt = {0, 0};
+    AllocationData allocationData{};
+    Ioctls additionalDestroyDeviceIoctls{};
+    EnvironmentWithCsrWrapper environmentWrapper;
+    DebugManagerStateRestore restore;
+};
+
+class DrmMemoryManagerWithLocalMemoryFixture : public DrmMemoryManagerFixture {
+  public:
+    void SetUp() override;
+    void TearDown() override;
+    std::unique_ptr<VariableBackup<UltHwConfig>> backup;
+};
+
+struct MockedMemoryInfo : public NEO::MemoryInfo {
+    MockedMemoryInfo(const std::vector<MemoryRegion> &regionInfo) : MemoryInfo(regionInfo) {}
+    ~MockedMemoryInfo() override{};
+
+    size_t getMemoryRegionSize(uint32_t memoryBank) override {
+        return 1024u;
+    }
+    uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override {
+        if (allocSize == 0) {
+            return EINVAL;
+        }
+        handle = 1u;
+        return 0u;
+    }
+    uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
+        if (allocSize == 0) {
+            return EINVAL;
+        }
+        handle = 1u;
+        return 0u;
+    }
+};
+
+class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
+  public:
+    std::unique_ptr<TestedDrmMemoryManager> memoryManager;
+    DrmMockCustom *mock;
+
+    void SetUp();                    // NOLINT(readability-identifier-naming)
+    void SetUp(bool enableLocalMem); // NOLINT(readability-identifier-naming)
+    void TearDown();                 // NOLINT(readability-identifier-naming)
+
+  protected:
+    ExecutionEnvironment *executionEnvironment = nullptr;
+    std::unique_ptr<MockDevice> device;
+    DrmMockCustom::IoctlResExt ioctlResExt = {0, 0};
+    DebugManagerStateRestore restore;
+    const uint32_t rootDeviceIndex = 1u;
+    const uint32_t numRootDevices = 2u;
+};
+
+class DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation : public DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
+  public:
+    void SetUp();
+    void TearDown();
+};
+} // namespace NEO

shared/test/common/os_interface/linux/drm_memory_manager_prelim_fixtures.h

@@ -15,7 +15,7 @@
 #include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/os_interface/linux/device_command_stream_fixture_prelim.h"
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/os_interface/linux/drm_mock_memory_info.h"
 
 #include "gtest/gtest.h"

shared/test/common/os_interface/linux/drm_memory_manager_tests.h

@@ -1,238 +0,0 @@
-/*
- * Copyright (C) 2019-2022 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
-#include "shared/source/os_interface/linux/memory_info.h"
-#include "shared/source/os_interface/os_interface.h"
-#include "shared/test/common/fixtures/memory_management_fixture.h"
-#include "shared/test/common/helpers/debug_manager_state_restore.h"
-#include "shared/test/common/helpers/ult_hw_config.h"
-#include "shared/test/common/helpers/variable_backup.h"
-#include "shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h"
-#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
-#include "shared/test/common/mocks/mock_builtins.h"
-#include "shared/test/common/mocks/mock_device.h"
-#include "shared/test/common/mocks/mock_execution_environment.h"
-#include "shared/test/common/os_interface/linux/device_command_stream_fixture.h"
-
-#include "hw_cmds.h"
-
-#include <memory>
-
-namespace NEO {
-
-extern std::vector<void *> mmapVector;
-
-class DrmMemoryManagerBasic : public ::testing::Test {
-  public:
-    DrmMemoryManagerBasic() : executionEnvironment(defaultHwInfo.get(), false, numRootDevices){};
-    void SetUp() override {
-        for (auto i = 0u; i < numRootDevices; i++) {
-            executionEnvironment.rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
-            executionEnvironment.rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();
-            auto drm = Drm::create(nullptr, *executionEnvironment.rootDeviceEnvironments[i]);
-            executionEnvironment.rootDeviceEnvironments[i]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
-            executionEnvironment.rootDeviceEnvironments[i]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*drm, i);
-            executionEnvironment.rootDeviceEnvironments[i]->initGmm();
-        }
-    }
-    const uint32_t rootDeviceIndex = 1u;
-    const uint32_t numRootDevices = 2u;
-    MockExecutionEnvironment executionEnvironment;
-};
-
-class DrmMemoryManagerFixture : public MemoryManagementFixture {
-  public:
-    DrmMockCustom *mock = nullptr;
-    bool dontTestIoctlInTearDown = false;
-    const uint32_t rootDeviceIndex = 1u;
-    const uint32_t numRootDevices = 2u;
-    TestedDrmMemoryManager *memoryManager = nullptr;
-    MockDevice *device = nullptr;
-
-    void SetUp() override {
-        MemoryManagementFixture::SetUp();
-
-        executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), numRootDevices - 1);
-        SetUp(new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]), false);
-    } // NOLINT(clang-analyzer-cplusplus.NewDeleteLeaks)
-
-    void SetUp(DrmMockCustom *mock, bool localMemoryEnabled) {
-        ASSERT_NE(nullptr, executionEnvironment);
-        executionEnvironment->incRefInternal();
-        DebugManager.flags.DeferOsContextInitialization.set(0);
-
-        environmentWrapper.setCsrType<TestedDrmCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME>>();
-        allocationData.rootDeviceIndex = rootDeviceIndex;
-        this->mock = mock;
-        for (auto i = 0u; i < numRootDevices; i++) {
-            auto rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[i].get();
-            rootDeviceEnvironment->setHwInfo(defaultHwInfo.get());
-            rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
-            rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(new DrmMockCustom(*rootDeviceEnvironment)));
-            rootDeviceEnvironment->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*rootDeviceEnvironment->osInterface->getDriverModel()->as<Drm>(), i);
-            rootDeviceEnvironment->builtins.reset(new MockBuiltins);
-            rootDeviceEnvironment->initGmm();
-        }
-
-        rootDeviceEnvironment = executionEnvironment->rootDeviceEnvironments[rootDeviceIndex].get();
-        rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(mock));
-
-        memoryManager = new (std::nothrow) TestedDrmMemoryManager(localMemoryEnabled, false, false, *executionEnvironment);
-        executionEnvironment->memoryManager.reset(memoryManager);
-        //assert we have memory manager
-        ASSERT_NE(nullptr, memoryManager);
-        if (memoryManager->getgemCloseWorker()) {
-            memoryManager->getgemCloseWorker()->close(true);
-        }
-        device = MockDevice::create<MockDevice>(executionEnvironment, rootDeviceIndex);
-        mock->reset();
-    }
-
-    void TearDown() override {
-        mock->testIoctls();
-        mock->reset();
-
-        int enginesCount = static_cast<int>(device->getMemoryManager()->getRegisteredEnginesCount());
-
-        mock->ioctl_expected.contextDestroy = enginesCount;
-        mock->ioctl_expected.gemClose = enginesCount;
-        mock->ioctl_expected.gemWait = enginesCount;
-
-        auto csr = static_cast<TestedDrmCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME> *>(device->getDefaultEngine().commandStreamReceiver);
-        if (csr->globalFenceAllocation) {
-            mock->ioctl_expected.gemClose += enginesCount;
-            mock->ioctl_expected.gemWait += enginesCount;
-        }
-        if (csr->getPreemptionAllocation()) {
-            mock->ioctl_expected.gemClose += enginesCount;
-            mock->ioctl_expected.gemWait += enginesCount;
-        }
-        mock->ioctl_expected.gemWait += additionalDestroyDeviceIoctls.gemWait.load();
-        mock->ioctl_expected.gemClose += additionalDestroyDeviceIoctls.gemClose.load();
-        delete device;
-        if (dontTestIoctlInTearDown) {
-            mock->reset();
-        }
-        mock->testIoctls();
-        executionEnvironment->decRefInternal();
-        MemoryManagementFixture::TearDown();
-        mmapVector.clear();
-    }
-
-  protected:
-    ExecutionEnvironment *executionEnvironment = nullptr;
-    RootDeviceEnvironment *rootDeviceEnvironment = nullptr;
-    DrmMockCustom::IoctlResExt ioctlResExt = {0, 0};
-    AllocationData allocationData{};
-    Ioctls additionalDestroyDeviceIoctls{};
-    EnvironmentWithCsrWrapper environmentWrapper;
-    DebugManagerStateRestore restore;
-};
-
-class DrmMemoryManagerWithLocalMemoryFixture : public DrmMemoryManagerFixture {
-  public:
-    void SetUp() override {
-        backup = std::make_unique<VariableBackup<UltHwConfig>>(&ultHwConfig);
-        ultHwConfig.csrBaseCallCreatePreemption = false;
-
-        MemoryManagementFixture::SetUp();
-        executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), numRootDevices - 1);
-        DrmMemoryManagerFixture::SetUp(new DrmMockCustom(*executionEnvironment->rootDeviceEnvironments[0]), true);
-    }
-    void TearDown() override {
-        DrmMemoryManagerFixture::TearDown();
-    }
-    std::unique_ptr<VariableBackup<UltHwConfig>> backup;
-};
-
-struct MockedMemoryInfo : public NEO::MemoryInfo {
-    MockedMemoryInfo(const std::vector<MemoryRegion> &regionInfo) : MemoryInfo(regionInfo) {}
-    ~MockedMemoryInfo() override{};
-
-    size_t getMemoryRegionSize(uint32_t memoryBank) override {
-        return 1024u;
-    }
-    uint32_t createGemExt(Drm *drm, const MemRegionsVec &memClassInstances, size_t allocSize, uint32_t &handle, std::optional<uint32_t> vmId) override {
-        if (allocSize == 0) {
-            return EINVAL;
-        }
-        handle = 1u;
-        return 0u;
-    }
-    uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
-        if (allocSize == 0) {
-            return EINVAL;
-        }
-        handle = 1u;
-        return 0u;
-    }
-};
-
-class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
-  public:
-    std::unique_ptr<TestedDrmMemoryManager> memoryManager;
-    DrmMockCustom *mock;
-
-    void SetUp() { // NOLINT(readability-identifier-naming)
-        SetUp(false);
-    }
-
-    void SetUp(bool enableLocalMem) { // NOLINT(readability-identifier-naming)
-        DebugManager.flags.DeferOsContextInitialization.set(0);
-
-        executionEnvironment = new ExecutionEnvironment;
-        executionEnvironment->prepareRootDeviceEnvironments(numRootDevices);
-        uint32_t i = 0;
-        for (auto &rootDeviceEnvironment : executionEnvironment->rootDeviceEnvironments) {
-            rootDeviceEnvironment->setHwInfo(defaultHwInfo.get());
-            rootDeviceEnvironment->osInterface = std::make_unique<OSInterface>();
-            rootDeviceEnvironment->osInterface->setDriverModel(std::unique_ptr<DriverModel>(new DrmMockCustom(*rootDeviceEnvironment)));
-            rootDeviceEnvironment->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*rootDeviceEnvironment->osInterface->getDriverModel()->as<Drm>(), i);
-            rootDeviceEnvironment->initGmm();
-            i++;
-        }
-        mock = static_cast<DrmMockCustom *>(executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Drm>());
-        std::vector<MemoryRegion> regionInfo(2);
-        regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
-        regionInfo[0].probedSize = 8 * GB;
-        regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
-        regionInfo[1].probedSize = 16 * GB;
-        mock->memoryInfo.reset(new MockedMemoryInfo(regionInfo));
-        executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0u);
-        memoryManager.reset(new TestedDrmMemoryManager(enableLocalMem, false, false, *executionEnvironment));
-
-        ASSERT_NE(nullptr, memoryManager);
-        if (memoryManager->getgemCloseWorker()) {
-            memoryManager->getgemCloseWorker()->close(true);
-        }
-        device.reset(MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, rootDeviceIndex));
-    }
-
-    void TearDown() { // NOLINT(readability-identifier-naming)
-    }
-
-  protected:
-    ExecutionEnvironment *executionEnvironment = nullptr;
-    std::unique_ptr<MockDevice> device;
-    DrmMockCustom::IoctlResExt ioctlResExt = {0, 0};
-    DebugManagerStateRestore restore;
-    const uint32_t rootDeviceIndex = 1u;
-    const uint32_t numRootDevices = 2u;
-};
-
-class DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation : public DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
-  public:
-    void SetUp() {
-        DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::SetUp(true);
-    }
-    void TearDown() {
-        DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::TearDown();
-    }
-};
-} // namespace NEO

shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp

@@ -19,7 +19,7 @@
 #include "shared/test/common/libult/ult_command_stream_receiver.h"
 #include "shared/test/common/mocks/linux/mock_drm_allocation.h"
 #include "shared/test/common/mocks/mock_device.h"
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include <memory>

shared/test/unit_test/os_interface/linux/drm_memory_manager_localmem_upstream_tests.cpp

@@ -18,7 +18,7 @@
 #include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
 #include "shared/test/common/mocks/mock_execution_environment.h"
 #include "shared/test/common/mocks/mock_gmm.h"
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/os_interface/linux/drm_mock_memory_info.h"
 #include "shared/test/common/test_macros/test.h"
 #include "shared/test/unit_test/os_interface/linux/drm_mock_impl.h"

shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp

@@ -5,17 +5,20 @@
  *
  */
 
-#include "shared/test/common/os_interface/linux/drm_memory_manager_tests.h"
-
+#include "shared/source/built_ins/sip.h"
 #include "shared/source/helpers/surface_format_info.h"
+#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
 #include "shared/source/os_interface/linux/os_context_linux.h"
 #include "shared/test/common/fixtures/memory_allocator_multi_device_fixture.h"
 #include "shared/test/common/helpers/engine_descriptor_helper.h"
 #include "shared/test/common/libult/linux/drm_mock.h"
 #include "shared/test/common/mocks/linux/mock_drm_allocation.h"
+#include "shared/test/common/mocks/linux/mock_drm_command_stream_receiver.h"
+#include "shared/test/common/mocks/linux/mock_drm_memory_manager.h"
 #include "shared/test/common/mocks/mock_allocation_properties.h"
 #include "shared/test/common/mocks/mock_gfx_partition.h"
 #include "shared/test/common/mocks/mock_gmm.h"
+#include "shared/test/common/os_interface/linux/drm_memory_manager_fixture.h"
 #include "shared/test/common/os_interface/linux/drm_mock_cache_info.h"
 #include "shared/test/common/test_macros/test.h"
 #include "shared/test/unit_test/helpers/gtest_helpers.h"