Create dedicated allocation for global fence purposes

smilczar · Compute-Runtime-Automation · commit 8560b2b26288 · 2020-02-07T10:50:47.000+01:00
Related-To: NEO-3216

Change-Id: I0483a99ea1095c7a10b1318f51569e479386cac4
Signed-off-by: Milczarek, Slawomir &lt;slawomir.milczarek@intel.com&gt;
diff --git a/core/memory_manager/graphics_allocation.h b/core/memory_manager/graphics_allocation.h
@@ -79,6 +79,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
         SVM_GPU,
         SVM_ZERO_COPY,
         TAG_BUFFER,
+        GLOBAL_FENCE,
         TIMESTAMP_PACKET_TAG_BUFFER,
         WRITE_COMBINED
     };
diff --git a/runtime/command_stream/command_stream_receiver.cpp b/runtime/command_stream/command_stream_receiver.cpp
@@ -178,6 +178,11 @@ void CommandStreamReceiver::cleanupResources() {
         tagAddress = nullptr;
     }
 
+    if (globalFenceAllocation) {
+        getMemoryManager()->freeGraphicsMemory(globalFenceAllocation);
+        globalFenceAllocation = nullptr;
+    }
+
     if (preemptionAllocation) {
         getMemoryManager()->freeGraphicsMemory(preemptionAllocation);
         preemptionAllocation = nullptr;
@@ -379,6 +384,15 @@ bool CommandStreamReceiver::initializeTagAllocation() {
     return true;
 }
 
+bool CommandStreamReceiver::createGlobalFenceAllocation() {
+    if (!localMemoryEnabled) {
+        return true;
+    }
+    DEBUG_BREAK_IF(this->globalFenceAllocation != nullptr);
+    this->globalFenceAllocation = getMemoryManager()->allocateGraphicsMemoryWithProperties({rootDeviceIndex, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::GLOBAL_FENCE});
+    return this->globalFenceAllocation != nullptr;
+}
+
 bool CommandStreamReceiver::createPreemptionAllocation() {
     auto hwInfo = executionEnvironment.getHardwareInfo();
     AllocationProperties properties{rootDeviceIndex, true, hwInfo->capabilityTable.requiredPreemptionSurfaceSize, GraphicsAllocation::AllocationType::PREEMPTION, false};
diff --git a/runtime/command_stream/command_stream_receiver.h b/runtime/command_stream/command_stream_receiver.h
@@ -149,6 +149,7 @@ class CommandStreamReceiver {
     void setExperimentalCmdBuffer(std::unique_ptr<ExperimentalCommandBuffer> &&cmdBuffer);
 
     bool initializeTagAllocation();
+    MOCKABLE_VIRTUAL bool createGlobalFenceAllocation();
     MOCKABLE_VIRTUAL bool createPreemptionAllocation();
     MOCKABLE_VIRTUAL bool createPerDssBackedBuffer(Device &device);
     MOCKABLE_VIRTUAL std::unique_lock<MutexType> obtainUniqueOwnership();
@@ -216,6 +217,7 @@ class CommandStreamReceiver {
     volatile uint32_t *tagAddress = nullptr;
 
     GraphicsAllocation *tagAllocation = nullptr;
+    GraphicsAllocation *globalFenceAllocation = nullptr;
     GraphicsAllocation *preemptionAllocation = nullptr;
     GraphicsAllocation *debugSurface = nullptr;
     GraphicsAllocation *perDssBackedBuffer = nullptr;
diff --git a/runtime/command_stream/command_stream_receiver_hw_base.inl b/runtime/command_stream/command_stream_receiver_hw_base.inl
@@ -385,8 +385,13 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
 
     this->makeResident(*tagAllocation);
 
-    if (preemptionAllocation)
+    if (globalFenceAllocation) {
+        makeResident(*globalFenceAllocation);
+    }
+
+    if (preemptionAllocation) {
         makeResident(*preemptionAllocation);
+    }
 
     if (dispatchFlags.preemptionMode == PreemptionMode::MidThread || device.isSourceLevelDebuggerActive()) {
         makeResident(*SipKernel::getSipKernelAllocation(device));
diff --git a/runtime/device/device.cpp b/runtime/device/device.cpp
@@ -140,6 +140,11 @@ bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engine
     if (!commandStreamReceiver->initializeTagAllocation()) {
         return false;
     }
+
+    if (!commandStreamReceiver->createGlobalFenceAllocation()) {
+        return false;
+    }
+
     if (engineType == defaultEngineType && !lowPriority && !internalUsage) {
         defaultEngineIndex = deviceCsrIndex;
     }
diff --git a/runtime/device/root_device.cpp b/runtime/device/root_device.cpp
@@ -105,6 +105,7 @@ void RootDevice::initializeRootCommandStreamReceiver() {
 
     rootCommandStreamReceiver->setupContext(*osContext);
     rootCommandStreamReceiver->initializeTagAllocation();
+    rootCommandStreamReceiver->createGlobalFenceAllocation();
     commandStreamReceivers.push_back(std::move(rootCommandStreamReceiver));
     engines.emplace_back(commandStreamReceivers.back().get(), osContext);
 }
diff --git a/runtime/memory_manager/memory_manager.cpp b/runtime/memory_manager/memory_manager.cpp
@@ -280,6 +280,7 @@ bool MemoryManager::getAllocationData(AllocationData &allocationData, const Allo
     case GraphicsAllocation::AllocationType::SVM_CPU:
     case GraphicsAllocation::AllocationType::SVM_ZERO_COPY:
     case GraphicsAllocation::AllocationType::TAG_BUFFER:
+    case GraphicsAllocation::AllocationType::GLOBAL_FENCE:
     case GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY:
         allocationData.flags.useSystemMemory = true;
     default:
diff --git a/runtime/utilities/logger.cpp b/runtime/utilities/logger.cpp
@@ -315,6 +315,8 @@ const char *FileLogger<DebugLevel>::getAllocationTypeString(GraphicsAllocation c
         return "SVM_ZERO_COPY";
     case GraphicsAllocation::AllocationType::TAG_BUFFER:
         return "TAG_BUFFER";
+    case GraphicsAllocation::AllocationType::GLOBAL_FENCE:
+        return "GLOBAL_FENCE";
     case GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER:
         return "TIMESTAMP_PACKET_TAG_BUFFER";
     case GraphicsAllocation::AllocationType::UNKNOWN:
diff --git a/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp b/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp
@@ -444,6 +444,25 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, handleTagAndScratchAllocationsResi
     EXPECT_TRUE(commandStreamReceiver->isMadeNonResident(scratchAllocation));
 }
 
+HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCommandStreamReceiverWhenLocalMemoryIsEnabledAndFlushTaskIsCalledThenGlobalFenceAlocationIsMadeResident) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.EnableLocalMemory.set(true);
+
+    auto commandStreamReceiver = new MockCsrHw<FamilyType>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
+    pDevice->resetCommandStreamReceiver(commandStreamReceiver);
+
+    auto globalFenceAllocation = commandStreamReceiver->globalFenceAllocation;
+    ASSERT_NE(globalFenceAllocation, nullptr);
+
+    EXPECT_FALSE(commandStreamReceiver->isMadeResident(globalFenceAllocation));
+    EXPECT_FALSE(commandStreamReceiver->isMadeNonResident(globalFenceAllocation));
+
+    flushTask(*commandStreamReceiver);
+
+    EXPECT_TRUE(commandStreamReceiver->isMadeResident(globalFenceAllocation));
+    EXPECT_TRUE(commandStreamReceiver->isMadeNonResident(globalFenceAllocation));
+}
+
 struct MockScratchController : public ScratchSpaceController {
     using ScratchSpaceController::privateScratchAllocation;
     using ScratchSpaceController::scratchAllocation;
diff --git a/unit_tests/command_stream/command_stream_receiver_tests.cpp b/unit_tests/command_stream/command_stream_receiver_tests.cpp
@@ -363,6 +363,19 @@ TEST(CommandStreamReceiverSimpleTest, givenCommandStreamReceiverWhenInitializeTa
     EXPECT_EQ(*csr->getTagAddress(), initialHardwareTag);
 }
 
+HWTEST_F(CommandStreamReceiverTest, givenCommandStreamReceiverWhenLocalMemoryIsEnabledAndCreateGlobalFenceAllocationIsCalledThenGlobalFenceAllocationIsAllocated) {
+    DebugManagerStateRestore dbgRestore;
+    DebugManager.flags.EnableLocalMemory.set(true);
+
+    MockCsrHw<FamilyType> csr(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex());
+    EXPECT_EQ(nullptr, csr.globalFenceAllocation);
+
+    EXPECT_TRUE(csr.createGlobalFenceAllocation());
+
+    ASSERT_NE(nullptr, csr.globalFenceAllocation);
+    EXPECT_EQ(GraphicsAllocation::AllocationType::GLOBAL_FENCE, csr.globalFenceAllocation->getAllocationType());
+}
+
 TEST(CommandStreamReceiverSimpleTest, givenNullHardwareDebugModeWhenInitializeTagAllocationIsCalledThenTagAllocationIsBeingAllocatedAndinitialValueIsMinusOne) {
     DebugManagerStateRestore dbgRestore;
     DebugManager.flags.EnableNullHardware.set(true);
diff --git a/unit_tests/device/device_tests.cpp b/unit_tests/device/device_tests.cpp
@@ -304,6 +304,29 @@ HWTEST_F(DeviceHwTest, givenHwHelperInputWhenInitializingCsrThenCreatePageTableM
     EXPECT_EQ(csr2.needsPageTableManager(defaultEngineType), csr2.createPageTableManagerCalled);
 }
 
+HWTEST_F(DeviceHwTest, givenDeviceCreationWhenCsrFailsToCreateGlobalSyncAllocationThenReturnNull) {
+    class MockUltCsrThatFailsToCreateGlobalFenceAllocation : public UltCommandStreamReceiver<FamilyType> {
+      public:
+        MockUltCsrThatFailsToCreateGlobalFenceAllocation(ExecutionEnvironment &executionEnvironment)
+            : UltCommandStreamReceiver<FamilyType>(executionEnvironment, 0) {}
+        bool createGlobalFenceAllocation() override {
+            return false;
+        }
+    };
+    class MockDeviceThatFailsToCreateGlobalFenceAllocation : public MockDevice {
+      public:
+        MockDeviceThatFailsToCreateGlobalFenceAllocation(ExecutionEnvironment *executionEnvironment, uint32_t deviceIndex)
+            : MockDevice(executionEnvironment, deviceIndex) {}
+        std::unique_ptr<CommandStreamReceiver> createCommandStreamReceiver() const override {
+            return std::make_unique<MockUltCsrThatFailsToCreateGlobalFenceAllocation>(*executionEnvironment);
+        }
+    };
+
+    auto executionEnvironment = platform()->peekExecutionEnvironment();
+    auto mockDevice(MockDevice::create<MockDeviceThatFailsToCreateGlobalFenceAllocation>(executionEnvironment, 0));
+    EXPECT_EQ(nullptr, mockDevice);
+}
+
 TEST(DeviceGenEngineTest, givenHwCsrModeWhenGetEngineThenDedicatedForInternalUsageEngineIsReturned) {
     auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<Device>(nullptr));
 
diff --git a/unit_tests/libult/ult_command_stream_receiver.h b/unit_tests/libult/ult_command_stream_receiver.h
@@ -46,6 +46,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
     using BaseClass::CommandStreamReceiver::executionEnvironment;
     using BaseClass::CommandStreamReceiver::experimentalCmdBuffer;
     using BaseClass::CommandStreamReceiver::flushStamp;
+    using BaseClass::CommandStreamReceiver::globalFenceAllocation;
     using BaseClass::CommandStreamReceiver::GSBAFor32BitProgrammed;
     using BaseClass::CommandStreamReceiver::internalAllocationStorage;
     using BaseClass::CommandStreamReceiver::isEnginePrologueSent;
diff --git a/unit_tests/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl b/unit_tests/memory_manager/memory_manager_allocate_in_preferred_pool_tests.inl
@@ -428,6 +428,14 @@ TEST(MemoryManagerTest, givenTagBufferTypeWhenGetAllocationDataIsCalledThenSyste
     EXPECT_TRUE(allocData.flags.useSystemMemory);
 }
 
+TEST(MemoryManagerTest, givenGlobalFenceTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
+    AllocationData allocData;
+    MockMemoryManager mockMemoryManager;
+    AllocationProperties properties{0, 1, GraphicsAllocation::AllocationType::GLOBAL_FENCE};
+    MockMemoryManager::getAllocationData(allocData, properties, nullptr, mockMemoryManager.createStorageInfoFromProperties(properties));
+    EXPECT_TRUE(allocData.flags.useSystemMemory);
+}
+
 TEST(MemoryManagerTest, givenPreemptionTypeWhenGetAllocationDataIsCalledThenSystemMemoryIsRequested) {
     AllocationData allocData;
     MockMemoryManager mockMemoryManager;
diff --git a/unit_tests/mocks/mock_csr.h b/unit_tests/mocks/mock_csr.h
@@ -243,6 +243,7 @@ class MockFlatBatchBufferHelper : public FlatBatchBufferHelperHw<GfxFamily> {
 class MockCommandStreamReceiver : public CommandStreamReceiver {
   public:
     using CommandStreamReceiver::CommandStreamReceiver;
+    using CommandStreamReceiver::globalFenceAllocation;
     using CommandStreamReceiver::internalAllocationStorage;
     using CommandStreamReceiver::latestFlushedTaskCount;
     using CommandStreamReceiver::latestSentTaskCount;
diff --git a/unit_tests/mocks/mock_device.cpp b/unit_tests/mocks/mock_device.cpp
@@ -101,6 +101,7 @@ void MockDevice::resetCommandStreamReceiver(CommandStreamReceiver *newCsr, uint3
     newCsr->setupContext(*osContext);
     commandStreamReceivers[engineIndex].reset(newCsr);
     commandStreamReceivers[engineIndex]->initializeTagAllocation();
+    commandStreamReceivers[engineIndex]->createGlobalFenceAllocation();
 
     if (preemptionMode == PreemptionMode::MidThread || isSourceLevelDebuggerActive()) {
         commandStreamReceivers[engineIndex]->createPreemptionAllocation();
diff --git a/unit_tests/utilities/file_logger_tests.cpp b/unit_tests/utilities/file_logger_tests.cpp
@@ -941,6 +941,7 @@ AllocationTypeTestCase allocationTypeValues[] = {
     {GraphicsAllocation::AllocationType::SVM_GPU, "SVM_GPU"},
     {GraphicsAllocation::AllocationType::SVM_ZERO_COPY, "SVM_ZERO_COPY"},
     {GraphicsAllocation::AllocationType::TAG_BUFFER, "TAG_BUFFER"},
+    {GraphicsAllocation::AllocationType::GLOBAL_FENCE, "GLOBAL_FENCE"},
     {GraphicsAllocation::AllocationType::TIMESTAMP_PACKET_TAG_BUFFER, "TIMESTAMP_PACKET_TAG_BUFFER"},
     {GraphicsAllocation::AllocationType::UNKNOWN, "UNKNOWN"},
     {GraphicsAllocation::AllocationType::WRITE_COMBINED, "WRITE_COMBINED"}};

Original file line number	Diff line number	Diff line change
`@@ -140,6 +140,11 @@ bool Device::createEngine(uint32_t deviceCsrIndex, aub_stream::EngineType engine`
`140`	`140`	`if (!commandStreamReceiver->initializeTagAllocation()) {`
`141`	`141`	`return false;`
`142`	`142`	`}`
	`143`	`+`
	`144`	`+ if (!commandStreamReceiver->createGlobalFenceAllocation()) {`
	`145`	`+ return false;`
	`146`	`+ }`
	`147`	`+`
`143`	`148`	`if (engineType == defaultEngineType && !lowPriority && !internalUsage) {`
`144`	`149`	`defaultEngineIndex = deviceCsrIndex;`
`145`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,7 @@ void RootDevice::initializeRootCommandStreamReceiver() {`
`105`	`105`
`106`	`106`	`rootCommandStreamReceiver->setupContext(*osContext);`
`107`	`107`	`rootCommandStreamReceiver->initializeTagAllocation();`
	`108`	`+ rootCommandStreamReceiver->createGlobalFenceAllocation();`
`108`	`109`	`commandStreamReceivers.push_back(std::move(rootCommandStreamReceiver));`
`109`	`110`	`engines.emplace_back(commandStreamReceivers.back().get(), osContext);`
`110`	`111`	`}`