Fixes for bindless configuration

- enhance ults code, do not inject memory manager
- fix some issues related to bindless global heap

Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>

Author: HoppeMateusz

level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl

@@ -102,12 +102,24 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::executeCommandListImm
         this->migrateSharedAllocations();
     }
 
+    auto ioh = (this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::INDIRECT_OBJECT));
+    NEO::IndirectHeap *dsh = nullptr;
+    NEO::IndirectHeap *ssh = nullptr;
+
+    if (!NEO::ApiSpecificConfig::getBindlessConfiguration()) {
+        dsh = (this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::DYNAMIC_STATE));
+        ssh = (this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::SURFACE_STATE));
+    } else {
+        dsh = this->device->getNEODevice()->getBindlessHeapsHelper()->getHeap(NEO::BindlessHeapsHelper::BindlesHeapType::GLOBAL_DSH);
+        ssh = this->device->getNEODevice()->getBindlessHeapsHelper()->getHeap(NEO::BindlessHeapsHelper::BindlesHeapType::GLOBAL_SSH);
+    }
+
     auto completionStamp = this->csr->flushTask(
         *commandStream,
         commandStreamStart,
-        this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::DYNAMIC_STATE),
-        this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::INDIRECT_OBJECT),
-        this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::SURFACE_STATE),
+        dsh,
+        ioh,
+        ssh,
         this->csr->peekTaskLevel(),
         dispatchFlags,
         *(this->device->getNEODevice()));

level_zero/core/test/unit_tests/sources/builtin/built_in_tests_l0.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "shared/source/built_ins/built_ins.h"
+#include "shared/source/helpers/api_specific_config.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
 #include "shared/test/common/test_macros/test.h"
 #include "shared/test/unit_test/built_ins/built_in_tests_shared.inl"
@@ -16,27 +17,29 @@
 
 using namespace NEO;
 
