Use blitter to initialize Global surface if required

Change-Id: I53cc532a5b5edd16a32deaf987f85db4224b9945
Signed-off-by: Bartosz Dunajski <[email protected]>

Author: BartoszDunajski

opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp

@@ -7,7 +7,9 @@
 
 #include "shared/source/helpers/pause_on_gpu_properties.h"
 #include "shared/source/helpers/vec.h"
+#include "shared/source/memory_manager/unified_memory_manager.h"
 #include "shared/test/unit_test/cmd_parse/hw_parse.h"
+#include "shared/test/unit_test/compiler_interface/linker_mock.h"
 #include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
 #include "shared/test/unit_test/helpers/variable_backup.h"
 #include "shared/test/unit_test/mocks/mock_device.h"
@@ -19,6 +21,7 @@
 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
 #include "opencl/test/unit_test/mocks/mock_context.h"
 #include "opencl/test/unit_test/mocks/mock_kernel.h"
+#include "opencl/test/unit_test/mocks/mock_program.h"
 #include "opencl/test/unit_test/mocks/mock_timestamp_container.h"
 #include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
 #include "test.h"
@@ -1671,4 +1674,31 @@ HWTEST_TEMPLATED_F(BlitCopyTests, givenKernelAllocationInLocalMemoryWhenCreating
     device->getMemoryManager()->freeGraphicsMemory(kernelInfo.kernelAllocation);
 }
 
+HWTEST_TEMPLATED_F(BlitCopyTests, givenLocalMemoryAccessNotAllowedWhenGlobalConstantsAreExportedThenUseBlitter) {
+    DebugManager.flags.EnableLocalMemory.set(1);
+    DebugManager.flags.ForceLocalMemoryAccessMode.set(static_cast<int32_t>(LocalMemoryAccessMode::CpuAccessDisallowed));
+
+    char constantData[128] = {};
+    ProgramInfo programInfo;
+    programInfo.globalConstants.initData = constantData;
+    programInfo.globalConstants.size = sizeof(constantData);
+    auto mockLinkerInput = std::make_unique<WhiteBox<LinkerInput>>();
+    mockLinkerInput->traits.exportsGlobalConstants = true;
+    programInfo.linkerInput = std::move(mockLinkerInput);
+
+    MockProgram program(*device->getExecutionEnvironment(), bcsMockContext.get(), false, &device->getDevice());
+
+    EXPECT_EQ(0u, bcsMockContext->bcsCsr->peekTaskCount());
+
+    program.processProgramInfo(programInfo);
+
+    EXPECT_EQ(1u, bcsMockContext->bcsCsr->peekTaskCount());
+
+    auto rootDeviceIndex = device->getRootDeviceIndex();
+
+    ASSERT_NE(nullptr, program.getConstantSurface(rootDeviceIndex));
+    auto gpuAddress = reinterpret_cast<const void *>(program.getConstantSurface(rootDeviceIndex)->getGpuAddress());
+    EXPECT_NE(nullptr, bcsMockContext->getSVMAllocsManager()->getSVMAlloc(gpuAddress));
+}
+
 } // namespace NEO

shared/source/helpers/hw_helper_base.inl

@@ -422,7 +422,8 @@ inline bool HwHelperHw<GfxFamily>::allowRenderCompression(const HardwareInfo &hw
 template <typename GfxFamily>
 inline bool HwHelperHw<GfxFamily>::isBlitCopyRequiredForLocalMemory(const HardwareInfo &hwInfo) const {
     HwHelper &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
-    return (hwHelper.getLocalMemoryAccessMode(hwInfo) == LocalMemoryAccessMode::CpuAccessDisallowed) && hwInfo.capabilityTable.blitterOperationsSupported;
+    return (hwHelper.getLocalMemoryAccessMode(hwInfo) == LocalMemoryAccessMode::CpuAccessDisallowed) &&
+           hwInfo.capabilityTable.blitterOperationsSupported;
 }
 
 template <typename GfxFamily>

shared/source/program/program_initialization.cpp

@@ -21,6 +21,8 @@ namespace NEO {
 GraphicsAllocation *allocateGlobalsSurface(NEO::SVMAllocsManager *const svmAllocManager, NEO::Device &device, size_t size, bool constant,
                                            LinkerInput *const linkerInput, const void *initData) {
     bool globalsAreExported = false;
+    GraphicsAllocation *gpuAllocation = nullptr;
+
     if (linkerInput != nullptr) {
         globalsAreExported = constant ? linkerInput->getTraits().exportsGlobalConstants : linkerInput->getTraits().exportsGlobalVariables;
     }
@@ -37,30 +39,33 @@ GraphicsAllocation *allocateGlobalsSurface(NEO::SVMAllocsManager *const svmAlloc
         }
         auto svmAlloc = svmAllocManager->getSVMAlloc(ptr);
         UNRECOVERABLE_IF(svmAlloc == nullptr);
-        auto gpuAlloc = svmAlloc->gpuAllocations.getGraphicsAllocation(device.getRootDeviceIndex());
-        UNRECOVERABLE_IF(gpuAlloc == nullptr);
-        device.getMemoryManager()->copyMemoryToAllocation(gpuAlloc, initData, static_cast<uint32_t>(size));
-        return gpuAlloc;
+        gpuAllocation = svmAlloc->gpuAllocations.getGraphicsAllocation(device.getRootDeviceIndex());
     } else {
         auto allocationType = constant ? GraphicsAllocation::AllocationType::CONSTANT_SURFACE : GraphicsAllocation::AllocationType::GLOBAL_SURFACE;
-        auto gpuAlloc = device.getMemoryManager()->allocateGraphicsMemoryWithProperties({device.getRootDeviceIndex(),
+        gpuAllocation = device.getMemoryManager()->allocateGraphicsMemoryWithProperties({device.getRootDeviceIndex(),
                                                                                          true, // allocateMemory
                                                                                          size, allocationType,
                                                                                          false, // isMultiStorageAllocation
                                                                                          device.getDeviceBitfield()});
-        DEBUG_BREAK_IF(gpuAlloc == nullptr);
-        if (gpuAlloc == nullptr) {
-            return nullptr;
-        }
-        auto &hwInfo = device.getHardwareInfo();
-        auto &helper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
-        if (gpuAlloc->isAllocatedInLocalMemoryPool() && helper.isBlitCopyRequiredForLocalMemory(hwInfo)) {
-            BlitHelperFunctions::blitMemoryToAllocation(device, gpuAlloc, 0, initData, {size, 1, 1});
-        } else {
-            memcpy_s(gpuAlloc->getUnderlyingBuffer(), gpuAlloc->getUnderlyingBufferSize(), initData, size);
-        }
-        return gpuAlloc;
     }
+
+    if (!gpuAllocation) {
+        return nullptr;
+    }
+
+    auto &hwInfo = device.getHardwareInfo();
+    auto &helper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
+
+    bool success = false;
+    if (gpuAllocation->isAllocatedInLocalMemoryPool() && helper.isBlitCopyRequiredForLocalMemory(hwInfo)) {
+        success = (BlitHelperFunctions::blitMemoryToAllocation(device, gpuAllocation, 0, initData, {size, 1, 1}) == BlitOperationResult::Success);
+    } else {
+        success = device.getMemoryManager()->copyMemoryToAllocation(gpuAllocation, initData, static_cast<uint32_t>(size));
+    }
+
+    UNRECOVERABLE_IF(!success);
+
+    return gpuAllocation;
 }
 
 } // namespace NEO