Reserve SSH space for bindless mode

HoppeMateusz · Compute-Runtime-Automation · commit ca39301ed83c · 2020-07-17T13:26:28.000+02:00
Related-To: NEO-4767

Change-Id: Id7876ea5a5a4fc12ab0b3192548b006fc1eea75c
Signed-off-by: Mateusz Hoppe &lt;mateusz.hoppe@intel.com&gt;
diff --git a/opencl/source/command_queue/hardware_interface_base.inl b/opencl/source/command_queue/hardware_interface_base.inl
@@ -257,6 +257,9 @@ void HardwareInterface<GfxFamily>::obtainIndirectHeaps(CommandQueue &commandQueu
     } else {
         if (parentKernel && (commandQueue.getIndirectHeap(IndirectHeap::SURFACE_STATE, 0).getUsed() > 0)) {
             commandQueue.releaseIndirectHeap(IndirectHeap::SURFACE_STATE);
+            // clean reserved bindless offsets
+            ssh = &getIndirectHeap<GfxFamily, IndirectHeap::SURFACE_STATE>(commandQueue, multiDispatchInfo);
+            ssh->replaceBuffer(ssh->getCpuBase(), ssh->getMaxAvailableSpace());
         }
         dsh = &getIndirectHeap<GfxFamily, IndirectHeap::DYNAMIC_STATE>(commandQueue, multiDispatchInfo);
         ioh = &getIndirectHeap<GfxFamily, IndirectHeap::INDIRECT_OBJECT>(commandQueue, multiDispatchInfo);
diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_tests.cpp
@@ -251,6 +251,20 @@ HWTEST_F(CommandStreamReceiverTest, givenCsrWhenAllocateHeapMemoryIsCalledThenHe
     delete dsh;
 }
 
+HWTEST_F(CommandStreamReceiverTest, givenSurfaceStateHeapTypeWhenAllocateHeapMemoryIsCalledThenSSHHasInitialSpaceReserevedForBindlessOffsets) {
+    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
+    IndirectHeap *ssh = nullptr;
+    csr.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh);
+    EXPECT_NE(nullptr, ssh);
+    ASSERT_NE(nullptr, ssh->getGraphicsAllocation());
+
+    auto sshReservedSize = UnitTestHelper<FamilyType>::getDefaultSshUsage();
+    EXPECT_EQ(sshReservedSize, ssh->getUsed());
+
+    csr.getMemoryManager()->freeGraphicsMemory(ssh->getGraphicsAllocation());
+    delete ssh;
+}
+
 TEST(CommandStreamReceiverSimpleTest, givenCsrWithoutTagAllocationWhenGetTagAllocationIsCalledThenNullptrIsReturned) {
     MockExecutionEnvironment executionEnvironment;
     executionEnvironment.prepareRootDeviceEnvironments(1);
diff --git a/opencl/test/unit_test/execution_model/enqueue_execution_model_kernel_tests.cpp b/opencl/test/unit_test/execution_model/enqueue_execution_model_kernel_tests.cpp
@@ -282,6 +282,25 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenParentKernelWhenEnqueu
     }
 }
 
+HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenParentKernelAndNotUsedSSHWhenEnqueuedThenSSHIsNotReallocated) {
+    if (std::string(pPlatform->getClDevice(0)->getDeviceInfo().clVersion).find("OpenCL 2.") != std::string::npos) {
+
+        const size_t globalOffsets[3] = {0, 0, 0};
+        const size_t workItems[3] = {1, 1, 1};
+
+        pKernel->createReflectionSurface();
+        MockMultiDispatchInfo multiDispatchInfo(pKernel);
+
+        auto ssh = &getIndirectHeap<FamilyType, IndirectHeap::SURFACE_STATE>(*pCmdQ, multiDispatchInfo);
+        ssh->replaceBuffer(ssh->getCpuBase(), ssh->getMaxAvailableSpace());
+
+        pCmdQ->enqueueKernel(pKernel, 1, globalOffsets, workItems, workItems, 0, nullptr, nullptr);
+        auto ssh2 = &getIndirectHeap<FamilyType, IndirectHeap::SURFACE_STATE>(*pCmdQ, multiDispatchInfo);
+        EXPECT_EQ(ssh, ssh2);
+        EXPECT_EQ(ssh->getGraphicsAllocation(), ssh2->getGraphicsAllocation());
+    }
+}
+
 HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenParentKernelWhenEnqueuedThenBlocksSurfaceStatesAreCopied) {
     using BINDING_TABLE_STATE = typename FamilyType::BINDING_TABLE_STATE;
     using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
@@ -307,10 +326,10 @@ HWCMDTEST_P(IGFX_GEN8_CORE, ParentKernelEnqueueTest, givenParentKernelWhenEnqueu
         // will be coies
         ssh->align(BINDING_TABLE_STATE::SURFACESTATEPOINTER_ALIGN_SIZE);
 
-        // mark the assumed place for surface states
-        size_t parentSshOffset = ssh->getUsed();
-
         pCmdQ->enqueueKernel(pKernel, 1, globalOffsets, workItems, workItems, 0, nullptr, nullptr);
+        // mark the assumed place for surface states
+        size_t parentSshOffset = 0;
+        ssh = &getIndirectHeap<FamilyType, IndirectHeap::SURFACE_STATE>(*pCmdQ, multiDispatchInfo);
 
         void *blockSSH = ptrOffset(ssh->getCpuBase(), parentSshOffset + parentKernelSSHSize); // note : unaligned at this point
 
diff --git a/opencl/test/unit_test/execution_model/parent_kernel_dispatch_tests.cpp b/opencl/test/unit_test/execution_model/parent_kernel_dispatch_tests.cpp
@@ -371,7 +371,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, MockParentKernelDispatch, GivenUsedSSHHeapWhenParent
             nullptr,
             CL_COMMAND_NDRANGE_KERNEL);
 
-        EXPECT_EQ(UnitTestHelper<FamilyType>::getDefaultSshUsage(), ssh.getUsed());
+        EXPECT_EQ(0u, ssh.getUsed());
 
         delete mockParentKernel;
     }
diff --git a/opencl/test/unit_test/execution_model/submit_blocked_parent_kernel_tests.cpp b/opencl/test/unit_test/execution_model/submit_blocked_parent_kernel_tests.cpp
@@ -297,7 +297,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenParentKernelWh
     delete parentKernel;
 }
 
-HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenUsedCommandQueueHeapshenParentKernelIsSubmittedThenQueueHeapsAreNotUsed) {
+HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenUsedCommandQueueHeapsWhenParentKernelIsSubmittedThenQueueHeapsAreNotUsed) {
     REQUIRE_DEVICE_ENQUEUE_OR_SKIP(device);
 
     cl_queue_properties properties[3] = {0};
@@ -330,6 +330,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenUsedCommandQue
     queueDsh.getSpace(usedSize);
     queueIoh.getSpace(usedSize);
 
+    auto intialSshUsed = queueSsh.getUsed();
+
     auto cmdStreamAllocation = device->getMemoryManager()->allocateGraphicsMemoryWithProperties({device->getRootDeviceIndex(), 4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER, device->getDeviceBitfield()});
     auto blockedCommandData = std::make_unique<KernelOperation>(new LinearStream(cmdStreamAllocation),
                                                                 *pCmdQ->getGpgpuCommandStreamReceiver().getInternalAllocationStorage());
@@ -345,7 +347,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenUsedCommandQue
     EXPECT_FALSE(cmdQ.releaseIndirectHeapCalled);
     EXPECT_EQ(usedSize, queueDsh.getUsed());
     EXPECT_EQ(usedSize, queueIoh.getUsed());
-    EXPECT_EQ(usedSize, queueSsh.getUsed());
+    EXPECT_EQ(intialSshUsed, queueSsh.getUsed());
 
     delete cmdComputeKernel;
     delete parentKernel;
@@ -372,8 +374,6 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ParentKernelCommandQueueFixture, givenNotUsedSSHWhen
     pCmdQ->allocateHeapMemory(IndirectHeap::SURFACE_STATE, sshSize, ssh);
     dsh->getSpace(mockDevQueue.getDshOffset());
 
-    EXPECT_EQ(0u, ssh->getUsed());
-
     pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, sshSize);
 
     void *sshBuffer = pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0u).getCpuBase();
