Allow cpu buffers copy on DG2 in 32bit

Resolves: NEO-6906, NEO-6000

Signed-off-by: Maciej Plewka <[email protected]>

Author: MaciejPlewka

opencl/source/mem_obj/buffer.cpp

@@ -643,7 +643,7 @@ bool Buffer::isReadWriteOnCpuAllowed(const Device &device) {
         return false;
     }
 
-    if (graphicsAllocation->isAllocatedInLocalMemoryPool()) {
+    if (graphicsAllocation->isAllocatedInLocalMemoryPool() && !graphicsAllocation->isAllocationLockable()) {
         return false;
     }
 

opencl/test/unit_test/command_queue/read_write_buffer_cpu_copy.cpp

@@ -9,6 +9,7 @@
 #include "shared/source/helpers/basic_math.h"
 #include "shared/source/helpers/local_memory_access_modes.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/mocks/mock_gmm.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include "opencl/test/unit_test/command_queue/enqueue_read_buffer_fixture.h"
@@ -331,7 +332,10 @@ TEST(ReadWriteBufferOnCpu, whenLocalMemoryPoolAllocationIsAskedForPreferenceThen
     cl_int retVal = 0;
     std::unique_ptr<Buffer> buffer(Buffer::create(&ctx, CL_MEM_READ_WRITE, MemoryConstants::pageSize, nullptr, retVal));
     ASSERT_NE(nullptr, buffer.get());
+    auto gmm = std::make_unique<MockGmm>(device->getGmmHelper());
+    reinterpret_cast<MemoryAllocation *>(buffer->getGraphicsAllocation(device->getRootDeviceIndex()))->setGmm(gmm.release(), 0);
     reinterpret_cast<MemoryAllocation *>(buffer->getGraphicsAllocation(device->getRootDeviceIndex()))->overrideMemoryPool(MemoryPool::LocalMemory);
+    reinterpret_cast<MemoryAllocation *>(buffer->getGraphicsAllocation(device->getRootDeviceIndex()))->getDefaultGmm()->resourceParams.Flags.Info.NotLockable = 1;
 
     EXPECT_FALSE(buffer->isReadWriteOnCpuAllowed(device->getDevice()));
     EXPECT_FALSE(buffer->isReadWriteOnCpuPreferred(reinterpret_cast<void *>(0x1000), MemoryConstants::pageSize, device->getDevice()));

opencl/test/unit_test/mem_obj/buffer_tests.cpp

@@ -68,7 +68,9 @@ TEST(Buffer, whenBufferAllocatedInLocalMemoryThenCpuCopyIsDisallowed) {
     MockBuffer buffer(allocation);
     UltDeviceFactory factory{1, 0};
     auto &device = *factory.rootDevices[0];
-
+    auto gmm = std::make_unique<MockGmm>(device.getGmmHelper());
+    allocation.setGmm(gmm.get(), 0);
+    allocation.getDefaultGmm()->resourceParams.Flags.Info.NotLockable = 1;
     allocation.memoryPool = MemoryPool::LocalMemory;
     EXPECT_FALSE(buffer.isReadWriteOnCpuAllowed(device));
 

opencl/test/unit_test/xe_hpg_core/dg2/windows/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 set(IGDRCL_SRCS_tests_xe_hpg_core_dg2_windows
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+    ${CMAKE_CURRENT_SOURCE_DIR}/wddm_tests_dg2.cpp
 )
 if(WIN32)
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_xe_hpg_core_dg2_windows})

opencl/test/unit_test/xe_hpg_core/dg2/windows/wddm_tests_dg2.cpp

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+using namespace NEO;
+
+#include "shared/source/helpers/constants.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/mock_allocation_properties.h"
+#include "shared/test/common/mocks/mock_execution_environment.h"
+#include "shared/test/common/mocks/mock_wddm_residency_allocations_container.h"
+#include "shared/test/common/os_interface/windows/mock_wddm_memory_manager.h"
+
+#include "opencl/source/platform/platform.h"
+#include "opencl/test/unit_test/mocks/mock_platform.h"
+#include "opencl/test/unit_test/os_interface/windows/mock_wddm_allocation.h"
+#include "opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.h"
+
+#include "mock_gmm_memory.h"
+
+HWTEST_EXCLUDE_PRODUCT(PlatformWithFourDevicesTest, givenPlatformWithFourDevicesWhenCreateBufferThenAllocationIsColouredAndHasFourHandles, IGFX_DG2);
+
+struct PlatformWithFourDevicesTestDG2 : public ::testing::Test {
+    PlatformWithFourDevicesTestDG2() {
+        ultHwConfig.useMockedPrepareDeviceEnvironmentsFunc = false;
+    }
+    void SetUp() override {
+        DebugManager.flags.CreateMultipleSubDevices.set(4);
+        initPlatform();
+    }
+
+    DebugManagerStateRestore restorer;
+
+    VariableBackup<UltHwConfig> backup{&ultHwConfig};
+};
+
+DG2TEST_F(PlatformWithFourDevicesTestDG2, givenPlatformWithFourDevicesWhenCreateBufferThenAllocationIsColouredAndHasFourHandles) {
+    auto wddm = reinterpret_cast<WddmMock *>(platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface->getDriverModel()->as<Wddm>());
+    wddm->mapGpuVaStatus = true;
+    VariableBackup<bool> restorer{&wddm->callBaseMapGpuVa, false};
+
+    MockWddmMemoryManager memoryManager(true, true, *platform()->peekExecutionEnvironment());
+    memoryManager.supportsMultiStorageResources = true;
+
+    platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0]->getMutableHardwareInfo()->featureTable.flags.ftrLocalMemory = true;
+    platform()->peekExecutionEnvironment()->rootDeviceEnvironments[0]->getMutableHardwareInfo()->featureTable.flags.ftrMultiTileArch = true;
+
+    auto allocation = static_cast<WddmAllocation *>(memoryManager.allocateGraphicsMemoryWithProperties({mockRootDeviceIndex, true, 4 * MemoryConstants::pageSize64k, AllocationType::BUFFER, true, 0b1111}));
+    EXPECT_EQ(4u, allocation->getNumGmms());
+    EXPECT_EQ(maxNBitValue(allocation->getNumGmms()), allocation->storageInfo.pageTablesVisibility.to_ullong());
+
+    EXPECT_FALSE(allocation->storageInfo.tileInstanced);
+    EXPECT_TRUE(allocation->storageInfo.multiStorage);
+    EXPECT_EQ(4u, wddm->mapGpuVirtualAddressResult.called);
+    for (auto gmmIndex = 0u; gmmIndex < 4u; gmmIndex++) {
+        auto gmm = allocation->getGmm(gmmIndex);
+        EXPECT_EQ(allocation->storageInfo.pageTablesVisibility, gmm->resourceParams.MultiTileArch.GpuVaMappingSet);
+        EXPECT_EQ(1u << gmmIndex, gmm->resourceParams.MultiTileArch.LocalMemEligibilitySet);
+        EXPECT_EQ(1u << gmmIndex, gmm->resourceParams.MultiTileArch.LocalMemPreferredSet);
+        EXPECT_EQ(MemoryConstants::pageSize64k, gmm->gmmResourceInfo->getSizeAllocation());
+        EXPECT_FALSE(gmm->gmmResourceInfo->getResourceFlags()->Info.NonLocalOnly);
+        if constexpr (is32bit) {
+            EXPECT_FALSE(gmm->gmmResourceInfo->getResourceFlags()->Info.LocalOnly);
+            EXPECT_FALSE(gmm->gmmResourceInfo->getResourceFlags()->Info.NotLockable);
+        } else {
+            EXPECT_TRUE(gmm->gmmResourceInfo->getResourceFlags()->Info.LocalOnly);
+            EXPECT_TRUE(gmm->gmmResourceInfo->getResourceFlags()->Info.NotLockable);
+        }
+    }
+    memoryManager.freeGraphicsMemory(allocation);
+}