-TEST(BuiltInTestsL0, givenUseBindlessBuiltinInApiDependentModeWhenBinExtensionPassedThenNameHasBindfulPrefix) {
+TEST(BuiltInTestsL0, givenUseBindlessBuiltinInApiDependentModeWhenBinExtensionPassedThenNameHasCorrectPrefix) {
     DebugManagerStateRestore dbgRestorer;
     DebugManager.flags.UseBindlessMode.set(-1);
     EBuiltInOps::Type builtin = EBuiltInOps::CopyBufferToBuffer;
     const std::string extension = ".bin";
     const std::string platformName = "platformName";
     const uint32_t deviceRevId = 123;
 
+    std::string prefix = ApiSpecificConfig::getBindlessConfiguration() ? "bindless" : "bindful";
+
     std::string resourceNameGeneric = createBuiltinResourceName(builtin, extension);
     std::string resourceNameForPlatform = createBuiltinResourceName(builtin, extension, platformName);
     std::string resourceNameForPlatformAndStepping = createBuiltinResourceName(builtin, extension, platformName, deviceRevId);
 
-    std::string expectedResourceNameGeneric = "bindful_copy_buffer_to_buffer.builtin_kernel.bin";
+    std::string expectedResourceNameGeneric = prefix + "_copy_buffer_to_buffer.builtin_kernel.bin";
 
     std::string expectedResourceNameForPlatform = platformName.c_str();
-    expectedResourceNameForPlatform += "_0_bindful_copy_buffer_to_buffer.builtin_kernel.bin";
+    expectedResourceNameForPlatform += "_0_" + prefix + "_copy_buffer_to_buffer.builtin_kernel.bin";
 
     std::string expectedResourceNameForPlatformAndStepping = platformName.c_str();
     expectedResourceNameForPlatformAndStepping += "_";
     expectedResourceNameForPlatformAndStepping += std::to_string(deviceRevId).c_str();
-    expectedResourceNameForPlatformAndStepping += "_bindful_copy_buffer_to_buffer.builtin_kernel.bin";
+    expectedResourceNameForPlatformAndStepping += "_" + prefix + "_copy_buffer_to_buffer.builtin_kernel.bin";
 
     EXPECT_EQ(0, strcmp(expectedResourceNameGeneric.c_str(), resourceNameGeneric.c_str()));
     EXPECT_EQ(0, strcmp(expectedResourceNameForPlatform.c_str(), resourceNameForPlatform.c_str()));

level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp

@@ -311,6 +311,30 @@ HWTEST_F(CommandListImmediateFlushTaskComputeTests, givenUseCsrImmediateSubmissi
     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
 }
 
+HWTEST_F(CommandListImmediateFlushTaskComputeTests, givenBindlessModeAndUseCsrImmediateSubmissionEnabledForImmediateCommandListForAppendPageFaultThenSuccessIsReturned) {
+    NEO::DebugManager.flags.EnableFlushTaskSubmission.set(1);
+    NEO::DebugManager.flags.UseBindlessMode.set(1);
+
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->createBindlessHeapsHelper(neoDevice->getMemoryManager(),
+                                                                                                                             neoDevice->getNumGenericSubDevices() > 1,
+                                                                                                                             neoDevice->getRootDeviceIndex(),
+                                                                                                                             neoDevice->getDeviceBitfield());
+
+    size_t size = 0x100000001;
+    NEO::MockGraphicsAllocation mockAllocationSrc(0, NEO::AllocationType::INTERNAL_HOST_MEMORY,
+                                                  reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
+                                                  MemoryPool::System4KBPages);
+    NEO::MockGraphicsAllocation mockAllocationDst(0, NEO::AllocationType::INTERNAL_HOST_MEMORY,
+                                                  reinterpret_cast<void *>(0x100003456), size, 0, sizeof(uint32_t),
+                                                  MemoryPool::System4KBPages);
+    ze_command_queue_desc_t queueDesc = {};
+    ze_result_t returnValue = ZE_RESULT_SUCCESS;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &queueDesc, false, NEO::EngineGroupType::Compute, returnValue));
+
+    auto result = commandList->appendPageFaultCopy(&mockAllocationDst, &mockAllocationSrc, size, false);
+    ASSERT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
 HWTEST_F(CommandListImmediateFlushTaskComputeTests, givenUseCsrImmediateSubmissionEnabledForImmediateWhenAppendEventResetThenSuccessIsReturned) {
     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(1);
 
@@ -935,6 +959,8 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
     auto event1 = std::unique_ptr<L0::Event>(L0::Event::create<uint32_t>(eventPool.get(), &eventDesc, device));
     events.push_back(event1.get());
 
+    auto offset = commandContainer.getCommandStream()->getUsed();
+
     result = commandList->appendMemoryFill(heapPointer, reinterpret_cast<void *>(&one), sizeof(one), size,
                                            events[0], 1u, nullptr);
     EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
@@ -944,12 +970,9 @@ HWTEST2_F(HostPointerManagerCommandListTest, givenCommandListWhenMemoryFillWithS
 
     GenCmdList cmdList;
     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
-        cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
+        cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), offset), commandContainer.getCommandStream()->getUsed() - offset));
 
     auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
-    EXPECT_NE(cmdList.end(), itor);
-    itor++;
-    itor = find<PIPE_CONTROL *>(itor, cmdList.end());
     EXPECT_EQ(cmdList.end(), itor);
 }
 

level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp

@@ -6,10 +6,12 @@
  */
 
 #include "shared/source/command_container/command_encoder.h"
+#include "shared/source/helpers/api_specific_config.h"
 #include "shared/source/helpers/preamble.h"
 #include "shared/source/helpers/register_offsets.h"
 #include "shared/source/os_interface/hw_info_config.h"
 #include "shared/test/common/cmd_parse/gen_cmd_parse.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
 #include "shared/test/common/helpers/unit_test_helper.h"
 #include "shared/test/common/test_macros/test.h"
 
@@ -192,7 +194,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandListAppendLaunchKernel, givenFunctionWhenBind
     auto cmd = genCmdCast<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(*itorMIDL);
     ASSERT_NE(cmd, nullptr);
 
