Fallback to cpu copy when filling work partition allocation

move some command stream receiver tests to shared

Related-To: NEO-6325
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

opencl/test/unit_test/command_stream/CMakeLists.txt

@@ -11,14 +11,14 @@ set(IGDRCL_SRCS_tests_command_stream
     ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_3_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/aub_file_stream_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/cl_command_stream_receiver_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/cmd_parse_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_1_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_2_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_fixture.h
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_hw_tests.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_mt_tests.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_flush_task_1_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_flush_task_2_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_flush_task_3_tests.cpp

opencl/test/unit_test/command_stream/cl_command_stream_receiver_tests.cpp

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2018-2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/memory_manager/surface.h"
+#include "shared/test/common/fixtures/device_fixture.h"
+#include "shared/test/common/mocks/mock_csr.h"
+
+#include "opencl/source/mem_obj/buffer.h"
+#include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
+#include "opencl/test/unit_test/helpers/raii_hw_helper.h"
+#include "opencl/test/unit_test/mocks/mock_context.h"
+#include "opencl/test/unit_test/mocks/mock_hw_helper.h"
+#include "test.h"
+
+#include "gmock/gmock.h"
+
+using namespace NEO;
+
+TEST(ClCommandStreamReceiverTest, WhenMakingResidentThenBufferResidencyFlagIsSet) {
+    MockContext context;
+    auto commandStreamReceiver = context.getDevice(0)->getDefaultEngine().commandStreamReceiver;
+    float srcMemory[] = {1.0f};
+
+    auto retVal = CL_INVALID_VALUE;
+    auto buffer = Buffer::create(
+        &context,
+        CL_MEM_USE_HOST_PTR,
+        sizeof(srcMemory),
+        srcMemory,
+        retVal);
+    ASSERT_NE(nullptr, buffer);
+
+    auto graphicsAllocation = buffer->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex());
+    EXPECT_FALSE(graphicsAllocation->isResident(commandStreamReceiver->getOsContext().getContextId()));
+
+    commandStreamReceiver->makeResident(*graphicsAllocation);
+
+    EXPECT_TRUE(graphicsAllocation->isResident(commandStreamReceiver->getOsContext().getContextId()));
+
+    delete buffer;
+}
+
+using ClCommandStreamReceiverTests = Test<DeviceFixture>;
+
+HWTEST_F(ClCommandStreamReceiverTests, givenCommandStreamReceiverWhenFenceAllocationIsRequiredAndCreateGlobalFenceAllocationIsCalledThenFenceAllocationIsAllocated) {
+    RAIIHwHelperFactory<MockHwHelperWithFenceAllocation<FamilyType>> hwHelperBackup{pDevice->getHardwareInfo().platform.eRenderCoreFamily};
+
+    MockCsrHw<FamilyType> csr(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());
+    csr.setupContext(*pDevice->getDefaultEngine().osContext);
+    EXPECT_EQ(nullptr, csr.globalFenceAllocation);
+
+    EXPECT_TRUE(csr.createGlobalFenceAllocation());
+
+    ASSERT_NE(nullptr, csr.globalFenceAllocation);
+    EXPECT_EQ(GraphicsAllocation::AllocationType::GLOBAL_FENCE, csr.globalFenceAllocation->getAllocationType());
+}
+
+HWTEST_F(ClCommandStreamReceiverTests, givenCommandStreamReceiverWhenGettingFenceAllocationThenCorrectFenceAllocationIsReturned) {
+    RAIIHwHelperFactory<MockHwHelperWithFenceAllocation<FamilyType>> hwHelperBackup{pDevice->getHardwareInfo().platform.eRenderCoreFamily};
+
+    CommandStreamReceiverHw<FamilyType> csr(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());
+    csr.setupContext(*pDevice->getDefaultEngine().osContext);
+    EXPECT_EQ(nullptr, csr.getGlobalFenceAllocation());
+
+    EXPECT_TRUE(csr.createGlobalFenceAllocation());
+
+    ASSERT_NE(nullptr, csr.getGlobalFenceAllocation());
+    EXPECT_EQ(GraphicsAllocation::AllocationType::GLOBAL_FENCE, csr.getGlobalFenceAllocation()->getAllocationType());
+}
+
+using CommandStreamReceiverMultiRootDeviceTest = MultiRootDeviceFixture;
+
+TEST_F(CommandStreamReceiverMultiRootDeviceTest, WhenCreatingCommandStreamGraphicsAllocationsThenTheyHaveCorrectRootDeviceIndex) {
+    auto commandStreamReceiver = &device1->getGpgpuCommandStreamReceiver();
+
+    ASSERT_NE(nullptr, commandStreamReceiver);
+    EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getRootDeviceIndex());
+
+    // Linear stream / Command buffer
+    GraphicsAllocation *allocation = mockMemoryManager->allocateGraphicsMemoryWithProperties({expectedRootDeviceIndex, 128u, GraphicsAllocation::AllocationType::COMMAND_BUFFER, device1->getDeviceBitfield()});
+    LinearStream commandStream{allocation};
+
+    commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 100u, 0u);
+    EXPECT_EQ(allocation, commandStream.getGraphicsAllocation());
+    EXPECT_EQ(128u, commandStream.getMaxAvailableSpace());
+    EXPECT_EQ(expectedRootDeviceIndex, commandStream.getGraphicsAllocation()->getRootDeviceIndex());
+
+    commandStreamReceiver->ensureCommandBufferAllocation(commandStream, 1024u, 0u);
+    EXPECT_NE(allocation, commandStream.getGraphicsAllocation());
+    EXPECT_EQ(0u, commandStream.getMaxAvailableSpace() % MemoryConstants::pageSize64k);
+    EXPECT_EQ(expectedRootDeviceIndex, commandStream.getGraphicsAllocation()->getRootDeviceIndex());
+    mockMemoryManager->freeGraphicsMemory(commandStream.getGraphicsAllocation());
+
+    // Debug surface
+    auto debugSurface = commandStreamReceiver->allocateDebugSurface(MemoryConstants::pageSize);
+    ASSERT_NE(nullptr, debugSurface);
+    EXPECT_EQ(expectedRootDeviceIndex, debugSurface->getRootDeviceIndex());
+
+    // Indirect heaps
+    IndirectHeap::Type heapTypes[]{IndirectHeap::DYNAMIC_STATE, IndirectHeap::INDIRECT_OBJECT, IndirectHeap::SURFACE_STATE};
+    for (auto heapType : heapTypes) {
+        IndirectHeap *heap = nullptr;
+        commandStreamReceiver->allocateHeapMemory(heapType, MemoryConstants::pageSize, heap);
+        ASSERT_NE(nullptr, heap);
+        ASSERT_NE(nullptr, heap->getGraphicsAllocation());
+        EXPECT_EQ(expectedRootDeviceIndex, heap->getGraphicsAllocation()->getRootDeviceIndex());
+        mockMemoryManager->freeGraphicsMemory(heap->getGraphicsAllocation());
+        delete heap;
+    }
+
+    // Tag allocation
+    ASSERT_NE(nullptr, commandStreamReceiver->getTagAllocation());
+    EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getTagAllocation()->getRootDeviceIndex());
+
+    // Preemption allocation
+    if (nullptr == commandStreamReceiver->getPreemptionAllocation()) {
+        commandStreamReceiver->createPreemptionAllocation();
+    }
+    EXPECT_EQ(expectedRootDeviceIndex, commandStreamReceiver->getPreemptionAllocation()->getRootDeviceIndex());
+
+    // HostPtr surface
+    char memory[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+    HostPtrSurface surface(memory, sizeof(memory), true);
+    EXPECT_TRUE(commandStreamReceiver->createAllocationForHostSurface(surface, false));
+    ASSERT_NE(nullptr, surface.getAllocation());
+    EXPECT_EQ(expectedRootDeviceIndex, surface.getAllocation()->getRootDeviceIndex());
+}

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