diff --git a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp
@@ -614,6 +614,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenSendingIndirectStateThenBi
     auto &ioh = cmdQ.getIndirectHeap(IndirectHeap::INDIRECT_OBJECT, 8192);
     auto &ssh = cmdQ.getIndirectHeap(IndirectHeap::SURFACE_STATE, 8192);
 
+    auto sshUsed = ssh.getUsed();
+
     // Obtain where the pointers will be stored
     const auto &kernelInfo = kernel->getKernelInfo();
     auto numSurfaceStates = kernelInfo.patchInfo.statelessGlobalMemObjKernelArgs.size() +
@@ -648,8 +650,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenSendingIndirectStateThenBi
         nullptr,
         true);
 
-    EXPECT_EQ(0x00000000u, *(&bindingTableStatesPointers[0]));
-    EXPECT_EQ(0x00000040u, *(&bindingTableStatesPointers[1]));
+    EXPECT_EQ(sshUsed + 0x00000000u, *(&bindingTableStatesPointers[0]));
+    EXPECT_EQ(sshUsed + 0x00000040u, *(&bindingTableStatesPointers[1]));
 }
 
 HWCMDTEST_F(IGFX_GEN8_CORE, HardwareCommandsTest, WhenGettingBindingTableStateThenSurfaceStatePointersAreCorrect) {
diff --git a/opencl/test/unit_test/helpers/unit_test_helper.inl b/opencl/test/unit_test/helpers/unit_test_helper.inl
@@ -37,7 +37,7 @@ bool UnitTestHelper<GfxFamily>::isExpectMemoryNotEqualSupported() {
 
 template <typename GfxFamily>
 uint32_t UnitTestHelper<GfxFamily>::getDefaultSshUsage() {
-    return 0;
+    return sizeof(typename GfxFamily::RENDER_SURFACE_STATE);
 }
 
 template <typename GfxFamily>
diff --git a/shared/source/command_container/cmdcontainer.cpp b/shared/source/command_container/cmdcontainer.cpp
@@ -13,6 +13,7 @@
 #include "shared/source/device/device.h"
 #include "shared/source/helpers/debug_helpers.h"
 #include "shared/source/helpers/heap_helper.h"
+#include "shared/source/helpers/hw_helper.h"
 #include "shared/source/indirect_heap/indirect_heap.h"
 #include "shared/source/memory_manager/memory_manager.h"
 
@@ -84,6 +85,8 @@ bool CommandContainer::initialize(Device *device) {
 
     instructionHeapBaseAddress = device->getMemoryManager()->getInternalHeapBaseAddress(device->getRootDeviceIndex(), allocationIndirectHeaps[IndirectHeap::Type::INDIRECT_OBJECT]->isAllocatedInLocalMemoryPool());
 
+    reserveBindlessOffsets(*indirectHeaps[IndirectHeap::Type::SURFACE_STATE]);
+
     iddBlock = nullptr;
     nextIddInBlock = this->getNumIddPerBlock();
 
@@ -123,6 +126,8 @@ void CommandContainer::reset() {
                                     indirectHeap->getMaxAvailableSpace());
         addToResidencyContainer(indirectHeap->getGraphicsAllocation());
     }
+
+    reserveBindlessOffsets(*indirectHeaps[HeapType::SURFACE_STATE]);
 }
 
 void *CommandContainer::getHeapSpaceAllowGrow(HeapType heapType,
@@ -172,11 +177,15 @@ IndirectHeap *CommandContainer::getHeapWithRequiredSizeAndAlignment(HeapType hea
         getDeallocationContainer().push_back(oldAlloc);
         setIndirectHeapAllocation(heapType, newAlloc);
         setHeapDirty(heapType);
+        if (heapType == HeapType::SURFACE_STATE) {
+            reserveBindlessOffsets(*indirectHeap);
+        }
     }
 
     if (alignment) {
         indirectHeap->align(alignment);
     }
+
     return indirectHeap;
 }
 
@@ -201,4 +210,11 @@ void CommandContainer::allocateNextCommandBuffer() {
     addToResidencyContainer(cmdBufferAllocation);
 }
 
+void CommandContainer::reserveBindlessOffsets(IndirectHeap &sshHeap) {
+    UNRECOVERABLE_IF(sshHeap.getUsed() > 0);
+    auto &helper = HwHelper::get(getDevice()->getHardwareInfo().platform.eRenderCoreFamily);
+    auto surfaceStateSize = helper.getRenderSurfaceStateSize();
+    sshHeap.getSpace(surfaceStateSize);
+}
+
 } // namespace NEO
