Pull out freelist allocation from GrVkSubHeap

src/gpu/vk/GrVkMemory.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkMemory.h"
 
 #include "GrVkGpu.h"
@@ skipping 224 matching lines @@
     } else if (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
         flags = VK_ACCESS_TRANSFER_WRITE_BIT;
     } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout) {
         flags = VK_ACCESS_TRANSFER_READ_BIT;
     } else if (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout) {
         flags = VK_ACCESS_SHADER_READ_BIT;
     }
     return flags;
 }
 
-GrVkSubHeap::GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex, 
-                         VkDeviceSize size, VkDeviceSize alignment)
-    : fGpu(gpu)
-    , fMemoryTypeIndex(memoryTypeIndex) {
-
-    VkMemoryAllocateInfo allocInfo = {
-        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,      // sType
-        NULL,                                        // pNext
-        size,                                        // allocationSize
-        memoryTypeIndex,                             // memoryTypeIndex
-    };
-
-    VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateMemory(gpu->device(),
-                                                                 &allocInfo,
-                                                                 nullptr,
-                                                                 &fAlloc));
-
-    if (VK_SUCCESS == err) {
-        fSize = size;
-        fAlignment = alignment;
-        fFreeSize = size;
-        fLargestBlockSize = size;
-        fLargestBlockOffset = 0;
-
-        Block* block = fFreeList.addToTail();
-        block->fOffset = 0;
-        block->fSize = fSize;
-    } else {
-        fSize = 0;
-        fAlignment = 0;
-        fFreeSize = 0;
-        fLargestBlockSize = 0;
-    }
-}
-
-GrVkSubHeap::~GrVkSubHeap() {
-    const GrVkInterface* iface = fGpu->vkInterface();
-    GR_VK_CALL(iface, FreeMemory(fGpu->device(), fAlloc, nullptr));
-
-    fFreeList.reset();
-}
-
-bool GrVkSubHeap::alloc(VkDeviceSize size, GrVkAlloc* alloc) {
-    VkDeviceSize alignedSize = align_size(size, fAlignment);
+bool GrVkFreeListAlloc::alloc(VkDeviceSize requestedSize,
+                              VkDeviceSize* allocOffset, VkDeviceSize* allocSize) {
+    VkDeviceSize alignedSize = align_size(requestedSize, fAlignment);
 
     // find the smallest block big enough for our allocation
     FreeList::Iter iter = fFreeList.headIter();
     FreeList::Iter bestFitIter;
     VkDeviceSize   bestFitSize = fSize + 1;
     VkDeviceSize   secondLargestSize = 0;
     VkDeviceSize   secondLargestOffset = 0;
     while (iter.get()) {
         Block* block = iter.get();
         // need to adjust size to match desired alignment
         SkASSERT(align_size(block->fOffset, fAlignment) - block->fOffset == 0);
         if (block->fSize >= alignedSize && block->fSize < bestFitSize) {
             bestFitIter = iter;
             bestFitSize = block->fSize;
         }
         if (secondLargestSize < block->fSize && block->fOffset != fLargestBlockOffset) {
             secondLargestSize = block->fSize;
             secondLargestOffset = block->fOffset;
         }
         iter.next();
     }
     SkASSERT(secondLargestSize <= fLargestBlockSize);
 
     Block* bestFit = bestFitIter.get();
     if (bestFit) {
-        alloc->fMemory = fAlloc;
         SkASSERT(align_size(bestFit->fOffset, fAlignment) == bestFit->fOffset);
-        alloc->fOffset = bestFit->fOffset;
-        alloc->fSize = alignedSize;
+        *allocOffset = bestFit->fOffset;
+        *allocSize = alignedSize;
         // adjust or remove current block
         VkDeviceSize originalBestFitOffset = bestFit->fOffset;
         if (bestFit->fSize > alignedSize) {
             bestFit->fOffset += alignedSize;
             bestFit->fSize -= alignedSize;
             if (fLargestBlockOffset == originalBestFitOffset) {
                 if (bestFit->fSize >= secondLargestSize) {
                     fLargestBlockSize = bestFit->fSize;
                     fLargestBlockOffset = bestFit->fOffset;
                 } else {
@@ skipping 27 matching lines @@
                 Block* block = iter.get();
                 if (largestSize < block->fSize) {
                     largestSize = block->fSize;
                 }
                 iter.next();
             }
             SkASSERT(largestSize == fLargestBlockSize);
 #endif
         }
         fFreeSize -= alignedSize;
-        SkASSERT(alloc->fSize > 0);
+        SkASSERT(allocSize > 0);
 
         return true;
     }
-    
+
     SkDebugf("Can't allocate %d bytes, %d bytes available, largest free block %d\n", alignedSize, fFreeSize, fLargestBlockSize);
 
     return false;
 }
 
-
-void GrVkSubHeap::free(const GrVkAlloc& alloc) {
-    SkASSERT(alloc.fMemory == fAlloc);
-
+void GrVkFreeListAlloc::free(VkDeviceSize allocOffset, VkDeviceSize allocSize) {
     // find the block right after this allocation
     FreeList::Iter iter = fFreeList.headIter();
     FreeList::Iter prev;
-    while (iter.get() && iter.get()->fOffset < alloc.fOffset) {
+    while (iter.get() && iter.get()->fOffset < allocOffset) {
         prev = iter;
         iter.next();
-    } 
+    }
     // we have four cases:
     // we exactly follow the previous one
     Block* block;
-    if (prev.get() && prev.get()->fOffset + prev.get()->fSize == alloc.fOffset) {
+    if (prev.get() && prev.get()->fOffset + prev.get()->fSize == allocOffset) {
         block = prev.get();
-        block->fSize += alloc.fSize;
+        block->fSize += allocSize;
         if (block->fOffset == fLargestBlockOffset) {
             fLargestBlockSize = block->fSize;
         }
         // and additionally we may exactly precede the next one
-        if (iter.get() && iter.get()->fOffset == alloc.fOffset + alloc.fSize) {
+        if (iter.get() && iter.get()->fOffset == allocOffset + allocSize) {
             block->fSize += iter.get()->fSize;
             if (iter.get()->fOffset == fLargestBlockOffset) {
                 fLargestBlockOffset = block->fOffset;
                 fLargestBlockSize = block->fSize;
             }
             fFreeList.remove(iter.get());
         }
     // or we only exactly proceed the next one
-    } else if (iter.get() && iter.get()->fOffset == alloc.fOffset + alloc.fSize) {
+    } else if (iter.get() && iter.get()->fOffset == allocOffset + allocSize) {
         block = iter.get();
-        block->fSize += alloc.fSize;
+        block->fSize += allocSize;
         if (block->fOffset == fLargestBlockOffset) {
-            fLargestBlockOffset = alloc.fOffset;
+            fLargestBlockOffset = allocOffset;
             fLargestBlockSize = block->fSize;
         }
-        block->fOffset = alloc.fOffset;
+        block->fOffset = allocOffset;
     // or we fall somewhere in between, with gaps
     } else {
         block = fFreeList.addBefore(iter);
-        block->fOffset = alloc.fOffset;
-        block->fSize = alloc.fSize;
+        block->fOffset = allocOffset;
+        block->fSize = allocSize;
     }
-    fFreeSize += alloc.fSize;
+    fFreeSize += allocSize;
     if (block->fSize > fLargestBlockSize) {
         fLargestBlockSize = block->fSize;
         fLargestBlockOffset = block->fOffset;
     }
 
 #ifdef SK_DEBUG
     VkDeviceSize   largestSize = 0;
     iter = fFreeList.headIter();
     while (iter.get()) {
         Block* block = iter.get();
         if (largestSize < block->fSize) {
             largestSize = block->fSize;
         }
         iter.next();
     }
     SkASSERT(fLargestBlockSize == largestSize);
 #endif
 }
 
-GrVkHeap::~GrVkHeap() {
+GrVkSubHeap::GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex,
+                         VkDeviceSize size, VkDeviceSize alignment)
+    : INHERITED(size, alignment)
+    , fGpu(gpu)
+    , fMemoryTypeIndex(memoryTypeIndex) {
+
+    VkMemoryAllocateInfo allocInfo = {
+        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,      // sType
+        NULL,                                        // pNext
+        size,                                        // allocationSize
+        memoryTypeIndex,                             // memoryTypeIndex
+    };
+
+    VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateMemory(gpu->device(),
+                                                                 &allocInfo,
+                                                                 nullptr,
+                                                                 &fAlloc));
+    if (VK_SUCCESS != err) {
+        this->reset();
+    }
+}
+
+GrVkSubHeap::~GrVkSubHeap() {
+    const GrVkInterface* iface = fGpu->vkInterface();
+    GR_VK_CALL(iface, FreeMemory(fGpu->device(), fAlloc, nullptr));
+}
+
+bool GrVkSubHeap::alloc(VkDeviceSize size, GrVkAlloc* alloc) {
+    alloc->fMemory = fAlloc;
+    return INHERITED::alloc(size, &alloc->fOffset, &alloc->fSize);
+}
+
+void GrVkSubHeap::free(const GrVkAlloc& alloc) {
+    SkASSERT(alloc.fMemory == fAlloc);
+
+    INHERITED::free(alloc.fOffset, alloc.fSize);
 }
 
 bool GrVkHeap::subAlloc(VkDeviceSize size, VkDeviceSize alignment, 
                         uint32_t memoryTypeIndex, GrVkAlloc* alloc) {
     VkDeviceSize alignedSize = align_size(size, alignment);
 
     // if requested is larger than our subheap allocation, just alloc directly
     if (alignedSize > fSubHeapSize) {
         VkMemoryAllocateInfo allocInfo = {
             VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,      // sType
@@ skipping 108 matching lines @@
             fSubHeaps[i]->free(alloc);
             fUsedSize -= alloc.fSize;
             return true;
         }
     }
 
     return false;
 }