@@ -763,6 +763,7 @@ TEST_F(DrmMemoryManagerCopyMemoryToAllocationTest, givenDrmMemoryManagerWhenCopy
     allocData.flags.allocateMemory = true;
     allocData.type = GraphicsAllocation::AllocationType::KERNEL_ISA;
     allocData.rootDeviceIndex = rootDeviceIndex;
+    allocData.storageInfo.memoryBanks.set(0, true);
     MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
     auto allocation = drmMemoryManger.allocateGraphicsMemoryInDevicePool(allocData, status);
     ASSERT_NE(nullptr, allocation);
@@ -785,6 +786,7 @@ TEST_F(DrmMemoryManagerCopyMemoryToAllocationTest, givenDrmMemoryManagerWhenCopy
     allocData.flags.allocateMemory = true;
     allocData.type = GraphicsAllocation::AllocationType::KERNEL_ISA;
     allocData.rootDeviceIndex = rootDeviceIndex;
+    allocData.storageInfo.memoryBanks.set(0, true);
     MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
     auto allocation = drmMemoryManger.allocateGraphicsMemoryInDevicePool(allocData, status);
     ASSERT_NE(nullptr, allocation);

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

@@ -5418,4 +5418,61 @@ TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenOversize
     memoryManager->freeGraphicsMemory(allocation);
 }
 
+struct DrmMemoryManagerToTestCopyMemoryToAllocationBanks : public DrmMemoryManager {
+    DrmMemoryManagerToTestCopyMemoryToAllocationBanks(ExecutionEnvironment &executionEnvironment, size_t lockableLocalMemorySize)
+        : DrmMemoryManager(gemCloseWorkerMode::gemCloseWorkerInactive, false, false, executionEnvironment) {
+        lockedLocalMemorySize = lockableLocalMemorySize;
+    }
+    void *lockResourceInLocalMemoryImpl(BufferObject *bo) override {
+        if (lockedLocalMemorySize > 0) {
+            if (static_cast<uint32_t>(bo->peekHandle()) < lockedLocalMemory.size()) {
+                lockedLocalMemory[bo->peekHandle()].reset(new uint8_t[lockedLocalMemorySize]);
+                return lockedLocalMemory[bo->peekHandle()].get();
+            }
+        }
+        return nullptr;
+    }
+    void unlockResourceInLocalMemoryImpl(BufferObject *bo) override {
+    }
+    std::array<std::unique_ptr<uint8_t[]>, 4> lockedLocalMemory;
+    size_t lockedLocalMemorySize = 0;
+};
+
+TEST(DrmMemoryManagerCopyMemoryToAllocationBanksTest, givenDrmMemoryManagerWhenCopyMemoryToAllocationOnSpecificMemoryBanksThenAllocationIsFilledWithCorrectDataOnSpecificBanks) {
+    uint8_t sourceData[64]{};
+    size_t offset = 3;
+    size_t sourceAllocationSize = sizeof(sourceData);
+    size_t destinationAllocationSize = sourceAllocationSize + offset;
+    MockExecutionEnvironment executionEnvironment;
+    auto drm = new DrmMock(mockFd, *executionEnvironment.rootDeviceEnvironments[0]);
+    executionEnvironment.rootDeviceEnvironments[0]->osInterface.reset(new OSInterface());
+    executionEnvironment.rootDeviceEnvironments[0]->osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
+    DrmMemoryManagerToTestCopyMemoryToAllocationBanks drmMemoryManger(executionEnvironment, destinationAllocationSize);
+    std::vector<uint8_t> dataToCopy(sourceAllocationSize, 1u);
+
+    MockDrmAllocation mockAllocation(GraphicsAllocation::AllocationType::WORK_PARTITION_SURFACE, MemoryPool::LocalMemory);
+
+    mockAllocation.storageInfo.memoryBanks = 0b1110;
+    DeviceBitfield memoryBanksToCopy = 0b1010;
+    mockAllocation.bufferObjects.clear();
+
+    for (auto index = 0u; index < 4; index++) {
+        drmMemoryManger.lockedLocalMemory[index].reset();
+        mockAllocation.bufferObjects.push_back(new BufferObject(drm, index, sourceAllocationSize, 3));
+    }
+
+    auto ret = drmMemoryManger.copyMemoryToAllocationBanks(&mockAllocation, offset, dataToCopy.data(), dataToCopy.size(), memoryBanksToCopy);
+    EXPECT_TRUE(ret);
+
+    EXPECT_EQ(nullptr, drmMemoryManger.lockedLocalMemory[0].get());
+    ASSERT_NE(nullptr, drmMemoryManger.lockedLocalMemory[1].get());
+    EXPECT_EQ(nullptr, drmMemoryManger.lockedLocalMemory[2].get());
+    ASSERT_NE(nullptr, drmMemoryManger.lockedLocalMemory[3].get());
+
+    EXPECT_EQ(0, memcmp(ptrOffset(drmMemoryManger.lockedLocalMemory[1].get(), offset), dataToCopy.data(), dataToCopy.size()));
+    EXPECT_EQ(0, memcmp(ptrOffset(drmMemoryManger.lockedLocalMemory[3].get(), offset), dataToCopy.data(), dataToCopy.size()));
+    for (auto index = 0u; index < 4; index++) {
+        delete mockAllocation.bufferObjects[index];
+    }
+}
 } // namespace NEO

opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp

@@ -2497,3 +2497,52 @@ TEST_F(WddmMemoryManagerSimpleTest, whenAlignmentRequirementExceedsPageSizeThenA
         EXPECT_EQ(0U, memoryManager.callCount.allocateGraphicsMemoryUsingKmdAndMapItToCpuVA);
     }
 }
+
+struct WddmWithMockedLock : public WddmMock {
+    using WddmMock::WddmMock;
+
+    void *lockResource(const D3DKMT_HANDLE &handle, bool applyMakeResidentPriorToLock, size_t size) override {
+        if (handle < storageLocked.size()) {
+            storageLocked.set(handle);
+        }
+        return storages[handle];
+    }
+    std::bitset<4> storageLocked{};
+    uint8_t storages[EngineLimits::maxHandleCount][MemoryConstants::pageSize64k] = {0u};
+};
+
+TEST(WddmMemoryManagerCopyMemoryToAllocationBanksTest, givenAllocationWithMultiTilePlacementWhenCopyDataSpecificMemoryBanksThenLockOnlySpecificStorages) {
+    uint8_t sourceData[32]{};
+    size_t offset = 3;
+    size_t sourceAllocationSize = sizeof(sourceData);
+    auto hwInfo = *defaultHwInfo;
+    hwInfo.featureTable.ftrLocalMemory = true;
+
+    MockExecutionEnvironment executionEnvironment(&hwInfo);
+    executionEnvironment.initGmm();
+    auto wddm = new WddmWithMockedLock(*executionEnvironment.rootDeviceEnvironments[0]);
+    wddm->init();
+    MemoryManagerCreate<WddmMemoryManager> memoryManager(true, true, executionEnvironment);
+
+    MockWddmAllocation mockAllocation(executionEnvironment.rootDeviceEnvironments[0]->getGmmClientContext());
+
+    mockAllocation.storageInfo.memoryBanks = 0b1110;
+    DeviceBitfield memoryBanksToCopy = 0b1010;
+    mockAllocation.handles.resize(4);
+    for (auto index = 0u; index < 4; index++) {
+        wddm->storageLocked.set(index, false);
+        if (mockAllocation.storageInfo.memoryBanks.test(index)) {
+            mockAllocation.handles[index] = index;
+        }
+    }
+    std::vector<uint8_t> dataToCopy(sourceAllocationSize, 1u);
+    auto ret = memoryManager.copyMemoryToAllocationBanks(&mockAllocation, offset, dataToCopy.data(), dataToCopy.size(), memoryBanksToCopy);
+    EXPECT_TRUE(ret);
+
+    EXPECT_FALSE(wddm->storageLocked.test(0));
+    ASSERT_TRUE(wddm->storageLocked.test(1));
+    EXPECT_FALSE(wddm->storageLocked.test(2));
+    ASSERT_TRUE(wddm->storageLocked.test(3));
+    EXPECT_EQ(0, memcmp(ptrOffset(wddm->storages[1], offset), dataToCopy.data(), dataToCopy.size()));
+    EXPECT_EQ(0, memcmp(ptrOffset(wddm->storages[3], offset), dataToCopy.data(), dataToCopy.size()));
+}

