Add new function to CommandContainer returning indirectHeap

- returned heap allocatino will have required size
 and alignment

Change-Id: I3612036d5598770fbe74d047de214aedde65ff77
Signed-off-by: Mateusz Hoppe <[email protected]>

Author: HoppeMateusz

core/command_container/cmdcontainer.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 Intel Corporation
+ * Copyright (C) 2019-2020 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -110,4 +110,35 @@ void CommandContainer::reset() {
     }
 }
 
+IndirectHeap *CommandContainer::getHeapWithRequiredSizeAndAlignment(NEO::HeapType heapType, size_t sizeRequired, size_t alignment) {
+    auto indirectHeap = getIndirectHeap(heapType);
+    auto sizeRequested = sizeRequired;
+
+    auto heapBuffer = indirectHeap->getSpace(0);
+    if (alignment && (heapBuffer != alignUp(heapBuffer, alignment))) {
+        sizeRequested += alignment;
+    }
+
+    if (indirectHeap->getAvailableSpace() < sizeRequested) {
+        size_t newSize = indirectHeap->getUsed() + indirectHeap->getAvailableSpace();
+        newSize = alignUp(newSize, 4096U);
+        auto oldAlloc = getIndirectHeapAllocation(heapType);
+        auto newAlloc = getHeapHelper()->getHeapAllocation(heapType, newSize, 4096u, device->getRootDeviceIndex());
+        UNRECOVERABLE_IF(!oldAlloc);
+        UNRECOVERABLE_IF(!newAlloc);
+        indirectHeap->replaceGraphicsAllocation(newAlloc);
+        indirectHeap->replaceBuffer(newAlloc->getUnderlyingBuffer(),
+                                    newAlloc->getUnderlyingBufferSize());
+        getResidencyContainer().push_back(newAlloc);
+        getDeallocationContainer().push_back(oldAlloc);
+        setIndirectHeapAllocation(heapType, newAlloc);
+        setHeapDirty(heapType);
+    }
+
+    if (alignment) {
+        indirectHeap->align(alignment);
+    }
+    return indirectHeap;
+}
+
 } // namespace NEO

core/command_container/cmdcontainer.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019 Intel Corporation
+ * Copyright (C) 2019-2020 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -63,6 +63,8 @@ class CommandContainer : public NonCopyableOrMovableClass {
 
     Device *getDevice() const { return device; }
 
+    IndirectHeap *getHeapWithRequiredSizeAndAlignment(NEO::HeapType heapType, size_t sizeRequired, size_t alignment);
+
     void reset();
 
     bool isHeapDirty(HeapType heapType) const { return (dirtyHeaps & (1u << heapType)); }

core/unit_tests/command_container/command_container_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2019 Intel Corporation
+ * Copyright (C) 2017-2020 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -187,3 +187,102 @@ TEST_F(CommandContainerTest, givenCommandContainerWhenWantToAddAleradyAddedAlloc
 
     EXPECT_EQ(sizeAfterFirstAdd, sizeAfterSecondAdd);
 }
+
+TEST_F(CommandContainerTest, givenAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenExistingAllocationIsReturned) {
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
+    auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
+    auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
+
+    const size_t sizeRequested = 32;
+    const size_t alignment = 32;
+
+    EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
+
+    auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
+    auto newAllocation = heapRequested->getGraphicsAllocation();
+
+    EXPECT_EQ(heap, heapRequested);
+    EXPECT_EQ(heapAllocation, newAllocation);
+
+    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
+    EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+}
+
+TEST_F(CommandContainerTest, givenUnalignedAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenHeapReturnedIsCorrectlyAligned) {
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
+    auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
+    auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
+
+    const size_t sizeRequested = 32;
+    const size_t alignment = 32;
+
+    heap->getSpace(sizeRequested / 2);
+
+    EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
+
+    auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
+    auto newAllocation = heapRequested->getGraphicsAllocation();
+
+    EXPECT_EQ(heap, heapRequested);
+    EXPECT_EQ(heapAllocation, newAllocation);
+
+    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
+    EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+}
+
+TEST_F(CommandContainerTest, givenNoAlignmentAndAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenHeapReturnedIsNotAligned) {
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
+    auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
+    auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
+
+    const size_t sizeRequested = 32;
+    const size_t alignment = 0;
+
+    heap->getSpace(sizeRequested / 2);
+
+    EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
+
+    auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
+    auto newAllocation = heapRequested->getGraphicsAllocation();
+
+    EXPECT_EQ(heap, heapRequested);
+    EXPECT_EQ(heapAllocation, newAllocation);
+
+    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (sizeRequested / 2)) == sizeRequested / 2);
+    EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+}
+
+TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenNewAllocationIsReturned) {
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
+    auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
+    auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
+
+    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(HeapType::SURFACE_STATE, sizeRequested, alignment);
+    auto newAllocation = heapRequested->getGraphicsAllocation();
+
+    EXPECT_EQ(heap, heapRequested);
+    EXPECT_NE(heapAllocation, newAllocation);
+
+    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
+    EXPECT_TRUE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+
+    for (auto deallocation : cmdContainer->getDeallocationContainer()) {
+        cmdContainer->getDevice()->getMemoryManager()->freeGraphicsMemory(deallocation);
+    }
+}