diff --git a/shared/source/command_container/cmdcontainer.h b/shared/source/command_container/cmdcontainer.h
@@ -94,6 +94,7 @@ class CommandContainer : public NonCopyableOrMovableClass {
     uint32_t getNumIddPerBlock() const { return numIddsPerBlock; }
 
   protected:
+    void reserveBindlessOffsets(IndirectHeap &sshHeap);
     void *iddBlock = nullptr;
     Device *device = nullptr;
     std::unique_ptr<HeapHelper> heapHelper;
diff --git a/shared/source/command_stream/scratch_space_controller_base.cpp b/shared/source/command_stream/scratch_space_controller_base.cpp
@@ -73,6 +73,11 @@ uint64_t ScratchSpaceControllerBase::getScratchPatchAddress() {
 }
 
 void ScratchSpaceControllerBase::reserveHeap(IndirectHeap::Type heapType, IndirectHeap *&indirectHeap) {
+    if (heapType == IndirectHeap::SURFACE_STATE) {
+        auto &hwHelper = HwHelper::get(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);
+        auto surfaceStateSize = hwHelper.getRenderSurfaceStateSize();
+        indirectHeap->getSpace(surfaceStateSize);
+    }
 }
 
 } // namespace NEO
diff --git a/shared/test/unit_test/command_container/command_container_tests.cpp b/shared/test/unit_test/command_container/command_container_tests.cpp
@@ -201,26 +201,62 @@ TEST_F(CommandContainerTest, givenCommandContainerWhenWantToAddAlreadyAddedAlloc
     EXPECT_EQ(sizeAfterFirstAdd, sizeAfterDuplicatesRemoved);
 }
 
-TEST_F(CommandContainerTest, givenAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenExistingAllocationIsReturned) {
+HWTEST_F(CommandContainerTest, givenCmdContainerWhenInitializeCalledThenSSHHeapHasBindlessOffsetReserved) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
     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;
+    ASSERT_NE(nullptr, heap);
+    EXPECT_EQ(sizeof(RENDER_SURFACE_STATE), heap->getUsed());
+}
 
-    EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
+HWTEST_F(CommandContainerTest, givenNotEnoughSpaceInSSHWhenGettingHeapWithRequiredSizeAndAlignmentThenSSHHeapHasBindlessOffsetReserved) {
+    using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
+    std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
+    cmdContainer->initialize(pDevice);
+    cmdContainer->setDirtyStateForAllHeaps(false);
 
-    auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
-    auto newAllocation = heapRequested->getGraphicsAllocation();
+    auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
+    ASSERT_NE(nullptr, heap);
+    heap->getSpace(heap->getAvailableSpace());
 
-    EXPECT_EQ(heap, heapRequested);
-    EXPECT_EQ(heapAllocation, newAllocation);
+    cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeof(RENDER_SURFACE_STATE), 0);
 