shared/source/command_stream/command_stream_receiver.cpp

@@ -570,12 +570,11 @@ bool CommandStreamReceiver::createWorkPartitionAllocation(const Device &device)
         }
 
         const uint32_t copySrc = deviceIndex;
-        const Vec3<size_t> copySrcSize = {sizeof(copySrc), 1, 1};
         DeviceBitfield copyBitfield{};
         copyBitfield.set(deviceIndex);
-        BlitOperationResult blitResult = BlitHelper::blitMemoryToAllocationBanks(device, workPartitionAllocation, 0, &copySrc, copySrcSize, copyBitfield);
+        auto copySuccess = MemoryTransferHelper::transferMemoryToAllocationBanks(device, workPartitionAllocation, 0, &copySrc, sizeof(copySrc), copyBitfield);
 
-        if (blitResult != BlitOperationResult::Success) {
+        if (!copySuccess) {
             return false;
         }
     }

shared/source/memory_manager/memory_manager.cpp

@@ -688,6 +688,11 @@ bool MemoryManager::copyMemoryToAllocation(GraphicsAllocation *graphicsAllocatio
     return true;
 }
 
+bool MemoryManager::copyMemoryToAllocationBanks(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy, DeviceBitfield dstMemoryBanks) {
+    memcpy_s(ptrOffset(static_cast<uint8_t *>(graphicsAllocation->getUnderlyingBuffer()), destinationOffset),
+             (graphicsAllocation->getUnderlyingBufferSize() - destinationOffset), memoryToCopy, sizeToCopy);
+    return true;
+}
 void MemoryManager::waitForEnginesCompletion(GraphicsAllocation &graphicsAllocation) {
     for (auto &engine : getRegisteredEngines()) {
         auto osContextId = engine.osContext->getContextId();
@@ -864,4 +869,13 @@ bool MemoryTransferHelper::transferMemoryToAllocation(bool useBlitter, const Dev
     }
     return device.getMemoryManager()->copyMemoryToAllocation(dstAllocation, dstOffset, srcMemory, srcSize);
 }
+bool MemoryTransferHelper::transferMemoryToAllocationBanks(const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory,
+                                                           size_t srcSize, DeviceBitfield dstMemoryBanks) {
+    auto blitSuccess = BlitHelper::blitMemoryToAllocationBanks(device, dstAllocation, dstOffset, srcMemory, {srcSize, 1, 1}, dstMemoryBanks) == BlitOperationResult::Success;
+
+    if (!blitSuccess) {
+        return device.getMemoryManager()->copyMemoryToAllocationBanks(dstAllocation, dstOffset, srcMemory, srcSize, dstMemoryBanks);
+    }
+    return true;
+}
 } // namespace NEO