-    auto dsh = commandList->commandContainer.getIndirectHeap(NEO::HeapType::DYNAMIC_STATE);
+    auto dsh = NEO::ApiSpecificConfig::getBindlessConfiguration() ? device->getNEODevice()->getBindlessHeapsHelper()->getHeap(BindlessHeapsHelper::GLOBAL_DSH) : commandList->commandContainer.getIndirectHeap(NEO::HeapType::DYNAMIC_STATE);
     auto idd = static_cast<INTERFACE_DESCRIPTOR_DATA *>(ptrOffset(dsh->getCpuBase(), cmd->getInterfaceDescriptorDataStartAddress()));
 
     if (NEO::EncodeSurfaceState<FamilyType>::doBindingTablePrefetch()) {
@@ -240,6 +242,10 @@ HWTEST_F(CommandListAppendLaunchKernel, givenKernelWithPrintfUsedWhenAppendedToC
 HWTEST_F(CommandListAppendLaunchKernel, WhenAppendingMultipleTimesThenSshIsNotDepletedButReallocated) {
     createKernel();
     ze_result_t returnValue;
+
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.UseBindlessMode.set(0);
+
     std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
     ze_group_count_t groupCount{1, 1, 1};
 

level_zero/core/test/unit_tests/sources/driver/test_driver.cpp

@@ -177,11 +177,12 @@ HWTEST_F(ImportNTHandle, givenNTHandleWhenCreatingDeviceMemoryThenSuccessIsRetur
     devProperties.pNext = &importNTHandle;
 
     NEO::MockDevice *neoDevice = nullptr;
-    neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
-    NEO::MemoryManager *prevMemoryManager = driverHandle->getMemoryManager();
-    NEO::MemoryManager *currMemoryManager = new MemoryManagerNTHandleMock(*neoDevice->executionEnvironment);
-    driverHandle->setMemoryManager(currMemoryManager);
-    neoDevice->injectMemoryManager(currMemoryManager);
+    auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(NEO::defaultHwInfo.get(), 0);
+    executionEnvironment->memoryManager.reset(new MemoryManagerNTHandleMock(*executionEnvironment));
+
+    neoDevice = NEO::MockDevice::createWithExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), executionEnvironment, 0);
+
+    driverHandle->setMemoryManager(executionEnvironment->memoryManager.get());
 
     ze_result_t result = ZE_RESULT_SUCCESS;
     auto device = L0::Device::create(driverHandle.get(), neoDevice, false, &result);
@@ -200,7 +201,6 @@ HWTEST_F(ImportNTHandle, givenNTHandleWhenCreatingDeviceMemoryThenSuccessIsRetur
     result = context->freeMem(ptr);
     EXPECT_EQ(result, ZE_RESULT_SUCCESS);
 
-    driverHandle->setMemoryManager(prevMemoryManager);
     delete device;
 }
 

level_zero/core/test/unit_tests/sources/image/test_image.cpp

@@ -394,11 +394,10 @@ HWTEST2_F(ImageCreate, givenNTHandleWhenCreatingImageThenSuccessIsReturned, IsAt
     desc.pNext = &importNTHandle;
 
     NEO::MockDevice *neoDevice = nullptr;
-    neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
-    NEO::MemoryManager *prevMemoryManager = driverHandle->getMemoryManager();
-    NEO::MemoryManager *currMemoryManager = new MemoryManagerNTHandleMock(*neoDevice->executionEnvironment);
-    driverHandle->setMemoryManager(currMemoryManager);
-    neoDevice->injectMemoryManager(currMemoryManager);
+    auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(NEO::defaultHwInfo.get(), 0);
+    executionEnvironment->memoryManager.reset(new MemoryManagerNTHandleMock(*executionEnvironment));
+    neoDevice = NEO::MockDevice::createWithExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), executionEnvironment, 0);
+    driverHandle->setMemoryManager(executionEnvironment->memoryManager.get());
 
     ze_result_t result = ZE_RESULT_SUCCESS;
     auto device = L0::Device::create(driverHandle.get(), neoDevice, false, &result);
@@ -410,16 +409,19 @@ HWTEST2_F(ImageCreate, givenNTHandleWhenCreatingImageThenSuccessIsReturned, IsAt
 
     imageHW.reset(nullptr);
     delete device;
-    driverHandle->setMemoryManager(prevMemoryManager);
 }
 
 class FailMemoryManagerMock : public NEO::OsAgnosticMemoryManager {
   public:
     FailMemoryManagerMock(NEO::ExecutionEnvironment &executionEnvironment) : NEO::OsAgnosticMemoryManager(executionEnvironment) {}
 
     NEO::GraphicsAllocation *allocateGraphicsMemoryWithProperties(const AllocationProperties &properties) override {
-        return nullptr;
+        if (fail) {
+            return nullptr;
+        }
+        return OsAgnosticMemoryManager::allocateGraphicsMemoryWithProperties(properties);
     }
+    bool fail = false;
 };
 
 HWTEST2_F(ImageCreate, givenImageDescWhenFailImageAllocationThenProperErrorIsReturned, IsAtLeastSkl) {
@@ -447,15 +449,17 @@ HWTEST2_F(ImageCreate, givenImageDescWhenFailImageAllocationThenProperErrorIsRet
     }
 
     NEO::MockDevice *neoDevice = nullptr;
-    neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
-    NEO::MemoryManager *currMemoryManager = new FailMemoryManagerMock(*neoDevice->executionEnvironment);
-    neoDevice->injectMemoryManager(currMemoryManager);
+    auto executionEnvironment = NEO::MockDevice::prepareExecutionEnvironment(NEO::defaultHwInfo.get(), 0);
+    auto failMemMngr = new FailMemoryManagerMock(*executionEnvironment);
+    executionEnvironment->memoryManager.reset(failMemMngr);
+    neoDevice = NEO::MockDevice::createWithExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), executionEnvironment, 0);
+    driverHandle->setMemoryManager(executionEnvironment->memoryManager.get());
 
     ze_result_t result = ZE_RESULT_SUCCESS;
     auto device = L0::Device::create(driverHandle.get(), neoDevice, false, &result);
 