-    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
-    EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+    EXPECT_EQ(sizeof(RENDER_SURFACE_STATE), heap->getUsed());
+}
+
+TEST_F(CommandContainerTest, givenAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenExistingAllocationIsReturned) {
+    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 heapAllocation = cmdContainer->getIndirectHeapAllocation(type);
+        auto heap = cmdContainer->getIndirectHeap(type);
+
+        const size_t sizeRequested = 32;
+        const size_t alignment = 32;
+
+        EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
+        auto sizeBefore = heap->getUsed();
+
+        auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, 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(type));
+
+        auto sizeAfter = heapRequested->getUsed();
+        EXPECT_EQ(sizeBefore, sizeAfter);
+    }
 }
 
 TEST_F(CommandContainerTest, givenUnalignedAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenHeapReturnedIsCorrectlyAligned) {
@@ -275,26 +311,30 @@ TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenGetHeapWithRequiredSizeAndAl
     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);
+    HeapType types[] = {HeapType::SURFACE_STATE,
+                        HeapType::DYNAMIC_STATE};
 
-    const size_t sizeRequested = 32;
-    const size_t alignment = 32;
-    size_t availableSize = heap->getAvailableSpace();
+    for (auto type : types) {
+        auto heapAllocation = cmdContainer->getIndirectHeapAllocation(type);
+        auto heap = cmdContainer->getIndirectHeap(type);
 
-    heap->getSpace(availableSize - sizeRequested / 2);
+        const size_t sizeRequested = 32;
+        const size_t alignment = 32;
+        size_t availableSize = heap->getAvailableSpace();
 
-    EXPECT_LT(heap->getAvailableSpace(), sizeRequested + alignment);
+        heap->getSpace(availableSize - sizeRequested / 2);
 
-    auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
-    auto newAllocation = heapRequested->getGraphicsAllocation();
+        EXPECT_LT(heap->getAvailableSpace(), sizeRequested + alignment);
 
-    EXPECT_EQ(heap, heapRequested);
-    EXPECT_NE(heapAllocation, newAllocation);
+        auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, sizeRequested, alignment);
+        auto newAllocation = heapRequested->getGraphicsAllocation();
 
-    EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
-    EXPECT_TRUE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
+        EXPECT_EQ(heap, heapRequested);
+        EXPECT_NE(heapAllocation, newAllocation);
 
+        EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
+        EXPECT_TRUE(cmdContainer->isHeapDirty(type));
+    }
     for (auto deallocation : cmdContainer->getDeallocationContainer()) {
         cmdContainer->getDevice()->getMemoryManager()->freeGraphicsMemory(deallocation);
     }
diff --git a/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp b/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp

Original file line number	Diff line number	Diff line change
`@@ -371,7 +371,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, MockParentKernelDispatch, GivenUsedSSHHeapWhenParent`
`371`	`371`	`nullptr,`
`372`	`372`	`CL_COMMAND_NDRANGE_KERNEL);`
`373`	`373`
`374`		`- EXPECT_EQ(UnitTestHelper<FamilyType>::getDefaultSshUsage(), ssh.getUsed());`
	`374`	`+ EXPECT_EQ(0u, ssh.getUsed());`
`375`	`375`
`376`	`376`	`delete mockParentKernel;`
`377`	`377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ bool UnitTestHelper<GfxFamily>::isExpectMemoryNotEqualSupported() {`
`37`	`37`
`38`	`38`	`template <typename GfxFamily>`
`39`	`39`	`uint32_t UnitTestHelper<GfxFamily>::getDefaultSshUsage() {`
`40`		`- return 0;`
	`40`	`+ return sizeof(typename GfxFamily::RENDER_SURFACE_STATE);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`template <typename GfxFamily>`
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,11 @@ uint64_t ScratchSpaceControllerBase::getScratchPatchAddress() {`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`void ScratchSpaceControllerBase::reserveHeap(IndirectHeap::Type heapType, IndirectHeap *&indirectHeap) {`
	`76`	`+ if (heapType == IndirectHeap::SURFACE_STATE) {`
	`77`	`+ auto &hwHelper = HwHelper::get(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);`
	`78`	`+ auto surfaceStateSize = hwHelper.getRenderSurfaceStateSize();`
	`79`	`+ indirectHeap->getSpace(surfaceStateSize);`
	`80`	`+ }`
`76`	`81`	`}`
`77`	`82`
`78`	`83`	`} // namespace NEO`