Remove obtainReusableAllocation method from memory manager

Change-Id: I629044d109822f02cfddc6418f025010e62ab65b
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

Author: JablonskiMateusz

runtime/command_queue/command_queue.cpp

@@ -214,7 +214,7 @@ LinearStream &CommandQueue::getCS(size_t minRequiredSize) {
 
         auto requiredSize = minRequiredSize + CSRequirements::csOverfetchSize;
 
-        GraphicsAllocation *allocation = memoryManager->obtainReusableAllocation(requiredSize, false).release();
+        GraphicsAllocation *allocation = storageForAllocation->obtainReusableAllocation(requiredSize, false).release();
 
         if (!allocation) {
             allocation = memoryManager->allocateGraphicsMemory(requiredSize);

runtime/command_queue/enqueue_svm.h

@@ -223,7 +223,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMMemFill(void *svmPtr,
     DEBUG_BREAK_IF(nullptr == memoryManager);
 
     auto commandStreamReceieverOwnership = device->getCommandStreamReceiver().obtainUniqueOwnership();
-    auto patternAllocation = memoryManager->obtainReusableAllocation(patternSize, false).release();
+    auto storageWithAllocations = device->getCommandStreamReceiver().getInternalAllocationStorage();
+    auto patternAllocation = storageWithAllocations->obtainReusableAllocation(patternSize, false).release();
     commandStreamReceieverOwnership.unlock();
 
     if (!patternAllocation) {
@@ -271,8 +272,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueSVMMemFill(void *svmPtr,
         eventWaitList,
         event);
 
-    auto storageForAllocation = device->getCommandStreamReceiver().getInternalAllocationStorage();
-    storageForAllocation->storeAllocationWithTaskCount(std::unique_ptr<GraphicsAllocation>(patternAllocation), REUSABLE_ALLOCATION, taskCount);
+    storageWithAllocations->storeAllocationWithTaskCount(std::unique_ptr<GraphicsAllocation>(patternAllocation), REUSABLE_ALLOCATION, taskCount);
 
     return CL_SUCCESS;
 }

runtime/command_stream/command_stream_receiver.cpp

@@ -134,7 +134,7 @@ LinearStream &CommandStreamReceiver::getCS(size_t minRequiredSize) {
 
         auto requiredSize = minRequiredSize + CSRequirements::csOverfetchSize;
 
-        auto allocation = getMemoryManager()->obtainReusableAllocation(requiredSize, false).release();
+        auto allocation = internalAllocationStorage->obtainReusableAllocation(requiredSize, false).release();
         if (!allocation) {
             allocation = getMemoryManager()->allocateGraphicsMemory(requiredSize);
         }
@@ -287,7 +287,7 @@ void CommandStreamReceiver::allocateHeapMemory(IndirectHeap::Type heapType,
 
     finalHeapSize = alignUp(std::max(finalHeapSize, minRequiredSize), MemoryConstants::pageSize);
 
-    auto heapMemory = getMemoryManager()->obtainReusableAllocation(finalHeapSize, requireInternalHeap).release();
+    auto heapMemory = internalAllocationStorage->obtainReusableAllocation(finalHeapSize, requireInternalHeap).release();
 
     if (!heapMemory) {
         if (requireInternalHeap) {

runtime/command_stream/experimental_command_buffer.cpp

@@ -58,16 +58,16 @@ void ExperimentalCommandBuffer::getCS(size_t minRequiredSize) {
         minRequiredSize = alignUp(minRequiredSize, MemoryConstants::pageSize);
 
         auto requiredSize = minRequiredSize + CSRequirements::csOverfetchSize;
-
-        GraphicsAllocation *allocation = memoryManager->obtainReusableAllocation(requiredSize, false).release();
+        auto storageWithAllocations = commandStreamReceiver->getInternalAllocationStorage();
+        GraphicsAllocation *allocation = storageWithAllocations->obtainReusableAllocation(requiredSize, false).release();
         if (!allocation) {
             allocation = memoryManager->allocateGraphicsMemory(requiredSize);
         }
         allocation->setAllocationType(GraphicsAllocation::AllocationType::LINEAR_STREAM);
         // Deallocate the old block, if not null
         auto oldAllocation = currentStream->getGraphicsAllocation();
         if (oldAllocation) {
-            commandStreamReceiver->getInternalAllocationStorage()->storeAllocation(std::unique_ptr<GraphicsAllocation>(oldAllocation), REUSABLE_ALLOCATION);
+            storageWithAllocations->storeAllocation(std::unique_ptr<GraphicsAllocation>(oldAllocation), REUSABLE_ALLOCATION);
         }
         currentStream->replaceBuffer(allocation->getUnderlyingBuffer(), minRequiredSize - CSRequirements::minCommandQueueCommandStreamSize);
         currentStream->replaceGraphicsAllocation(allocation);

runtime/memory_manager/memory_manager.cpp

@@ -148,10 +148,6 @@ void MemoryManager::freeSystemMemory(void *ptr) {
     ::alignedFree(ptr);
 }
 
-std::unique_ptr<GraphicsAllocation> MemoryManager::obtainReusableAllocation(size_t requiredSize, bool internalAllocation) {
-    return getCommandStreamReceiver(0)->getInternalAllocationStorage()->obtainReusableAllocation(requiredSize, internalAllocation);
-}
-
 void MemoryManager::setForce32BitAllocations(bool newValue) {
     if (newValue && !this->allocator32Bit) {
         this->allocator32Bit.reset(new Allocator32bit);

runtime/memory_manager/memory_manager.h

@@ -208,8 +208,6 @@ class MemoryManager {
     TagAllocator<HwPerfCounter> *getEventPerfCountAllocator();
     TagAllocator<TimestampPacket> *getTimestampPacketAllocator();
 
-    MOCKABLE_VIRTUAL std::unique_ptr<GraphicsAllocation> obtainReusableAllocation(size_t requiredSize, bool isInternalAllocationRequired);
-
     virtual GraphicsAllocation *createGraphicsAllocation(OsHandleStorage &handleStorage, size_t hostPtrSize, const void *hostPtr) = 0;
 
     bool peek64kbPagesEnabled() const { return enable64kbpages; }

unit_tests/command_stream/command_stream_receiver_flush_task_tests.cpp

@@ -1663,7 +1663,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, InForced32BitAllocationsModeDoNotS
     auto newScratchAllocation = commandStreamReceiver->getScratchAllocation();
     EXPECT_NE(scratchAllocation, newScratchAllocation); // Allocation changed
 
-    std::unique_ptr<GraphicsAllocation> allocationReusable = pDevice->getMemoryManager()->obtainReusableAllocation(4096, false);
+    std::unique_ptr<GraphicsAllocation> allocationReusable = commandStreamReceiver->getInternalAllocationStorage()->obtainReusableAllocation(4096, false);
 
     if (allocationReusable.get() != nullptr) {
         if (is64bit) {