shared/source/memory_manager/memory_manager.h

@@ -56,7 +56,9 @@ constexpr size_t paddingBufferSize = 2 * MemoryConstants::megaByte;
 
 namespace MemoryTransferHelper {
 bool transferMemoryToAllocation(bool useBlitter, const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory, size_t srcSize);
-}
+bool transferMemoryToAllocationBanks(const Device &device, GraphicsAllocation *dstAllocation, size_t dstOffset, const void *srcMemory,
+                                     size_t srcSize, DeviceBitfield dstMemoryBanks);
+} // namespace MemoryTransferHelper
 
 class MemoryManager {
   public:
@@ -191,6 +193,7 @@ class MemoryManager {
     HostPtrManager *getHostPtrManager() const { return hostPtrManager.get(); }
     void setDefaultEngineIndex(uint32_t rootDeviceIndex, uint32_t engineIndex) { defaultEngineIndex[rootDeviceIndex] = engineIndex; }
     virtual bool copyMemoryToAllocation(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy);
+    virtual bool copyMemoryToAllocationBanks(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy, DeviceBitfield dstMemoryBanks);
     HeapIndex selectHeap(const GraphicsAllocation *allocation, bool hasPointer, bool isFullRangeSVM, bool useFrontWindow);
     static std::unique_ptr<MemoryManager> createMemoryManager(ExecutionEnvironment &executionEnvironment, DriverModelType driverModel = DriverModelType::UNKNOWN);
     virtual void *reserveCpuAddressRange(size_t size, uint32_t rootDeviceIndex) { return nullptr; };

shared/source/os_interface/linux/drm_memory_manager.cpp

@@ -1111,8 +1111,17 @@ bool DrmMemoryManager::copyMemoryToAllocation(GraphicsAllocation *graphicsAlloca
     if (graphicsAllocation->getUnderlyingBuffer() || !isLocalMemorySupported(graphicsAllocation->getRootDeviceIndex())) {
         return MemoryManager::copyMemoryToAllocation(graphicsAllocation, destinationOffset, memoryToCopy, sizeToCopy);
     }
+    return copyMemoryToAllocationBanks(graphicsAllocation, destinationOffset, memoryToCopy, sizeToCopy, graphicsAllocation->storageInfo.memoryBanks);
+}
+bool DrmMemoryManager::copyMemoryToAllocationBanks(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy, DeviceBitfield dstMemoryBanks) {
+    if (MemoryPool::isSystemMemoryPool(graphicsAllocation->getMemoryPool())) {
+        return false;
+    }
     auto drmAllocation = static_cast<DrmAllocation *>(graphicsAllocation);
-    for (auto handleId = 0u; handleId < graphicsAllocation->storageInfo.getNumBanks(); handleId++) {
+    for (auto handleId = 0u; handleId < graphicsAllocation->storageInfo.getTotalBanksCnt(); handleId++) {
+        if (!dstMemoryBanks.test(handleId)) {
+            continue;
+        }
         auto ptr = lockResourceInLocalMemoryImpl(drmAllocation->getBOs()[handleId]);
         if (!ptr) {
             return false;

shared/source/os_interface/linux/drm_memory_manager.h

@@ -57,6 +57,7 @@ class DrmMemoryManager : public MemoryManager {
 
     DrmGemCloseWorker *peekGemCloseWorker() const { return this->gemCloseWorker.get(); }
     bool copyMemoryToAllocation(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy) override;
+    bool copyMemoryToAllocationBanks(GraphicsAllocation *graphicsAllocation, size_t destinationOffset, const void *memoryToCopy, size_t sizeToCopy, DeviceBitfield dstMemoryBanks) override;
 
     MOCKABLE_VIRTUAL int obtainFdFromHandle(int boHandle, uint32_t rootDeviceindex);
     AddressRange reserveGpuAddress(size_t size, uint32_t rootDeviceIndex) override;