-    L0::Image *imageHandle;
-
+    L0::Image *imageHandle = nullptr;
+    failMemMngr->fail = true;
     auto ret = L0::Image::create(neoDevice->getHardwareInfo().platform.eProductFamily, device, &desc, &imageHandle);
 
     ASSERT_EQ(ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, ret);

level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp

@@ -804,6 +804,7 @@ TEST_F(KernelImmutableDataTests, whenHasRTCallsIsTrueAndNoRTDispatchGlobalsIsAll
 
     immDataVector->push_back(std::move(mockKernelImmutableData));
 
+    neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->bindlessHeapsHelper.reset(nullptr);
     neoDevice->injectMemoryManager(currMemoryManager);
 
     EXPECT_EQ(ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY, kernel->initialize(&kernelDesc));

shared/source/command_container/command_encoder_bdw_and_later.inl

@@ -248,6 +248,7 @@ void EncodeMediaInterfaceDescriptorLoad<Family>::encode(CommandContainer &contai
     *mediaStateFlush = Family::cmdInitMediaStateFlush;
 
     auto iddOffset = static_cast<uint32_t>(ptrDiff(container.getIddBlock(), heapBase));
+
     iddOffset += ApiSpecificConfig::getBindlessConfiguration() ? static_cast<uint32_t>(container.getDevice()->getBindlessHeapsHelper()->getHeap(BindlessHeapsHelper::GLOBAL_DSH)->getGraphicsAllocation()->getGpuAddress() -
                                                                                        container.getDevice()->getBindlessHeapsHelper()->getHeap(BindlessHeapsHelper::GLOBAL_DSH)->getGraphicsAllocation()->getGpuBaseAddress())
                                                                : 0;