Fix reset border color offset when replacing heap buffer

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

Author: MaciejPlewka

opencl/test/unit_test/command_queue/command_queue_tests.cpp

@@ -571,6 +571,19 @@ TEST_P(CommandQueueIndirectHeapTest, WhenGettingIndirectHeapWithNewSizeThenMaxAv
     }
 }
 
+TEST_P(CommandQueueIndirectHeapTest, WhenGettingIndirectHeapWithNewSizeThenBorderColorOffsetIsSetToMaxUint) {
+    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
+    MockCommandQueue cmdQ(context.get(), pClDevice, props);
+
+    auto &indirectHeapInitial = cmdQ.getIndirectHeap(this->GetParam(), 10);
+    indirectHeapInitial.setBorderColor(nullptr, 0);
+    EXPECT_NE(indirectHeapInitial.getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+    size_t requiredSize = indirectHeapInitial.getMaxAvailableSpace() + 42;
+
+    const auto &indirectHeap = cmdQ.getIndirectHeap(this->GetParam(), requiredSize);
+    EXPECT_EQ(indirectHeap.getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+}
+
 TEST_P(CommandQueueIndirectHeapTest, WhenGettingIndirectHeapThenSizeIsAlignedToCacheLine) {
     const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
     MockCommandQueue cmdQ(context.get(), pClDevice, props);
@@ -707,6 +720,27 @@ TEST_P(CommandQueueIndirectHeapTest, GivenCommandQueueWithHeapAllocatedWhenIndir
     EXPECT_EQ(0u, indirectHeap.getMaxAvailableSpace());
 }
 
+TEST_P(CommandQueueIndirectHeapTest, GivenCommandQueueWithHeapAllocatedWhenIndirectHeapIsReleasedThenBorderColorOffsetResetWasCalled) {
+    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
+    MockCommandQueue cmdQ(context.get(), pClDevice, props);
+
+    EXPECT_TRUE(pDevice->getDefaultEngine().commandStreamReceiver->getAllocationsForReuse().peekIsEmpty());
+
+    const auto &indirectHeap = cmdQ.getIndirectHeap(this->GetParam(), 100);
+    auto heapSize = indirectHeap.getMaxAvailableSpace();
+
+    EXPECT_NE(0u, heapSize);
+
+    auto graphicsAllocation = indirectHeap.getGraphicsAllocation();
+    EXPECT_NE(nullptr, graphicsAllocation);
+
+    auto &csr = pDevice->getUltCommandStreamReceiver<DEFAULT_TEST_FAMILY_NAME>();
+    csr.indirectHeap[this->GetParam()]->setBorderColor(nullptr, 0);
+    EXPECT_NE(csr.indirectHeap[this->GetParam()]->getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+    cmdQ.releaseIndirectHeap(this->GetParam());
+    EXPECT_EQ(csr.indirectHeap[this->GetParam()]->getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+}
+
 TEST_P(CommandQueueIndirectHeapTest, GivenCommandQueueWithoutHeapAllocatedWhenIndirectHeapIsReleasedThenIndirectHeapAllocationStaysNull) {
     const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
     MockCommandQueue cmdQ(context.get(), pClDevice, props);

shared/source/command_container/cmdcontainer.cpp

@@ -203,6 +203,7 @@ IndirectHeap *CommandContainer::getHeapWithRequiredSizeAndAlignment(HeapType hea
         getResidencyContainer().push_back(newAlloc);
         getDeallocationContainer().push_back(oldAlloc);
         setIndirectHeapAllocation(heapType, newAlloc);
+        indirectHeap->resetBorderColorOffset();
         if (oldBase != newBase) {
             setHeapDirty(heapType);
         }

shared/source/command_stream/command_stream_receiver.cpp

@@ -420,6 +420,7 @@ void CommandStreamReceiver::allocateHeapMemory(IndirectHeap::Type heapType,
     if (indirectHeap) {
         indirectHeap->replaceBuffer(heapMemory->getUnderlyingBuffer(), finalHeapSize);
         indirectHeap->replaceGraphicsAllocation(heapMemory);
+        indirectHeap->resetBorderColorOffset();
     } else {
         indirectHeap = new IndirectHeap(heapMemory, requireInternalHeap);
         indirectHeap->overrideMaxSize(finalHeapSize);
@@ -437,6 +438,7 @@ void CommandStreamReceiver::releaseIndirectHeap(IndirectHeap::Type heapType) {
             internalAllocationStorage->storeAllocation(std::unique_ptr<GraphicsAllocation>(heapMemory), REUSABLE_ALLOCATION);
         heap->replaceBuffer(nullptr, 0);
         heap->replaceGraphicsAllocation(nullptr);
+        heap->resetBorderColorOffset();
     }
 }
 

shared/source/indirect_heap/indirect_heap.h

@@ -47,6 +47,7 @@ class IndirectHeap : public LinearStream {
     uint32_t getHeapSizeInPages() const;
     uint32_t getBorderColorOffset() const;
     void setBorderColor(void *borderColor, size_t size);
+    void resetBorderColorOffset();
 
   protected:
     bool canBeUtilizedAs4GbHeap = false;
@@ -90,4 +91,7 @@ inline void IndirectHeap::setBorderColor(void *borderColor, size_t size) {
     auto ptr = getSpace(size);
     memcpy_s(ptr, size, borderColor, size);
 }
+inline void IndirectHeap::resetBorderColorOffset() {
+    borderColorOffset = std::numeric_limits<uint32_t>::max();
+}
 } // namespace NEO

shared/test/unit_test/command_container/command_container_tests.cpp

@@ -367,6 +367,33 @@ TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenGetHeapWithRequiredSizeAndAl
     cmdContainer->getDeallocationContainer().clear();
 }
 
+TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenBorderColorOffestHasBeenReset) {
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
+    HeapType types[] = {HeapType::SURFACE_STATE,
+                        HeapType::DYNAMIC_STATE};
+
+    for (auto type : types) {
+        auto heap = cmdContainer->getIndirectHeap(type);
+        heap->setBorderColor(nullptr, 0);
+        EXPECT_NE(heap->getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+        const size_t sizeRequested = 32;
+        const size_t alignment = 32;
+        size_t availableSize = heap->getAvailableSpace();
+
+        heap->getSpace(availableSize - sizeRequested / 2);
+
+        EXPECT_LT(heap->getAvailableSpace(), sizeRequested + alignment);
+        auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, sizeRequested, alignment);
+        EXPECT_EQ(heapRequested->getBorderColorOffset(), std::numeric_limits<uint32_t>::max());
+    }
+    for (auto deallocation : cmdContainer->getDeallocationContainer()) {
+        cmdContainer->getDevice()->getMemoryManager()->freeGraphicsMemory(deallocation);
+    }
+    cmdContainer->getDeallocationContainer().clear();
+}
+
 TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenCreatedAlocationHaveDifferentBaseThenHeapIsDirty) {
     std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
     cmdContainer->initialize(pDevice);