shared/source/helpers/extra_allocation_data_xehp_and_later.inl

@@ -38,5 +38,11 @@ void HwHelperHw<Family>::setExtraAllocationData(AllocationData &allocationData,
             allocationData.storageInfo.isLockable = false;
         }
     }
+
+    if (HwInfoConfig::get(hwInfo.platform.eProductFamily)->isStorageInfoAdjustmentRequired()) {
+        if (properties.allocationType == AllocationType::BUFFER && !properties.flags.preferCompressed && !properties.flags.shareable) {
+            allocationData.storageInfo.isLockable = true;
+        }
+    }
 }
 } // namespace NEO

shared/source/xe_hpg_core/dg2/os_agnostic_hw_info_config_dg2.inl

@@ -185,3 +185,11 @@ template <>
 bool HwInfoConfigHw<gfxProduct>::isMatrixMultiplyAccumulateSupported(const HardwareInfo &hwInfo) const {
     return true;
 }
+template <>
+bool HwInfoConfigHw<gfxProduct>::isStorageInfoAdjustmentRequired() const {
+    if constexpr (is32bit) {
+        return true;
+    } else {
+        return false;
+    }
+}

shared/test/unit_test/xe_hpg_core/dg2/excludes_xe_hpg_core_dg2.cpp

@@ -17,3 +17,4 @@ HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfPipeControl
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfTile64With3DSurfaceOnBCSIsSupportedThenTrueIsReturned, IGFX_DG2);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, WhenAllowRenderCompressionIsCalledThenTrueIsReturned, IGFX_DG2);
 HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, whenConvertingTimestampsToCsDomainThenNothingIsChanged, IGFX_DG2);
+HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenHwInfoConfigWhenAskedIfStorageInfoAdjustmentIsRequiredThenFalseIsReturned, IGFX_DG2);

shared/test/unit_test/xe_hpg_core/dg2/hw_info_config_tests_dg2.cpp

@@ -450,3 +450,12 @@ DG2TEST_F(ProductConfigTests, givenDg2G11DeviceIdWhenDifferentRevisionIsPassedTh
         EXPECT_EQ(productConfig, DG2_G11);
     }
 }
+
+DG2TEST_F(HwInfoConfigTestDg2, givenHwInfoConfigWhenAskedIfStorageInfoAdjustmentIsRequiredThenTrueIsReturned) {
+    auto hwInfoConfig = HwInfoConfig::get(defaultHwInfo->platform.eProductFamily);
+    if constexpr (is32bit) {
+        EXPECT_TRUE(hwInfoConfig->isStorageInfoAdjustmentRequired());
+    } else {
+        EXPECT_FALSE(hwInfoConfig->isStorageInfoAdjustmentRequired());
+    }
+}